@gaunt-sloth/agent 2.0.0-alpha.9 → 2.0.0-beta.0

package/dist/modules/acp/acpUpdates.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @packageDocumentation
+ * Translates the agent runtime's typed {@link AgentStreamEvent} stream into ACP **v2**
+ * `session/update` payloads. (`acpUpdatesV1.ts` is the v1 half; both extend the tool-call tracker
+ * in `acpToolCalls.ts`, which is where the parts that are not about the dialect live.)
+ *
+ * Kept as a pure, stateful-but-transport-free mapper rather than inlined in the request handlers
+ * for two reasons. It is the half of the ACP surface with real logic — message identity, tool-call
+ * upserts, which events open and close a run — so it is the half worth testing without a
+ * connection. And the `session/update` **upsert semantics** live here and nowhere else: what the
+ * mapper omits is what a client must leave unchanged, so a mapper that re-sent a full replacement
+ * on every update would silently erase fields a client had already rendered.
+ *
+ * ## The upsert contract this mapper is written against
+ *
+ * A client applies updates per id, in arrival order: an omitted field leaves the stored value
+ * unchanged, `null` clears it, a concrete value replaces it, and a chunk appends. The first
+ * `tool_call_update` a client sees for a `toolCallId` CREATES the tool call. So the mapper sends
+ * the descriptive fields **once**, on the creating update, and every later update for that call
+ * carries only what actually changed — which is what makes a client's rendering of a running tool
+ * call correct rather than flickering back to a bare id.
+ */
+import type { SessionUpdate } from '@agentclientprotocol/sdk/experimental/v2';
+import type { AgentStreamEvent } from '@gaunt-sloth/core/core/types.js';
+import { AcpToolCallTracker } from '#src/modules/acp/acpToolCalls.js';
+/**
+ * Turns one agent run's event stream into ACP v2 `session/update` payloads.
+ *
+ * One instance per prompt turn: it holds the message identity of the assistant text run and of the
+ * reasoning run, plus the accumulated argument text per tool call. A fresh instance per turn is
+ * what makes a new turn a new `messageId`, which is how a client tells two messages apart.
+ */
+export declare class AcpUpdateMapper extends AcpToolCallTracker {
+    /**
+     * `messageId` of the assistant text message currently being streamed, or `null` when no text run
+     * is open. Cleared whenever something else interrupts the text (a tool call, a reasoning block),
+     * so the text that resumes afterwards is a NEW message rather than an append to the one the
+     * client already considers finished.
+     */
+    private assistantMessageId;
+    /** `messageId` of the reasoning message currently being streamed, or `null` outside one. */
+    private thoughtMessageId;
+    /**
+     * The `session/update` payloads one runtime event produces — usually one, sometimes none
+     * (`tool_args`, which only accumulates; the reasoning boundaries, which only move state).
+     */
+    map(event: AgentStreamEvent): SessionUpdate[];
+}

package/dist/modules/acp/acpUpdates.js

