@jskit-ai/assistant-core 0.2.6 → 0.2.8

package/src/server/lib/serviceToolEntries.js

@@ -0,0 +1,270 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveSchemaTransportSchemaDefinition } from "@jskit-ai/kernel/shared/validators";
+
+// Which application actions become assistant tools: an action on the automation channel with
+// input and output schemas, minus the barred and excluded ones, each under one unique tool name.
+
+const AUTOMATION_CHANNEL = "automation";
+
+function normalizeAssistantExtension(value) {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  // readable-check: allow method-probe - input validation: an action's assistant extension may bring its own result transform
+  if (source.transformResult != null && typeof source.transformResult !== "function") {
+    throw new TypeError("extensions.assistant.transformResult must be a function when provided.");
+  }
+
+  return Object.freeze({
+    description: normalizeText(source.description),
+    exclude: normalizeText(source.exclude),
+    alwaysAvailable: source.alwaysAvailable === true,
+    output: Object.hasOwn(source, "output") ? source.output : null,
+    transformResult: source.transformResult ?? null
+  });
+}
+
+function normalizeAssistantActionExtension(action = {}) {
+  const source = action && typeof action === "object" && !Array.isArray(action) ? action : {};
+  const actionId = normalizeText(source.id);
+
+  if (Object.prototype.hasOwnProperty.call(source, "assistantTool")) {
+    throw new Error(
+      `Action definition \"${actionId || "<unknown>"}\" assistantTool is not supported. Use extensions.assistant instead.`
+    );
+  }
+
+  const extensions = source.extensions && typeof source.extensions === "object" && !Array.isArray(source.extensions)
+    ? source.extensions
+    : {};
+  return normalizeAssistantExtension(extensions.assistant);
+}
+
+function normalizeBarredEntry(value) {
+  return normalizeText(value).toLowerCase();
+}
+
+function normalizeBarredActionSet(value) {
+  const source = Array.isArray(value) ? value : [value];
+  const exact = new Set();
+  const prefixes = [];
+
+  for (const entry of source) {
+    const normalized = normalizeBarredEntry(entry);
+    if (!normalized) {
+      continue;
+    }
+
+    if (normalized.endsWith(".*")) {
+      const prefix = normalized.slice(0, -1);
+      if (prefix) {
+        prefixes.push(prefix);
+      }
+      continue;
+    }
+
+    exact.add(normalized);
+  }
+
+  return Object.freeze({
+    exact,
+    prefixes: Object.freeze(prefixes)
+  });
+}
+
+function isActionBarred(barredRules, actionId) {
+  const normalizedActionId = normalizeText(actionId).toLowerCase();
+  if (!normalizedActionId) {
+    return true;
+  }
+
+  if (barredRules.exact.has(normalizedActionId)) {
+    return true;
+  }
+
+  return barredRules.prefixes.some((prefix) => normalizedActionId.startsWith(prefix));
+}
+
+function sanitizeToolName(value) {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_]+/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+
+  if (!normalized) {
+    return "tool";
+  }
+
+  return normalized;
+}
+
+function resolveUniqueToolName(baseName, used) {
+  const normalizedBase = sanitizeToolName(baseName) || "tool";
+  let candidate = normalizedBase.slice(0, 64);
+  let suffix = 1;
+
+  while (used.has(candidate)) {
+    const suffixText = `_${suffix}`;
+    const baseBudget = Math.max(1, 64 - suffixText.length);
+    candidate = `${normalizedBase.slice(0, baseBudget)}${suffixText}`;
+    suffix += 1;
+  }
+
+  used.add(candidate);
+  return candidate;
+}
+
+function normalizePermissionSpec(permission) {
+  const source = permission && typeof permission === "object" && !Array.isArray(permission)
+    ? permission
+    : {};
+  const requireMode = normalizeText(source.require || "none").toLowerCase();
+  const permissions = Array.isArray(source.permissions) ? source.permissions : [];
+
+  return Object.freeze({
+    require: requireMode || "none",
+    permissions,
+    message: normalizeText(source.message),
+    code: normalizeText(source.code)
+  });
+}
+
+function hasAutomationChannel(action = {}) {
+  const channels = Array.isArray(action.channels) ? action.channels : [];
+  return channels.some((channel) => normalizeText(channel).toLowerCase() === AUTOMATION_CHANNEL);
+}
+
+function normalizeSurfaceList(value) {
+  const source = Array.isArray(value) ? value : [value];
+  const resolved = [];
+
+  for (const entry of source) {
+    const normalized = normalizeSurfaceId(entry);
+    if (normalized) {
+      resolved.push(normalized);
+    }
+  }
+
+  return Object.freeze(resolved);
+}
+
+/**
+ * The automation actions that can become tools, by action id.
+ * @param {{ listDefinitions(): object[] }} actions The action runtime the tool catalogue has validated.
+ */
+function resolveActionBackedToolEntries(actions) {
+  const entriesByActionId = new Map();
+  for (const action of actions.listDefinitions()) {
+    if (!action || typeof action !== "object") {
+      continue;
+    }
+    if (!hasAutomationChannel(action)) {
+      continue;
+    }
+
+    const actionId = normalizeText(action.id);
+    if (!actionId) {
+      continue;
+    }
+
+    let assistantExtension = null;
+    try {
+      assistantExtension = normalizeAssistantActionExtension(action);
+    } catch {
+      continue;
+    }
+
+    if (assistantExtension.exclude) {
+      continue;
+    }
+
+    const outputDefinition = assistantExtension.output || action.output;
+    const inputSchema = resolveSchemaTransportSchemaDefinition(action.input, {
+      context: `Action definition "${actionId}" input`,
+      defaultMode: "patch"
+    }) || null;
+    const outputSchema = resolveSchemaTransportSchemaDefinition(outputDefinition, {
+      context: `Action definition "${actionId}" assistant output`,
+      defaultMode: "replace"
+    }) || null;
+    if (!inputSchema || !outputSchema) {
+      continue;
+    }
+
+    const actionVersion = Number(action.version) || 1;
+    const actionKey = actionId.toLowerCase();
+    const nextEntry = Object.freeze({
+      actionId,
+      actionVersion,
+      kind: normalizeText(action.kind).toLowerCase() || "command",
+      toolBaseName: actionId,
+      description: assistantExtension.description || `Run ${actionId}.`,
+      alwaysAvailable: assistantExtension.alwaysAvailable,
+      inputSchema,
+      outputDefinition,
+      outputSchema,
+      transformResult: assistantExtension.transformResult,
+      permission: normalizePermissionSpec(action.permission),
+      surfaces: normalizeSurfaceList(action.surfaces)
+    });
+    const existing = entriesByActionId.get(actionKey);
+    if (!existing || actionVersion >= Number(existing.actionVersion || 0)) {
+      entriesByActionId.set(actionKey, nextEntry);
+    }
+  }
+
+  return entriesByActionId;
+}
+
+function resolveActionToolEntries(
+  actions,
+  { barredActionIds = [], skipActionPrefixes = [] } = {}
+) {
+  const actionBackedEntries = resolveActionBackedToolEntries(actions);
+  const barredRules = normalizeBarredActionSet(barredActionIds);
+  const usedToolNames = new Set();
+  const entries = [];
+
+  for (const actionEntry of actionBackedEntries.values()) {
+    const actionId = normalizeText(actionEntry?.actionId);
+    if (!actionId) {
+      continue;
+    }
+
+    const normalizedActionId = actionId.toLowerCase();
+    const skipByPrefix = skipActionPrefixes.some((prefix) => normalizedActionId.startsWith(prefix));
+    if (skipByPrefix) {
+      continue;
+    }
+
+    if (isActionBarred(barredRules, actionId)) {
+      continue;
+    }
+
+    const toolName = resolveUniqueToolName(actionEntry.toolBaseName, usedToolNames);
+    entries.push(
+      Object.freeze({
+        descriptor: Object.freeze({
+          name: toolName,
+          actionId,
+          actionVersion: Number(actionEntry.actionVersion) || null,
+          description: normalizeText(actionEntry.description) || `Run ${actionId}.`,
+          alwaysAvailable: actionEntry.alwaysAvailable === true,
+          parameters: actionEntry.inputSchema,
+          outputSchema: actionEntry.outputSchema
+        }),
+        kind: actionEntry.kind,
+        acceptsWorkspaceSlug: Object.hasOwn(actionEntry.inputSchema.properties || {}, "workspaceSlug"),
+        outputDefinition: actionEntry.outputDefinition,
+        transformResult: actionEntry.transformResult,
+        permission: actionEntry.permission,
+        surfaces: actionEntry.surfaces
+      })
+    );
+  }
+
+  return Object.freeze(entries.sort((left, right) => left.descriptor.name.localeCompare(right.descriptor.name)));
+}
+
+export { AUTOMATION_CHANNEL, normalizePermissionSpec, resolveActionToolEntries };

