@aexol/spectral 0.9.231 → 0.9.240

package/dist/sdk/ai/providers/leaked-tool-call-parser.js

@@ -15,6 +15,12 @@
  * where the wrapper tag is `function_calls` (optionally with an `antml:`
  * namespace prefix) and invoke/parameter tags follow the same convention.
  *
+ * Models also emit the same markup WITHOUT the wrapper — orphan
+ * `<invoke name="x">…</invoke>` blocks straight in prose (pi-style) — or
+ * truncated blocks that never receive their closing tags before the stream
+ * ends. Both shapes are recovered: orphan blocks during streaming, truncated
+ * parameter-complete tails at end of stream (see salvageLeakedToolCallTail).
+ *
  * Everything here is pure string logic — no provider imports — so the tests
  * cover it without any streaming harness.
  */
@@ -22,16 +28,52 @@
 const NS = "(?:antml:)?";
 const INVOKE_RE = new RegExp(`<${NS}invoke\\s+name="([^"]*)"\\s*>([\\s\\S]*?)</${NS}invoke\\s*>`, "g");
 const PARAMETER_RE = new RegExp(`<${NS}parameter\\s+name="([^"]*)"\\s*>([\\s\\S]*?)</${NS}parameter\\s*>`, "g");
+const INVOKE_OPEN_RE = new RegExp(`<${NS}invoke\\s+name="([^"]*)"\\s*>`, "g");
+const INVOKE_CLOSE_RE = new RegExp(`</${NS}invoke\\s*>`, "g");
+const PARAMETER_OPEN_RE = new RegExp(`<${NS}parameter\\s+name="[^"]*"\\s*>`, "g");
 const WRAPPER_OPEN_RE = /<(?:antml:)?function_calls\s*>/;
 const WRAPPER_CLOSE = /<\/(?:antml:)?function_calls\s*>/;
-/** Longest opener tag is the antml-prefixed one (22 chars). Keep a margin. */
+/**
+ * Floor for how much tail a caller should expect a partial opener to occupy
+ * (the longest opener tag is the antml-prefixed one, 22 chars, plus margin).
+ * Partial detection anchors at the last `<` of the buffered text, so an
+ * invoke opener whose name attribute is still open can hold back more than
+ * this when the tool name is long — it is a floor, not a cap.
+ */
 export const LEAK_TAIL_LENGTH = 32;
 const OPENER_PREFIXES = ["<function_calls", "<antml:function_calls"];
+const INVOKE_OPENER_PREFIXES = ['<invoke name="', '<antml:invoke name="'];
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * A buffered tail that could still grow into a leaked opener, matched
+ * (anchored) against everything from the last `<` of the buffered text:
+ * - any prefix of a wrapper/invoke opener literal, from a bare `<` up to the
+ *   full declared prefix (`<function_ca`, `<invoke name="`),
+ * - an invoke opener whose double-quoted name attribute is still open
+ *   (`<invoke name="bash` — the closing `">` has not arrived), however long
+ *   the name is.
+ * Single-quoted names and attribute-less `<invoke>` tags never match, so
+ * ordinary prose (`a < b`, `Array<string>`) stays out of the buffer.
+ */
+const PARTIAL_TAIL_RE = new RegExp(`^(?:${[
+    ...[...OPENER_PREFIXES, ...INVOKE_OPENER_PREFIXES].flatMap((opener) => {
+        const prefixes = [];
+        for (let size = 1; size <= opener.length; size++) {
+            prefixes.push(escapeRegExp(opener.slice(0, size)));
+        }
+        return prefixes;
+    }),
+    '<(?:antml:)?invoke\\s+name="[^">]*',
+].join("|")})$`);
 /**
- * Locate a leaked wrapper-opener tag in `text`.
+ * Locate a leaked opener tag in `text` — either the wrapper
+ * (`<function_calls>`) or an orphan invoke (`<invoke name="x">`, pi-style
+ * markup emitted without the wrapper).
  * - "full": a complete opener tag exists; `index` points at its `<`.
- * - "partial": the text ENDS with a strict prefix of an opener tag (an opener
- *   split across streaming deltas); `index` points at the start of that tail.
+ * - "partial": the text ENDS mid-opener (an opener split across streaming
+ *   deltas); `index` points at the start of that tail. A partial always
+ *   starts at the last `<` — the tail matcher admits no further `<` — so the
+ *   scan is a single anchored match there instead of a prefix enumeration.
  * - "none": no opener, complete or partial.
  */
 export function findLeakedToolCallOpener(text) {
@@ -46,19 +88,16 @@ export function findLeakedToolCallOpener(text) {
             best = { match: "full", index: m.index };
         }
     }