@@ -0,0 +1,142 @@
+/**
+ * @packageDocumentation
+ * Translates the agent runtime's typed {@link AgentStreamEvent} stream into ACP **v2**
+ * `session/update` payloads. (`acpUpdatesV1.ts` is the v1 half; both extend the tool-call tracker
+ * in `acpToolCalls.ts`, which is where the parts that are not about the dialect live.)
+ *
+ * Kept as a pure, stateful-but-transport-free mapper rather than inlined in the request handlers
+ * for two reasons. It is the half of the ACP surface with real logic — message identity, tool-call
+ * upserts, which events open and close a run — so it is the half worth testing without a
+ * connection. And the `session/update` **upsert semantics** live here and nowhere else: what the
+ * mapper omits is what a client must leave unchanged, so a mapper that re-sent a full replacement
+ * on every update would silently erase fields a client had already rendered.
+ *
+ * ## The upsert contract this mapper is written against
+ *
+ * A client applies updates per id, in arrival order: an omitted field leaves the stored value
+ * unchanged, `null` clears it, a concrete value replaces it, and a chunk appends. The first
+ * `tool_call_update` a client sees for a `toolCallId` CREATES the tool call. So the mapper sends
+ * the descriptive fields **once**, on the creating update, and every later update for that call
+ * carries only what actually changed — which is what makes a client's rendering of a running tool
+ * call correct rather than flickering back to a bare id.
+ */
+import { randomUUID } from 'node:crypto';
+import { AcpToolCallTracker, toolKindFor } from '#src/modules/acp/acpToolCalls.js';
+/** One text content block, the shape both message chunks and tool content wrap. */
+function textBlock(text) {
+    return { type: 'text', text };
+}
+/**
+ * Turns one agent run's event stream into ACP v2 `session/update` payloads.
+ *
+ * One instance per prompt turn: it holds the message identity of the assistant text run and of the
+ * reasoning run, plus the accumulated argument text per tool call. A fresh instance per turn is
+ * what makes a new turn a new `messageId`, which is how a client tells two messages apart.
+ */
+export class AcpUpdateMapper extends AcpToolCallTracker {
+    /**
+     * `messageId` of the assistant text message currently being streamed, or `null` when no text run
+     * is open. Cleared whenever something else interrupts the text (a tool call, a reasoning block),
+     * so the text that resumes afterwards is a NEW message rather than an append to the one the
+     * client already considers finished.
+     */
+    assistantMessageId = null;
+    /** `messageId` of the reasoning message currently being streamed, or `null` outside one. */
+    thoughtMessageId = null;
+    /**
+     * The `session/update` payloads one runtime event produces — usually one, sometimes none
+     * (`tool_args`, which only accumulates; the reasoning boundaries, which only move state).
+     */
+    map(event) {
+        switch (event.type) {
+            case 'text': {
+                this.assistantMessageId ??= randomUUID();
+                return [
+                    {
+                        sessionUpdate: 'agent_message_chunk',
+                        messageId: this.assistantMessageId,
+                        content: textBlock(event.delta),
+                    },
+                ];
+            }
+            case 'reasoning_start': {
+                this.assistantMessageId = null;
+                this.thoughtMessageId = randomUUID();
+                return [];
+            }
+            case 'reasoning_delta': {
+                this.thoughtMessageId ??= randomUUID();
+                return [
+                    {
+                        sessionUpdate: 'agent_thought_chunk',
+                        messageId: this.thoughtMessageId,
+                        content: textBlock(event.delta),
+                    },
+                ];
+            }
+            case 'reasoning_end': {
+                this.thoughtMessageId = null;
+                return [];
+            }
+            case 'tool_start': {
+                // A tool call ends the open text run: the text that follows the tool is a separate message.
+                this.assistantMessageId = null;
+                this.trackToolStart(event.id, event.name);
+                // The CREATING update — the first one a client sees for this id. Everything descriptive is
+                // sent here and never resent, because from here on omission means "unchanged".
+                return [
+                    {
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: event.id,
+                        name: event.name,
+                        title: event.name,
+                        kind: toolKindFor(event.name),
+                        status: 'pending',
+                    },
+                ];
+            }
+            case 'tool_args': {
+                this.appendToolArgs(event.id, event.delta);
+                return [];
+            }
+            case 'tool_end': {
+                const rawInput = this.rawInputFor(event.id);
+                // Status only (plus the arguments, once they are complete). No title, no kind, no name —
+                // the client keeps the ones the creating update set.
+                return [
+                    {
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: event.id,
+                        status: 'in_progress',
+                        ...(rawInput === undefined ? {} : { rawInput }),
+                    },
+                ];
+            }
+            case 'tool_output': {
+                // Live output from an executing tool. A CHUNK, not an update: it appends to whatever the
+                // client has for this call, where a `tool_call_update` carrying `content` would replace it.
+                if (event.id === undefined)
+                    return [];
+                return [
+                    {
+                        sessionUpdate: 'tool_call_content_chunk',
+                        toolCallId: event.id,
+                        content: { type: 'content', content: textBlock(event.chunk) },
+                    },
+                ];
+            }
+            case 'tool_result': {
+                this.trackToolSettled(event.id);
+                return [
+                    {
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: event.id,
+                        status: event.isError ? 'failed' : 'completed',
+                        content: [{ type: 'content', content: textBlock(event.content) }],
+                    },
+                ];
+            }
+        }
+    }
+}
+//# sourceMappingURL=acpUpdates.js.map

