@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/test/frameworkActions.test.js

@@ -9,6 +9,20 @@ import { createAssistantActions } from "../../assistant-runtime/src/server/actio
 import { accountSettingsResponseFormatter } from "../../users-core/src/server/common/formatters/accountSettingsResponseFormatter.js";
 import { DEFAULT_USER_SETTINGS } from "../../users-core/src/shared/settings.js";
 
+// Each action's definition with a run(service, input, context) that executes
+// it against the service a test supplies.
+function specificationsOf(createActions) {
+  let service = null;
+  const forwarding = new Proxy({}, { get: (_target, method) => (...args) => service[method](...args) });
+  return createActions(new Proxy({}, { get: () => forwarding })).map(({ execute, ...definition }) => ({
+    ...definition,
+    run(nextService, input, context) {
+      service = nextService;
+      return execute(input, context);
+    }
+  }));
+}
+
 const specifications = [];
 for (const owner of ["users-core", "workspaces-core", "console-core"]) {
   const directory = new URL(`../../${owner}/src/server/`, import.meta.url);
@@ -16,7 +30,7 @@ for (const owner of ["users-core", "workspaces-core", "console-core"]) {
     if (!path.endsWith("Actions.js")) continue;
     const module = await import(new URL(path, directory));
     for (const [name, value] of Object.entries(module)) {
-      if (name.endsWith("ActionSpecifications")) specifications.push(...value);
+      if (/^create\w+Actions$/u.test(name)) specifications.push(...specificationsOf(value));
     }
   }
 }
