@qvac/sdk 0.10.1 → 0.11.0

package/dist/server/rpc/handlers/load-model/resolve.d.ts

@@ -1,5 +1,6 @@
 import { type ModelProgressUpdate } from "../../../../schemas/index";
 import type { ResolveResult, DownloadHooks } from "./types";
-export declare function resolveModelPath(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, hooks?: DownloadHooks): Promise<string>;
-export declare function resolveModelPathWithStats(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, hooks?: DownloadHooks): Promise<ResolveResult>;
+import type { AbortSignal } from "bare-abort-controller";
+export declare function resolveModelPath(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks): Promise<string>;
+export declare function resolveModelPathWithStats(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks): Promise<ResolveResult>;
 //# sourceMappingURL=resolve.d.ts.map

package/dist/server/rpc/handlers/load-model/resolve.js

@@ -7,7 +7,7 @@ import { downloadModelFromHttp } from "./http.js";
 import { downloadModelFromHyperdrive } from "./hyperdrive.js";
 import { downloadModelFromRegistry } from "./registry.js";
 import { downloadModelFromHttpWithStats, downloadModelFromHyperdriveWithStats, downloadModelFromRegistryWithStats, } from "./download-stats.js";
-import { ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError, } from "../../../../utils/errors-server.js";
+import { InferenceCancelledError, ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError, } from "../../../../utils/errors-server.js";
 import { validateAndJoinPath } from "../../../utils/path-security.js";
 import { getServerLogger } from "../../../../logging/index.js";
 import { modelInputToSrcSchema } from "../../../../schemas/index.js";
@@ -74,7 +74,10 @@ function buildResult(pathOrResult, sourceType) {
     }
     return { path: pathOrResult, sourceType };
 }
-async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, hooks) {
+async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, signal, hooks) {
+    if (signal?.aborted) {
+        throw new InferenceCancelledError(hooks?.requestBinding?.requestId ?? "unknown");
+    }
     const srcString = modelInputToSrcSchema.parse(modelSrc);
     // Parse hyperdrive URLs if present
     let hyperdriveKey;
@@ -137,10 +140,10 @@ async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, hook
     }
     return { path: resolvedPath, sourceType: "filesystem" };
 }
-export async function resolveModelPath(modelSrc, progressCallback, seed, hooks) {
-    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, "base", hooks);
+export async function resolveModelPath(modelSrc, progressCallback, seed, signal, hooks) {
+    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, "base", signal, hooks);
     return result.path;
 }
-export async function resolveModelPathWithStats(modelSrc, progressCallback, seed, hooks) {
-    return resolveModelPathCore(modelSrc, progressCallback, seed, "stats", hooks);
+export async function resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, hooks) {
+    return resolveModelPathCore(modelSrc, progressCallback, seed, "stats", signal, hooks);
 }

package/dist/server/rpc/handlers/load-model/types.d.ts

@@ -1,4 +1,6 @@
 import type { SourceType } from "../../../../schemas/index";