package/dist/modules/acp/acpUpdates.js.map

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

package/dist/modules/acp/acpUpdatesV1.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @packageDocumentation
+ * Translates the agent runtime's typed {@link AgentStreamEvent} stream into ACP **v1**
+ * `session/update` payloads. (`acpUpdates.ts` is the v2 half.)
+ *
+ * ## Where v1 differs, and why the mapper could not be shared
+ *
+ * The two dialects report the same events, but not with the same messages, and each difference
+ * changes what a conforming client ends up rendering:
+ *
+ * - **v1 has a distinct `tool_call` update that CREATES a tool call**, where v2 folded creation into
+ *   the first `tool_call_update`. Sending only `tool_call_update`s on v1 would leave a client
+ *   patching a call it was never told about.
+ * - **v1 has no `tool_call_content_chunk`.** Its `tool_call_update.content` REPLACES the whole
+ *   collection, so live tool output is streamed by accumulating it here and resending the
+ *   collection — the opposite of v2, where each chunk appends and only a `tool_call_update` replaces.
+ * - **v1 has no `state_update`.** There is nowhere to report `running` / `requires_action` / `idle`,
+ *   and no notification carries the stop reason: the turn's outcome is the `session/prompt`
+ *   RESPONSE. See `acpAgentAppV1.ts`.
+ * - **A prompt turn does not echo the user's message.** v1 reserves replay for `session/load`; a
+ *   client already renders what it sent, so echoing it would draw the message twice.
+ *
+ * What is NOT duplicated is tool-call identity — the kind hint, the argument reassembly, and the
+ * pairing that lets a permission request name the call it is about all come from
+ * {@link AcpToolCallTracker}.
+ */
+import type { SessionUpdate } from '@agentclientprotocol/sdk';
+import type { AgentStreamEvent } from '@gaunt-sloth/core/core/types.js';
+import { AcpToolCallTracker } from '#src/modules/acp/acpToolCalls.js';
+/**
+ * Turns one agent run's event stream into ACP v1 `session/update` payloads.
+ *
+ * One instance per prompt turn: it holds the message identity of the assistant text run and of the
+ * reasoning run, the accumulated argument text per tool call, and the output accumulated for each
+ * running tool. A fresh instance per turn is what makes a new turn a new `messageId`, which is how
+ * a client tells two messages apart.
+ */
+export declare class AcpV1UpdateMapper extends AcpToolCallTracker {
+    /**
+     * `messageId` of the assistant text message currently being streamed, or `null` when no text run
+     * is open. Cleared whenever something else interrupts the text (a tool call, a reasoning block),
+     * so the text that resumes afterwards is a NEW message rather than an append to the one the
+     * client already considers finished.
+     */
+    private assistantMessageId;
+    /** `messageId` of the reasoning message currently being streamed, or `null` outside one. */
+    private thoughtMessageId;
+    /**
+     * Live output accumulated per tool call, because v1 can only REPLACE a tool call's content.
+     *
+     * With no append-a-chunk update in the dialect, the only way to show a tool's output as it
+     * arrives is to resend everything seen so far; keeping the collection here is what makes each
+     * replacement a superset of the last rather than a flicker back to the newest line alone.
+     */
+    private readonly toolOutput;
+    /**
+     * The `session/update` payloads one runtime event produces — usually one, sometimes none
+     * (`tool_args`, which only accumulates; the reasoning boundaries, which only move state).
+     */
+    map(event: AgentStreamEvent): SessionUpdate[];
+}

package/dist/modules/acp/acpUpdatesV1.js

