@jskit-ai/assistant-core 0.1.205 → 0.1.206

package/src/server/conversation/openCodeTurn.js

@@ -340,7 +340,7 @@ export async function waitForOpenCodeMessages(client, conversationId = "", input
     if (result?.complete && (await client.sessionStatus(conversationId, { signal })).type === "idle" &&
         expectedInputMessageId === text(resolveInputMessageId())) {
       if (completedInputMessageId === expectedInputMessageId) {
-        return { messages, result };
+        return { messages, result, inputMessageId: expectedInputMessageId };
       }
       completedInputMessageId = expectedInputMessageId;
     } else {
@@ -353,18 +353,34 @@ export async function waitForOpenCodeMessages(client, conversationId = "", input
 export async function waitForOpenCodeFinalResponse(client, conversationId, turn, {
   agent, model, recoveryMessageId, beforeRecovery = null, ...options
 } = {}) {
-  const waitForCompletion = () => waitForOpenCodeMessages(
-    client, conversationId, () => turn.inputMessageId, options
-  );
-  let completion = await waitForCompletion();
-  // Work around https://github.com/anomalyco/opencode/issues/37073. Some
-  // reasoning models finish successfully without emitting a text part.
-  if (
-    !turn.interruptRequested &&
-    !completion.result?.error &&
-    !text(completion.result?.text)
-  ) {
+  const waitForCompletion = async () => {
+    for (;;) {
+      const completion = await waitForOpenCodeMessages(
+        client, conversationId, () => turn.inputMessageId, options
+      );
+      // Keep native polling/progress live while an admitted input's local
+      // commit is pending, but do not accept its terminal result yet.
+      const admission = turn.admission;
+      await admission?.promise;
+      options.signal?.throwIfAborted();
+      if (admission !== turn.admission || completion.inputMessageId !== text(turn.inputMessageId)) {
+        continue;
+      }
+      return completion;
+    }
+  };
+  for (;;) {
+    const completion = await waitForCompletion();
+    // Work around https://github.com/anomalyco/opencode/issues/37073. Some
+    // reasoning models complete successfully without a user-facing text part.
+    if (turn.interruptRequested || completion.result?.error || text(completion.result?.text)) return completion;
     await beforeRecovery?.(completion);
+    const admission = turn.admission;
+    await admission?.promise;
+    options.signal?.throwIfAborted();
+    if (admission !== turn.admission || completion.inputMessageId !== text(turn.inputMessageId)) {
+      continue;
+    }
     const admitted = await client.prompt(conversationId, {
       agent,
       delivery: "queue",
@@ -375,11 +391,12 @@ export async function waitForOpenCodeFinalResponse(client, conversationId, turn,
       },
       resume: true
     }, { signal: options.signal });
-    turn.inputMessageId = text(admitted?.id) || recoveryMessageId;
-    turn.updatedAt = new Date().toISOString();
-    completion = await waitForCompletion();
+    if (admission === turn.admission && completion.inputMessageId === text(turn.inputMessageId)) {
+      turn.inputMessageId = text(admitted?.id) || recoveryMessageId;
+      turn.updatedAt = new Date().toISOString();
+    }
+    return waitForCompletion();
   }
-  return completion;
 }
 
 // Production detached-turn lifetime. Applications project the completed native

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

@@ -69,6 +69,7 @@ export function createApiConversationDriver({ connections, apiClientFactory, fet
           const connection = await connections.resolve({ context, integrationId: configuration.integrationId });
           validateConnectionModel(configuration, connection);
           client = createAiConnectionClient(connection, { fetch, effort: configuration.effort,
+            reportUnavailableToolCalls: Boolean(tools),
             maxOutputTokens: limits.maxOutputTokens, timeoutMs: limits.timeoutMs });
         }
         signal.throwIfAborted();

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;
     }
   });
 }