@jskit-ai/assistant-core 0.1.204 → 0.1.206

package/src/server/conversation/providers/claudeDriver.js

@@ -271,6 +271,19 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
     async createConversation({ native, input, context }) {
       return native.owner.createConversation(input, { context, acquire: native.owner.acquire });
     },
+    async runDetachedConversation({ native, input, context }) {
+      const conversationId = input.conversationId || input.threadId || randomUUID();
+      const created = !input.conversationId && !input.threadId;
+      const { owner } = native;
+      const entry = await owner.acquire(context, conversationId, { create: created });
+      const executionProfile = native.executionProfile;
+      if (created && context.assistantScope) entry.profile = executionProfile;
+      if (executionProfile) await context.onEvent?.({ type: "execution-profile", executionProfile });
+      const request = { ...input, conversationId };
+      await owner.startTurn(await owner.acquire(context, conversationId, { operation: "start", input: request }), request);
+      const result = await owner.wait(await owner.acquire(context, conversationId), request, { context, acquire: owner.acquire });
+      return executionProfile ? { ...result, executionProfile } : result;
+    },
     async createBinding() {
       return { conversationId: randomUUID(), workdir: await realpath(workdir), configRoot, executionId: "", sent: false };
     },

package/src/server/conversation/providers/codex.js

