gaunt-sloth 2.0.0-alpha.2 → 2.0.0-alpha.20

package/README.md

@@ -39,11 +39,61 @@ This is the only package in the workspace that pulls in AI vendor dependencies d
 npm install -g gaunt-sloth
 ```
 
-For full usage documentation see the [root README](../../README.md) and [docs/COMMANDS.md](../../docs/COMMANDS.md).
+For full usage documentation see the [root README](https://github.com/pukeko-robotics/gaunt-sloth/blob/main/README.md) and [docs/COMMANDS.md](https://github.com/pukeko-robotics/gaunt-sloth/blob/main/docs/COMMANDS.md).
+
+## ACP server (editor integration)
+
+Gaunt Sloth can run as an [Agent Client Protocol](https://agentclientprotocol.com/) (ACP)
+server, so an ACP host — Zed, JetBrains, a future Pukeko client — can spawn it as a coding
+agent. It speaks ACP JSON-RPC over **stdio** (no port, no flags beyond the switch below); the
+host launches it as a subprocess.
+
+Run it through this package:
+
+```bash
+npm install -g gaunt-sloth@alpha
+gaunt-sloth --acp-agent
+```
+
+**Install the app (`gaunt-sloth`), not `@gaunt-sloth/agent`.** The agent package also ships a
+standalone `gaunt-sloth-acp` binary, but the LLM providers (`@langchain/anthropic`, `openai`,
+`google`, …) are `peerDependencies` of `@gaunt-sloth/core` that **only this app package
+declares as real dependencies**. A bare `@gaunt-sloth/agent` install leaves those peers unmet,
+so its ACP server has no provider to build a model from. `gaunt-sloth --acp-agent` runs the
+exact same ACP server but resolves providers out of the app's dependency tree, so every
+configured provider works. (`stdout` is the protocol channel and is kept clean — gsloth's
+status/config output is redirected to `stderr`.)
+
+Provider credentials and model selection come from your usual gsloth config
+(`.gsloth.config.*` / env vars such as `ANTHROPIC_API_KEY`); the ACP server reads them via the
+same `initConfig` path as the CLI. Run the host from your project directory (or set its `cwd`)
+so config and the per-session workspace resolve correctly.
+
+### Zed
+
+Add to Zed `settings.json` (or Settings -> External Agents -> Add Agent -> Custom Agent):
+
+```json
+{
+  "agent_servers": {
+    "Gaunt Sloth": {
+      "type": "custom",
+      "command": "gaunt-sloth",
+      "args": ["--acp-agent"],
+      "env": {}
+    }
+  }
+}
+```
+
+Point `command` at the global `gaunt-sloth` binary (after `npm install -g gaunt-sloth@alpha`),
+or at an absolute path to `cli.js` for a local build. Other ACP hosts (JetBrains, etc.) take
+the same `command` + `args` pair.
 
 ## Related packages
 
-- [`@gaunt-sloth/core`](../core) — Core utilities, config, and agent infrastructure
-- [`@gaunt-sloth/agent`](../agent) — Agent runtime, built-in tools, API/AG-UI/ACP server
-- [`@gaunt-sloth/review`](../review) — Review and Q&A modules with standalone CLI
-- [`gaunt-sloth`](../app) — Main CLI application (this package)
+- [`@gaunt-sloth/core`](https://www.npmjs.com/package/@gaunt-sloth/core) — Core utilities, config, and agent infrastructure ([source](https://github.com/pukeko-robotics/gaunt-sloth/tree/main/packages/core))
+- [`@gaunt-sloth/agent`](https://www.npmjs.com/package/@gaunt-sloth/agent) — Agent runtime, built-in tools, API/AG-UI/ACP server ([source](https://github.com/pukeko-robotics/gaunt-sloth/tree/main/packages/agent))
+- [`@gaunt-sloth/review`](https://www.npmjs.com/package/@gaunt-sloth/review) — Review and Q&A modules with standalone CLI ([source](https://github.com/pukeko-robotics/gaunt-sloth/tree/main/packages/review))
+- [`@gaunt-sloth/batch`](https://www.npmjs.com/package/@gaunt-sloth/batch) — Batch / eval / workflow runtime ([source](https://github.com/pukeko-robotics/gaunt-sloth/tree/main/packages/batch))
+- [`gaunt-sloth`](https://www.npmjs.com/package/gaunt-sloth) — Main CLI application (this package) ([source](https://github.com/pukeko-robotics/gaunt-sloth/tree/main/packages/app))

package/cli.js

@@ -9,15 +9,48 @@ process.on('warning', (warning) => {
   console.warn(warning);
 });
 
-// This is a minimalistic entry point that sets the installDir in systemUtils
-// and delegates to the compiled TypeScript code in dist/cli.js
-import { setEntryPoint } from './dist/utils/systemUtils.js';
+// --- ACP server bypass -----------------------------------------------------
+// `gaunt-sloth --acp-agent` runs the Agent Client Protocol (ACP) server instead
+// of the normal CLI, so an ACP host (Zed, JetBrains, a future Pukeko client) can
+// spawn the fat `gaunt-sloth` package as a coding-agent subprocess.
+//
+// Why route ACP through the app rather than the standalone `gaunt-sloth-acp`
+// binary in @gaunt-sloth/agent: the LLM providers (@langchain/anthropic, openai,
+// google, …) are peerDependencies of @gaunt-sloth/core, and only this app package
+// declares them as real dependencies. A bare `@gaunt-sloth/agent` install leaves
+// those peers unmet, so its ACP server has no providers to construct a model from.
+// Starting the same ACP server from here resolves providers out of the app's tree.
+//
+// ACP speaks JSON-RPC over stdio, so stdout MUST stay a clean protocol channel:
+// redirect console.log/info (used by initConfig/status output) to stderr BEFORE
+// touching config, exactly as the standalone `gaunt-sloth-acp` entry does.
+if (process.argv.includes('--acp-agent')) {
+  for (const method of ['log', 'info']) {
+    console[method] = (...args) => process.stderr.write(args.join(' ') + '\n');
+  }
+  const [{ initConfig }, { displayError }, { startAcpServer }] = await Promise.all([
+    import('@gaunt-sloth/core/config.js'),
+    import('@gaunt-sloth/core/utils/consoleUtils.js'),
+    import('@gaunt-sloth/agent'),
+  ]);
+  try {
+    const config = await initConfig({});
+    await startAcpServer(config);
+  } catch (err) {
+    displayError(`ACP server failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+} else {
+  // This is a minimalistic entry point that sets the installDir in systemUtils
+  // and delegates to the compiled TypeScript code in dist/cli.js
+  const { setEntryPoint } = await import('./dist/utils/systemUtils.js');
 
-// Set the installation directory in systemUtils
-setEntryPoint(import.meta.url);
+  // Set the installation directory in systemUtils
+  setEntryPoint(import.meta.url);
 
-// Import and run the compiled TypeScript code
-import('./dist/cli.js').catch((err) => {
-  console.error('Failed to load application:', err);
-  process.exit(1);
-});
+  // Import and run the compiled TypeScript code
+  import('./dist/cli.js').catch((err) => {
+    console.error('Failed to load application:', err);
+    process.exit(1);
+  });
+}

