@zq-silk/yui 0.15.7 → 0.15.8

package/dist/runtime/structuredProviderHost.js

@@ -1,13 +1,23 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { Duplex } from "node:stream";
+import { fileURLToPath } from "node:url";
 import WebSocket from "ws";
-import { CodexAppServerRequestError, CodexAppServerRuntime, codexGoalNotification, codexAppServerErrorIsMissing, codexTurnInput, codexTurnOutput } from "./codexAppServerRuntime.js";
+import { CodexAppServerRequestError, CodexAppServerRuntime, codexClientInitialization, codexGoalNotification, codexAppServerErrorIsMissing, codexTurnInput, codexTurnOutput } from "./codexAppServerRuntime.js";
 import { serializeAgentErrorRaw } from "./agentError.js";
-import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
+import { AcpStructuredProviderSession } from "./acpSession.js";
+import { acpDesiredSessionConfiguration } from "./acpSessionConfiguration.js";
+import { unsupportedAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { YUI_VERSION } from "../version.js";
-const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
+import { JsonLineChannel, PROVIDER_MESSAGE_MAX_BYTES, terminateProcessGroup } from "./jsonLineChannel.js";
+import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 const CODEX_PROXY_HANDSHAKE_TIMEOUT_MS = 10_000;
+/**
+ * These Session implementations do not expose run-configuration observations.
+ * Do not echo launch flags as Provider confirmation.
+ */
+const CODEX_RUN_CONFIGURATION = unsupportedAgentRunConfiguration("The Codex app-server protocol");
+const CLAUDE_RUN_CONFIGURATION = unsupportedAgentRunConfiguration("Claude Code's stream-json interface");
 export class ProviderDeliveryUnknownError extends Error {
     attemptId;
     name = "ProviderDeliveryUnknownError";
@@ -51,7 +61,8 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control === undefined) {
         throw new Error("Managed Agent Host launch requires Provider control metadata.");
     }
-    const child = spawn(payload.command, [...payload.args], {
+    const ownedClaude = control.adapterId === "claude" && control.transport !== "acp-stdio";
+    const child = spawn(ownedClaude ? fileURLToPath(new URL("./claude-process-owner", import.meta.url)) : payload.command, ownedClaude ? [payload.command, ...payload.args] : [...payload.args], {
         cwd: payload.cwd,
         env: { ...payload.environment },
         stdio: ["pipe", "pipe", "pipe"],
@@ -63,8 +74,40 @@ export async function startStructuredProviderSession(payload, input = {}) {
     child.stderr.on("data", (chunk) => mirror("stderr", chunk));
     const exit = childExit(child, processInstanceId);
     try {
+        // Dispatch is on the negotiated transport, not on a product name: every
+        // Agent that speaks a given transport is opened by the same code.
+        if (control.transport === "acp-stdio") {
+            const session = await AcpStructuredProviderSession.open({
+                child,
+                exit,
+                processInstanceId,
+                clientVersion: YUI_VERSION,
+                cwd: payload.cwd,
+                ...(control.acpSession?.additionalDirectories === undefined
+                    ? {}
+                    : { additionalDirectories: control.acpSession.additionalDirectories }),
+                ...(control.acpSession?.sessionBootstrap === undefined
+                    ? {}
+                    : { sessionBootstrap: control.acpSession.sessionBootstrap }),
+                ...(control.acpSession?.desiredConfiguration === undefined
+                    ? {}
+                    : {
+                        desiredConfiguration: acpDesiredSessionConfiguration(control.acpSession.desiredConfiguration)
+                    }),
+                // The product identity comes from the Agent binding the launch was
+                // compiled from. It is needed for one decision only — which mode value
+                // grants bypass — and is never inferred from the command that was run.
+                ...(control.component === undefined ? {} : { component: control.component }),
+                ...(control.nativeSessionId === undefined
+                    ? {}
+                    : { nativeSessionId: control.nativeSessionId }),
+                ...(input.onTerminal === undefined ? {} : { onTerminal: input.onTerminal }),
+                mirror
+            });
+            return Object.freeze({ session });
+        }
         if (control.adapterId === "codex") {
-            const opened = await CodexStructuredProviderSession.open(child, exit, processInstanceId, payload, control, input.onStarted, input.onTerminal, input.onGoal, mirror);
+            const opened = await CodexStructuredProviderSession.open(child, exit, processInstanceId, payload, control, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, mirror);
             return Object.freeze({
                 session: opened.session,
                 ...(opened.recoveredTerminal === undefined
@@ -73,7 +116,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
                 goal: opened.goal
             });
         }
-        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onTerminal, input.onGoal, mirror);
+        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, mirror);
         return Object.freeze({ session });
     }
     catch (error) {
@@ -168,7 +211,10 @@ class CodexProxyWebSocketChannel {
             throw this.#closedError;
         const id = String(this.#nextId++);
         const response = new Promise((resolvePromise, reject) => {
-            const timer = setTimeout(() => {
+            // A live turn submission may legitimately outlast the observation
+            // deadline. Retain its exact callback until acknowledgement or actual
+            // disconnect; a clock alone is not evidence of unknown delivery.
+            const timer = method === "turn/start" || method === "turn/steer" ? undefined : setTimeout(() => {
                 this.#pending.delete(id);
                 reject(new Error(`Provider request timed out: ${method}.`));
             }, PROVIDER_ACCEPT_TIMEOUT_MS);
@@ -305,73 +351,6 @@ class ChildProcessDuplex extends Duplex {
         return this;
     }
 }
-class JsonLineChannel {
-    child;
-    mirror;
-    #listeners = new Set();
-    #buffer = "";
-    #closedError;
-    constructor(child, mirror) {
-        this.child = child;
-        this.mirror = mirror;
-        child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => this.#receive(chunk));
-        child.once("error", (error) => this.#close(error));
-        child.once("close", (code, signal) => this.#close(new Error(`Provider process exited (code=${code ?? "none"}, signal=${signal ?? "none"}).`)));
-    }
-    onMessage(listener) {
-        this.#listeners.add(listener);
-        return () => this.#listeners.delete(listener);
-    }
-    async send(message) {
-        if (this.#closedError !== undefined)
-            throw this.#closedError;
-        const line = `${JSON.stringify(message)}\n`;
-        if (Buffer.byteLength(line, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
-            throw new Error("Provider request exceeds its message bound.");
-        }
-        await new Promise((resolvePromise, reject) => {
-            this.child.stdin.write(line, "utf8", (error) => {
-                if (error === null || error === undefined)
-                    resolvePromise();
-                else
-                    reject(error);
-            });
-        });
-    }
-    #receive(chunk) {
-        this.mirror("stdout", chunk);
-        this.#buffer += chunk;
-        if (Buffer.byteLength(this.#buffer, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
-            this.#close(new Error("Provider response line exceeds its message bound."));
-            terminateProcessGroup(this.child, "SIGTERM");
-            return;
-        }
-        for (;;) {
-            const newline = this.#buffer.indexOf("\n");
-            if (newline < 0)
-                return;
-            const line = this.#buffer.slice(0, newline).trim();
-            this.#buffer = this.#buffer.slice(newline + 1);
-            if (line.length === 0)
-                continue;
-            try {
-                const parsed = JSON.parse(line);
-                if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
-                    continue;
-                for (const listener of this.#listeners)
-                    listener(parsed);
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    #close(error) {
-        if (this.#closedError === undefined)
-            this.#closedError = error;
-    }
-}
 class CodexStructuredProviderSession {
     child;
     exit;
@@ -381,6 +360,10 @@ class CodexStructuredProviderSession {
     onStarted;
     onTerminal;
     onGoal;
+    onInput;
+    onActivity;
+    nativeAccountHome;
+    #turnAttempts = new Map();
     adapterId = "codex";
     #activeTurnId;
     #clientOwnedTurnId;
@@ -388,7 +371,8 @@ class CodexStructuredProviderSession {
     #submissionPending = false;
     #bufferedStarts = [];
     #bufferedTerminals = [];
-    constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal) {
+    #bufferedActivities = [];
+    constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, nativeAccountHome) {
         this.child = child;
         this.exit = exit;
         this.processInstanceId = processInstanceId;
@@ -397,18 +381,15 @@ class CodexStructuredProviderSession {
         this.onStarted = onStarted;
         this.onTerminal = onTerminal;
         this.onGoal = onGoal;
+        this.onInput = onInput;
+        this.onActivity = onActivity;
+        this.nativeAccountHome = nativeAccountHome;
     }
-    static async open(child, exit, processInstanceId, payload, control, onStarted, onTerminal, onGoal, mirror) {
+    static async open(child, exit, processInstanceId, payload, control, onStarted, onTerminal, onGoal, onInput, onActivity, mirror) {
         const channel = await CodexProxyWebSocketChannel.connect(child, mirror);
         const openingMessages = [];
         const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
-        await channel.request("initialize", {
-            clientInfo: { name: "yui", title: "Yui", version: YUI_VERSION },
-            capabilities: {
-                experimentalApi: true,
-                requestAttestation: false
-            }
-        });
+        const initialized = await channel.request("initialize", codexClientInitialization());
         await channel.notify("initialized");
         const runtime = new CodexAppServerRuntime(channel);
         let conversationId;
@@ -443,11 +424,13 @@ class CodexStructuredProviderSession {
                 name: control.sessionTitle
             });
         }
-        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal);
+        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, optionalId(initialized.codexHome));
         session.#activeTurnId = resumedActiveTurnId;
         const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
         session.#clientOwnedTurnId = ownedTurn?.turnId;
         session.#clientOwnedAttemptId = ownedTurn?.attemptId;
+        if (ownedTurn !== undefined)
+            session.#turnAttempts.set(ownedTurn.turnId, ownedTurn.attemptId);
         stopOpeningBuffer();
         let recoveredTerminal;
         for (const message of openingMessages) {
@@ -507,6 +490,38 @@ class CodexStructuredProviderSession {
                 this.onGoal?.(goal);
             return undefined;
         }
+        if (emit && (method === "item/started" || method === "item/completed"
+            || method === "item/agentMessage/delta" || method === "item/reasoning/summaryTextDelta")) {
+            const item = object(params.item);
+            const id = optionalId(item?.id) ?? optionalId(params.itemId);
+            const nativeTurnId = optionalId(params.turnId);
+            const tool = ["commandExecution", "mcpToolCall", "dynamicToolCall", "fileChange"].includes(String(item?.type));
+            const model = ["agentMessage", "reasoning"].includes(String(item?.type)) || method.endsWith("Delta") || method.endsWith("/delta");
+            if (id !== undefined && nativeTurnId !== undefined && (tool || model)) {
+                const activity = {
+                    conversationId: this.conversationId, nativeSessionId: this.conversationId,
+                    nativeTurnId, id, observedAt: new Date().toISOString(),
+                    phase: model ? "model" : method === "item/started" ? "started"
+                        : item?.status === "failed" || (typeof item?.exitCode === "number" && item.exitCode !== 0)
+                            ? "failed" : "completed"
+                };
+                if (this.#submissionPending)
+                    this.#bufferedActivities.push(activity);
+                else
+                    this.#emitActivity(activity);
+            }
+        }
+        if (method === "item/completed") {
+            const item = object(params.item);
+            const nativeTurnId = optionalId(params.turnId);
+            const inputId = optionalId(item?.id);
+            const input = item === null ? undefined : codexTurnInput({ items: [item] });
+            if (emit && nativeTurnId !== undefined && inputId !== undefined && input !== undefined) {
+                this.onInput?.({ conversationId: this.conversationId, nativeSessionId: this.conversationId,
+                    nativeTurnId, inputId, input, observedAt: new Date().toISOString() });
+            }
+            return undefined;
+        }
         if (method === "turn/started") {
             const turnId = nestedId(params, "turn") ?? optionalId(params.turnId);
             if (turnId !== undefined) {
@@ -563,6 +578,12 @@ class CodexStructuredProviderSession {
     get activeTurnId() {
         return this.#activeTurnId;
     }
+    /**
+     * This implementation has no run-configuration observation reader.
+     */
+    get runConfiguration() {
+        return CODEX_RUN_CONFIGURATION;
+    }
     async submitTurn(turn) {
         if (this.#activeTurnId !== undefined) {
             throw new ProviderTurnBusyError(`Provider Conversation already has active Turn ${this.#activeTurnId}.`, turn.attemptId, this.#activeTurnId);
@@ -587,6 +608,7 @@ class CodexStructuredProviderSession {
             this.#activeTurnId = acceptance.turnId;
             this.#clientOwnedTurnId = acceptance.turnId;
             this.#clientOwnedAttemptId = turn.attemptId;
+            this.#turnAttempts.set(acceptance.turnId, turn.attemptId);
             return Object.freeze({
                 attemptId: turn.attemptId,
                 conversationId: this.conversationId,
@@ -602,6 +624,8 @@ class CodexStructuredProviderSession {
             for (const started of starts)
                 this.#emitStarted(started);
             const buffered = this.#bufferedTerminals.splice(0);
+            for (const activity of this.#bufferedActivities.splice(0))
+                this.#emitActivity(activity);
             for (const terminal of buffered)
                 this.#emitTerminal(terminal);
         }
@@ -635,6 +659,11 @@ class CodexStructuredProviderSession {
     #emitTerminal(terminal) {
         this.#completeTerminal(terminal, true);
     }
+    #emitActivity(activity) {
+        const attemptId = this.#turnAttempts.get(activity.nativeTurnId);
+        if (attemptId !== undefined)
+            this.onActivity?.({ ...activity, attemptId });
+    }
     #emitStarted(started) {
         this.onStarted?.({
             ...started,
@@ -642,12 +671,12 @@ class CodexStructuredProviderSession {
         });
     }
     #completeTerminal(terminal, emit) {
-        const clientOwned = terminal.nativeTurnId !== undefined
-            && terminal.nativeTurnId === this.#clientOwnedTurnId;
-        const attemptId = clientOwned ? this.#clientOwnedAttemptId : undefined;
+        const attemptId = terminal.nativeTurnId === undefined ? undefined
+            : this.#turnAttempts.get(terminal.nativeTurnId);
+        const clientOwned = attemptId !== undefined;
         if (terminal.nativeTurnId === this.#activeTurnId)
             this.#activeTurnId = undefined;
-        if (clientOwned) {
+        if (terminal.nativeTurnId === this.#clientOwnedTurnId) {
             this.#clientOwnedTurnId = undefined;
             this.#clientOwnedAttemptId = undefined;
         }
@@ -663,6 +692,16 @@ class CodexStructuredProviderSession {
     waitForExit() {
         return this.exit;
     }
+    async cancelTurn(attemptId) {
+        if (this.#clientOwnedAttemptId !== attemptId || this.#clientOwnedTurnId === undefined) {
+            return this.#submissionPending ? "unknown" : "not-active";
+        }
+        const result = await this.runtime.interruptTurn({
+            conversationId: this.conversationId,
+            turnId: this.#clientOwnedTurnId
+        });
+        return result === "interrupted" ? "requested" : result;
+    }
     terminate(signal) {
         terminateProcessGroup(this.child, signal);
     }
@@ -675,7 +714,12 @@ class ClaudeStructuredProviderSession {
     channel;
     onGoal;
     adapterId = "claude";
+    get ownedProcessId() { return this.child.pid; }
     #activeAttemptId;
+    #acceptedAttemptId;
+    #cancelledAttemptId;
+    #seenAssistantIds = new Set();
+    #openToolIds = new Set();
     #resultAttempts = new Map();
     #lastGoalKey;
     constructor(child, exit, processInstanceId, conversationId, channel, onGoal) {
@@ -686,14 +730,30 @@ class ClaudeStructuredProviderSession {
         this.channel = channel;
         this.onGoal = onGoal;
     }
-    static async open(child, exit, processInstanceId, control, onTerminal, onGoal, mirror) {
+    static async open(child, exit, processInstanceId, control, onAccepted, onTerminal, onGoal, onActivity, mirror) {
         const channel = new JsonLineChannel(child, mirror);
         const nativeSessionId = control.nativeSessionId;
         if (nativeSessionId === undefined) {
             throw new Error("Managed Claude launch requires a preallocated native Session id.");
         }
         const session = new ClaudeStructuredProviderSession(child, exit, processInstanceId, nativeSessionId, channel, onGoal);
-        channel.onMessage((message) => session.#receive(message, onTerminal));
+        channel.onMessage((message) => session.#receive(message, onTerminal, onAccepted, onActivity));
+        // This client owns the whole Claude execution process, unlike a Codex
+        // proxy. An exit without a result ends the exact local input as failure,
+        // not as continuing work merely because the supervising Host is alive.
+        void exit.then(result => {
+            const attemptId = session.#activeAttemptId;
+            if (attemptId === undefined)
+                return;
+            session.#activeAttemptId = undefined;
+            onTerminal?.({
+                conversationId: nativeSessionId, nativeSessionId, attemptId,
+                clientOwned: true,
+                status: session.#cancelledAttemptId === attemptId ? "cancelled" : "failed",
+                observedAt: new Date().toISOString(),
+                error: `Owned Provider process exited before a terminal result (code=${result.code}, signal=${result.signal}).`
+            });
+        });
         return session;
     }
     get nativeSessionId() {
@@ -703,9 +763,15 @@ class ClaudeStructuredProviderSession {
         // stream-json result.uuid is a message identity, not an execution identity.
         return undefined;
     }
+    /**
+     * This implementation has no run-configuration observation reader.
+     */
+    get runConfiguration() {
+        return CLAUDE_RUN_CONFIGURATION;
+    }
     async submitTurn(turn) {
         if (this.#activeAttemptId !== undefined) {
-            throw new ProviderTurnRejectedError("Provider Conversation already has an unsettled Turn.", turn.attemptId);
+            throw new ProviderTurnBusyError("Provider Conversation already has an unsettled Turn.", turn.attemptId);
         }
         // Reserve before the pipe write: a fast result can precede its callback.
         // A failed write is ambiguous and must retain the same occupancy.
@@ -723,10 +789,10 @@ class ClaudeStructuredProviderSession {
             throw new ProviderDeliveryUnknownError(`Claude input write did not complete: ${error instanceof Error ? error.message : String(error)}`, turn.attemptId, { cause: error });
         }
         // AgentHost is the sole writer to this dedicated stream-json process.
-        // A completed pipe write is the smallest reliable acceptance boundary;
-        // Claude's later `result` is the matching terminal for this serialized
-        // Turn. Requiring an echoed user-message creates a second, brittle
-        // protocol without improving delivery safety.
+        // A pipe write is transport evidence only. The later result establishes
+        // native acceptance and completion through this exact serialized local
+        // attempt. A main assistant response can confirm acceptance earlier, without
+        // inventing a provider execution id or trusting the echoed user input.
         return Object.freeze({
             attemptId: turn.attemptId,
             conversationId: this.conversationId,
@@ -738,13 +804,20 @@ class ClaudeStructuredProviderSession {
     async steerTurn(turn) {
         throw new ProviderTurnRejectedError("Claude stream-json does not expose an exact native Turn identity for steering.", turn.attemptId);
     }
+    async cancelTurn(attemptId) {
+        if (this.#activeAttemptId !== attemptId)
+            return "not-active";
+        this.#cancelledAttemptId = attemptId;
+        terminateProcessGroup(this.child, "SIGTERM");
+        return "requested";
+    }
     waitForExit() {
         return this.exit;
     }
     terminate(signal) {
         terminateProcessGroup(this.child, signal);
     }
-    #receive(message, onTerminal) {
+    #receive(message, onTerminal, onAccepted, onActivity) {
         const goal = claudeActiveGoal(message, this.conversationId);
         if (goal !== undefined) {
             const key = JSON.stringify(goal === null ? null : {
@@ -757,8 +830,64 @@ class ClaudeStructuredProviderSession {
                 this.onGoal?.(goal);
             }
         }
-        if (message.type === "user")
+        const activity = (id, phase) => {
+            if (this.#activeAttemptId !== undefined)
+                onActivity?.({
+                    conversationId: this.conversationId, nativeSessionId: this.conversationId,
+                    attemptId: this.#activeAttemptId, id, phase, observedAt: new Date().toISOString()
+                });
+        };
+        if (message.type === "user") {
+            if (optionalId(message.session_id) !== this.conversationId || message.parent_tool_use_id != null)
+                return;
+            const body = object(message.message);
+            for (const raw of Array.isArray(body?.content) ? body.content : []) {
+                const block = object(raw), id = optionalId(block?.tool_use_id);
+                if (block?.type === "tool_result" && id !== undefined && this.#openToolIds.delete(id)) {
+                    activity(id, block.is_error === true ? "failed" : "completed");
+                }
+            }
+            return;
+        }
+        if (message.type === "assistant") {
+            if (optionalId(message.session_id) !== this.conversationId
+                || message.parent_tool_use_id != null
+                || object(message.message)?.role !== "assistant")
+                return;
+            const messageId = optionalId(message.uuid);
+            if (messageId === undefined || this.#seenAssistantIds.has(messageId))
+                return;
+            this.#seenAssistantIds.add(messageId);
+            const attemptId = this.#activeAttemptId;
+            if (attemptId === undefined)
+                return;
+            // This dedicated stream has exactly one owned input in flight. Main
+            // assistant output proves it is being processed; init, echo and child
+            // output do not. Keep the local attempt identity, not the message UUID,
+            // as the correlation key (Claude exposes no exact native Turn id).
+            if (this.#acceptedAttemptId !== attemptId) {
+                this.#acceptedAttemptId = attemptId;
+                onAccepted?.({
+                    attemptId,
+                    conversationId: this.conversationId,
+                    nativeSessionId: this.conversationId,
+                    acceptedAt: new Date().toISOString(),
+                    acceptance: "provider"
+                });
+            }
+            const body = object(message.message);
+            for (const raw of Array.isArray(body?.content) ? body.content : []) {
+                const block = object(raw), id = optionalId(block?.id);
+                if (block?.type === "tool_use" && id !== undefined && !this.#openToolIds.has(id)) {
+                    this.#openToolIds.add(id);
+                    activity(id, "started");
+                }
+                else if (block?.type === "text" || block?.type === "thinking") {
+                    activity(messageId, "model");
+                }
+            }
             return;
+        }
         if (message.type !== "result"
             || optionalId(message.session_id) !== this.conversationId)
             return;
@@ -772,12 +901,14 @@ class ClaudeStructuredProviderSession {
             return;
         if (resultId !== undefined)
             this.#resultAttempts.set(resultId, attemptId);
-        if (attemptId === this.#activeAttemptId)
+        if (attemptId === this.#activeAttemptId) {
             this.#activeAttemptId = undefined;
+            this.#openToolIds.clear();
+        }
         const failed = message.is_error === true || message.subtype === "error_during_execution";
         const result = typeof message.result === "string" && message.result.length > 0
             ? message.result
-            : "Provider Turn failed.";
+            : providerErrorEvidence(message).error;
         onTerminal?.({
             conversationId: this.conversationId,
             nativeSessionId: this.conversationId,
@@ -861,21 +992,6 @@ function childExit(child, processInstanceId) {
         })));
     });
 }
-function terminateProcessGroup(child, signal) {
-    if (child.pid === undefined)
-        return;
-    // Managed Providers are spawned detached and therefore own a process group.
-    // Kill that exact group so a CLI helper cannot outlive the Agent Host. The
-    // direct-child fallback covers embedded runtimes that cannot create setsid.
-    try {
-        process.kill(-child.pid, signal);
-    }
-    catch (error) {
-        if (error.code !== "ESRCH")
-            throw error;
-        child.kill(signal);
-    }
-}
 function defaultMirrorOutput(stream, text) {
     (stream === "stdout" ? process.stdout : process.stderr).write(text);
 }
@@ -895,10 +1011,14 @@ function nestedId(value, key) {
 }
 function providerErrorEvidence(value) {
     const error = object(value);
+    const errors = Array.isArray(error?.errors)
+        ? error.errors.filter((entry) => typeof entry === "string" && entry.length > 0)
+        : [];
     const message = typeof error?.message === "string" && error.message.length > 0
         ? error.message
-        : typeof value === "string" && value.length > 0
-            ? value
-            : "Provider Turn failed.";
+        : errors.length > 0 ? errors.join("\n")
+            : typeof value === "string" && value.length > 0
+                ? value
+                : "Provider Turn failed.";
     return { error: message, rawError: serializeAgentErrorRaw(value) };
 }