+    for (const m of text.matchAll(INVOKE_OPEN_RE)) {
+        if (best.match !== "full" || m.index < best.index) {
+            best = { match: "full", index: m.index };
+        }
+    }
     if (best.match === "full")
         return best;
-    for (const opener of OPENER_PREFIXES) {
-        const maxLen = Math.min(opener.length - 1, text.length);
-        for (let size = maxLen; size > 0; size--) {
-            if (text.endsWith(opener.slice(0, size))) {
-                const index = text.length - size;
-                if (best.match === "none" || index < best.index) {
-                    best = { match: "partial", index };
-                }
-                break;
-            }
-        }
+    const lastLt = text.lastIndexOf("<");
+    if (lastLt >= 0 && PARTIAL_TAIL_RE.test(text.slice(lastLt))) {
+        best = { match: "partial", index: lastLt };
     }
     return best;
 }
@@ -71,13 +110,17 @@ export function findLeakedToolCallOpener(text) {
  *   before + after). `consumed` is the raw block text (opener→closer
  *   inclusive) so callers can fall back to emitting it as text when the
  *   parsed tool names turn out to be unknown.
- * - `complete: false` → no closed wrapper block yet; `calls` is empty and
- *   `remaining`/`consumed` echo the input so nothing is cut prematurely.
+ * When no wrapper opener exists at all, orphan invoke blocks (pi-style, no
+ * wrapper) are parsed instead — but only when EVERY invoke opener has a
+ * matching closer; otherwise `complete: false` and `remaining`/`consumed`
+ * echo the input so nothing is cut prematurely. (A wrapper opener blocks the
+ * orphan path: wrapper-less invokes around a wrapper block are picked up
+ * later from `remaining`, once the wrapper block itself is consumed.)
  */
 export function extractLeakedToolCalls(text) {
     const openMatch = WRAPPER_OPEN_RE.exec(text);
     if (!openMatch) {
-        return { calls: [], complete: false, remaining: text, consumed: "" };
+        return extractOrphanInvokes(text);
     }
     const openStart = openMatch.index;
     const bodyStart = openStart + openMatch[0].length;
@@ -112,6 +155,104 @@ export function extractLeakedToolCalls(text) {
         remaining: text.slice(0, openStart) + text.slice(closeEnd + 1),
     };
 }