package/dist/cli.js

@@ -1,6 +1,9 @@
 import { Command, Option } from 'commander';
 import { askCommand } from '#src/commands/askCommand.js';
 import { execCommand } from '#src/commands/execCommand.js';
+import { batchCommand } from '#src/commands/batchCommand.js';
+import { evalCommand } from '#src/commands/evalCommand.js';
+import { workflowCommand } from '#src/commands/workflowCommand.js';
 import { initCommand } from '#src/commands/initCommand.js';
 import { reviewCommand } from '#src/commands/reviewCommand.js';
 import { prCommand } from '#src/commands/prCommand.js';
@@ -8,12 +11,17 @@ import { chatCommand } from '#src/commands/chatCommand.js';
 import { codeCommand } from '#src/commands/codeCommand.js';
 import { apiCommand } from '#src/commands/apiCommand.js';
 import { getCommand } from '#src/commands/getCommand.js';
+import { configCommand } from '#src/commands/configCommand.js';
+import { historyCommand } from '#src/commands/historyCommand.js';
+import { insightsCommand } from '#src/commands/insightsCommand.js';
+import { modelsCommand } from '#src/commands/modelsCommand.js';
 import { argv, getSlothVersion, readStdin } from '@gaunt-sloth/core/utils/systemUtils.js';
+import { commandSkipsStdin, resolveInvokedCommandName } from '#src/utils/stdinPolicy.js';
 import { coerceBooleanOrString } from '@gaunt-sloth/core/utils/consoleUtils.js';
 const program = new Command();
 program
     .name('gsloth')