@@ -0,0 +1,162 @@
+/**
+ * @packageDocumentation
+ * Translates the agent runtime's typed {@link AgentStreamEvent} stream into ACP **v1**
+ * `session/update` payloads. (`acpUpdates.ts` is the v2 half.)
+ *
+ * ## Where v1 differs, and why the mapper could not be shared
+ *
+ * The two dialects report the same events, but not with the same messages, and each difference
+ * changes what a conforming client ends up rendering:
+ *
+ * - **v1 has a distinct `tool_call` update that CREATES a tool call**, where v2 folded creation into
+ *   the first `tool_call_update`. Sending only `tool_call_update`s on v1 would leave a client
+ *   patching a call it was never told about.
+ * - **v1 has no `tool_call_content_chunk`.** Its `tool_call_update.content` REPLACES the whole
+ *   collection, so live tool output is streamed by accumulating it here and resending the
+ *   collection — the opposite of v2, where each chunk appends and only a `tool_call_update` replaces.
+ * - **v1 has no `state_update`.** There is nowhere to report `running` / `requires_action` / `idle`,
+ *   and no notification carries the stop reason: the turn's outcome is the `session/prompt`
+ *   RESPONSE. See `acpAgentAppV1.ts`.
+ * - **A prompt turn does not echo the user's message.** v1 reserves replay for `session/load`; a
+ *   client already renders what it sent, so echoing it would draw the message twice.
+ *
+ * What is NOT duplicated is tool-call identity — the kind hint, the argument reassembly, and the
+ * pairing that lets a permission request name the call it is about all come from
+ * {@link AcpToolCallTracker}.
+ */
+import { randomUUID } from 'node:crypto';
+import { AcpToolCallTracker, toolKindFor } from '#src/modules/acp/acpToolCalls.js';
+/** One text content block, the shape both message chunks and tool content wrap. */
+function textBlock(text) {
+    return { type: 'text', text };
+}
+/** One tool-call content entry wrapping a text block. */
+function toolText(text) {
+    return { type: 'content', content: textBlock(text) };
+}
+/**
+ * Turns one agent run's event stream into ACP v1 `session/update` payloads.
+ *
+ * One instance per prompt turn: it holds the message identity of the assistant text run and of the
+ * reasoning run, the accumulated argument text per tool call, and the output accumulated for each
+ * running tool. A fresh instance per turn is what makes a new turn a new `messageId`, which is how
+ * a client tells two messages apart.
+ */
+export class AcpV1UpdateMapper extends AcpToolCallTracker {
+    /**
+     * `messageId` of the assistant text message currently being streamed, or `null` when no text run
+     * is open. Cleared whenever something else interrupts the text (a tool call, a reasoning block),
+     * so the text that resumes afterwards is a NEW message rather than an append to the one the
+     * client already considers finished.
+     */
+    assistantMessageId = null;
+    /** `messageId` of the reasoning message currently being streamed, or `null` outside one. */
+    thoughtMessageId = null;
+    /**
+     * Live output accumulated per tool call, because v1 can only REPLACE a tool call's content.
+     *
+     * With no append-a-chunk update in the dialect, the only way to show a tool's output as it
+     * arrives is to resend everything seen so far; keeping the collection here is what makes each
+     * replacement a superset of the last rather than a flicker back to the newest line alone.
+     */
+    toolOutput = new Map();
+    /**
+     * The `session/update` payloads one runtime event produces — usually one, sometimes none
+     * (`tool_args`, which only accumulates; the reasoning boundaries, which only move state).
+     */
+    map(event) {
+        switch (event.type) {
+            case 'text': {
+                this.assistantMessageId ??= randomUUID();
+                return [
+                    {
+                        sessionUpdate: 'agent_message_chunk',
+                        messageId: this.assistantMessageId,
+                        content: textBlock(event.delta),
+                    },
+                ];
+            }
+            case 'reasoning_start': {
+                this.assistantMessageId = null;
+                this.thoughtMessageId = randomUUID();
+                return [];
+            }
+            case 'reasoning_delta': {
+                this.thoughtMessageId ??= randomUUID();
+                return [
+                    {
+                        sessionUpdate: 'agent_thought_chunk',
+                        messageId: this.thoughtMessageId,
+                        content: textBlock(event.delta),
+                    },
+                ];
+            }
+            case 'reasoning_end': {
+                this.thoughtMessageId = null;
+                return [];
+            }
+            case 'tool_start': {
+                // A tool call ends the open text run: the text that follows the tool is a separate message.
+                this.assistantMessageId = null;
+                this.trackToolStart(event.id, event.name);
+                this.toolOutput.set(event.id, []);
+                // v1's CREATE. `title` is required here, and everything descriptive is sent with it; the
+                // later `tool_call_update`s carry only what changed.
+                return [
+                    {
+                        sessionUpdate: 'tool_call',
+                        toolCallId: event.id,
+                        name: event.name,
+                        title: event.name,
+                        kind: toolKindFor(event.name),
+                        status: 'pending',
+                    },
+                ];
+            }
+            case 'tool_args': {
+                this.appendToolArgs(event.id, event.delta);
+                return [];
+            }
+            case 'tool_end': {
+                const rawInput = this.rawInputFor(event.id);
+                // Status only (plus the arguments, once they are complete). No title, no kind, no name —
+                // the client keeps the ones the creating update set.
+                return [
+                    {
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: event.id,
+                        status: 'in_progress',
+                        ...(rawInput === undefined ? {} : { rawInput }),
+                    },
+                ];
+            }
+            case 'tool_output': {
+                if (event.id === undefined)
+                    return [];
+                const collected = this.toolOutput.get(event.id) ?? [];
+                collected.push(toolText(event.chunk));
+                this.toolOutput.set(event.id, collected);
+                // The whole collection, because v1 replaces rather than appends. Copied so a later push
+                // cannot mutate an update already handed to the transport.
+                return [
+                    { sessionUpdate: 'tool_call_update', toolCallId: event.id, content: [...collected] },
+                ];
+            }
+            case 'tool_result': {
+                this.trackToolSettled(event.id);
+                this.toolOutput.delete(event.id);
+                // The result REPLACES whatever live output was showing — it is the authoritative record of
+                // what the tool produced, and the same thing v2's final update does.
+                return [
+                    {
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: event.id,
+                        status: event.isError ? 'failed' : 'completed',
+                        content: [toolText(event.content)],
+                    },
+                ];
+            }
+        }
+    }
+}
+//# sourceMappingURL=acpUpdatesV1.js.map