package/src/server/types.js

@@ -0,0 +1,78 @@
+// The types of assistant-core's server facilities, for the code that receives them, and the
+// contracts of what an application passes the conversation runtime.
+
+/** @typedef {ReturnType<typeof import("./conversation/runtime.js").createConversationRuntime>} ConversationRuntime */
+/** @typedef {ReturnType<typeof import("./conversation/transcript.js").createConversationTranscript>} ConversationTranscript */
+/** @typedef {ReturnType<typeof import("./conversation/streams.js").createConversationStreams>} ConversationStreams */
+/** @typedef {ReturnType<typeof import("./conversation/storage.js").createReentrantConversationStorage>} ReentrantConversationStorage */
+/** @typedef {ReturnType<typeof import("./lib/serviceToolCatalog.js").createServiceToolCatalog>} ServiceToolCatalog */
+/** @typedef {ReturnType<typeof import("./lib/aiClient.js").createAiClient>} AiClient */
+/** @typedef {ReturnType<typeof import("./lib/aiConnectionClient.js").createAiConnectionClient>} AiConnectionClient */
+
+/**
+ * The storage an application gives the conversation runtime. Each operation runs in one transaction
+ * of the conversation scope; createConversationStorage, createFileConversationStorage and
+ * createMemoryConversationStorage implement it, and the storage contract checks prove another.
+ * @typedef {object} ConversationStorage
+ * @property {<T>(scope: string, operation: (transaction: object) => Promise<T>) => Promise<T>} read
+ * @property {<T>(scope: string, operation: (transaction: object) => Promise<T>) => Promise<T>} write
+ * @property {(scope: string) => Promise<void>} [deleteConversation]
+ */
+
+/**
+ * Whether the caller of one operation may use one conversation.
+ * @typedef {(request: { context: object, conversationId: string, operation: string }) => boolean | Promise<boolean>} ConversationAuthorize
+ */
+
+/**
+ * The application's own conversation host: it may supply each conversation's native facilities.
+ * @typedef {object} ConversationHost
+ * @property {(request: { id?: string, context: object, input?: unknown, options?: unknown, operation?: string }) => unknown} [conversation]
+ * @property {boolean} [nativeTools] Whether native engines may use their own coding tools.
+ * @property {object} [commandWrapper]
+ */
+
+/**
+ * The application's files offered as message attachments.
+ * @typedef {object} ConversationAttachments
+ * @property {(request: { attachmentIds: string[], context: object, conversationId: string, signal: AbortSignal }) =>
+ *   Promise<{ attachments: object[], content?: object[], localFiles?: object[] }>} resolve
+ */
+
+/**
+ * The authorized AI connections an API conversation resolves its integrationId through.
+ * @typedef {object} ConversationConnections
+ * @property {(request: { context: object, integrationId: string }) => Promise<object>} resolve
+ */
+
+/**
+ * An application's own API model client, instead of its AI connections.
+ * @typedef {object} ConversationApiClientFactory
+ * @property {(request: { context: object, configuration: object }) =>
+ *   Promise<{ enabled: boolean, model: object, defaultModel: string }>} resolveClient
+ */
+
+/**
+ * The API history an application selects for one request, instead of the whole transcript.
+ * @typedef {(request: { context: object }) => unknown | Promise<unknown>} ConversationApiHistory
+ */
+
+/**
+ * Receives each stage of one message's delivery; its result is never awaited.
+ * @typedef {(event: { engine: string, conversationId: string, messageId?: string, stage: string, previousStage: string,
+ *   durationMs: number, elapsedMs: number, timings: Record<string, number> }) => unknown} ConversationDeliveryTimingObserver
+ */
+
+/**
+ * The runtime's numeric limits; each absent one takes its default.
+ * @typedef {object} ConversationLimits
+ * @property {number} [maxToolCalls]
+ * @property {number} [maxInputCharacters]
+ * @property {number} [maxFinalReplyCharacters]
+ * @property {number} [maxOutputCharacters]
+ * @property {number} [maxContinuityCharacters]
+ * @property {number} [maxAttachmentBytes]
+ * @property {number} [timeoutMs]
+ */
+
+export {};