+import type { AbortSignal } from "bare-abort-controller";
+import type { DisposableScope } from "../../../bare/runtime/disposable-scope";
 export interface DownloadStats {
     downloadTimeMs?: number;
     totalBytesDownloaded?: number;
@@ -16,12 +18,34 @@ export interface DownloadResult {
     path: string;
     stats?: DownloadStats;
 }
+/**
+ * Internal request binding threaded through `DownloadHooks` so the
+ * download manager's `startOrJoinDownload` can register a per-subscriber
+ * cancel hook against the caller's `RequestContext`. The binding's
+ * fields mirror the registry context's surface area: `signal` is wired
+ * to a subscriber-removing listener, `scope` registers the idempotent
+ * cleanup, and `requestId` lets `cancelTransfer` (legacy entry point)
+ * route cancels through `registry.cancel(...)` rather than reaching
+ * into the transfer directly.
+ */
+export interface DownloadRequestBinding {
+    signal: AbortSignal;
+    scope: DisposableScope;
+    requestId: string;
+}
 export interface DownloadHooks {
     onDownloadKey?: (key: string) => void;
     markCacheHit?: () => void;
     markCacheMiss?: () => void;
     markSharedTransfer?: () => void;
     addChecksumValidationTimeMs?: (durationMs: number) => void;
+    /**
+     * When set, `startOrJoinDownload` attaches a per-subscriber cancel
+     * listener bound to this request. `registry.cancel({ requestId })`
+     * aborts only this subscriber; the transfer keeps running for siblings
+     * joined on the same `downloadKey` until the last subscriber leaves.
+     */
+    requestBinding?: DownloadRequestBinding;
 }
 export interface LoadModelProfilingMeta {
     sourceType?: string;

package/dist/server/rpc/handlers/rag.js

@@ -1,4 +1,59 @@
-import { chunk, ingest, reindex, saveEmbeddings, search, deleteEmbeddings, listWorkspaces, closeWorkspace, deleteWorkspace, DEFAULT_WORKSPACE, registerRagOperation, unregisterRagOperation, } from "../../bare/rag-hyperdb/index.js";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { chunk, ingest, reindex, saveEmbeddings, search, deleteEmbeddings, listWorkspaces, closeWorkspace, deleteWorkspace, DEFAULT_WORKSPACE, getActiveRagRequest, setActiveRagRequest, clearActiveRagRequest, } from "../../bare/rag-hyperdb/index.js";
+import { getRequestRegistry, withRequestContext, } from "../../bare/runtime/index.js";
+import { generateServerRequestId } from "../../bare/runtime/request-id.js";
+import { getServerLogger } from "../../../logging/index.js";
 import { profileReplyHandler, registerOperationMetrics, } from "../profiling/index.js";
 registerOperationMetrics({
     op: "rag",
@@ -20,8 +75,7 @@ registerOperationMetrics({
         return Object.keys(gauges).length > 0 ? gauges : undefined;
     },
 });
-function createHandlerOptions(operation, workspace, onProgress) {
-    const signal = registerRagOperation(workspace, operation);
+function createHandlerOptions(operation, workspace, signal, onProgress) {
     const options = { signal };
     if (onProgress) {
         options.onProgress = (stage, current, total) => onProgress({
@@ -42,6 +96,37 @@ function omitOnProgress(obj) {
     void withProgress;
     return rest;
 }
+/**
+ * Begin a registry-tracked RAG context with workspace-level pre-emption.
+ *
+ * Workspace-level admission lives in the dispatcher rather than as a
+ * registry policy primitive (it's a dispatch concern, not a registry
+ * `kind` admission rule). The sequence is **cancel-prior → begin-new**:
+ * if another RAG operation is already running on the same workspace,
+ * cancel it first, then begin the new context. Reversing the order
+ * would cancel the just-installed context.
+ *
+ * The workspace → requestId map is updated after `begin(...)` succeeds
+ * and cleared on scope unwind via `scope.defer(...)`, with a
+ * "still mine?" guard so an older op's deferred cleanup cannot stomp
+ * a newer op's mapping.
+ */
+function beginRagContext(workspace, requestId) {
+    const registry = getRequestRegistry();
+    const prev = getActiveRagRequest(workspace);
+    if (prev !== undefined && prev !== requestId) {
+        registry.cancel({ requestId: prev, reason: "rag-workspace-preempt" });
+    }
+    const ctx = registry.begin({
+        requestId,
+        kind: "rag",
+    });
+    setActiveRagRequest(workspace, requestId);
+    ctx.scope.defer(() => {
+        clearActiveRagRequest(workspace, requestId);
+    });
+    return ctx;
+}
 export async function handleRag(request, onProgress) {
     return profileReplyHandler({ op: "rag", request }, async () => handleRagInternal(request, onProgress));
 }
@@ -57,10 +142,15 @@ async function handleRagInternal(request, onProgress) {
             };
         }
         case "ingest": {
-            const workspace = request.workspace ?? DEFAULT_WORKSPACE;
-            const handlerOptions = createHandlerOptions("ingest", workspace, onProgress);
-            const params = omitOnProgress(request);
+            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
+                const workspace = request.workspace ?? DEFAULT_WORKSPACE;
+                const requestId = request.requestId ?? generateServerRequestId();
+                const ctx = __addDisposableResource(env_1, beginRagContext(workspace, requestId), true);
+                const log = withRequestContext(getServerLogger(), ctx);
+                log.debug("ingest start");
+                const handlerOptions = createHandlerOptions("ingest", workspace, ctx.signal, onProgress);
+                const params = omitOnProgress(request);
                 const result = await ingest(params, handlerOptions);
                 return {
                     type: "rag",
@@ -70,15 +160,26 @@ async function handleRagInternal(request, onProgress) {
                     droppedIndices: result.droppedIndices,
                 };
             }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
             finally {
-                unregisterRagOperation(workspace);
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
             }
         }
         case "saveEmbeddings": {
-            const workspace = request.workspace ?? DEFAULT_WORKSPACE;
-            const handlerOptions = createHandlerOptions("saveEmbeddings", workspace, onProgress);
-            const params = omitOnProgress(request);
+            const env_2 = { stack: [], error: void 0, hasError: false };
             try {
+                const workspace = request.workspace ?? DEFAULT_WORKSPACE;
+                const requestId = request.requestId ?? generateServerRequestId();
+                const ctx = __addDisposableResource(env_2, beginRagContext(workspace, requestId), true);
+                const log = withRequestContext(getServerLogger(), ctx);
+                log.debug("saveEmbeddings start");
+                const handlerOptions = createHandlerOptions("saveEmbeddings", workspace, ctx.signal, onProgress);
+                const params = omitOnProgress(request);
                 const processed = await saveEmbeddings(params, handlerOptions);
                 return {
                     type: "rag",
@@ -87,8 +188,14 @@ async function handleRagInternal(request, onProgress) {
                     processed,
                 };
             }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
             finally {
-                unregisterRagOperation(workspace);
+                const result_2 = __disposeResources(env_2);
+                if (result_2)
+                    await result_2;
             }
         }
         case "search": {
@@ -109,10 +216,15 @@ async function handleRagInternal(request, onProgress) {
             };
         }
         case "reindex": {
-            const workspace = request.workspace ?? DEFAULT_WORKSPACE;
-            const handlerOptions = createHandlerOptions("reindex", workspace, onProgress);
-            const params = omitOnProgress(request);
+            const env_3 = { stack: [], error: void 0, hasError: false };
             try {
+                const workspace = request.workspace ?? DEFAULT_WORKSPACE;
+                const requestId = request.requestId ?? generateServerRequestId();
+                const ctx = __addDisposableResource(env_3, beginRagContext(workspace, requestId), true);
+                const log = withRequestContext(getServerLogger(), ctx);
+                log.debug("reindex start");
+                const handlerOptions = createHandlerOptions("reindex", workspace, ctx.signal, onProgress);
+                const params = omitOnProgress(request);
                 const result = await reindex(params, handlerOptions);
                 return {
                     type: "rag",
@@ -121,8 +233,14 @@ async function handleRagInternal(request, onProgress) {
                     result,
                 };
             }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
             finally {
-                unregisterRagOperation(workspace);
+                const result_3 = __disposeResources(env_3);
+                if (result_3)
+                    await result_3;
             }
         }
         case "listWorkspaces": {

package/dist/server/rpc/handlers/upscale-stream.d.ts

@@ -0,0 +1,3 @@
+import type { UpscaleStreamRequest, UpscaleStreamResponse } from "../../../schemas/sdcpp-config";
+export declare function handleUpscaleStream(request: UpscaleStreamRequest): AsyncGenerator<UpscaleStreamResponse>;
+//# sourceMappingURL=upscale-stream.d.ts.map

package/dist/server/rpc/handlers/upscale-stream.js

@@ -0,0 +1,4 @@
+import { dispatchPluginStream } from "./plugin-dispatch.js";
+export async function* handleUpscaleStream(request) {
+    yield* dispatchPluginStream(request.modelId, "upscaleStream", request);
+}

package/dist/server/utils/completion-normalizer.js

@@ -34,6 +34,14 @@ const DIALECT_SPECS = {
             "<|return|>",
         ],
     },
+    qwen35: {
+        // Same <tool_call>…</tool_call> framing as hermes; inner content is XML.
+        toolFrames: [{ open: "<tool_call>", close: "</tool_call>" }],
+    },
+    gemma4: {
+        toolFrames: [{ open: "<|tool_call>", close: "<tool_call|>" }],
+        thinkingFrames: [{ open: "<|channel>thought", close: "<channel|>" }],
+    },
 };
 // Capture-gated reasoning marker — the generic `<think>...</think>`
 // convention used by reasoning-tuned models. When the gate is off the

package/dist/server/utils/tools/dialect.js

@@ -6,6 +6,10 @@
 export function detectToolDialectFromName(name, path) {
     const basename = path.toLowerCase().split(/[/\\]/).pop() ?? "";
     const tag = `${(name ?? "").toLowerCase()}|${basename}`;
+    if (/qwen3[._-]?[56](?![a-z0-9])/.test(tag))
+        return "qwen35";
+    if (/gemma[-_]?4(?=[^a-z0-9]|$)/.test(tag))
+        return "gemma4";
     if (/gpt[_-]?oss/.test(tag))
         return "harmony";
     if (/lfm[_-]?\d/.test(tag))

package/dist/server/utils/tools/parser.js

@@ -3,6 +3,8 @@ import { parseGemmaFormat, parseGenericFormat, parseLlamacppFormat, } from "./pa
 import { parseHermesFormat } from "./parsers/hermes.js";
 import { parsePythonicFormat } from "./parsers/pythonic.js";
 import { parseHarmonyFormat } from "./parsers/harmony.js";
+import { parseQwen35Format } from "./parsers/qwen35.js";
+import { parseGemma4NativeFormat } from "./parsers/gemma4native.js";
 function pickFormatParsers(dialect) {
     switch (dialect) {
         case "pythonic":
@@ -15,13 +17,26 @@ function pickFormatParsers(dialect) {
             return [parseGemmaFormat, parseLlamacppFormat];
         case "harmony":
             return [parseHarmonyFormat];
+        case "qwen35":
+            // Hermes fallback: Qwen3.5 templates sometimes emit OpenAI-style JSON
+            // when the native XML format fails; Hermes chain recovers those.
+            return [parseQwen35Format, parseHermesFormat];
+        case "gemma4":
+            // No JSON fallback: Gemma4 emits only its native channel-thought dialect
+            // and never falls back to JSON-envelope formats.
+            return [parseGemma4NativeFormat];
         default:
-            // Harmony first: `to=functions.` is uniquely Harmony and can't
+            // Gemma4 first: `<|tool_call>` is uniquely distinctive and can't
             // false-match other dialects.
+            // Harmony next: `to=functions.` is also uniquely Harmony.
+            // Qwen35 before Hermes: defers to Hermes when JSON is inside <tool_call>,
+            // so the XML path is recovered without breaking Hermes-JSON payloads.
             // Pythonic last: its bare `[name(...)]` form can match payloads that
             // look like other dialects.
             return [
+                parseGemma4NativeFormat,
                 parseHarmonyFormat,
+                parseQwen35Format,
                 parseHermesFormat,
                 parseGemmaFormat,
                 parseLlamacppFormat,

package/dist/server/utils/tools/parsers/gemma4native.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "../../../../schemas/index";
+import { type ParserResult } from "../shared";
+export declare function parseGemma4NativeFormat(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=gemma4native.d.ts.map

package/dist/server/utils/tools/parsers/gemma4native.js

@@ -0,0 +1,60 @@
+import { generateStableToolCallId, validateToolArguments, } from "../shared.js";
+// Transliterates Gemma 4's JS-literal argument body to valid JSON so it can
+// be parsed with JSON.parse. The body uses:
+//   - <|"|>...<|"|> instead of "..." for string values
+//   - bare (unquoted) object keys
+// Strategy: split by <|"|> tokens so structural parts (even indices) and
+// string value parts (odd indices) are processed separately, preventing
+// the key-quoting regex from matching `, key:` patterns inside string values.
+function gemmaArgsToJson(argsRaw) {
+    const parts = ("{" + argsRaw + "}").split(/<\|"\|>/);
+    return parts
+        .map((part, i) => i % 2 === 0
+        ? part.replace(/([{,]\s*)([A-Za-z_][\w-]*)\s*:/g, '$1"$2":')
+        : '"' + part.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/[\x00-\x1f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`) + '"')
+        .join("");
+}
+// Parses Gemma 4's native tool-call dialect:
+//   <|tool_call>call:NAME{key:<|"|>val<|"|>,key2:bareNum,...}<tool_call|>
+// Keys are bare identifiers; string values are wrapped in <|"|>...<|"|>;
+// numbers/booleans are bare literals; nested objects/arrays use JS-literal
+// syntax throughout. Transliterates to JSON then parses.
+export function parseGemma4NativeFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    if (!text.includes("<|tool_call>")) {
+        return { matched: false, toolCalls, errors };
+    }
+    const callRegex = /<\|tool_call>call:([A-Za-z_][\w-]*)\{([\s\S]*?)\}<tool_call\|>/g;
+    const matches = Array.from(text.matchAll(callRegex));
+    if (matches.length === 0)
+        return { matched: false, toolCalls, errors };
+    for (const match of matches) {
+        const name = match[1];
+        const argsRaw = match[2];
+        let args;
+        try {
+            args = JSON.parse(gemmaArgsToJson(argsRaw));
+        }
+        catch (err) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: `Failed to parse Gemma 4 tool call arguments: ${err instanceof Error ? err.message : String(err)}`,
+                raw: match[0],
+            });
+            continue;
+        }
+        const validation = validateToolArguments(name, args, tools);
+        if (!validation.isValid && validation.error) {
+            errors.push({ ...validation.error, raw: match[0] });
+            continue;
+        }
+        toolCalls.push({
+            id: generateStableToolCallId(name, args),
+            name,
+            arguments: args,
+            raw: match[0],
+        });
+    }
+    return { matched: true, toolCalls, errors };
+}

package/dist/server/utils/tools/parsers/qwen35.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "../../../../schemas/index";
+import { type ParserResult } from "../shared";
+export declare function parseQwen35Format(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=qwen35.d.ts.map

package/dist/server/utils/tools/parsers/qwen35.js

@@ -0,0 +1,120 @@
+import { generateStableToolCallId, validateToolArguments, } from "../shared.js";
+// Coerce raw parameter text to the type declared in the tool's JSON schema.
+// String values are raw (not JSON-quoted); arrays/objects are valid JSON.
+function coerceParamValue(raw, schema) {
+    const trimmed = raw.trim();
+    if (!schema?.type)
+        return trimmed;
+    switch (schema.type) {
+        case "number": {
+            if (trimmed.length === 0)
+                throw new Error(`invalid numeric value: ""`);
+            const n = Number(trimmed);
+            if (Number.isNaN(n))
+                throw new Error(`invalid numeric value: "${trimmed}"`);
+            return n;
+        }
+        case "integer": {
+            if (trimmed.length === 0)
+                throw new Error(`invalid integer value: ""`);
+            const n = Number(trimmed);
+            if (Number.isNaN(n) || !Number.isInteger(n))
+                throw new Error(`invalid integer value: "${trimmed}"`);
+            return n;
+        }
+        case "boolean":
+            if (trimmed === "true")
+                return true;
+            if (trimmed === "false")
+                return false;
+            throw new Error(`invalid boolean value: "${trimmed}"`);
+        case "array":
+        case "object":
+            return JSON.parse(trimmed);
+        default:
+            return trimmed;
+    }
+}
+// Parses Qwen3.5/3.6 Pythonic-XML tool-call format:
+//   <tool_call>
+//   <function=NAME>
+//   <parameter=KEY>VALUE</parameter>
+//   </function>
+//   </tool_call>
+// String parameter values are raw text (not JSON-quoted); arrays/objects
+// are JSON. Type coercion uses the tool schema; unknown params pass through.
+export function parseQwen35Format(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    if (!text.includes("<tool_call>")) {
+        return { matched: false, toolCalls, errors };
+    }
+    const outerRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+    const outerMatches = Array.from(text.matchAll(outerRegex));
+    if (outerMatches.length === 0)
+        return { matched: false, toolCalls, errors };
+    // If no match contains XML function syntax, check if this is JSON format
+    // (defer to hermes) or just malformed content (surface as PARSE_ERROR).
+    if (!outerMatches.some((m) => m[1].includes("<function="))) {
+        const looksLikeJson = outerMatches.some((m) => {
+            const inner = m[1].trim();
+            return inner.startsWith("{") || inner.startsWith("[");
+        });
+        if (looksLikeJson)
+            return { matched: false, toolCalls, errors };
+        return {
+            matched: true,
+            toolCalls,
+            errors: outerMatches.map((m) => ({
+                code: "PARSE_ERROR",
+                message: "Qwen3.5 tool call missing <function=NAME>...</function>",
+                raw: m[1].trim(),
+            })),
+        };
+    }
+    for (const outerMatch of outerMatches) {
+        const inner = outerMatch[1].trim();
+        const fnMatch = /<function=([^>\s]+)\s*>([\s\S]*?)<\/function>/i.exec(inner);
+        if (!fnMatch) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: "Qwen3.5 tool call missing <function=NAME>...</function>",
+                raw: inner,
+            });
+            continue;
+        }
+        const name = fnMatch[1].trim();
+        const paramsBlock = fnMatch[2];
+        const tool = tools.find((t) => t.name === name);
+        const schemaProperties = tool?.parameters?.properties ?? {};
+        const args = {};
+        let parseError;
+        try {
+            const paramRegex = /<parameter=([^>\s]+)\s*>([\s\S]*?)<\/parameter>/gi;
+            let pm;
+            while ((pm = paramRegex.exec(paramsBlock)) !== null) {
+                const paramName = pm[1].trim();
+                args[paramName] = coerceParamValue(pm[2], schemaProperties[paramName]);
+            }
+        }
+        catch (err) {
+            parseError = err instanceof Error ? err.message : String(err);
+        }
+        if (parseError !== undefined) {
+            errors.push({ code: "PARSE_ERROR", message: parseError, raw: inner });
+            continue;
+        }
+        const validation = validateToolArguments(name, args, tools);
+        if (!validation.isValid && validation.error) {
+            errors.push({ ...validation.error, raw: inner });
+            continue;
+        }
+        toolCalls.push({
+            id: generateStableToolCallId(name, args),
+            name,
+            arguments: args,
+            raw: inner,
+        });
+    }
+    return { matched: true, toolCalls, errors };
+}

package/dist/utils/aggregate-events.d.ts

@@ -7,10 +7,19 @@ export type AggregatedEvents = {
     toolCalls: ToolCall[];
     rawFullText: string | undefined;
     error: CompletionError | undefined;
+    /**
+     * True when the terminal `completionDone` carried
+     * `stopReason: "cancelled"`. The client wrapper rejects the
+     * promise-aggregates (`final` / `text` / `toolCalls` / `stats`) with
+     * `InferenceCancelledError` carrying the partial state when this is
+     * set; the `events` stream itself still ends normally.
+     */
+    cancelled: boolean;
 };
 export declare function aggregateEvents(events: CompletionEvent[]): AggregatedEvents;
 export declare function buildFinalFromEvents(events: CompletionEvent[], handlers: ToolHandlerMap): {
     final: CompletionFinal;
     error: CompletionError | undefined;
+    cancelled: boolean;
 };
 //# sourceMappingURL=aggregate-events.d.ts.map

package/dist/utils/aggregate-events.js

@@ -6,6 +6,7 @@ export function aggregateEvents(events) {
     let stats;
     let rawFullText;
     let error;
+    let cancelled = false;
     const toolCalls = [];
     for (const event of events) {
         if (event.type === "contentDelta") {
@@ -24,15 +25,29 @@ export function aggregateEvents(events) {
             if ("raw" in event && event.raw) {
                 rawFullText = event.raw.fullText;
             }
+            // Error wins over cancelled if a wire event ever carries both
+            // signals: a mid-stream addon failure makes the partial state
+            // unsafe to expose, regardless of why the loop exited.
             if (event.stopReason === "error" && "error" in event) {
                 error = event.error;
             }
+            else if (event.stopReason === "cancelled") {
+                cancelled = true;
+            }
         }
     }
-    return { contentText, thinkingText, stats, toolCalls, rawFullText, error };
+    return {
+        contentText,
+        thinkingText,
+        stats,
+        toolCalls,
+        rawFullText,
+        error,
+        cancelled,
+    };
 }
 export function buildFinalFromEvents(events, handlers) {
-    const { contentText, thinkingText, stats, toolCalls, rawFullText, error } = aggregateEvents(events);
+    const { contentText, thinkingText, stats, toolCalls, rawFullText, error, cancelled, } = aggregateEvents(events);
     const attachedToolCalls = attachHandlersToToolCalls(toolCalls, handlers);
     const fullText = rawFullText ?? contentText;
     const cacheableAssistantContent = attachedToolCalls.length === 0
@@ -48,5 +63,5 @@ export function buildFinalFromEvents(events, handlers) {
             cacheableAssistantContent,
         }),
     };
-    return { final, error };
+    return { final, error, cancelled };
 }