package/dist/modules/acp/acpUpdatesV1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acpUpdatesV1.js","sourceRoot":"","sources":["../../../src/modules/acp/acpUpdatesV1.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEnF,mFAAmF;AACnF,SAAS,SAAS,CAAC,IAAY;IAC7B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAChC,CAAC;AAED,yDAAyD;AACzD,SAAS,QAAQ,CAAC,IAAY;IAC5B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;AACvD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,iBAAkB,SAAQ,kBAAkB;IACvD;;;;;OAKG;IACK,kBAAkB,GAAkB,IAAI,CAAC;IAEjD,4FAA4F;IACpF,gBAAgB,GAAkB,IAAI,CAAC;IAE/C;;;;;;OAMG;IACc,UAAU,GAAG,IAAI,GAAG,EAA6B,CAAC;IAEnE;;;OAGG;IACH,GAAG,CAAC,KAAuB;QACzB,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,MAAM,EAAE,CAAC;gBACZ,IAAI,CAAC,kBAAkB,KAAK,UAAU,EAAE,CAAC;gBACzC,OAAO;oBACL;wBACE,aAAa,EAAE,qBAAqB;wBACpC,SAAS,EAAE,IAAI,CAAC,kBAAkB;wBAClC,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;qBAChC;iBACF,CAAC;YACJ,CAAC;YACD,KAAK,iBAAiB,EAAE,CAAC;gBACvB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;gBAC/B,IAAI,CAAC,gBAAgB,GAAG,UAAU,EAAE,CAAC;gBACrC,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,KAAK,iBAAiB,EAAE,CAAC;gBACvB,IAAI,CAAC,gBAAgB,KAAK,UAAU,EAAE,CAAC;gBACvC,OAAO;oBACL;wBACE,aAAa,EAAE,qBAAqB;wBACpC,SAAS,EAAE,IAAI,CAAC,gBAAgB;wBAChC,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;qBAChC;iBACF,CAAC;YACJ,CAAC;YACD,KAAK,eAAe,EAAE,CAAC;gBACrB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;gBAC7B,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,KAAK,YAAY,EAAE,CAAC;gBAClB,4FAA4F;gBAC5F,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;gBAC/B,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC1C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAClC,yFAAyF;gBACzF,qDAAqD;gBACrD,OAAO;oBACL;wBACE,aAAa,EAAE,WAAW;wBAC1B,UAAU,EAAE,KAAK,CAAC,EAAE;wBACpB,IAAI,EAAE,KAAK,CAAC,IAAI;wBAChB,KAAK,EAAE,KAAK,CAAC,IAAI;wBACjB,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC;wBAC7B,MAAM,EAAE,SAAS;qBAClB;iBACF,CAAC;YACJ,CAAC;YACD,KAAK,WAAW,EAAE,CAAC;gBACjB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC3C,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,KAAK,UAAU,EAAE,CAAC;gBAChB,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAC5C,yFAAyF;gBACzF,qDAAqD;gBACrD,OAAO;oBACL;wBACE,aAAa,EAAE,kBAAkB;wBACjC,UAAU,EAAE,KAAK,CAAC,EAAE;wBACpB,MAAM,EAAE,aAAa;wBACrB,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC;qBAChD;iBACF,CAAC;YACJ,CAAC;YACD,KAAK,aAAa,EAAE,CAAC;gBACnB,IAAI,KAAK,CAAC,EAAE,KAAK,SAAS;oBAAE,OAAO,EAAE,CAAC;gBACtC,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;gBACtD,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBACtC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;gBACzC,wFAAwF;gBACxF,2DAA2D;gBAC3D,OAAO;oBACL,EAAE,aAAa,EAAE,kBAAkB,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE;iBACrF,CAAC;YACJ,CAAC;YACD,KAAK,aAAa,EAAE,CAAC;gBACnB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAChC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACjC,2FAA2F;gBAC3F,qEAAqE;gBACrE,OAAO;oBACL;wBACE,aAAa,EAAE,kBAAkB;wBACjC,UAAU,EAAE,KAAK,CAAC,EAAE;wBACpB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW;wBAC9C,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;qBACnC;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