@@ -30,8 +44,9 @@ const roleCatalog = { collaborationEnabled: true, defaultInviteRole: "member", r
 const memberResult = { workspace, members: [], roleCatalog };
 const invite = { id: "31", email: "invite@example.test", roleSid: "member", status: "pending", expiresAt: "2026-10-01" };
 const invitesResult = { workspace, invites: [invite], roleCatalog };
+// An auth service without the optional settings-profile operation: email is managed by auth.
 const settings = accountSettingsResponseFormatter({
-  profile: { id: "7", displayName: "Alice", email: "alice@example.test" }, settings: DEFAULT_USER_SETTINGS
+  authService: {}, profile: { id: "7", displayName: "Alice", email: "alice@example.test" }, settings: DEFAULT_USER_SETTINGS
 });
 const workspaceSettings = {
   workspace: { id: "11", slug: "acme", ownerUserId: "7" }, roleCatalog,
@@ -49,24 +64,24 @@ const fixtures = {
   "settings.security.password_method.toggle": [{ enabled: true }, returnJsonApiData({ securityStatus: settings.security, settings, session: "SECRET" })],
   "settings.security.oauth.unlink": [{ provider: "google" }, returnJsonApiData({ securityStatus: settings.security, providerMessageId: "SECRET" })],
   "settings.security.sessions.logout_others": [{}, null],
-  "workspace.workspaces.create": [{ name: "Acme" }, { ...workspace, isPersonal: false, createdAt: "2026-09-13", updatedAt: "2026-09-13", deletedAt: null }],
-  "workspace.workspaces.list": [{}, [{ ...workspace, roleSid: "owner", isAccessible: true, membershipStatus: "active", createdAt: "2026-09-13" }]],
-  "workspace.workspaces.read": [{ workspaceSlug: "evil" }, { ...workspace, isPersonal: false, createdAt: "2026-09-13" }],
-  "workspace.workspaces.update": [{ workspaceSlug: "evil", name: "Acme" }, workspace],
-  "workspace.settings.read": [{ workspaceSlug: "evil" }, workspaceSettings],
-  "workspace.settings.update": [{ workspaceSlug: "evil", invitesEnabled: false }, workspaceSettings],
-  "workspace.roles.list": [{ workspaceSlug: "evil" }, roleCatalog],
-  "workspace.members.list": [{ workspaceSlug: "evil" }, memberResult],
-  "workspace.member.role.update": [{ workspaceSlug: "evil", memberUserId: "8", roleSid: "member" }, memberResult],
-  "workspace.member.remove": [{ workspaceSlug: "evil", memberUserId: "8" }, memberResult],
-  "workspace.invites.list": [{ workspaceSlug: "evil" }, invitesResult],
-  "workspace.invite.create": [{ workspaceSlug: "evil", email: invite.email, roleSid: "member" }, {
+  "workspace.workspaces.create": [{ name: "Acme" }, returnJsonApiData({ ...workspace, isPersonal: false, createdAt: "2026-09-13", updatedAt: "2026-09-13", deletedAt: null })],
+  "workspace.workspaces.list": [{}, returnJsonApiData({ items: [{ ...workspace, roleSid: "owner", isAccessible: true, membershipStatus: "active", createdAt: "2026-09-13" }], nextCursor: null })],
+  "workspace.workspaces.read": [{ workspaceSlug: "evil" }, returnJsonApiData({ ...workspace, isPersonal: false, createdAt: "2026-09-13" })],
+  "workspace.workspaces.update": [{ workspaceSlug: "evil", name: "Acme" }, returnJsonApiData(workspace)],
+  "workspace.settings.read": [{ workspaceSlug: "evil" }, returnJsonApiData(workspaceSettings)],
+  "workspace.settings.update": [{ workspaceSlug: "evil", invitesEnabled: false }, returnJsonApiData(workspaceSettings)],
+  "workspace.roles.list": [{ workspaceSlug: "evil" }, returnJsonApiData(roleCatalog)],
+  "workspace.members.list": [{ workspaceSlug: "evil" }, returnJsonApiData(memberResult)],
+  "workspace.member.role.update": [{ workspaceSlug: "evil", memberUserId: "8", roleSid: "member" }, returnJsonApiData(memberResult)],
+  "workspace.member.remove": [{ workspaceSlug: "evil", memberUserId: "8" }, returnJsonApiData(memberResult)],
+  "workspace.invites.list": [{ workspaceSlug: "evil" }, returnJsonApiData(invitesResult)],
+  "workspace.invite.create": [{ workspaceSlug: "evil", email: invite.email, roleSid: "member" }, returnJsonApiData({
     ...invitesResult, createdInviteId: "31", inviteTokenPreview: "SECRET", inviteUrl: "https://example.test/invite?token=SECRET",
     inviteDelivery: { status: "sent", message: "SECRET", providerMessageId: "SECRET" }
-  }],
-  "workspace.invite.revoke": [{ workspaceSlug: "evil", inviteId: "31" }, { ...invitesResult, revokedInviteId: "31" }],
-  "workspace.invitations.pending.list": [{}, [{ id: "31", workspaceId: "11", workspaceSlug: "acme", workspaceName: "Acme",
-    workspaceAvatarUrl: "", roleSid: "member", status: "pending", expiresAt: "2026-10-01", token: "SECRET" }]]
+  })],
+  "workspace.invite.revoke": [{ workspaceSlug: "evil", inviteId: "31" }, returnJsonApiData({ ...invitesResult, revokedInviteId: "31" })],
+  "workspace.invitations.pending.list": [{}, returnJsonApiData({ pendingInvites: [{ id: "31", workspaceId: "11", workspaceSlug: "acme", workspaceName: "Acme",
+    workspaceAvatarUrl: "", roleSid: "member", status: "pending", expiresAt: "2026-10-01", token: "SECRET" }] })]
 };
 
 function catalogFor(spec, result, observe = () => {}) {

package/test/localConversationExecution.test.js

@@ -12,7 +12,7 @@ function host(t) {
   t.after(() => execution.close());
   return execution;
 }
-const spec = (code) => ({ command: process.execPath, args: ["-e", code], cwd: process.cwd(), stream: true });
+const spec = (code) => ({ command: process.execPath, args: ["-e", code], cwd: process.cwd(), env: process.env, stream: true });
 
 test("the supplied execution host carries native protocol bytes and proves owned cleanup", options, async (t) => {
   const execution = host(t);
@@ -59,14 +59,14 @@ test("native command requests use the same execution owner and retain bounded ca
   t.after(() => rm(directory, { recursive: true, force: true }));
   const captured = await execution.run({ command: process.execPath,
     args: ["-e", 'process.stdout.write("x".repeat(70000)); process.stderr.write("finished");'],
-    cwd: directory, mode: "capture" });
+    cwd: directory, baseEnv: process.env, mode: "capture" });
   assert.equal(captured.ok, true);
   assert.equal(Buffer.byteLength(captured.output), 64 * 1024);
   assert.ok(captured.output.endsWith("finished"));
   const logPath = join(directory, "detached.log");
   const child = await execution.run({ command: process.execPath,
     args: ["-e", 'process.stderr.write("ready"); setInterval(() => {}, 1000);'],
-    cwd: directory, mode: "detached", logPath });
+    cwd: directory, baseEnv: process.env, mode: "detached", logPath });
   assert.equal(child.ok, true);
   assert.ok(Number.isSafeInteger(child.pid) && child.pid > 0);
   const deadline = Date.now() + 3000;
@@ -83,7 +83,7 @@ test("native capture timeout drains its execution before returning", options, as
   const execution = host(t);
   const result = await execution.run({ command: process.execPath,
     args: ["-e", 'process.stdout.write(String(process.pid)); setInterval(() => {}, 1000);'],
-    cwd: process.cwd(), mode: "capture", timeout: 500 });
+    cwd: process.cwd(), baseEnv: process.env, mode: "capture", timeout: 500 });
   assert.equal(result.ok, false);
   assert.equal(result.timedOut, true);
   assert.throws(() => process.kill(Number(result.output), 0), { code: "ESRCH" });

package/test/localExecution.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { test } from "node:test";
-import { createConversationProcessIdentity } from "../src/server/conversation/localExecution.js";
+import { createConversationProcessIdentity } from "../src/server/conversation/processIdentity.js";
 
 const TOKEN_ENV = "JSKIT_EXECUTION_RUNTIME_TOKEN";
 const HASH_ENV = "JSKIT_EXECUTION_COMMAND_HASH";

package/test/openCodeConnectionChange.test.js

@@ -1,7 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { setTimeout as delay } from "node:timers/promises";
-import { createOpenCodeSharedRuntime, openCodeServerForDirectory } from "../src/server/conversation/openCodeRuntime.js";
+import { createOpenCodeSharedRuntime } from "../src/server/conversation/openCodeRuntime.js";
+import { openCodeServerForDirectory } from "../src/server/conversation/openCodeNativeSession.js";
 
 // One shared server whose native directories record what OpenCode is asked to do.
 function sharedServer() {
@@ -31,7 +32,7 @@ function sharedServer() {
 const deepseek = (fingerprint, apiKey) => ({ modelProviderId: "deepseek", canonicalUrl: "", endpointCode: "native", fingerprint, apiKey });
 
 async function startedRuntime(saved) {
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   const native = sharedServer();
   const shared = await runtime.ensure(saved[0], async () => ({ server: native.server, connections: [...saved] }), async () => saved);
   return { runtime, native, shared };

package/test/openCodeRuntime.test.js

@@ -4,11 +4,12 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import { setTimeout as delay } from "node:timers/promises";
-import { createOpenCodeSharedRuntime, ensureOpenCodeSession, openCodeServerForDirectory, readOpenCodeEnvironments } from "../src/server/conversation/openCodeRuntime.js";
+import { createOpenCodeSharedRuntime, readOpenCodeEnvironments } from "../src/server/conversation/openCodeRuntime.js";
+import { ensureOpenCodeSession, openCodeServerForDirectory } from "../src/server/conversation/openCodeNativeSession.js";
 import { createOpenCodeServerClient } from "../src/server/conversation/openCodeClient.js";
 
 function fixture(options = {}) {
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   const starts = [], stops = [];
   const connection = { modelProviderId: "provider", canonicalUrl: "https://provider.invalid", fingerprint: "account", endpointCode: "api" };
   const start = async selected => {
@@ -37,7 +38,7 @@ function fixture(options = {}) {
 }
 
 test("history projection supplies ordered reasoning facts without native part envelopes", async () => {
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   const message = { id: "reply", type: "assistant", time: { created: 1_000 }, content: [
     { type: "tool", id: "tool", text: "Not reasoning" },
     { type: "reasoning", id: "first", text: "  First thought\n", time: { end: 0 }, nativeOnly: true },
@@ -250,7 +251,7 @@ test("deleting a scoped OpenCode conversation returns its scope's exit proof and
 });
 
 test("an active OpenCode turn with missing native identity still fails instead of claiming Stop", async () => {
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:1",
     fetchImpl: async () => assert.fail("Invalid identity must fail before transport.") });
   const turn = { active: true, state: "inProgress" };
@@ -447,7 +448,7 @@ test("OpenCode bindings share atomic publication without overwriting another con
   const root = await mkdtemp(path.join(os.tmpdir(), "jskit-opencode-bindings-"));
   t.after(() => rm(root, { force: true, recursive: true }));
   const registry = path.join(root, "private", "session-environments.json");
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   const main = { upstreamSessionId: "main", workdir: "/work/main", env: { OWNER: "main" } };
   const colleague = { upstreamSessionId: "colleague", workdir: "/work/colleague", systemPrompt: "Current instructions" };
   await Promise.all([
@@ -467,7 +468,7 @@ test("OpenCode bindings share atomic publication without overwriting another con
 
 
 test("native output identity is opt-in for every existing OpenCode projection writer", async () => {
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   for (const configured of [false, true]) {
     const writes = [];
     const streams = [];
@@ -545,7 +546,7 @@ async function finalReaderMonitorFixture(t, { publication, checkpoint, recovery
 }
 
 test("native final projection opt-in returns only its original published receipt without changing default fields", async () => {
-  const runtime = createOpenCodeSharedRuntime();
+  const runtime = createOpenCodeSharedRuntime({});
   const originalTurn = { turnId: "authored", assistant: { messageId: "real-final:assistant",
     outputId: "real-final:assistant", role: "assistant", text: "Actual final." } };
   const rows = [{ id: "accepted", type: "user", time: { created: 1 } },

package/test/openCodeTools.test.js

@@ -118,7 +118,7 @@ test("one native plugin routes current instructions, command policy and tools by
     parameters: { type: "object", properties: { query: { type: "string" } } } } }];
   process.env.JSKIT_OPENCODE_ENV_REGISTRY = registry;
   process.env.JSKIT_OPENCODE_TOOL_SCHEMAS = JSON.stringify(schemas);
-  const owner = createOpenCodeSharedRuntime();
+  const owner = createOpenCodeSharedRuntime({});
   const calls = [];
   const bindings = [];
   for (const id of ["first", "second"]) {

package/test/opencodeConversationSession.test.js

@@ -525,7 +525,7 @@ function applicationActions(execute) {
   const actions = createActionCatalogue();
   actions.register({ contributorId: "test.tools", domain: "numbers", actions: [{
     id: "numbers.read", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
-    permission: { require: "all", permissions: ["numbers.read"] }, idempotency: "none",
+    permission: { require: "all", permissions: ["numbers.read"] },
     input: { schema: createSchema({}), mode: "replace" },
     output: { schema: createSchema({ value: { type: "number", required: true } }), mode: "replace" }, execute
   }] });
@@ -894,7 +894,7 @@ for (const change of ["model", "effort"]) {
     if (change === "model") model = "other-model";
     const selection = { operationId: `fresh-${change}`, expectedSegmentId: before.segmentId, engine: "opencode",
       configuration: { ...configuration, model, effort: change === "effort" ? "high" : "low" }, retireNative: true };
-    await assert.rejects(f.conversation.select({ ...selection, retireNative: "yes" }), { code: "conversation_invalid_replacement" });
+    await assert.rejects(f.conversation.select({ ...selection, retireNative: "yes" }), { code: "conversation_replacement_request_invalid" });
     assert.deepEqual(await f.binding(), original);
     const selected = await f.conversation.select(selection);
     assert.notEqual(selected.segmentId, before.segmentId);
@@ -1098,7 +1098,8 @@ for (const savedStatus of ["cancelled", "failed", "unknown-tool", "interrupted"]
 // The original standalone fixture above remains byte-for-byte unchanged.
 async function boundToolFixture(t, { runInContext, monitorRunInContext, monitorContext } = {}) {
   const { createOpenCodeConversationServer, openCodeApplicationToolSchemas } = await import("../src/server/conversation/openCodeProcess.js");
-  const { createOpenCodeSharedRuntime, ensureOpenCodeSession } = await import("../src/server/conversation/openCodeRuntime.js");
+  const { createOpenCodeSharedRuntime } = await import("../src/server/conversation/openCodeRuntime.js");
+  const { ensureOpenCodeSession } = await import("../src/server/conversation/openCodeNativeSession.js");
   const { observeOpenCodeEvents } = await import("../src/server/conversation/openCodeTurn.js");
   let owner;
   const handles = [];

package/test/serviceToolCatalog.test.js

@@ -40,7 +40,6 @@ function action({
     permission,
     input,
     output,
-    idempotency: "none",
     extensions,
     execute
   };
@@ -284,8 +283,7 @@ test("large authorized catalogs use compact paged discovery, exact contracts, an
       input: workspaceInput,
       extensions: {
         assistant: {
-          alwaysAvailable: true,
-          preflight: ["CURRENT-TIME", "current-time"]
+          alwaysAvailable: true
         }
       },
       execute: async (input, context) => {
@@ -327,7 +325,6 @@ test("large authorized catalogs use compact paged discovery, exact contracts, an
     "demo_clock_read"
   ]);
   const clockTool = toolSet.tools.find((entry) => entry.actionId === "demo.clock.read");
-  assert.deepEqual(clockTool.preflight, ["current-time"]);
   assert.equal(clockTool.alwaysAvailable, true);
   assert.equal(clockTool.parameters.required?.includes("workspaceSlug") || false, false);
   assert.deepEqual(await catalog.executeToolCall({
@@ -489,8 +486,7 @@ test("discovery mode bounds authorized always-available tools", () => {
     id: `demo.clock-${String(index + 1).padStart(2, "0")}.read`,
     extensions: {
       assistant: {
-        alwaysAvailable: true,
-        preflight: ["current-time"]
+        alwaysAvailable: true
       }
     }
   }));
@@ -499,8 +495,7 @@ test("discovery mode bounds authorized always-available tools", () => {
     permission: { require: "all", permissions: ["clock.read"] },
     extensions: {
       assistant: {
-        alwaysAvailable: true,
-        preflight: ["current-time"]
+        alwaysAvailable: true
       }
     }
   }));

package/src/server/lib/assistantCompletion.js

@@ -1,190 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function extractTextDelta(deltaContent) {
-  if (typeof deltaContent === "string") {
-    return deltaContent;
-  }
-
-  if (!Array.isArray(deltaContent)) {
-    return "";
-  }
-
-  return deltaContent
-    .map((entry) => {
-      if (typeof entry === "string") {
-        return entry;
-      }
-      if (!entry || typeof entry !== "object") {
-        return "";
-      }
-      return String(entry.text || "");
-    })
-    .join("");
-}
-
-function sanitizeAssistantMessageText(value, { preserveWhitespace = false } = {}) {
-  let source = String(value || "");
-  if (!source) {
-    return "";
-  }
-
-  const blockPatterns = [
-    /<[^>\n]*function_calls[^>\n]*>[\s\S]*?(?:<\/[^>\n]*function_calls>|$)/gi,
-    /<[^>\n]*tool_calls?[^>\n]*>[\s\S]*?(?:<\/[^>\n]*tool_calls?[^>\n]*>|$)/gi,
-    /<[^>\n]*invoke\b[^>\n]*>[\s\S]*?(?:<\/[^>\n]*invoke>|$)/gi,
-    /<(?:analysis|reasoning|think)>[\s\S]*?(?:<\/(?:analysis|reasoning|think)>|$)/gi
-  ];
-  for (const pattern of blockPatterns) {
-    source = source.replace(pattern, " ");
-  }
-
-  const inlineTagPatterns = [
-    /<[^>\n]*invoke\b[^>]*\/>/gi,
-    /<\/?[^>\n]*invoke[^>\n]*>/gi,
-    /<\/?[^>\n]*function_calls[^>\n]*>/gi,
-    /<\/?[^>\n]*tool_calls?[^>\n]*>/gi,
-    /<\/?[^>\n]*DSML[^>\n]*>/gi
-  ];
-  for (const pattern of inlineTagPatterns) {
-    source = source.replace(pattern, " ");
-  }
-
-  if (preserveWhitespace) return source;
-
-  return source
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join("\n");
-}
-
-function parseDsmlToolCallsFromText(value = "") {
-  const source = String(value || "");
-  if (!source) {
-    return [];
-  }
-
-  const functionCallsMatch = source.match(
-    /<[^>\n]*function_calls[^>\n]*>([\s\S]*?)<\/[^>\n]*function_calls>/i
-  );
-  if (!functionCallsMatch) {
-    return [];
-  }
-
-  const blockText = String(functionCallsMatch[1] || "");
-  if (!blockText) {
-    return [];
-  }
-
-  const calls = [];
-  const invokePattern = /<[^>\n]*invoke\b([^>]*)>([\s\S]*?)<\/[^>\n]*invoke>/gi;
-  let match = invokePattern.exec(blockText);
-  while (match) {
-    const attributes = String(match[1] || "");
-    const body = normalizeText(String(match[2] || ""));
-    const quotedNameMatch =
-      attributes.match(/\bname\s*=\s*"([^"]+)"/i) || attributes.match(/\bname\s*=\s*'([^']+)'/i);
-    const bareNameMatch = attributes.match(/\bname\s*=\s*([^\s"'/>]+)/i);
-    const name = normalizeText(quotedNameMatch?.[1] || bareNameMatch?.[1]);
-    if (name) {
-      calls.push({
-        id: `dsml_tool_call_${calls.length + 1}`,
-        name,
-        arguments: body && /^[\[{]/.test(body) ? body : "{}"
-      });
-    }
-
-    match = invokePattern.exec(blockText);
-  }
-
-  return calls;
-}
-
-async function consumeCompletionStream(stream, onText = () => {}, {
-  signal, limits, preserveWhitespace = false, requireCallIds = false, callIdPrefix = ""
-} = {}) {
-  let assistantText = "";
-  let finishReason;
-  const toolCallsByIndex = new Map();
-
-  function checkToolLimits(call, count) {
-    if (!limits) return;
-    if (limits.maxToolCalls === 0) throw new Error("This conversation has no configured application tools.");
-    if (count > limits.maxToolCalls || call.name.length > 256 || call.id.length > 256 ||
-        Buffer.byteLength(call.arguments) > limits.maxToolArgumentBytes) {
-      throw new Error("The model exceeded the configured application tool-call limits.");
-    }
-  }
-
-  for await (const chunk of stream) {
-    signal?.throwIfAborted();
-    const choice = chunk?.choices?.[0] || {};
-    const delta = choice?.delta || {};
-    finishReason = choice.finish_reason || finishReason;
-
-    const textDelta = extractTextDelta(delta.content);
-    if (textDelta) {
-      assistantText += textDelta;
-      if (limits && assistantText.length > limits.maxOutputCharacters) {
-        throw new Error("The assistant exceeded the configured response limit.");
-      }
-      // An opening provider tag can be split between chunks. Keep it private
-      // until its boundary is known; complete internal blocks are stripped below.
-      const tagStart = assistantText.lastIndexOf("<");
-      const safeText = tagStart > assistantText.lastIndexOf(">") ? assistantText.slice(0, tagStart) : assistantText;
-      await onText(sanitizeAssistantMessageText(safeText, { preserveWhitespace }));
-    }
-
-    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-    for (const partialToolCall of toolCalls) {
-      const index = Number(partialToolCall?.index || 0);
-      const existing =
-        toolCallsByIndex.get(index) ||
-        {
-          id: normalizeText(partialToolCall?.id) || (requireCallIds ? "" : `tool_call_${index + 1}`),
-          name: "",
-          arguments: ""
-        };
-
-      if (partialToolCall?.id) {
-        existing.id = normalizeText(partialToolCall.id) || existing.id;
-      }
-      if (partialToolCall?.function?.name) {
-        existing.name += String(partialToolCall.function.name || "");
-      }
-      if (partialToolCall?.function?.arguments) {
-        existing.arguments += String(partialToolCall.function.arguments || "");
-      }
-
-      toolCallsByIndex.set(index, existing);
-      checkToolLimits(existing, toolCallsByIndex.size);
-    }
-  }
-
-  let toolCalls = [...toolCallsByIndex.values()].map((toolCall, index) => ({
-    id: normalizeText(toolCall.id) || (requireCallIds ? "" : `tool_call_${index + 1}`),
-    name: normalizeText(toolCall.name),
-    arguments: String(toolCall.arguments || "")
-  }));
-
-  let toolCallSource = toolCalls.length ? "structured" : "";
-  if (toolCalls.length < 1) {
-    const parsedDsmlCalls = parseDsmlToolCallsFromText(assistantText);
-    if (parsedDsmlCalls.length > 0) {
-      toolCallSource = "text";
-      toolCalls = parsedDsmlCalls.map(call => ({ ...call, id: `${callIdPrefix}${call.id}` }));
-      for (const call of toolCalls) checkToolLimits(call, toolCalls.length);
-      const visible = sanitizeAssistantMessageText(assistantText, { preserveWhitespace });
-      assistantText = preserveWhitespace ? visible : normalizeText(visible);
-    }
-  }
-
-  return {
-    assistantText,
-    toolCalls,
-    toolCallSource,
-    finishReason
-  };
-}
-
-export { consumeCompletionStream, sanitizeAssistantMessageText };