Las matemáticas me enseñaron a ver los problemas como rompecabezas. El código me enseñó a resolverlos. Ahora, estoy enseñando a una IA a unirse.

type CacheEntry<T> = {
  data: T;
  fetchedAt: number;
  inFlight: Promise<T> | null;
};

const cache = new Map<string, CacheEntry<unknown>>();

// Serve cached data instantly; only go back to the network once it's this old.
const STALE_AFTER_MS = 30_000;

export function useCachedFetch<T>(key: string, fetcher: () => Promise<T>) {
  const [data, setData] = useState<T | null>(
    () => (cache.get(key)?.data as T | undefined) ?? null
  );

  useEffect(() => {
    const entry = cache.get(key) as CacheEntry<T> | undefined;
    const isStale = !entry || Date.now() - entry.fetchedAt > STALE_AFTER_MS;

    // Fresh cache hit: the UI already has the data, nothing to do.
    if (!isStale) return;

    // Dedupe: if a request for this key is already in flight — say, from
    // another component mounted a millisecond earlier during the same
    // spike — piggyback on it instead of firing a second identical call.
    const request =
      entry?.inFlight ??
      fetcher().then((result) => {
        cache.set(key, { data: result, fetchedAt: Date.now(), inFlight: null });
        return result;
      });

    cache.set(key, {
      data: entry?.data as T,
      fetchedAt: entry?.fetchedAt ?? 0,
      inFlight: request,
    });

    // Trade-off: on failure we keep serving the last good (stale) value
    // instead of surfacing an error — resilience over freshness.
    request.then(setData).catch(() => {});
  }, [key, fetcher]);

  return data;
}

name: CI/CD

on:
  push:
    branches: [main, develop]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run lint

  test:
    needs: lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test -- --coverage

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run build
      - uses: actions/upload-artifact@v4
        with:
          name: build-output
          path: dist/

  deploy-qa:
    # develop merges go straight to QA. This environment exists to break —
    # the gate is "did it build," not "did a human sign off."
    if: github.ref == 'refs/heads/develop'
    needs: build
    runs-on: ubuntu-latest
    environment: qa
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: build-output
      - run: ./scripts/deploy.sh qa # pm2 reload on the QA host

  deploy-production:
    # Production only ships from main, and only behind a required reviewer
    # on the "production" GitHub environment — one bad merge shouldn't be
    # able to reach real users without a second set of eyes.
    if: github.ref == 'refs/heads/main'
    needs: build
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: build-output
      - run: ./scripts/deploy.sh production # pm2 reload on the prod host

interface Tool {
  name: string;
  description: string;
  execute: (args: Record<string, unknown>) => string;
}

const tools: Tool[] = [
  {
    name: "get_weather",
    description: "Get the current weather for a city",
    execute: ({ city }) => `${city}: 22°C, clear skies`,
  },
  {
    name: "convert_currency",
    description: "Convert an amount from one currency to another",
    execute: ({ amount, from, to }) =>
      `${amount} ${from} ≈ ${(Number(amount) * 1.08).toFixed(2)} ${to}`,
  },
];

// The model never calls a function directly — it returns structured JSON
// naming a tool and its arguments. We parse that decision ourselves and
// decide whether to act on it, which is what keeps the model sandboxed.
interface ToolCall {
  tool: string;
  args: Record<string, unknown>;
}

function parseToolCall(modelOutput: string): ToolCall | null {
  try {
    const parsed = JSON.parse(modelOutput);
    if (typeof parsed.tool === "string") return parsed as ToolCall;
  } catch {
    // Not valid JSON — treat the output as a plain text reply instead.
  }
  return null;
}

export async function runAgentTurn(modelOutput: string): Promise<string> {
  const call = parseToolCall(modelOutput);

  // No tool call parsed: the model just answered in plain text.
  if (!call) return modelOutput;

  const tool = tools.find((t) => t.name === call.tool);
  if (!tool) return `Error: no tool named "${call.tool}"`;

  return tool.execute(call.args);
}