package/dist/modules/apiAgUiModule.d.ts

@@ -1,2 +1,89 @@
 import { GthConfig } from '@gaunt-sloth/core/config.js';
+import type { BaseMessage } from '@langchain/core/messages';
+/** An AG-UI wire message as received on the run input (the shape {@link convertMessage} accepts). */
+type AgUiWireMessage = {
+    role: string;
+    content?: string;
+    id: string;
+    toolCalls?: Array<{
+        id: string;
+        type: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    toolCallId?: string;
+};
+/** Per-message options for {@link convertMessage}. */
+interface ConvertMessageOptions {
+    /**
+     * Whether an assistant text-emitted tool call may be PROMOTED to a native tool_call for this
+     * message. Defaults to `true` (the EXT-35 behaviour). {@link convertMessages} sets this to `false`
+     * for a DANGLING history call (one not followed by its tool result) so a stalled replayed call
+     * stays plain text — see EXT-43 and that function's doc.
+     */
+    allowTextCallPromotion?: boolean;
+    /**
+     * RC-32: the tool NAME to stamp on a `role:'tool'` message, resolved by
+     * {@link convertMessages} from the parenting assistant `tool_call`. The AG-UI wire format does
+     * not carry it, and a `ToolMessage` without a name is invisible to every result-inspecting
+     * middleware — `frontend-image-injection` keys on `msg.name === 'capture_image'`, so a replayed
+     * capture silently stopped producing a vision block on every turn after the capture itself.
+     * Absent on the standalone {@link convertMessage} path (a queued resume message has no history
+     * to resolve against), where the name is simply unknown.
+     */
+    toolName?: string;
+}
+/**
+ * Convert AG-UI message format to LangChain BaseMessage.
+ *
+ * `allowedToolNames` is the set of tool names bound to this run (config.tools + any run-input
+ * client tools). It gates EXT-35 plain-text tool-call repair on the assistant branch: an incoming
+ * assistant message with NO native `toolCalls` whose content is a STANDALONE text-emitted call
+ * (bracket / `<function=…>` / Harmony — the dialects small/local models produce) is promoted to a
+ * native tool_call so a replayed history turn is a real tool call rather than inert prose. An empty
+ * (or absent) allow-list promotes nothing — the prose-safe default. This runs alongside
+ * {@link parseToolArguments} (which rescues malformed args on an ALREADY-native tool_call).
+ *
+ * EXT-43: `options.allowTextCallPromotion` (default `true`) lets a caller suppress promotion for a
+ * single message; {@link convertMessages} uses it to leave a DANGLING history call as text.
+ */
+export declare function convertMessage(msg: AgUiWireMessage, allowedToolNames?: Set<string>, options?: ConvertMessageOptions): BaseMessage;
+/**
+ * Convert a whole AG-UI history array to LangChain messages, applying TWO symmetric replay guards
+ * so a poisoned history can never abort every subsequent turn on the thread.
+ *
+ * EXT-43 (forward, dangling-CALL): EXT-35's per-message promotion is unconditional, which is correct
+ * for a call that WILL be executed this turn. But when replaying HISTORY, promoting a STALLED text
+ * call (one the client recorded but that never ran) yields an `AIMessage` with `tool_calls` and NO
+ * following `tool_result` — a shape a strict provider (Anthropic) 400s on, where the pre-EXT-35
+ * plain text was valid. So promotion is allowed ONLY when the assistant message is immediately
+ * followed by a `tool` result message; a dangling call stays plain text (`allowTextCallPromotion:
+ * false`).
+ *
+ * RC-18 (backward, orphan-RESULT): the mirror image. A replayed `role:'tool'` message whose matching
+ * `tool_call` id is absent from EVERY PRECEDING assistant message is an ORPHAN — converting it to a
+ * `ToolMessage` yields a tool result with no preceding `AIMessage.tool_calls`, which the same strict
+ * provider 400s on (`Invalid parameter: messages with role 'tool' must be a response to a preceding
+ * message with 'tool_calls'`, INVALID_TOOL_RESULTS). Such orphans arise when a terminal
+ * (`returnDirect`) tool call's result is reconstructed by the client without its parenting assistant
+ * `tool_call`. We DROP the orphan (match on tool_call_id, NOT adjacency; keep genuine pairs; do NOT
+ * fabricate a synthetic call — mirroring EXT-43's demote-don't-invent spirit). Ids are accumulated
+ * in iteration order, so a result whose matching call appears only LATER is still an orphan.
+ *
+ * RC-32 (tool NAME restoration): the AG-UI wire message for a `tool` result carries `toolCallId`
+ * but no tool name, so a naively-converted `ToolMessage` has none — and every middleware that
+ * inspects results by name is blind to it. `frontend-image-injection` keys on
+ * `msg.name === 'capture_image'`, so a captured photo reached the model on the resume turn (where
+ * the graph builds the ToolMessage itself, with a name) and then vanished from every later turn,
+ * leaving the model to answer questions about a picture it could no longer see. The name is
+ * recoverable from the parenting assistant `tool_call`, which this function already walks for the
+ * RC-18 guard, so it is resolved there and stamped back on.
+ *
+ * The live middleware path (`GthLangChainAgent`, fixing the CURRENT turn) is unaffected — the two
+ * guards and the name restoration are history-replay only.
+ */
+export declare function convertMessages(messages: AgUiWireMessage[], allowedToolNames?: Set<string>): BaseMessage[];
 export declare function startAgUiServer(config: GthConfig, port: number): Promise<void>;
+export {};