+/**
+ * Orphan invoke blocks: pi-style markup without any wrapper tag. Complete
+ * only when EVERY invoke opener has a matching closer; otherwise nothing is
+ * cut and the caller keeps buffering. `consumed` spans the first opener
+ * through the last closer (prose between invokes inside the parsed region is
+ * dropped, mirroring the wrapper path) and `remaining` echoes the prose
+ * before and after.
+ */
+function extractOrphanInvokes(text) {
+    const opens = [...text.matchAll(INVOKE_OPEN_RE)];
+    if (opens.length === 0) {
+        return { calls: [], complete: false, remaining: text, consumed: "" };
+    }
+    const closes = [...text.matchAll(INVOKE_CLOSE_RE)];
+    let closerPtr = 0;
+    const calls = [];
+    let firstOpen = -1;
+    let lastCloseEnd = -1;
+    for (const open of opens) {
+        const openStart = open.index;
+        if (firstOpen === -1)
+            firstOpen = openStart;
+        while (closerPtr < closes.length && closes[closerPtr].index < openStart) {
+            closerPtr++;
+        }
+        const closer = closes[closerPtr];
+        if (!closer) {
+            return { calls: [], complete: false, remaining: text, consumed: "" };
+        }
+        const body = text.slice(openStart + open[0].length, closer.index);
+        const args = {};
+        for (const p of body.matchAll(PARAMETER_RE)) {
+            args[p[1]] = p[2].trim();
+        }
+        calls.push({ name: open[1], args });
+        closerPtr++;
+        lastCloseEnd = closer.index + closer[0].length;
+    }
+    return {
+        calls,
+        complete: true,
+        consumed: text.slice(firstOpen, lastCloseEnd),
+        remaining: text.slice(0, firstOpen) + text.slice(lastCloseEnd),
+    };
+}
+/**
+ * End-of-stream recovery for a leaked buffer that never received its closing
+ * tags (stream cut off, or a model that forgets `</invoke>` / the wrapper
+ * closer). Parses invoke blocks tolerantly: a missing closer is fine as long
+ * as every `<parameter>` value is fully closed. A truncated parameter value
+ * means the model was cut mid-argument — guessing at the value is unsafe, so
+ * the whole tail degrades to plain text (null).
+ *
+ * Returns the parsed calls (leading wrapper skeleton dropped), or null when
+ * nothing salvageable remains. Callers still validate tool names before
+ * emitting synthetic tool calls.
+ */
+export function salvageLeakedToolCallTail(text) {
+    const opens = [...text.matchAll(INVOKE_OPEN_RE)];
+    if (opens.length === 0)
+        return null;
+    const closes = [...text.matchAll(INVOKE_CLOSE_RE)];
+    const calls = [];
+    let closerPtr = 0;
+    for (let i = 0; i < opens.length; i++) {
+        const open = opens[i];
+        const openStart = open.index;
+        while (closerPtr < closes.length && closes[closerPtr].index < openStart) {
+            closerPtr++;
+        }
+        const closer = closes[closerPtr];
+        const nextOpen = opens[i + 1];
+        let bodyEnd;
+        if (closer && (!nextOpen || closer.index < nextOpen.index)) {
+            bodyEnd = closer.index;
+            closerPtr++;
+        }
+        else if (nextOpen) {
+            // Unclosed invoke whose body runs up to the next opener.
+            bodyEnd = nextOpen.index;
+        }
+        else {
+            bodyEnd = text.length;
+        }
+        const body = text.slice(openStart + open[0].length, bodyEnd);
+        const args = {};
+        for (const p of body.matchAll(PARAMETER_RE)) {
+            args[p[1]] = p[2].trim();
+        }
+        const paramOpeners = [...body.matchAll(PARAMETER_OPEN_RE)];
+        if (paramOpeners.length > 0 &&
+            paramOpeners.length !== [...body.matchAll(PARAMETER_RE)].length) {
+            return null;
+        }
+        calls.push({ name: open[1], args });
+    }
+    return calls;
+}
 /**
  * Coerce a leaked parameter string into a JSON value when it clearly parses
  * as one — native `tool_calls` arguments are real JSON, so a leaked

package/dist/sdk/ai/providers/openai-completions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai-completions.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/openai-completions.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAMX,0BAA0B,EAE1B,MAAM,sCAAsC,CAAC;AAI9C,OAAO,KAAK,EAGX,OAAO,EAGP,KAAK,EACL,uBAAuB,EACvB,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AA+FrB,MAAM,WAAW,wBAAyB,SAAQ,aAAa;IAC9D,UAAU,CAAC,EACR,MAAM,GACN,MAAM,GACN,UAAU,GACV;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACpD,eAAe,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;CAClE;AAED,KAAK,+BAA+B,GAAG,QAAQ,CAAC,uBAAuB,CAAC,CAAC;AAuBzE,eAAO,MAAM,uBAAuB,EAAE,cAAc,CACnD,oBAAoB,EACpB,wBAAwB,CAylBxB,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,cAAc,CACzD,oBAAoB,EACpB,mBAAmB,CAyBnB,CAAC;AAkNF,wBAAgB,eAAe,CAC9B,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,+BAA+B,GACrC,0BAA0B,EAAE,CA0R9B"}
+{"version":3,"file":"openai-completions.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/openai-completions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAMX,0BAA0B,EAE1B,MAAM,sCAAsC,CAAC;AAI9C,OAAO,KAAK,EAGX,OAAO,EAGP,KAAK,EACL,uBAAuB,EACvB,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AA+FrB,MAAM,WAAW,wBAAyB,SAAQ,aAAa;IAC9D,UAAU,CAAC,EACR,MAAM,GACN,MAAM,GACN,UAAU,GACV;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACpD,eAAe,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;CAClE;AAED,KAAK,+BAA+B,GAAG,QAAQ,CAAC,uBAAuB,CAAC,CAAC;AAuBzE,eAAO,MAAM,uBAAuB,EAAE,cAAc,CACnD,oBAAoB,EACpB,wBAAwB,CAumBxB,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,cAAc,CACzD,oBAAoB,EACpB,mBAAmB,CAyBnB,CAAC;AAkNF,wBAAgB,eAAe,CAC9B,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,+BAA+B,GACrC,0BAA0B,EAAE,CA0R9B"}

package/dist/sdk/ai/providers/openai-completions.js

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import { coerceLeakedParameterValue, extractLeakedToolCalls, findLeakedToolCallOpener, } from "./leaked-tool-call-parser.js";
+import { coerceLeakedParameterValue, extractLeakedToolCalls, findLeakedToolCallOpener, salvageLeakedToolCallTail, } from "./leaked-tool-call-parser.js";
 import { backendHostedImageResolver } from "../utils/hosted-image-resolver.js";
 import { getApiUrl, readConfig } from "../../../config.js";
 import { getEnvApiKey } from "../env-api-keys.js";
@@ -179,9 +179,11 @@ export const streamOpenAICompletions = (model, context, options) => {
             let inlineThinkingPending = "";
             let inInlineThinking = false;
             // Leaked tool-call XML: some OpenRouter models emit antml-style
-            // markup in plain content instead of native tool_calls. Text is
-            // buffered here until a complete wrapper block arrives, then parsed
-            // into real toolCall blocks (see leaked-tool-call-parser.ts).
+            // markup in plain content instead of native tool_calls — either a
+            // wrapper block or orphan pi-style invoke blocks with no wrapper
+            // at all. Text is buffered here until a complete block arrives,
+            // then parsed into real toolCall blocks (see
+            // leaked-tool-call-parser.ts).
             let leakMode = false;
             let leakBuffer = "";
             let leakPending = "";
@@ -548,11 +550,23 @@ export const streamOpenAICompletions = (model, context, options) => {
                 }
                 inlineThinkingPending = "";
             }
-            // Flush leak buffers. A never-closed block is emitted as plain text
-            // (graceful degradation) so no content is lost; a held-back tail
-            // without an opener is just prose.
+            // Flush leak buffers. A never-closed block is first offered to the
+            // end-of-stream salvage (models that were cut off after emitting
+            // complete parameter values); whatever it cannot recover is emitted
+            // as plain text (graceful degradation) so no content is lost. A
+            // held-back tail without an opener is just prose.
             if (leakMode && leakBuffer) {
-                emitTextDelta(leakBuffer);
+                const salvaged = salvageLeakedToolCallTail(leakBuffer);
+                if (salvaged &&
+                    salvaged.length > 0 &&
+                    salvaged.every((call) => availableToolNames.has(call.name))) {
+                    for (const call of salvaged)
+                        emitSyntheticToolCall(call);
+                    emittedLeakedToolCalls = true;
+                }
+                else {
+                    emitTextDelta(leakBuffer);
+                }
                 leakBuffer = "";
                 leakMode = false;
             }

package/dist/sdk/ai/providers/openrouter-videos.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderVideosOptions, VideosContext, VideosModel, VideosResult } from "../types.js";
+export declare function generateOpenRouterVideos(model: VideosModel<"openrouter-videos">, context: VideosContext, options?: ProviderVideosOptions): Promise<VideosResult>;
+//# sourceMappingURL=openrouter-videos.d.ts.map

package/dist/sdk/ai/providers/openrouter-videos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter-videos.d.ts","sourceRoot":"","sources":["../../../../src/sdk/ai/providers/openrouter-videos.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,qBAAqB,EAIrB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,MAAM,aAAa,CAAC;AAgarB,wBAAsB,wBAAwB,CAC7C,KAAK,EAAE,WAAW,CAAC,mBAAmB,CAAC,EACvC,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,qBAA0B,GACjC,OAAO,CAAC,YAAY,CAAC,CAkCvB"}