package/src/shared/assistantResource.js

@@ -7,7 +7,6 @@ import {
 import { ASSISTANT_ATTACHMENT_ID_MAX_LENGTH, ASSISTANT_ATTACHMENT_MAX_ITEMS } from "./conversation/attachments.js";
 
 const MAX_INPUT_CHARS = 8000;
-const MAX_HISTORY_MESSAGES = 20;
 const MAX_PAGE_SIZE = 200;
 const MAX_MESSAGE_PAGE_SIZE = 500;
 
@@ -15,21 +14,6 @@ const attachmentIdsField = {
   type: "array", required: false, maxItems: ASSISTANT_ATTACHMENT_MAX_ITEMS,
   items: { type: "string", minLength: 1, maxLength: ASSISTANT_ATTACHMENT_ID_MAX_LENGTH }
 };
-const historyMessageSchema = createSchema({
-  attachmentIds: attachmentIdsField,
-  role: {
-    type: "string",
-    required: true,
-    enum: ["user", "assistant"]
-  },
-  content: {
-    type: "string",
-    required: true,
-    minLength: 1,
-    maxLength: MAX_INPUT_CHARS
-  }
-});
-
 const clientContextSchema = createSchema({
   locale: {
     type: "string",
@@ -64,12 +48,6 @@ const chatStreamBodySchema = createSchema({
     minLength: 1,
     maxLength: MAX_INPUT_CHARS
   },
-  history: {
-    type: "array",
-    required: false,
-    maxItems: MAX_HISTORY_MESSAGES,
-    items: historyMessageSchema
-  },
   clientContext: {
     type: "object",
     required: false,
@@ -312,7 +290,6 @@ const assistantResource = defineResource({
 
 export {
   MAX_INPUT_CHARS,
-  MAX_HISTORY_MESSAGES,
   MAX_MESSAGE_PAGE_SIZE,
   attachmentIdsField,
   assistantResource,

package/src/shared/conversation/answerChoiceSugar.js

@@ -1,3 +1,5 @@
+import { answerChoiceHeadingLine, isSingleTextareaMessageField, optionalValueMatches } from "./messageInputSugar.js";
+
 const UI_ANSWER_CHOICE_FIELD = "__ui_answer_choice";
 const ANSWER_CHOICE_MIN_COUNT = 2;
 const ANSWER_CHOICE_MAX_COUNT = 6;
@@ -14,16 +16,6 @@ function normalizedChoiceText(value = "") {
   return String(value || "").trim().replace(/\s+/gu, " ");
 }
 
-function isSingleTextareaMessageField(fields = [], fieldName = "response") {
-  return fields.length === 1 &&
-    fields[0]?.name === fieldName &&
-    fields[0]?.kind === "textarea";
-}
-
-function optionalValueMatches(actual = "", expected = "") {
-  return !expected || String(actual || "") === String(expected || "");
-}
-
 function canRenderAnswerChoiceSugar({
   fields = [],
   fieldName = "response",
@@ -39,10 +31,6 @@ function canRenderAnswerChoiceSugar({
   );
 }
 
-function answerChoiceHeadingLine(line = "") {
-  return /^(possible answers|choices):$/iu.test(String(line || "").trim());
-}
-
 function answerChoiceLineText(line = "") {
   const match = String(line || "").trim().match(/^[-*]\s+(.+)$/u);
   return match ? normalizedChoiceText(match[1]) : "";

package/src/shared/conversation/messageInputSugar.js

@@ -0,0 +1,18 @@
+// What the answer-choice and numbered-question sugars share: whether a message input can
+// show sugar, and the heading line that introduces answer choices.
+
+function isSingleTextareaMessageField(fields = [], fieldName = "response") {
+  return fields.length === 1 &&
+    fields[0]?.name === fieldName &&
+    fields[0]?.kind === "textarea";
+}
+
+function optionalValueMatches(actual = "", expected = "") {
+  return !expected || String(actual || "") === String(expected || "");
+}
+
+function answerChoiceHeadingLine(line = "") {
+  return /^(possible answers|choices):$/iu.test(String(line || "").trim());
+}
+
+export { answerChoiceHeadingLine, isSingleTextareaMessageField, optionalValueMatches };

package/src/shared/conversation/numberedQuestionSugar.js

@@ -1,4 +1,5 @@
 import { answerChoiceFromLine } from "./answerChoiceSugar.js";
+import { answerChoiceHeadingLine, isSingleTextareaMessageField, optionalValueMatches } from "./messageInputSugar.js";
 
 const UI_QUESTION_FIELD_PREFIX = "__ui_question_";
 
@@ -10,16 +11,6 @@ function inactiveNumberedQuestionSugar() {
   };
 }
 
-function isSingleTextareaMessageField(fields = [], fieldName = "response") {
-  return fields.length === 1 &&
-    fields[0]?.name === fieldName &&
-    fields[0]?.kind === "textarea";
-}
-
-function optionalValueMatches(actual = "", expected = "") {
-  return !expected || String(actual || "") === String(expected || "");
-}
-
 function canRenderNumberedQuestionSugar({
   fields = [],
   fieldName = "response",
@@ -39,10 +30,6 @@ function numberedQuestionMarkerMatch(line = "") {
   return String(line || "").match(/^\[(?:Q)?(\d+)\]\s+(.+)$/iu);
 }
 
-function trailingAnswerChoiceHeadingLine(line = "") {
-  return /^(possible answers|choices):$/iu.test(String(line || "").trim());
-}
-
 function trailingAnswerChoiceLine(line = "") {
   return /^[-*]\s+.+/u.test(String(line || "").trim());
 }
@@ -72,7 +59,7 @@ function numberedQuestionChoice(line = "") {
 }
 
 function trailingAnswerChoiceBlock(lines = [], startIndex = 0) {
-  if (!trailingAnswerChoiceHeadingLine(lines[startIndex])) {
+  if (!answerChoiceHeadingLine(lines[startIndex])) {
     return null;
   }
   const choices = [];
@@ -152,7 +139,7 @@ function parseLineNumberedQuestionPrompt(value = "") {
       }
       const trailingLines = lines.slice(index);
       if (
-        trailingLines.some((trailingLine) => trailingAnswerChoiceHeadingLine(trailingLine)) ||
+        trailingLines.some((trailingLine) => answerChoiceHeadingLine(trailingLine)) ||
         trailingLines.some((trailingLine) => numberedQuestionMarkerMatch(trailingLine))
       ) {
         return inactiveNumberedQuestionSugar();
@@ -238,6 +225,7 @@ function numberedQuestionSugarForInput(interaction = {}, fields = []) {
   return numberedQuestionSugarForMessageInput({
     fields,
     fieldName: "response",
+    // readable-check: allow no-optional-after-default - data: the interaction is null until a caller knows it
     message: interaction?.prompt
   });
 }
@@ -269,7 +257,9 @@ function numberedQuestionSugarForMessageInput({
 const ANSWER_REQUIRED = Object.freeze({ messageCode: "assistant.questions.answerRequired" });
 
 function numberedQuestionInputFields(questions = [], options = {}) {
+  // readable-check: allow no-optional-after-default - data: null field options mean none
   const autocomplete = String(options?.autocomplete || "").trim();
+  // readable-check: allow no-optional-after-default - data: null field options mean none
   const density = String(options?.density || "").trim();
   return questions.map((question) => ({
     ...(autocomplete ? { autocomplete } : {}),

package/src/shared/conversation/pagination.js

@@ -1,7 +1,7 @@
 import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 import { conversationTurnMessages } from "./turns.js";
 
-// Original paged transcript representation, shared by all browser bindings.
+// The paged transcript representation, shared by all browser bindings.
 const CONVERSATION_LOG_PAGE_LIMIT = 10;
 
 const messageRoles = ["system", "user", "assistant"];

package/src/shared/conversation/questions.js

@@ -3,6 +3,7 @@ function messageText(value = "") {
 }
 
 function conversationTurns(conversationLog = {}) {
+  // readable-check: allow no-optional-after-default - data: the conversation is null until a caller knows it
   if (Array.isArray(conversationLog?.turns)) {
     return conversationLog.turns;
   }

package/src/shared/conversation/streaming.js

@@ -3,6 +3,7 @@ import { conversationTurnMessages } from "./turns.js";
 /** Overlay live provider output without changing the saved transcript. */
 export function mergeConversationStream(turns = [], snapshot = {}) {
   const savedIds = new Set(turns.flatMap(conversationTurnMessages).map((message) => message.messageId));
+  // readable-check: allow no-optional-after-default - data: the live snapshot is null until a caller knows it
   const messages = (snapshot?.messages || []).filter((message) => message.text && !savedIds.has(message.messageId));
   if (!messages.length) return turns;
   const result = [...turns];

package/src/shared/index.js

@@ -27,7 +27,6 @@ export {
 
 export {
   MAX_INPUT_CHARS,
-  MAX_HISTORY_MESSAGES,
   MAX_MESSAGE_PAGE_SIZE,
   attachmentIdsField,
   assistantResource,

package/src/testing/conversationStorageContract.js

@@ -60,6 +60,26 @@ export async function verifyConversationStorageContract(storage, { runtime = fal
       metadata: await transaction.readMetadata(), turn: await transaction.readTurn(first.turnId), ids: await transaction.listTurnIds()
     }));
     assert.deepEqual(after, before, "Failed runtime writes must preserve transcript and metadata together.");
+    const ids = before.ids;
+    const later = await storage.read(scope, async transaction => ({
+      all: await transaction.readTurnsAfter(""), after: await transaction.readTurnsAfter(first.turnId),
+      each: await Promise.all(ids.map(id => transaction.readTurn(id))), summary: await transaction.readSummary()
+    }));
+    assert.deepEqual(later.all, later.each, "readTurnsAfter(\"\") reads every turn in order.");
+    assert.deepEqual(later.after, later.each.slice(1), "readTurnsAfter reads only the turns after the given one.");
+    assert.equal(later.summary, null, "A conversation starts without a summary.");
+    const summary = { text: "The person asked a first question.", throughTurnId: first.turnId };
+    await storage.write(scope, transaction => transaction.writeSummary(summary));
+    assert.deepEqual(await storage.read(scope, transaction => transaction.readSummary()), summary);
+    assert.equal(await storage.read(other, transaction => transaction.readSummary()), null, "Summaries must remain scoped.");
+    const detachedSummary = await storage.read(scope, transaction => transaction.readSummary());
+    detachedSummary.text = "client edit";
+    await assert.rejects(storage.write(scope, async transaction => {
+      await transaction.writeSummary({ text: "Uncommitted", throughTurnId: ids.at(-1) });
+      throw new Error("contract-rollback");
+    }), /contract-rollback/);
+    assert.deepEqual(await storage.read(scope, transaction => transaction.readSummary()), summary,
+      "Failed runtime writes must preserve the summary.");
   }
   return { scope, other, transcript };
 }

package/test/aiConnectionClient.test.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
 import test from "node:test";
 import { createAiConnectionResolver } from "../../connectors-catalog/src/server/ai.js";
 import { createAiConnectionClient } from "../src/server/lib/aiConnectionClient.js";
@@ -13,6 +14,11 @@ function publicConnection(model = "opencode/mimo-v2.5-free") {
   }).resolve({ context: {}, integrationId: "assistant" });
 }
 
+// Node 26.5's web streams lose a rejection when a piped read is cancelled mid-stream; Node 22, 24
+// and 26.13 (the runtime packs' version) do not.
+const NODE_LOSES_CANCELLED_PIPE_REJECTIONS = process.versions.node.startsWith("26.") &&
+  Number(process.versions.node.split(".")[1]) < 13 && "this Node 26 loses a web-stream rejection; 26.13 does not";
+
 function eventsResponse(events) {
   return new Response(events.map(data => `data: ${JSON.stringify(data)}\n\n`).join(""), {
     headers: { "content-type": "text/event-stream" }
@@ -248,7 +254,9 @@ test("SDK streaming rejects the first invalid tool input without yielding later
   assert.equal(requests, 1);
 });
 
-test("SDK cancellation after its first text retains the original reason and suppresses later output", { timeout: 5000 }, async t => {
+test("SDK cancellation after its first text retains the original reason and suppresses later output", {
+  timeout: 5000, skip: NODE_LOSES_CANCELLED_PIPE_REJECTIONS
+}, async t => {
   const source = new TransformStream();
   const writer = source.writable.getWriter();
   t.after(() => writer.abort().catch(() => {}));
@@ -425,3 +433,36 @@ for (const modelId of ["deepseek-flash", "deepseek-v4-flash", "deepseek-v4-flash
     assert.deepEqual(connection.modelLimits, { context: 1048576, output: 393216 });
   });
 }
+
+test("a stream cancelled mid-way leaves no unhandled rejection under strict rejection handling", {
+  timeout: 20_000, skip: NODE_LOSES_CANCELLED_PIPE_REJECTIONS
+}, () => {
+  const client = new URL("../src/server/lib/aiConnectionClient.js", import.meta.url).href;
+  const script = `
+    const { createAiConnectionClient } = await import(${JSON.stringify(client)});
+    const source = new TransformStream();
+    const writer = source.writable.getWriter();
+    const send = data => writer.write(new TextEncoder().encode("data: " + JSON.stringify(data) + "\\n\\n"));
+    const abort = new AbortController();
+    const connection = { providerId: "test", model: "test-model", sdkPackage: "@ai-sdk/openai-compatible", apiKey: "test",
+      baseURL: "http://test.invalid/v1" };
+    const client = createAiConnectionClient(connection, {
+      fetch: async () => new Response(source.readable, { headers: { "content-type": "text/event-stream" } })
+    });
+    const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hello" }], signal: abort.signal });
+    const first = iterator.next();
+    await send({ choices: [{ index: 0, delta: { content: "First text" } }] });
+    await first;
+    const ending = iterator.next().then(() => null, error => error);
+    abort.abort(new Error("Stopped"));
+    await send({ choices: [{ index: 0, delta: { content: "Late text" } }] }).catch(() => {});
+    await writer.close().catch(() => {});
+    if ((await ending)?.message !== "Stopped") throw new Error("The stream did not end with the abort reason.");
+    await new Promise(resolve => setTimeout(resolve, 200));
+    process.stdout.write("clean");
+  `;
+  const child = spawnSync(process.execPath, ["--unhandled-rejections=strict", "--input-type=module", "-e", script],
+    { encoding: "utf8", timeout: 15_000 });
+  assert.equal(child.status, 0, child.stderr);
+  assert.equal(child.stdout, "clean");
+});