@@ -41,8 +41,13 @@ export function createCodexConversationAdapter(host) {
     const previous = tasks.get(threadId) || Promise.resolve();
     const task = previous.catch(() => null).then(() => host.runRequest(async () => {
       const client = await host.client();
-      params = await prepareInstructions(params, threadId);
       const generation = contextGeneration;
+      const bound = bindings.get(threadId);
+      const requestedParams = params;
+      const retainInstalledInstructions = bound?.params.developerInstructions != null && !params.ephemeral && !bound.params.ephemeral;
+      params = await prepareInstructions(retainInstalledInstructions
+        ? { ...params, systemPrompt: undefined, developerInstructions: bound.params.developerInstructions }
+        : params, threadId);
       const signal = AbortSignal.timeout(host.timeoutMs || 10_000);
       const assertRecoveryOpen = () => {
         signal.throwIfAborted();
@@ -54,7 +59,6 @@ export function createCodexConversationAdapter(host) {
         assertRecoveryOpen();
         return client.request(method, input, { signal });
       };
-      const bound = bindings.get(threadId);
       const fixedPolicy = params.config?.shell_environment_policy ||
         (bound?.managed === false ? bound.params.config.shell_environment_policy : null);
       if (fixedPolicy && (params.developerInstructions == null || params.ephemeral || bound?.params.ephemeral)) {
@@ -63,7 +67,7 @@ export function createCodexConversationAdapter(host) {
         }
         return operation(threadParameters({ ...bound?.params, ...params }, {}));
       }
-      const environment = instructionEnvironment(params, fixedPolicy?.set || await host.prepareEnvironment(
+      let environment = instructionEnvironment(params, fixedPolicy?.set || await host.prepareEnvironment(
         bound?.params?.config?.shell_environment_policy?.set || host.environment || {}
       ));
       const previousConfig = { ...bound?.params?.config };
@@ -94,7 +98,7 @@ export function createCodexConversationAdapter(host) {
         nativeHistoryPath = thread?.path || "";
         return typeof thread?.status === "string" ? thread.status : thread?.status?.type;
       };
-      const nativeStatus = await readStatus();
+      let nativeStatus = await readStatus();
       if (!bound && !requestParams.modelProvider && nativeModelProvider) {
         // A restored observer has no saved request parameters. Recover the
         // native thread's provider configuration before resuming its controls.
@@ -122,14 +126,29 @@ export function createCodexConversationAdapter(host) {
           processChanged: Boolean(bound?.executionId)
         }) || requestParams;
       }
-      const bindingMatches = !providerChanged && bound?.client === client &&
+      let bindingMatches = !providerChanged && bound?.client === client &&
         bound.params.developerInstructions === requestParams.developerInstructions &&
         bound.params.config.openai_base_url === requestParams.config.openai_base_url &&
         JSON.stringify(bound.params.config.model_providers) === JSON.stringify(requestParams.config.model_providers) &&
         Object.keys(requestParams.config).filter((key) => key.startsWith("model_providers.")).every((key) =>
           JSON.stringify(bound.params.config[key]) === JSON.stringify(requestParams.config[key])) &&
         JSON.stringify(bound.params.config.shell_environment_policy) === JSON.stringify(requestParams.config.shell_environment_policy);
-      const instructionsChanged = requestParams.developerInstructions != null &&
+      const controlBindingMatches = bindingMatches;
+      const installedRequestParams = requestParams;
+      if (retainInstalledInstructions && (!bindingMatches || nativeStatus !== "active")) {
+        // An active healthy turn keeps its installed prompt. Real control
+        // recovery and the next idle admission still read current instructions.
+        params = await prepareInstructions(requestedParams, threadId);
+        environment = instructionEnvironment(params, environment);
+        requestParams = { ...requestParams,
+          ...(Object.hasOwn(params, "developerInstructions") ? { developerInstructions: params.developerInstructions } : {}),
+          config: { ...requestParams.config, shell_environment_policy: { ...requestParams.config.shell_environment_policy, set: environment } }
+        };
+        bindingMatches = bindingMatches && bound.params.developerInstructions === requestParams.developerInstructions &&
+          JSON.stringify(bound.params.config.shell_environment_policy) === JSON.stringify(requestParams.config.shell_environment_policy);
+      }
+      const instructionOnly = retainInstalledInstructions && controlBindingMatches && !bindingMatches;
+      let instructionsChanged = requestParams.developerInstructions != null &&
         instructionPrompts.get(threadId) !== requestParams.developerInstructions;
       let pausedGoal = null;
       let resumed = null;
@@ -138,6 +157,16 @@ export function createCodexConversationAdapter(host) {
         goal.createdAt === original.createdAt && goal.objective === original.objective;
       const log = (event, fields = {}) => host.log?.(event, fields, { threadId, environment });
       try {
+        if (instructionOnly) {
+          // A native goal can start work while the host reads its prompt.
+          nativeStatus = await readStatus();
+          if (nativeStatus === "active") {
+            requestParams = installedRequestParams;
+            environment = requestParams.config.shell_environment_policy.set;
+            bindingMatches = true;
+            instructionsChanged = false;
+          }
+        }
         if (!bindingMatches || nativeStatus === "notLoaded") {
           log("reload_started", { reason: bound ? "control-environment-changed" : "unverified-thread-binding", nativeStatus });
           if (nativeStatus !== "notLoaded") {
@@ -150,57 +179,71 @@ export function createCodexConversationAdapter(host) {
               }
             }
             if (await readStatus() !== "idle") {
-              const page = await request("thread/turns/list", { threadId, limit: 1, sortDirection: "desc", itemsView: "summary" });
-              const turnId = page.data?.[0]?.id;
-              if (!turnId) throw new Error("Codex's running turn could not be identified for control recovery.");
-              await request("turn/interrupt", { threadId, turnId });
-              while (await readStatus() !== "idle") {
-                signal.throwIfAborted();
-                await new Promise((resolve) => setTimeout(resolve, 25));
+              if (instructionOnly) {
+                // Never interrupt work solely to refresh its instructions.
+                requestParams = installedRequestParams;
+                environment = requestParams.config.shell_environment_policy.set;
+                bindingMatches = true;
+                instructionsChanged = false;
+              } else {
+                const page = await request("thread/turns/list", { threadId, limit: 1, sortDirection: "desc", itemsView: "summary" });
+                const turnId = page.data?.[0]?.id;
+                if (!turnId) throw new Error("Codex's running turn could not be identified for control recovery.");
+                assertRecoveryOpen();
+                host.recordInterruption?.(threadId, turnId);
+                await request("turn/interrupt", { threadId, turnId });
+                while (await readStatus() !== "idle") {
+                  signal.throwIfAborted();
+                  await new Promise((resolve) => setTimeout(resolve, 25));
+                }
               }
             }
             if (pausedGoal) {
               const { goal } = await request("thread/goal/get", { threadId });
               pausedGoal = isSamePausedGoal(goal, pausedGoal) ? goal : null;
             }
-            const detached = await request("thread/unsubscribe", { threadId });
-            if (!["unsubscribed", "notSubscribed", "notLoaded"].includes(detached?.status)) {
-              throw new Error("Codex did not confirm detachment before control recovery.");
+            if (!bindingMatches) {
+              const detached = await request("thread/unsubscribe", { threadId });
+              if (!["unsubscribed", "notSubscribed", "notLoaded"].includes(detached?.status)) {
+                throw new Error("Codex did not confirm detachment before control recovery.");
+              }
             }
           }
-          bindings.delete(threadId);
-          await host.beforeResume?.(threadId);
-          resumed = await request("thread/resume", { excludeTurns: true, ...requestParams, threadId });
-          if (requestParams.modelProvider && resumed.modelProvider !== requestParams.modelProvider) {
-            throw Object.assign(new Error("Another native subscriber retained the previous model provider. Close the native assistant terminal and retry."), {
-              code: "assistant_codex_provider_binding_retained"
-            });
-          }
-          if (!["idle", "active"].includes(await readStatus())) throw new Error("Codex did not confirm the thread loaded.");
-          if (nativeStatus !== "notLoaded") {
-            await host.verifyEnvironment(threadId, environment, request, signal, {
-              requiredKeys: requestParams.developerInstructions == null ? [] : [INSTRUCTION_REVISION_ENV]
-            });
-          }
-          const checked = fixedPolicy ? environment : instructionEnvironment(params, await host.prepareEnvironment(environment));
-          if (JSON.stringify(checked) !== JSON.stringify(environment)) {
-            throw new Error("Managed controls changed again during thread recovery.");
-          }
-          if (instructionsChanged) {
-            // Resume config supplies the next compacted context, but existing
-            // history retains its original developer message. A revision in
-            // the developer lane makes this change effective before new work.
-            // An unknown binding also needs restoration; ordinary turns and
-            // socket reconnects with an acknowledged binding do not repeat it.
-            await request("thread/inject_items", { threadId, items: [{ type: "message", role: "developer", content: [{
-              type: "input_text", text: "These are the current application instructions. They replace earlier application instructions; other instructions remain in effect.\n\n" + requestParams.developerInstructions
-            }] }] });
+          if (!bindingMatches || nativeStatus === "notLoaded") {
+            bindings.delete(threadId);
+            await host.beforeResume?.(threadId);
+            resumed = await request("thread/resume", { excludeTurns: true, ...requestParams, threadId });
+            if (requestParams.modelProvider && resumed.modelProvider !== requestParams.modelProvider) {
+              throw Object.assign(new Error("Another native subscriber retained the previous model provider. Close the native assistant terminal and retry."), {
+                code: "assistant_codex_provider_binding_retained"
+              });
+            }
+            if (!["idle", "active"].includes(await readStatus())) throw new Error("Codex did not confirm the thread loaded.");
+            if (nativeStatus !== "notLoaded") {
+              await host.verifyEnvironment(threadId, environment, request, signal, {
+                requiredKeys: requestParams.developerInstructions == null ? [] : [INSTRUCTION_REVISION_ENV]
+              });
+            }
+            const checked = fixedPolicy ? environment : instructionEnvironment(params, await host.prepareEnvironment(environment));
+            if (JSON.stringify(checked) !== JSON.stringify(environment)) {
+              throw new Error("Managed controls changed again during thread recovery.");
+            }
+            if (instructionsChanged) {
+              // Resume config supplies the next compacted context, but existing
+              // history retains its original developer message. A revision in
+              // the developer lane makes this change effective before new work.
+              // An unknown binding also needs restoration; ordinary turns and
+              // socket reconnects with an acknowledged binding do not repeat it.
+              await request("thread/inject_items", { threadId, items: [{ type: "message", role: "developer", content: [{
+                type: "input_text", text: "These are the current application instructions. They replace earlier application instructions; other instructions remain in effect.\n\n" + requestParams.developerInstructions
+              }] }] });
+              assertRecoveryOpen();
+              instructionPrompts.set(threadId, requestParams.developerInstructions);
+            }
             assertRecoveryOpen();
-            instructionPrompts.set(threadId, requestParams.developerInstructions);
+            bindings.set(threadId, { client, executionId, params: requestParams, managed: !fixedPolicy });
+            log("ready");
           }
-          assertRecoveryOpen();
-          bindings.set(threadId, { client, executionId, params: requestParams, managed: !fixedPolicy });
-          log("ready");
         }
       } catch (cause) {
         host.onRecoveryFailure?.(threadId);

package/src/server/conversation/providers/codexDriver.js

@@ -214,6 +214,9 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
     async createConversation({ sessionId, native, input, context }) {
       return native.runOwner.createConversation(sessionId, input, context);
     },
+    async runDetachedConversation({ sessionId, native, input, options }) {
+      return native.runOwner.runDetachedConversation(sessionId, input, options);
+    },
     async createBinding() {
       return { threadId: "", workdir: await realpath(workdir), configRoot, executionId: "" };
     },
@@ -452,7 +455,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             },
             complete: completeObservation
           }
-        }));
+        }), providerKey, providerOptions);
       }
 
       async function stop() {

package/src/server/conversation/providers/opencodeDriver.js

@@ -109,6 +109,9 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
     async createConversation({ native, input, context }) {
       return native.owner.createPreparedConversation(await native.preparation.creation(input, context));
     },
+    async runDetachedConversation({ native, input, options }) {
+      return native.owner.runPreparedConversationTurn(await native.preparation.turn(input, options));
+    },
     async createBinding() {
       const directory = path.join(stateDirectory, randomUUID());
       await mkdir(directory, { recursive: true, mode: 0o700 });

package/src/server/conversation/runtime.js

@@ -1497,11 +1497,12 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       return entry.conversation.commands.select(input, context);
     }
     if (entry.conversation?.native?.scoped) throw failure("This scoped conversation retains its original selected profile.", "conversation_unsupported");
-    const keys = selection ? ["operationId", "expectedSegmentId", "engine", "configuration"]
+    const keys = selection ? ["operationId", "expectedSegmentId", "engine", "configuration", "retireNative"]
       : ["operationId", "expectedSegmentId", "reason", "engine", "configuration", "briefing"];
     if (!input || !/^[\w-]{1,128}$/u.test(input.operationId || "") || typeof input.expectedSegmentId !== "string" ||
         !input.expectedSegmentId || (selection ? typeof input.engine !== "string" : !["engine-change", "model-change", "renewal"].includes(input.reason)) ||
         input.briefing !== undefined && typeof input.briefing !== "string" ||
+        input.retireNative !== undefined && typeof input.retireNative !== "boolean" ||
         Object.keys(input).some(key => !keys.includes(key))) {
       throw failure("Replacement needs an operationId, exact predecessor segment, and an engine-change, model-change or renewal reason.", "conversation_invalid_replacement", 400);
     }
@@ -1569,7 +1570,9 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     const predecessorId = nativeIdentity(state);
     const nativeReplacement = !selection && state.engine !== "api" && predecessorId &&
       (state.engine !== "claude" || state.binding.sent);
-    if (selection && engine !== "api" && engine === state.engine && !pending) {
+    const retainNativeBinding = input.retireNative !== true && engine === state.engine &&
+      (engine !== "opencode" || configuration.integrationId === state.configuration.integrationId);
+    if (selection && engine !== "api" && retainNativeBinding && !pending) {
       // The production native owners apply compatible settings to the running
       // conversation themselves. Selecting a model is not process retirement.
       await storage.write(entry.id, async transaction => {
@@ -1587,8 +1590,14 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     }
     if (!pending) {
       const history = (await readTranscript(entry)).filter(turn => !turn.metadata?.runtime?.supersededBy);
-      const destination = selection ? state.engine === engine ? state
-        : driver.createBinding ? retainedSegments(state).findLast(segment => segment.engine === engine) : null : null;
+      let destination = null;
+      if (selection) {
+        if (retainNativeBinding) destination = state;
+        else if (input.retireNative !== true && engine !== state.engine && driver.createBinding) {
+          destination = retainedSegments(state).findLast(segment => segment.engine === engine &&
+            (engine !== "opencode" || segment.configuration.integrationId === configuration.integrationId));
+        }
+      }
       if (engine !== "api" && (input.briefing || "").length > maximumContinuity) throw new Error("The continuity briefing exceeds the configured history budget.");
       const continuity = destination ? { text: destination.continuity, attachments: destination.continuityAttachments || [] }
         : engine === "api" ? conversationContinuity({ history, briefing: input.briefing, maximumCharacters: maximumContinuity })
@@ -1660,7 +1669,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
               if (value) {
                 if (engine !== "api") state.seen = value.engines[engine].seen;
                 state.lastEngine = value.lastEngine;
-              } else if (!selection && engine !== "api") state.lastEngine = "";
+              } else if (engine !== "api" &&
+                  (!selection || input.retireNative === true || engine === "opencode" && !pending.binding.sessionId)) {
+                state.lastEngine = "";
+              }
               delete state.replacement;
               await transaction.writeMetadata(metadata);
             }
@@ -1881,6 +1893,21 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       }
       return createDriver(prepared.engine, defaultHost).createConversation(prepared);
     },
+    async runNativeDetachedConversation({ id, context, input = {}, options } = {}) {
+      if (typeof id !== "string" || !id.trim()) throw new TypeError("A parent conversation or scope id is required.");
+      await access(context, id, "runDetachedConversation");
+      if (typeof defaultHost?.conversation !== "function") {
+        throw new TypeError("Native detached execution requires a configured conversation host.");
+      }
+      const prepared = await defaultHost.conversation({ id, context, input,
+        ...(options === undefined ? {} : { options }), operation: "runDetachedConversation" });
+      if (closed) throw failure("This conversation runtime is closed.", "conversation_closed");
+      if (prepared?.sessionId !== id || !["codex", "claude", "opencode"].includes(prepared.engine) || !prepared.native ||
+          !Object.hasOwn(prepared, "input") || !Object.hasOwn(prepared, "context") || !Object.hasOwn(prepared, "options")) {
+        throw new TypeError("Native detached execution requires its authorized host preparation.");
+      }
+      return createDriver(prepared.engine, defaultHost).runDetachedConversation(prepared);
+    },
     async open({ id, context, configuration, engine, host, representation = "canonical" } = {}) {
       if (typeof id !== "string" || !id.trim()) throw new TypeError("A conversation id is required.");
       await access(context, id, "open");

package/src/server/hosts/codexEvents.js

@@ -1,4 +1,19 @@
 export {
+  classifyCodexAppServerEvent,
+  codexAppServerAssistantItemText,
+  codexAppServerContentText,
+  codexAppServerErrorText,
+  codexAppServerNotificationError,
+  codexAppServerNotificationEventPayload,
+  codexAppServerNotificationEventType,
+  codexAppServerNotificationItem,
+  codexAppServerNotificationParams,
+  codexAppServerNotificationThreadId,
+  codexAppServerNotificationTurnStatus,
+  codexAppServerNotificationUsageLimitExceeded,
+  codexAppServerOutputOwnerTurnId,
+  codexAppServerStatusFromValue,
+  codexAppServerUserMessageText,
   codexContextUsageFromNotification,
   codexAppServerContextRefreshReason,
   codexAppServerNotificationEvent,

package/src/server/hosts/codexTurn.js

@@ -1,4 +1,9 @@
 export {
+  codexAppServerTurnStatusIsActive,
+  codexAppServerTurnStatusIsComplete,
+  codexAppServerTurnStatusIsProviderFailure,
+  codexAppServerTurnStatusIsSuccessfulComplete,
+  createCodexAppServerDetachedTurnWatcher,
   codexAppServerAgentRun,
   codexAppServerConversationTurnIsActive,
   codexAppServerFrozenTurnInterruptResponse,

package/src/server/hosts/openCodeClient.js

@@ -1,3 +1,7 @@
 export {
+  OPENCODE_RESPONSE_LIMIT_BYTES,
+  createOpenCodeServerClient,
+  openCodeAssistantMessageText,
+  readBoundedResponse,
   retireOpenCodeConversationHistory
 } from "../conversation/openCodeClient.js";

package/src/server/lib/aiConnectionClient.js

@@ -1,4 +1,4 @@
-import { generateText, jsonSchema, streamText } from "ai";
+import { generateText, jsonSchema, NoSuchToolError, streamText } from "ai";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createAnthropic } from "@ai-sdk/anthropic";
@@ -47,7 +47,7 @@ function sdkMessages(messages) {
 }
 
 /** Accept only the server-side result of an authorized AI connection resolver. */
-export function createAiConnectionClient(connection, { fetch, timeoutMs = 120_000, maxOutputTokens, effort } = {}) {
+export function createAiConnectionClient(connection, { fetch, timeoutMs = 120_000, maxOutputTokens, effort, reportUnavailableToolCalls = false } = {}) {
   if (!connection?.apiKey || !connection.model || !Object.hasOwn(providers, connection.sdkPackage)) {
     throw new TypeError("An authorized AI connection with a supported SDK and model is required.");
   }
@@ -75,23 +75,21 @@ export function createAiConnectionClient(connection, { fetch, timeoutMs = 120_00
     async *createChatCompletionStream(input) {
       const result = streamText({ ...options(input), onError() {} });
       let toolIndex = 0;
-      let failure;
       for await (const part of result.fullStream) {
-        // Let the SDK settle its stream before reporting a rejected tool call.
-        // Cancelling this iterator mid-step leaves its completion unresolved.
-        if (part.type === "error" || (part.type === "tool-call" && part.invalid)) {
-          failure ||= part.error || new Error("The model returned an invalid tool call.");
-        }
-        if (part.type === "abort") failure ||= input?.signal?.reason || new Error("Assistant request was aborted.");
-        if (failure) continue;
+        if (part.type === "error") throw part.error;
+        if (part.type === "abort") throw input?.signal?.reason || new Error("Assistant request was aborted.");
         if (part.type === "text-delta") yield { choices: [{ delta: { content: part.text } }] };
         if (part.type === "finish") yield { choices: [{ delta: {}, finish_reason: part.finishReason }], usage: part.totalUsage };
         if (part.type === "tool-call") {
+          // Only the application catalogue can reject an unavailable action
+          // and persist its no-effect receipt. Other invalid calls stay errors.
+          const unavailable = reportUnavailableToolCalls === true && NoSuchToolError.isInstance(part.error) &&
+            !part.providerExecuted && part.input !== null && typeof part.input === "object" && !Array.isArray(part.input);
+          if (part.invalid && !unavailable) throw part.error;
           yield { choices: [{ delta: { tool_calls: [{ index: toolIndex++, id: part.toolCallId,
             function: { name: part.toolName, arguments: JSON.stringify(part.input) } }] } }] };
         }
       }
-      if (failure) throw failure;
     }
   });
 }

package/test/aiConnectionClient.test.js

@@ -159,3 +159,212 @@ test("authorized image bytes use the selected provider protocol", async () => {
   ] }] }));
   assert.equal(chunks[0].choices[0].delta.content, "An image");
 });
