talon-agent 5.3.0 → 5.4.0

package/src/backend/agy/models.ts

@@ -0,0 +1,335 @@
+/**
+ * Antigravity model catalog.
+ *
+ * There is no models API and no cache file to read — the authority is
+ * `agy models`, which prints a "Fetching available models..." line
+ * followed by one `id<TAB>label` row per model. Talon runs it once at
+ * init and re-runs it behind a TTL, so a model Google adds appears
+ * without a Talon release.
+ *
+ * Effort is baked into most ids (`gemini-3.8-flash-high|medium|low`),
+ * so the catalog is where `supportedReasoningLevels` comes from too:
+ * a model advertises the levels its sibling slugs exist for, plus
+ * whatever `--effort` can express. See `effort.ts` for the precedence.
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type {
+  UnifiedModelInfo,
+  UnifiedModelResolution,
+  UnifiedProviderInfo,
+  ModelButton,
+  ModelPickerOptions,
+  ModelPickerResult,
+  ReasoningEffortLevel,
+} from "../../core/types.js";
+import { logWarn } from "../../util/log.js";
+import { agyBinary } from "./state.js";
+import { AGY_DEFAULT_MODEL } from "./constants.js";
+import { effortSuffixOf, modelIdStem } from "./effort.js";
+
+const execFileAsync = promisify(execFile);
+
+/** How long a parsed catalog is reused before `agy models` runs again. */
+const CATALOG_TTL_MS = 10 * 60 * 1000;
+
+/** Vendor prefix → Talon provider identity. */
+const PROVIDERS: ReadonlyArray<{
+  id: string;
+  name: string;
+  prefixes: readonly string[];
+}> = [
+  { id: "google", name: "Google", prefixes: ["gemini"] },
+  { id: "anthropic", name: "Anthropic", prefixes: ["claude"] },
+  { id: "openai", name: "OpenAI", prefixes: ["gpt", "o1", "o3", "o4"] },
+];
+
+export type AgyModelInfo = UnifiedModelInfo;
+
+// ── Cache ───────────────────────────────────────────────────────────────────
+
+let catalog: AgyModelInfo[] = [];
+let fetchedAt: number | null = null;
+let inFlight: Promise<AgyModelInfo[]> | null = null;
+
+/** Drop the cached catalog — test isolation and the cleanup hook. */
+export function resetModelCache(): void {
+  catalog = [];
+  fetchedAt = null;
+  inFlight = null;
+}
+
+/** The catalog as last parsed, without triggering a probe. */
+export function getCachedModels(): AgyModelInfo[] {
+  return [...catalog];
+}
+
+// ── Parsing ─────────────────────────────────────────────────────────────────
+
+/**
+ * Parse `agy models` stdout.
+ *
+ * Tolerates the "Fetching available models..." preamble the CLI prints
+ * before the table, blank lines, and any future non-tabbed banner:
+ * only lines with a TAB are rows, and an empty id is skipped.
+ */
+export function parseAgyModels(stdout: string): AgyModelInfo[] {
+  const rows: Array<{ id: string; label: string }> = [];
+  for (const line of stdout.split("\n")) {
+    const tab = line.indexOf("\t");
+    if (tab < 0) continue;
+    const id = line.slice(0, tab).trim();
+    const label = line.slice(tab + 1).trim();
+    if (!id) continue;
+    rows.push({ id, label });
+  }
+  const byStem = new Map<string, Set<string>>();
+  for (const { id } of rows) {
+    const suffix = effortSuffixOf(id);
+    if (!suffix) continue;
+    const stem = modelIdStem(id);
+    const set = byStem.get(stem) ?? new Set<string>();
+    set.add(suffix);
+    byStem.set(stem, set);
+  }
+  return rows.map(({ id, label }) => toModelInfo(id, label, byStem));
+}
+
+function toModelInfo(
+  id: string,
+  label: string,
+  byStem: Map<string, Set<string>>,
+): AgyModelInfo {
+  const provider = providerFor(id);
+  const siblings = byStem.get(modelIdStem(id));
+  const suffix = effortSuffixOf(id);
+  // Levels this model can actually be run at: the suffixes its sibling
+  // slugs exist for, or — for a suffix-less id — the three `--effort`
+  // accepts. Ordered low→high so pickers render predictably.
+  const levels: ReasoningEffortLevel[] = (
+    ["low", "medium", "high"] as const
+  ).filter((level) => (siblings ? siblings.has(level) : true));
+  return {
+    id,
+    displayName: label || id,
+    provider: provider.id,
+    providerName: provider.name,
+    selectable: true,
+    reasoning: true,
+    supportedReasoningLevels: levels,
+    ...(suffix ? { defaultReasoningLevel: suffix } : {}),
+  };
+}
+
+function providerFor(id: string): { id: string; name: string } {
+  const lower = id.toLowerCase();
+  for (const provider of PROVIDERS) {
+    if (provider.prefixes.some((p) => lower.startsWith(p))) {
+      return { id: provider.id, name: provider.name };
+    }
+  }
+  return { id: "antigravity", name: "Antigravity" };
+}
+
+/**
+ * Minimal entry for an id the catalog doesn't list — a model the user
+ * pinned by hand, or one that landed between probes. Mirrors codex's
+ * `synthesizeUnknownModel`: never hide a configured model from
+ * `/status` just because discovery hasn't caught up.
+ */
+export function synthesizeUnknownModel(id: string): AgyModelInfo {
+  const provider = providerFor(id);
+  return {
+    id,
+    displayName: id,
+    provider: provider.id,
+    providerName: provider.name,
+    selectable: true,
+    reasoning: true,
+    supportedReasoningLevels: ["low", "medium", "high"],
+  };
+}
+
+// ── Probing ─────────────────────────────────────────────────────────────────
+
+/**
+ * Run `agy models` and cache the result. Concurrent callers share one
+ * spawn; a failure is logged and leaves the previous catalog in place
+ * (an empty one on the very first failure), so a transient network
+ * blip degrades the picker rather than breaking a turn.
+ */
+export async function refreshModels(force = false): Promise<AgyModelInfo[]> {
+  const fresh =
+    fetchedAt !== null && Date.now() - fetchedAt < CATALOG_TTL_MS && !force;
+  if (fresh && catalog.length > 0) return [...catalog];
+  if (inFlight) return inFlight;
+
+  inFlight = (async () => {
+    try {
+      const { stdout } = await execFileAsync(agyBinary(), ["models"], {
+        timeout: 30_000,
+        maxBuffer: 4 * 1024 * 1024,
+      });
+      const parsed = parseAgyModels(stdout);
+      if (parsed.length > 0) {
+        catalog = parsed;
+        fetchedAt = Date.now();
+      }
+    } catch (err) {
+      logWarn(
+        "agent",
+        `agy models failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    } finally {
+      inFlight = null;
+    }
+    return [...catalog];
+  })();
+  return inFlight;
+}
+
+/** Catalog for read paths: cached when warm, probed when cold. */
+async function effectiveModels(): Promise<AgyModelInfo[]> {
+  if (catalog.length > 0) return [...catalog];
+  return refreshModels();
+}
+
+// ── Catalog surface ─────────────────────────────────────────────────────────
+
+/**
+ * Resolve a query: exact id, then case-insensitive id, then a prefix
+ * match on id or display name. Ambiguity is reported rather than
+ * guessed — headless agy exits non-zero on an unknown `--model`, so a
+ * wrong guess costs a failed turn.
+ */
+export async function resolveModel(
+  query: string,
+): Promise<UnifiedModelResolution> {
+  const q = query.trim();
+  if (!q) return { kind: "missing" };
+  const models = await effectiveModels();
+
+  const exact = models.find((m) => m.id === q);
+  if (exact) return { kind: "exact", model: exact, storedValue: exact.id };
+
+  const lower = q.toLowerCase();
+  const insensitive = models.find((m) => m.id.toLowerCase() === lower);
+  if (insensitive) {
+    return { kind: "exact", model: insensitive, storedValue: insensitive.id };
+  }
+
+  const matches = models.filter(
+    (m) =>
+      m.id.toLowerCase().startsWith(lower) ||
+      m.displayName.toLowerCase().startsWith(lower),
+  );
+  if (matches.length === 0) return { kind: "missing" };
+  if (matches.length === 1) {
+    return { kind: "exact", model: matches[0], storedValue: matches[0].id };
+  }
+  return { kind: "ambiguous", matches };
+}
+
+/** Default model id. */
+export function getDefaultModelId(): string {
+  return AGY_DEFAULT_MODEL;
+}
+
+/** Look up one model, synthesising an entry for an unlisted id. */
+export async function getModelInfo(
+  id: string,
+): Promise<UnifiedModelInfo | undefined> {
+  if (!id) return undefined;
+  const models = await effectiveModels();
+  return models.find((m) => m.id === id) ?? synthesizeUnknownModel(id);
+}
+
+/** Quick-pick buttons for `/model` and `/settings`. */
+export async function getSettingsPresentation(
+  activeModel: string,
+  options: ModelPickerOptions = {},
+): Promise<ModelPickerResult> {
+  const models = await effectiveModels();
+  const callbackPrefix = options.callbackPrefix ?? "settings:model:";
+  const modelButtons: ModelButton[] = models.map((m) => ({
+    text: `${m.id === activeModel ? "● " : ""}${m.displayName}`,
+    callback_data: `${callbackPrefix}${m.id}`,
+  }));
+  const active = models.find((m) => m.id === activeModel);
+  const modelDetails = [
+    ...(active ? [`Active: ${active.displayName} (${active.id})`] : []),
+    `Backend: Antigravity — ${models.length} models (agy models)`,
+  ];
+  return {
+    modelButtons,
+    modelDetails,
+    view: "models",
+    page: 1,
+    totalPages: 1,
+    filter: "all",
+    freeCount: 0,
+    totalCount: models.length,
+  };
+}
+
+/** Providers, grouped by the vendor prefix of each model id. */
+export async function getProviders(): Promise<UnifiedProviderInfo[]> {
+  const models = await effectiveModels();
+  const counts = new Map<string, number>();
+  for (const m of models) {
+    counts.set(m.provider, (counts.get(m.provider) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([id, modelCount]) => ({
+    id,
+    name: models.find((m) => m.provider === id)?.providerName ?? id,
+    connected: true,
+    modelCount,
+  }));
+}
+
+/** Models for one provider (paginated). */
+export async function getProviderModels(
+  providerId: string,
+  page = 1,
+  pageSize = 50,
+): Promise<{ models: UnifiedModelInfo[]; total: number }> {
+  const models = (await effectiveModels()).filter(
+    (m) => m.provider === providerId,
+  );
+  const start = (page - 1) * pageSize;
+  return {
+    models: models.slice(start, start + pageSize),
+    total: models.length,
+  };
+}
+
+/** Human-readable error for an unresolvable model query. */
+export function formatModelError(
+  query: string,
+  resolution: UnifiedModelResolution,
+): string {
+  if (resolution.kind === "ambiguous") {
+    const list = resolution.matches.map((m) => `\`${m.id}\``).join(", ");
+    return `Multiple Antigravity models match \`${query}\`: ${list}. Pick one.`;
+  }
+  const ids = catalog.map((m) => m.id).join(", ");
+  return (
+    `No Antigravity model matches \`${query}\`. ` +
+    (ids
+      ? `Available: ${ids}.`
+      : "Run `agy models` to see what your account offers.")
+  );
+}
+
+/**
+ * Catalog listing. Antigravity is subscription-backed with no free
+ * tier, so `free` is honestly empty rather than aliased to `all`.
+ */
+export async function listModels(
+  filter?: "free" | "all",
+): Promise<{ models: UnifiedModelInfo[]; total: number }> {
+  if (filter === "free") return { models: [], total: 0 };
+  const models = await refreshModels();
+  return { models, total: models.length };
+}

package/src/backend/agy/one-shot.ts

@@ -0,0 +1,301 @@
+/**
+ * Antigravity one-shot runner — heartbeat, dream, cron and sub-agents.
+ *
+ * Unlike the chat path (one warm child per chat, many turns) an
+ * isolated run gets a FRESH `agy -p` process that exits when the turn
+ * does. The output format is still `stream-json` so tool steps reach
+ * the run log while the run is happening, which is what claude-sdk and
+ * codex both do — a heartbeat that only logged its final answer would
+ * be undebuggable.
+ *
+ * Its MCP entries live under their own `__talon__oneshot-<label>__`
+ * scope so a heartbeat's servers never collide with a chat's, and are
+ * removed in a `finally` whatever the run did.
+ */
+
+import { spawn } from "node:child_process";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
+import { log, logWarn } from "../../util/log.js";
+import { appendBackendSuffix } from "../runtime/index.js";
+import { emitAssistantText } from "../runtime/one-shot-hooks.js";
+import { AGY_SYSTEM_PROMPT_SUFFIX } from "./constants.js";
+import { agyBinary, getState } from "./state.js";
+import { agyScopeSlug } from "./mcp/config.js";
+import { registerMcpForChat, unregisterMcpScope } from "./mcp/register.js";
+import { toAgyEffort } from "./effort.js";
+import { getDefaultModelId } from "./models.js";
+import { isAgyAuthFailure, agyAuthError } from "./auth.js";
+import {
+  agyUsageToTokens,
+  describeAgyTool,
+  parseAgyLine,
+  type AgyEvent,
+  type AgyResult,
+  type AgyStepUpdate,
+} from "./events.js";
+
+const ts = (): string => new Date().toISOString().slice(11, 19);
+
+/** MCP scope for one isolated run — never a chat's. */
+export function oneShotScope(contextLabel: string): string {
+  return `oneshot-${agyScopeSlug(contextLabel)}`;
+}
+
+interface SpawnOutcome {
+  result: AgyResult | undefined;
+  stderr: string;
+  code: number | null;
+}
+
+/** Everything the child loop needs, so the spawn helper stays small. */
+interface RunInputs {
+  binary: string;
+  args: string[];
+  cwd: string;
+  prompt: string;
+  abortController: AbortController;
+  appendLog: (text: string) => Promise<void>;
+  onAssistantText?: OneShotAgentParams["onAssistantText"];
+}
+
+/** Render one stream event into the run log (and the assistant hook). */
+async function logEvent(
+  inputs: Pick<RunInputs, "appendLog" | "onAssistantText">,
+  event: AgyEvent,
+): Promise<void> {
+  const { appendLog } = inputs;
+  if (event.event === "init") {
+    await appendLog(
+      `\n### [${ts()}] Conversation started\n\`${event.conversation_id ?? "(unknown)"}\`\n`,
+    );
+    return;
+  }
+  if (event.event === "result") {
+    await logResult(appendLog, event.result);
+    return;
+  }
+  const step = event.step_update;
+  if (step) await logStep(inputs, step);
+}
+
+async function logStep(
+  inputs: Pick<RunInputs, "appendLog" | "onAssistantText">,
+  step: AgyStepUpdate,
+): Promise<void> {
+  if (step.step_type === "tool" && step.state !== "ACTIVE") {
+    const shape = describeAgyTool(step);
+    const where = shape.server ? `${shape.server}.${shape.name}` : shape.name;
+    const failed = step.state === "ERROR" || Boolean(step.tool_info?.error);
+    const detail = step.tool_info?.error?.message;
+    await inputs.appendLog(
+      `\n**Tool:** \`${where}\`${failed ? " (FAILED)" : ""}\n` +
+        "```json\n" +
+        `${JSON.stringify(shape.input, null, 2).slice(0, 2000)}\n` +
+        "```\n" +
+        (detail ? `${detail}\n` : ""),
+    );
+    return;
+  }
+  if (step.step_type === "agent_response" && step.state === "DONE") {
+    const usage = step.usage;
+    if (usage) {
+      await inputs.appendLog(
+        `\n_step: input=${usage.input_tokens ?? 0} output=${usage.output_tokens ?? 0} ` +
+          `thinking=${usage.thinking_tokens ?? 0} cached=${usage.cache_read_tokens ?? 0}_\n`,
+      );
+    }
+  }
+}
+
+async function logResult(
+  appendLog: (text: string) => Promise<void>,
+  result: AgyResult | undefined,
+): Promise<void> {
+  if (!result) return;
+  if (result.status && result.status !== "SUCCESS") {
+    await appendLog(
+      `\n### [${ts()}] Turn ${result.status}\n${result.error ?? "(no message)"}\n`,
+    );
+    return;
+  }
+  const u = result.usage;
+  await appendLog(
+    `\n### [${ts()}] Turn completed\ninput=${u?.input_tokens ?? 0} ` +
+      `output=${u?.output_tokens ?? 0} thinking=${u?.thinking_tokens ?? 0} ` +
+      `cached=${u?.cache_read_tokens ?? 0}\n`,
+  );
+}
+
+/** Spawn `agy -p`, stream its NDJSON into the log, resolve on exit. */
+function runAgyOnce(inputs: RunInputs): Promise<SpawnOutcome> {
+  return new Promise<SpawnOutcome>((resolve, reject) => {
+    const proc = spawn(inputs.binary, inputs.args, {
+      cwd: inputs.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const outcome: SpawnOutcome = { result: undefined, stderr: "", code: null };
+    let buffer = "";
+    let queue: Promise<void> = Promise.resolve();
+
+    const onAbort = () => proc.kill("SIGTERM");
+    inputs.abortController.signal.addEventListener("abort", onAbort, {
+      once: true,
+    });
+
+    proc.stdout.setEncoding("utf-8");
+    proc.stdout.on("data", (chunk: string) => {
+      buffer += chunk;
+      let nl = buffer.indexOf("\n");
+      while (nl >= 0) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const event = parseAgyLine(line);
+        if (event) {
+          if (event.event === "result") outcome.result = event.result;
+          queue = queue.then(() => logEvent(inputs, event)).catch(() => {});
+        }
+        nl = buffer.indexOf("\n");
+      }
+    });
+    proc.stderr.setEncoding("utf-8");
+    proc.stderr.on("data", (chunk: string) => {
+      outcome.stderr = (outcome.stderr + chunk).slice(-4000);
+    });
+    proc.on("error", (err) => {
+      inputs.abortController.signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      inputs.abortController.signal.removeEventListener("abort", onAbort);
+      outcome.code = code;
+      queue.then(() => resolve(outcome)).catch(() => resolve(outcome));
+    });
+  });
+}
+
+/** Build the argv for a one-shot `agy -p` run. */
+export function buildOneShotArgs(params: {
+  prompt: string;
+  model: string;
+  effort?: string;
+  workspace: string;
+}): string[] {
+  const args = [
+    "-p",
+    params.prompt,
+    "--output-format",
+    "stream-json",
+    "--dangerously-skip-permissions",
+    "--print-timeout",
+    "0s",
+    "--model",
+    params.model,
+    "--add-dir",
+    params.workspace,
+  ];
+  if (params.effort) args.push("--effort", params.effort);
+  return args;
+}
+
+export async function runOneShotAgent(
+  params: OneShotAgentParams,
+): Promise<OneShotUsage | void> {
+  const {
+    prompt,
+    systemPrompt,
+    model,
+    reasoningEffort,
+    workspace,
+    contextLabel,
+    abortController,
+    appendLog,
+    onAssistantText,
+  } = params;
+
+  const scope = oneShotScope(contextLabel);
+  registerMcpForChat(contextLabel, { scope });
+
+  // No system-prompt flag; a one-shot has no history to inherit one
+  // from, so it is prepended to the prompt verbatim.
+  const finalSystemPrompt = appendBackendSuffix(
+    systemPrompt,
+    AGY_SYSTEM_PROMPT_SUFFIX,
+  );
+  const effort = toAgyEffort(reasoningEffort);
+  if (reasoningEffort && !effort) {
+    logWarn(
+      "agent",
+      `[${contextLabel}] agy one-shot: effort "${reasoningEffort}" has no ` +
+        `agy equivalent — using the model default`,
+    );
+  }
+  const activeModel = model || getDefaultModelId();
+  log("agent", `[${contextLabel}] agy one-shot model: ${activeModel}`);
+
+  try {
+    if (abortController.signal.aborted) {
+      throw new Error("Aborted before prompt was sent");
+    }
+    const outcome = await runAgyOnce({
+      binary: agyBinary(getState().config?.agyBinary),
+      args: buildOneShotArgs({
+        prompt: `${finalSystemPrompt}\n\n---\n\n${prompt}`,
+        model: activeModel,
+        ...(effort ? { effort } : {}),
+        workspace,
+      }),
+      cwd: workspace,
+      prompt,
+      abortController,
+      appendLog,
+      ...(onAssistantText ? { onAssistantText } : {}),
+    });
+    return await settleOneShot({
+      outcome,
+      contextLabel,
+      appendLog,
+      ...(onAssistantText ? { onAssistantText } : {}),
+      aborted: abortController.signal.aborted,
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (abortController.signal.aborted || /abort/i.test(msg)) {
+      await appendLog(`\n### [${ts()}] Aborted\nRun aborted by timeout.\n`);
+      return;
+    }
+    logWarn("agent", `agy one-shot run failed: ${msg}`);
+    await appendLog(`\n### [${ts()}] Error\n${msg}\n`);
+  } finally {
+    unregisterMcpScope(scope);
+  }
+}
+
+/** Report the run's answer + usage, or its failure, to the log. */
+async function settleOneShot(inputs: {
+  outcome: SpawnOutcome;
+  contextLabel: string;
+  appendLog: (text: string) => Promise<void>;
+  onAssistantText?: OneShotAgentParams["onAssistantText"];
+  aborted: boolean;
+}): Promise<OneShotUsage | void> {
+  const { outcome, appendLog } = inputs;
+  if (inputs.aborted) {
+    await appendLog(`\n### [${ts()}] Aborted\nRun aborted by timeout.\n`);
+    return;
+  }
+  if (!outcome.result) {
+    const reason = isAgyAuthFailure(outcome.stderr)
+      ? agyAuthError().message
+      : outcome.stderr.trim() || `agy exited ${outcome.code ?? "n/a"}`;
+    logWarn("agent", `agy one-shot produced no result: ${reason}`);
+    await appendLog(`\n### [${ts()}] Error\n${reason}\n`);
+    return;
+  }
+  const response = outcome.result.response ?? "";
+  if (response.trim()) {
+    emitAssistantText(inputs.onAssistantText, response);
+    await appendLog(`\n## [${ts()}] Assistant\n${response}\n`);
+  }
+  return agyUsageToTokens(outcome.result.usage);
+}