-    .description('Gaunt Sloth Assistant reviewing your PRs')
+    .description('Gaunt Sloth reviewing your PRs')
     .version(getSlothVersion())
     .option('--verbose', 'Set LangChain/LangGraph to verbose mode, ' +
     'causing LangChain/LangGraph to log many details to the console. ' +
@@ -23,7 +31,8 @@ program
     .option('-w, --write-output-to-file <value>', 'Write output to file. Accepts true/false or a filename. Shortcuts: -wn or -w0 for false.')
     .option('--tui', 'Force the interactive Ink TUI for chat/code sessions (overrides CI auto-off)')
     .option('--no-tui', 'Force the plain readline session for chat/code (disable the TUI)')
-    .addOption(new Option('--nopipe').hideHelp(true));
+    .addOption(new Option('--nopipe').hideHelp(true))
+    .addOption(new Option('--no-pipe').hideHelp(true));
 const cliConfigOverrides = {};
 // Parse global options before binding any commands
 program.parseOptions(argv);
@@ -62,9 +71,31 @@ reviewCommand(program, cliConfigOverrides);
 prCommand(program, cliConfigOverrides);
 askCommand(program, cliConfigOverrides);
 execCommand(program, cliConfigOverrides);
+batchCommand(program, cliConfigOverrides);
+evalCommand(program, cliConfigOverrides);
+workflowCommand(program, cliConfigOverrides);
 chatCommand(program, cliConfigOverrides);
 codeCommand(program, cliConfigOverrides);
 apiCommand(program, cliConfigOverrides);
 getCommand(program, cliConfigOverrides);
+configCommand(program, cliConfigOverrides);
+// GS2-7 (B20) — read-only, local history/insights surfaces. They resolve their own DB path (global
+// default or --db) and do not build the LLM, so they stay decoupled from config/provider setup.
+historyCommand(program);
+insightsCommand(program);
+// GS2-6 (B16) — model catalog: lists providers/models enriched with models.dev cost/limit metadata.
+// Read-only; enrichment never gates what `/v1/models` reports as callable.
+modelsCommand(program);
+// BATCH-11 (#405 gotcha #5): `eval`/`batch` never consume piped stdin, so they must not block
+// waiting for stdin EOF before dispatch — a scripted/CI `gth eval suite.yaml` inherits a non-TTY,
+// non-closing stdin and would otherwise hang until EOF (or need `</dev/null`). Resolve the invoked
+// subcommand from argv via commander's own operand parsing (so a `-c <path>` value or a file
+// argument is never mistaken for the command name) and, for those commands, imply the existing
+// `--no-pipe` fast path in readStdin. ask/review/pr etc. are untouched and still block-and-read a
+// piped diff.
+const invokedCommand = resolveInvokedCommandName(program.commands.map((command) => command.name()), program.parseOptions(argv).operands);
+if (commandSkipsStdin(invokedCommand)) {
+    program.setOptionValue('nopipe', true);
+}
 await readStdin(program);
 //# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/commands/adkEvalRunner.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @module adkEvalRunner
+ * BATCH-14 — the ADK (A2A) target's production runner builders for `gth eval`. The eval runner
+ * ({@link @gaunt-sloth/batch#runEvalSuite}) is target-agnostic: it consumes an injected
+ * {@link RunCellFn} (single-shot) and {@link RunConversationFn} (multi-turn) and grades whatever
+ * `answer` they produce with the SAME assertion surface used for the `gth-agent` target. This module
+ * builds those two functions for an EXTERNAL Google ADK agent, driving it over the A2A protocol via
+ * {@link A2AClientWrapper} (the existing `@a2a-js/sdk` wrapper) — the analogue of `batchCommand.ts`'s
+ * `buildProductionRunCell`/`buildProductionRunConversation` for the in-process gth agent.
+ *
+ * The A2A client is INJECTABLE (like `RunCellFn`/`RunConversationFn` themselves) so unit tests drive
+ * these builders against a FAKE client with no network and no live ADK agent — the live end-to-end
+ * validation is a separate node (BATCH-16).
+ *
+ * Honest boundaries (BATCH-14 design point 4): A2A exposes text (and file/data) parts plus task
+ * status/artifact events, but NOT the agent's intermediate tool/function calls — so the ADK outcomes
+ * never populate `tools`, and `must_call`/`must_not_call` are rejected at suite-parse time rather
+ * than silently passed. A2A likewise carries no token accounting, so `tokensInput`/`tokensOutput`
+ * are left unset (undefined), unlike the gth-agent path.
+ */
+import type { AdkAgentTarget, RunCellFn, RunConversationFn } from '@gaunt-sloth/batch';
+/** One A2A turn's result as the ADK runner needs it: the answer text plus the continuity handles to
+ * thread into follow-up turns. */
+export interface AdkA2AResponse {
+    text: string;
+    contextId?: string;
+    taskId?: string;
+}
+/**
+ * The minimal A2A client the ADK runner depends on — a single `sendMessage(text, context?)` that
+ * returns text + continuity handles. Production wraps {@link A2AClientWrapper.sendMessageWithContext};
+ * tests inject a fake implementing exactly this. Kept deliberately narrow so a fake is trivial and
+ * the runner never reaches into the full SDK surface.
+ */
+export interface AdkA2AClient {
+    sendMessage(text: string, context?: {
+        contextId?: string;
+        taskId?: string;
+    }): Promise<AdkA2AResponse>;
+}
+/** Builds an {@link AdkA2AClient} for a target — the injection seam for tests. */
+export type AdkClientFactory = (target: AdkAgentTarget) => AdkA2AClient;
+/** Production factory: a real {@link A2AClientWrapper} over the target's A2A endpoint, adapted to the
+ * narrow {@link AdkA2AClient} shape via its context-threading {@link A2AClientWrapper.sendMessageWithContext}. */
+export declare const defaultAdkClientFactory: AdkClientFactory;
+/**
+ * Build the injectable single-shot {@link RunCellFn} that drives ONE ADK agent turn over A2A: send
+ * the cell's prompt as the A2A message text and return the agent's text as the cell `answer`. A
+ * transport/agent error is contained as a failed cell (`ok:false`) so one bad case can never take the
+ * whole suite down — matching `buildProductionRunCell`'s discipline for the gth-agent path.
+ *
+ * `tools`/tokens are intentionally unset (A2A exposes neither); content assertions grade the answer.
+ */
+export declare function buildAdkRunCell(target: AdkAgentTarget, createClient?: AdkClientFactory): RunCellFn;
+/**
+ * Build the injectable multi-turn {@link RunConversationFn} that drives a whole scripted conversation
+ * against the ADK agent over A2A, threading the A2A `contextId` across turns so turn N sees turn
+ * N-1's context (an ADK agent keeps conversational memory by `contextId`). ONE client is built for
+ * the conversation; the first turn sends no context, and each subsequent turn carries the `contextId`
+ * the previous response returned.
+ *
+ * Returns one {@link TurnRunOutcome} per turn attempted. A turn that throws is recorded as a failed
+ * turn and ABORTS the conversation (the returned array is short) — the runner fails the un-run turns
+ * with a clear reason, exactly as it does for a gth-agent conversation that ended early.
+ */
+export declare function buildAdkRunConversation(target: AdkAgentTarget, createClient?: AdkClientFactory): RunConversationFn;

package/dist/commands/adkEvalRunner.js

@@ -0,0 +1,69 @@
+import { A2AClientWrapper } from '#src/modules/a2a/A2AClientWrapper.js';
+/** Production factory: a real {@link A2AClientWrapper} over the target's A2A endpoint, adapted to the
+ * narrow {@link AdkA2AClient} shape via its context-threading {@link A2AClientWrapper.sendMessageWithContext}. */
+export const defaultAdkClientFactory = (target) => {
+    const wrapper = new A2AClientWrapper({
+        agentId: target.agentId ?? 'adk-agent',
+        agentUrl: target.url,
+    });
+    return {
+        sendMessage: (text, context) => wrapper.sendMessageWithContext(text, context),
+    };
+};
+/**
+ * Build the injectable single-shot {@link RunCellFn} that drives ONE ADK agent turn over A2A: send
+ * the cell's prompt as the A2A message text and return the agent's text as the cell `answer`. A
+ * transport/agent error is contained as a failed cell (`ok:false`) so one bad case can never take the
+ * whole suite down — matching `buildProductionRunCell`'s discipline for the gth-agent path.
+ *
+ * `tools`/tokens are intentionally unset (A2A exposes neither); content assertions grade the answer.
+ */
+export function buildAdkRunCell(target, createClient = defaultAdkClientFactory) {
+    return async (cell) => {
+        try {
+            const client = createClient(target);
+            const { text } = await client.sendMessage(cell.content);
+            return { ok: true, answer: text };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+}
+/**
+ * Build the injectable multi-turn {@link RunConversationFn} that drives a whole scripted conversation
+ * against the ADK agent over A2A, threading the A2A `contextId` across turns so turn N sees turn
+ * N-1's context (an ADK agent keeps conversational memory by `contextId`). ONE client is built for
+ * the conversation; the first turn sends no context, and each subsequent turn carries the `contextId`
+ * the previous response returned.
+ *
+ * Returns one {@link TurnRunOutcome} per turn attempted. A turn that throws is recorded as a failed
+ * turn and ABORTS the conversation (the returned array is short) — the runner fails the un-run turns
+ * with a clear reason, exactly as it does for a gth-agent conversation that ended early.
+ */
+export function buildAdkRunConversation(target, createClient = defaultAdkClientFactory) {
+    return async (userMessages) => {
+        const client = createClient(target);
+        const outcomes = [];
+        let contextId;
+        for (const message of userMessages) {
+            try {
+                const response = await client.sendMessage(message, contextId ? { contextId } : undefined);
+                // Carry the server's contextId forward so the next turn continues the same conversation.
+                if (response.contextId)
+                    contextId = response.contextId;
+                outcomes.push({ ok: true, answer: response.text });
+            }
+            catch (error) {
+                outcomes.push({
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // A failed turn aborts the conversation — the runner marks the remaining turns FAILed.
+                break;
+            }
+        }
+        return outcomes;
+    };
+}
+//# sourceMappingURL=adkEvalRunner.js.map

package/dist/commands/adkEvalRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adkEvalRunner.js","sourceRoot":"","sources":["../../src/commands/adkEvalRunner.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AA0BxE;kHACkH;AAClH,MAAM,CAAC,MAAM,uBAAuB,GAAqB,CAAC,MAAM,EAAE,EAAE;IAClE,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,WAAW;QACtC,QAAQ,EAAE,MAAM,CAAC,GAAG;KACrB,CAAC,CAAC;IACH,OAAO;QACL,WAAW,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC;KAC9E,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAsB,EACtB,YAAY,GAAqB,uBAAuB;IAExD,OAAO,KAAK,EAAE,IAAI,EAAE,EAAE;QACpB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;YACpC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACxD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACtF,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,uBAAuB,CACrC,MAAsB,EACtB,YAAY,GAAqB,uBAAuB;IAExD,OAAO,KAAK,EAAE,YAAY,EAAE,EAAE;QAC5B,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;QACpC,MAAM,QAAQ,GAAqB,EAAE,CAAC;QACtC,IAAI,SAA6B,CAAC;QAElC,KAAK,MAAM,OAAO,IAAI,YAAY,EAAE,CAAC;YACnC,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;gBAC1F,yFAAyF;gBACzF,IAAI,QAAQ,CAAC,SAAS;oBAAE,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;gBACvD,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;YACrD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,QAAQ,CAAC,IAAI,CAAC;oBACZ,EAAE,EAAE,KAAK;oBACT,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;iBAC9D,CAAC,CAAC;gBACH,uFAAuF;gBACvF,MAAM;YACR,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;AACJ,CAAC"}

package/dist/commands/agUiEvalRunner.d.ts

@@ -0,0 +1,73 @@
+import type { AgUiAgentTarget, RunCellFn, RunConversationFn } from '@gaunt-sloth/batch';
+/** One AG-UI message as sent in the `RunAgentInput.messages` array. The eval only ever sends `user`
+ * turns and, for conversation continuity, the `assistant` answers it assembled — the minimal shape
+ * the reference server's `convertMessage` consumes (`{ id, role, content }`). */
+export interface AgUiMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+}
+/** The `RunAgentInput` fields the runner drives per request. `threadId` provides conversation
+ * continuity (stable across the turns of ONE conversation); `runId` is fresh per request. */
+export interface AgUiRunInput {
+    threadId: string;
+    runId: string;
+    messages: AgUiMessage[];
+}
+/** One AG-UI run's decoded result: the answer assembled from `TEXT_MESSAGE_CONTENT` deltas and the
+ * tool names captured from `TOOL_CALL_START` events (empty array when the agent called no tools —
+ * NOT undefined, so `must_not_call` grades against a real, present trace). */
+export interface AgUiRunResult {
+    answer: string;
+    tools: string[];
+}
+/**
+ * The minimal AG-UI client the runner depends on — a single `run(input)` that POSTs one
+ * `RunAgentInput` and returns the decoded answer + tools. Production wraps {@link createAgUiClient};
+ * tests inject a fake implementing exactly this. Kept deliberately narrow so a fake is trivial and
+ * the runner never reaches into transport details.
+ */
+export interface AgUiClient {
+    run(input: AgUiRunInput): Promise<AgUiRunResult>;
+}
+/** Builds an {@link AgUiClient} for a target — the injection seam for tests. */
+export type AgUiClientFactory = (target: AgUiAgentTarget) => AgUiClient;
+/** The `fetch` seam — global `fetch` in production, a fake in tests (so the real POST-body
+ * construction + SSE decode are exercised with no network). */
+export type FetchLike = typeof fetch;
+/**
+ * Create a real {@link AgUiClient} that drives the target's AG-UI run endpoint over HTTP/SSE. Each
+ * `run` POSTs a `RunAgentInput` to `{url}/agents/{agentId}/run` and decodes the SSE response via
+ * {@link decodeAgUiStream}. A non-2xx response, an absent body, a `RUN_ERROR` event, or a truncated
+ * stream all throw — the runner builders contain that into a failed cell (`ok:false`).
+ *
+ * `fetchImpl` defaults to global `fetch`; tests pass a fake returning a synthetic SSE `Response` so
+ * the body construction + decode are exercised without a network or a live server.
+ */
+export declare function createAgUiClient(target: AgUiAgentTarget, fetchImpl?: FetchLike): AgUiClient;
+/** Production factory: a real HTTP/SSE {@link AgUiClient} over the target's AG-UI endpoint. */
+export declare const defaultAgUiClientFactory: AgUiClientFactory;
+/**
+ * Build the injectable single-shot {@link RunCellFn} that drives ONE AG-UI run: send the cell's
+ * prompt as the sole `user` message (fresh `threadId`/`runId`) and return the agent's assembled text
+ * as the cell `answer` plus the tool names captured from the stream as `tools`. A transport/stream
+ * error is contained as a failed cell (`ok:false`) so one bad case can never take the whole suite
+ * down — matching `buildProductionRunCell`'s discipline for the gth-agent path.
+ *
+ * `tools` is ALWAYS populated (possibly `[]`) — the AG-UI wire exposes the trace — so
+ * `must_call`/`must_not_call` grade normally, the key difference from the ADK target.
+ */
+export declare function buildAgUiRunCell(target: AgUiAgentTarget, createClient?: AgUiClientFactory): RunCellFn;
+/**
+ * Build the injectable multi-turn {@link RunConversationFn} that drives a whole scripted conversation
+ * against the AG-UI agent, threading continuity via the `messages` array + a STABLE `threadId` across
+ * the turns of ONE conversation: each turn appends its `user` message, POSTs the accumulated history
+ * under the same `threadId`, then appends the assistant's answer so the next turn's request carries
+ * it. ONE `threadId` for the whole conversation; a fresh `runId` per turn.
+ *
+ * Returns one {@link TurnRunOutcome} per turn attempted (answer + per-turn tool trace). A turn that
+ * throws is recorded as a failed turn and ABORTS the conversation (the returned array is short) — the
+ * runner fails the un-run turns with a clear reason, exactly as it does for a gth-agent conversation
+ * that ended early.
+ */
+export declare function buildAgUiRunConversation(target: AgUiAgentTarget, createClient?: AgUiClientFactory): RunConversationFn;

package/dist/commands/agUiEvalRunner.js

@@ -0,0 +1,216 @@
+/**
+ * @module agUiEvalRunner
+ * BATCH-15 — the AG-UI target's production runner builders for `gth eval`. The eval runner
+ * ({@link @gaunt-sloth/batch#runEvalSuite}) is target-agnostic: it consumes an injected
+ * {@link RunCellFn} (single-shot) and {@link RunConversationFn} (multi-turn) and grades whatever
+ * `answer` (and `tools`) they produce with the SAME assertion surface used for the `gth-agent`
+ * target. This module builds those two functions for an EXTERNAL agent exposed over the AG-UI
+ * protocol, driving its HTTP/SSE run endpoint — the analogue of `batchCommand.ts`'s
+ * `buildProductionRunCell`/`buildProductionRunConversation` (in-process gth agent) and of
+ * `adkEvalRunner.ts` (external ADK agent over A2A).
+ *
+ * The transport is INJECTABLE (like `RunCellFn`/`RunConversationFn` themselves) so unit tests drive
+ * these builders against a FAKE client — or the real decoder against a FAKE `fetch` — with no
+ * network and no live AG-UI server. The live end-to-end validation against a running `gth api ag-ui`
+ * server is a separate node (BATCH-17).
+ *
+ * KEY DIFFERENCE from the ADK (A2A) runner: the AG-UI wire DOES stream the agent's tool calls
+ * (`TOOL_CALL_START`). So this runner CAPTURES each `TOOL_CALL_START`'s `toolCallName` into the
+ * outcome's `tools`, and `must_call`/`must_not_call` grade normally — unlike the adk-agent target,
+ * where the tool trace is invisible and those assertions are rejected at parse time. AG-UI carries
+ * no token accounting either, so `tokensInput`/`tokensOutput` are left unset (undefined).
+ *
+ * The wire contract (see the reference endpoint, `@gaunt-sloth/api`'s `apiAgUiModule.ts`):
+ * - Request: `POST {url}/agents/{agentId}/run` with a `RunAgentInput` body
+ *   `{ threadId, runId, messages, tools, forwardedProps }`.
+ * - Response: an SSE stream of AG-UI events. We decode `TEXT_MESSAGE_CONTENT` deltas into the
+ *   `answer`, `TOOL_CALL_START` names into `tools`, and treat `RUN_ERROR` (or a non-200, or a stream
+ *   that ends without the terminal `RUN_FINISHED`) as a failed run — a gradeable `ok:false`, never
+ *   an uncaught throw that aborts the whole suite.
+ */
+import { randomUUID } from 'node:crypto';
+import { EventType } from '@ag-ui/core';
+/**
+ * Decode an AG-UI SSE stream into an {@link AgUiRunResult}. The reference encoder frames each event
+ * as `data: <json>\n\n` (`@ag-ui/encoder`), so we split on the blank-line delimiter, JSON-parse each
+ * frame's `data:` payload, and fold the relevant event types:
+ * - `TEXT_MESSAGE_CONTENT` → append `delta` to the answer.
+ * - `TOOL_CALL_START` → capture `toolCallName` into `tools`.
+ * - `RUN_ERROR` → remember the message; the run FAILED.
+ * - `RUN_FINISHED` → the terminal success signal.
+ *
+ * Throws on `RUN_ERROR` OR on a stream that ends without a terminal `RUN_FINISHED` (a truncated /
+ * malformed stream is a failed run, not an "empty answer" success). Non-JSON frames (SSE comments /
+ * keep-alives) are ignored. The throw is contained by the runner builders below into `ok:false`.
+ */
+async function decodeAgUiStream(body) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let answer = '';
+    const tools = [];
+    let runError;
+    let sawRunFinished = false;
+    const handleFrame = (frame) => {
+        const payload = frame
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice('data:'.length).trim())
+            .join('\n');
+        if (!payload)
+            return;
+        let event;
+        try {
+            event = JSON.parse(payload);
+        }
+        catch {
+            // Non-JSON frame (SSE comment / keep-alive) — ignore.
+            return;
+        }
+        switch (event.type) {
+            case EventType.TEXT_MESSAGE_CONTENT:
+                if (typeof event.delta === 'string')
+                    answer += event.delta;
+                break;
+            case EventType.TOOL_CALL_START:
+                if (typeof event.toolCallName === 'string')
+                    tools.push(event.toolCallName);
+                break;
+            case EventType.RUN_ERROR:
+                runError = typeof event.message === 'string' ? event.message : 'unknown run error';
+                break;
+            case EventType.RUN_FINISHED:
+                sawRunFinished = true;
+                break;
+        }
+    };
+    for await (const chunk of body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        let sep;
+        while ((sep = buffer.indexOf('\n\n')) !== -1) {
+            handleFrame(buffer.slice(0, sep));
+            buffer = buffer.slice(sep + 2);
+        }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim().length > 0)
+        handleFrame(buffer);
+    if (runError !== undefined) {
+        throw new Error(`AG-UI run error: ${runError}`);
+    }
+    if (!sawRunFinished) {
+        throw new Error('AG-UI stream ended without a terminal RUN_FINISHED event (truncated or malformed stream).');
+    }
+    return { answer, tools };
+}
+/**
+ * Create a real {@link AgUiClient} that drives the target's AG-UI run endpoint over HTTP/SSE. Each
+ * `run` POSTs a `RunAgentInput` to `{url}/agents/{agentId}/run` and decodes the SSE response via
+ * {@link decodeAgUiStream}. A non-2xx response, an absent body, a `RUN_ERROR` event, or a truncated
+ * stream all throw — the runner builders contain that into a failed cell (`ok:false`).
+ *
+ * `fetchImpl` defaults to global `fetch`; tests pass a fake returning a synthetic SSE `Response` so
+ * the body construction + decode are exercised without a network or a live server.
+ */
+export function createAgUiClient(target, fetchImpl = fetch) {
+    const base = target.url.replace(/\/+$/, '');
+    const endpoint = `${base}/agents/${encodeURIComponent(target.agentId)}/run`;
+    return {
+        async run(input) {
+            const response = await fetchImpl(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', Accept: 'text/event-stream' },
+                body: JSON.stringify({
+                    threadId: input.threadId,
+                    runId: input.runId,
+                    messages: input.messages,
+                    // The eval declares no client-fulfilled frontend tools; an empty array makes the server
+                    // serve the run from its own statically-configured agent.
+                    tools: [],
+                    forwardedProps: {},
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`AG-UI server responded ${response.status} ${response.statusText || ''}`.trim());
+            }
+            if (!response.body) {
+                throw new Error('AG-UI server returned no response body to stream.');
+            }
+            return decodeAgUiStream(response.body);
+        },
+    };
+}
+/** Production factory: a real HTTP/SSE {@link AgUiClient} over the target's AG-UI endpoint. */
+export const defaultAgUiClientFactory = (target) => createAgUiClient(target);
+/**
+ * Build the injectable single-shot {@link RunCellFn} that drives ONE AG-UI run: send the cell's
+ * prompt as the sole `user` message (fresh `threadId`/`runId`) and return the agent's assembled text
+ * as the cell `answer` plus the tool names captured from the stream as `tools`. A transport/stream
+ * error is contained as a failed cell (`ok:false`) so one bad case can never take the whole suite
+ * down — matching `buildProductionRunCell`'s discipline for the gth-agent path.
+ *
+ * `tools` is ALWAYS populated (possibly `[]`) — the AG-UI wire exposes the trace — so
+ * `must_call`/`must_not_call` grade normally, the key difference from the ADK target.
+ */
+export function buildAgUiRunCell(target, createClient = defaultAgUiClientFactory) {
+    return async (cell) => {
+        try {
+            const client = createClient(target);
+            const result = await client.run({
+                threadId: randomUUID(),
+                runId: randomUUID(),
+                messages: [{ id: randomUUID(), role: 'user', content: cell.content }],
+            });
+            return { ok: true, answer: result.answer, tools: result.tools };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+}
+/**
+ * Build the injectable multi-turn {@link RunConversationFn} that drives a whole scripted conversation
+ * against the AG-UI agent, threading continuity via the `messages` array + a STABLE `threadId` across
+ * the turns of ONE conversation: each turn appends its `user` message, POSTs the accumulated history
+ * under the same `threadId`, then appends the assistant's answer so the next turn's request carries
+ * it. ONE `threadId` for the whole conversation; a fresh `runId` per turn.
+ *
+ * Returns one {@link TurnRunOutcome} per turn attempted (answer + per-turn tool trace). A turn that
+ * throws is recorded as a failed turn and ABORTS the conversation (the returned array is short) — the
+ * runner fails the un-run turns with a clear reason, exactly as it does for a gth-agent conversation
+ * that ended early.
+ */
+export function buildAgUiRunConversation(target, createClient = defaultAgUiClientFactory) {
+    return async (userMessages) => {
+        const client = createClient(target);
+        const outcomes = [];
+        // One stable thread for the whole conversation (continuity), plus the accumulated history the
+        // server replays each turn (its `add_messages` reducer dedupes by id, so re-sending is safe).
+        const threadId = randomUUID();
+        const messages = [];
+        for (const userMessage of userMessages) {
+            messages.push({ id: randomUUID(), role: 'user', content: userMessage });
+            try {
+                const result = await client.run({
+                    threadId,
+                    runId: randomUUID(),
+                    // Snapshot the history so the caller/test sees exactly what THIS turn sent, unaffected by
+                    // later mutation.
+                    messages: [...messages],
+                });
+                // Thread the assistant's answer into the history so the next turn carries it (memory).
+                messages.push({ id: randomUUID(), role: 'assistant', content: result.answer });
+                outcomes.push({ ok: true, answer: result.answer, tools: result.tools });
+            }
+            catch (error) {
+                outcomes.push({
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // A failed turn aborts the conversation — the runner marks the remaining turns FAILed.
+                break;
+            }
+        }
+        return outcomes;
+    };
+}
+//# sourceMappingURL=agUiEvalRunner.js.map