+
+test("SDK streaming rejects its first provider failure before EOF without exposing later output", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch(url, options) {
+      requests++;
+      assert.equal(String(url), "https://opencode.ai/zen/v1/chat/completions");
+      assert.equal(new Headers(options.headers).get("authorization"), "Bearer public");
+      assert.equal(JSON.parse(options.body).tools[0].function.name, "lookup");
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const tools = [{ type: "function", function: { name: "lookup", parameters: {
+    type: "object", properties: { query: { type: "string" } }, required: ["query"]
+  } } }];
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Find records" }], tools });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "Before failure" } }] });
+  assert.deepEqual((await first).value, { choices: [{ delta: { content: "Before failure" } }] });
+  let settled = false;
+  const ending = iterator.next().then(
+    result => { settled = true; return { result }; },
+    error => { settled = true; return { error }; }
+  );
+  const firstFailure = { message: "First provider failure", code: "FIRST_FAILURE" };
+  await send({ error: firstFailure });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the original provider failure rejects before any late output or transport EOF");
+  await send({ choices: [{ index: 0, delta: { content: "Must not be exposed" } }] });
+  await send({ choices: [{ index: 0, delta: { tool_calls: [
+    { index: 0, id: "late_call", type: "function", function: { name: "lookup", arguments: '{"query":"records"}' } }
+  ] } }] });
+  await send({ error: { message: "Later provider failure", code: "LATER_FAILURE" } });
+  await send({ choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+    usage: { prompt_tokens: 3, completion_tokens: 4, total_tokens: 7 } });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the original provider failure rejects before transport EOF");
+  await writer.close();
+  const outcome = await ending;
+  assert.equal(outcome.error?.name, "AI_StreamProviderError");
+  assert.equal(outcome.error.message, firstFailure.message);
+  assert.equal(outcome.error.code, firstFailure.code);
+  assert.deepEqual(outcome.error.data, firstFailure, "a later provider error must not replace the first failure");
+  assert.equal(outcome.result, undefined, "late text, tool calls, finish and usage never become a yielded chunk");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1, "draining a failed stream must not retry or start a tool round");
+});
+
+test("SDK streaming rejects the first invalid tool input without yielding later calls or completion", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch() {
+      requests++;
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const tools = [{ type: "function", function: { name: "lookup", parameters: {
+    type: "object", properties: { query: { type: "string" } }, required: ["query"]
+  } } }];
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Find records" }], tools });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "Before tool validation" } }] });
+  assert.equal((await first).value.choices[0].delta.content, "Before tool validation");
+  const ending = iterator.next().then(result => ({ result }), error => ({ error }));
+  // The compatible adapter flushes these calls at EOF; malformed JSON reaches
+  // the SDK's invalid-input branch rather than relying on schema validation.
+  await send({ choices: [{ index: 0, delta: { tool_calls: [
+    { index: 0, id: "invalid_first", type: "function", function: { name: "lookup", arguments: '{"query":}' } },
+    { index: 1, id: "invalid_later", type: "function", function: { name: "lookup", arguments: '{"later":}' } },
+    { index: 2, id: "valid_later", type: "function", function: { name: "lookup", arguments: '{"query":"records"}' } }
+  ] }, finish_reason: "tool_calls" }], usage: { prompt_tokens: 3, completion_tokens: 4, total_tokens: 7 } });
+  await writer.close();
+  const outcome = await ending;
+  assert.equal(outcome.error?.name, "AI_InvalidToolInputError");
+  assert.equal(outcome.error.toolName, "lookup");
+  assert.equal(outcome.error.toolInput, '{"query":}', "the second invalid call cannot replace the first error");
+  assert.equal(outcome.result, undefined, "invalid and later valid calls, finish and usage remain unexposed");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1);
+});
+
+test("SDK cancellation after its first text retains the original reason and suppresses later output", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  const abort = new AbortController();
+  const reason = new Error("Stopped after the first text");
+  let requestSignal;
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch(_url, options) {
+      requests++;
+      requestSignal = options.signal;
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hello" }], signal: abort.signal });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "First text" } }] });
+  assert.equal((await first).value.choices[0].delta.content, "First text");
+  const ending = iterator.next().then(result => ({ result }), error => ({ error }));
+  abort.abort(reason);
+  assert.equal(requestSignal.aborted, true);
+  assert.equal(requestSignal.reason, reason);
+  // Fetch remains controlled: let the real SDK observe abort while consuming
+  // the response, then finish the transport instead of replacing its runner.
+  await send({ choices: [{ index: 0, delta: { content: "Late text" } }] });
+  await send({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+    usage: { prompt_tokens: 1, completion_tokens: 2, total_tokens: 3 } });
+  await writer.close();
+  const outcome = await ending;
+  assert.equal(outcome.error, reason);
+  assert.equal(outcome.result, undefined, "abort after text cannot publish later text, finish or usage");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1);
+});
+
+test("SDK streaming retains its immediate provider failure when the later transport fails", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch() {
+      requests++;
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hello" }] });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "Before failure" } }] });
+  assert.equal((await first).value.choices[0].delta.content, "Before failure");
+  let settled = false;
+  const ending = iterator.next().then(
+    result => { settled = true; return { result }; },
+    error => { settled = true; return { error }; }
+  );
+  const firstFailure = { message: "First provider failure", code: "FIRST_FAILURE" };
+  await send({ error: firstFailure });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the first failure rejects before the later transport error");
+  await send({ choices: [{ index: 0, delta: { content: "Late text after rejection" } }] });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the original provider failure rejects without waiting for later transport failure");
+  const lateTransportError = new Error("Late transport drain failure");
+  await writer.abort(lateTransportError);
+  const outcome = await ending;
+  assert.notEqual(outcome.error, lateTransportError, "transport drain failure must not replace the observed provider failure");
+  assert.equal(outcome.error?.name, "AI_StreamProviderError");
+  assert.equal(outcome.error.message, firstFailure.message);
+  assert.equal(outcome.error.code, firstFailure.code);
+  assert.deepEqual(outcome.error.data, firstFailure);
+  assert.equal(outcome.result, undefined, "late text and transport failure do not publish another chunk");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1);
+});
+
+
+test("only explicit application-catalogue mode reports well-formed unavailable tool calls", async () => {
+  const toolCall = argumentsText => ({ choices: [{ index: 0, delta: { tool_calls: [
+    { index: 0, id: "unavailable-call", type: "function", function: { name: "unavailable_action", arguments: argumentsText } }
+  ] }, finish_reason: "tool_calls" }] });
+  const connection = await publicConnection();
+  for (const [reportUnavailableToolCalls, argumentsText] of [
+    [false, '{"value":"must not execute"}'], [true, '{"value":}'], [true, 'null'], [true, '[]'], [true, '"text"']
+  ]) {
+    let requests = 0;
+    const client = createAiConnectionClient(connection, { reportUnavailableToolCalls,
+      async fetch() { requests++; return eventsResponse([toolCall(argumentsText)]); }
+    });
+    await assert.rejects(Array.fromAsync(client.createChatCompletionStream({
+      messages: [{ role: "user", content: "Check without changing anything" }], tools: []
+    })), error => error.name === "AI_NoSuchToolError" && error.toolName === "unavailable_action");
+    assert.equal(requests, 1, "unavailable validation must not trigger an inference retry");
+  }
+  const invalidKnown = createAiConnectionClient(connection, { reportUnavailableToolCalls: true,
+    async fetch() { return eventsResponse([{ choices: [{ index: 0, delta: { tool_calls: [
+      { index: 0, id: "invalid-known", type: "function", function: { name: "lookup", arguments: '{"query":}' } }
+    ] }, finish_reason: "tool_calls" }] }]); }
+  });
+  await assert.rejects(Array.fromAsync(invalidKnown.createChatCompletionStream({
+    messages: [{ role: "user", content: "Find records" }],
+    tools: [{ type: "function", function: { name: "lookup", parameters: {
+      type: "object", properties: { query: { type: "string" } }, required: ["query"]
+    } } }]
+  })), error => error.name === "AI_InvalidToolInputError" && error.toolName === "lookup");
+  let requests = 0;
+  const client = createAiConnectionClient(connection, { reportUnavailableToolCalls: true,
+    async fetch() { requests++; return eventsResponse([toolCall('{"value":"must not execute"}')]); }
+  });
+  const chunks = await Array.fromAsync(client.createChatCompletionStream({
+    messages: [{ role: "user", content: "Check without changing anything" }], tools: []
+  }));
+  assert.deepEqual(chunks.flatMap(chunk => chunk.choices[0].delta.tool_calls || []), [{
+    index: 0, id: "unavailable-call", function: { name: "unavailable_action", arguments: '{"value":"must not execute"}' }
+  }]);
+  assert.equal(chunks.at(-1).choices[0].finish_reason, "tool-calls");
+  assert.equal(requests, 1, "reporting the attempted call neither executes an action nor starts another request");
+});