@sunerpy/opencode-kiro-auth 0.5.0 → 0.5.2

package/dist/infrastructure/transformers/tool-call-parser.d.ts

@@ -2,3 +2,18 @@ import type { ToolCall } from '../../plugin/types.js';
 export declare function parseBracketToolCalls(text: string): ToolCall[];
 export declare function deduplicateToolCalls(toolCalls: ToolCall[]): ToolCall[];
 export declare function cleanToolCallsFromText(text: string, toolCalls: ToolCall[]): string;
+export declare const DSML_MARKER = "<\uFF5CDSML\uFF5Cfunction_calls";
+/**
+ * Recognize Anthropic XML, deepseek DSML, and legacy bracket tool-call dialects
+ * in `text`. Returns the parsed tool calls plus `cleanedText` with EXACTLY the
+ * matched dialect spans removed (all other text preserved verbatim).
+ *
+ * Phantom-execution guards:
+ *  - only COMPLETE closed tags match (an unclosed `<invoke name="x">` is text);
+ *  - candidates inside fenced/inline code are skipped;
+ *  - a dialect that yields no parseable call is stripped, never fabricated.
+ */
+export declare function parseTextToolCalls(text: string): {
+    toolCalls: ToolCall[];
+    cleanedText: string;
+};

package/dist/infrastructure/transformers/tool-call-parser.js

@@ -43,3 +43,245 @@ export function cleanToolCallsFromText(text, toolCalls) {
     cleaned = cleaned.replace(/\s+/g, ' ').trim();
     return cleaned;
 }
+// ---------------------------------------------------------------------------
+// Text-dialect tool-call recovery (bleed-stop)
+//
+// Some models emit tool calls as literal TEXT dialects instead of the
+// structured toolUseEvent path:
+//   (a) Anthropic XML:  <function_calls><invoke name="X"><parameter name="k">v</parameter></invoke></function_calls>
+//                       (and a standalone <invoke name="X">...</invoke>)
+//   (b) deepseek DSML:  <｜DSML｜function_calls...   (U+FF5C '｜', NOT ASCII '|')
+//   (c) bracket:        [Called X with args:{...}]  (legacy, kept)
+//
+// These leak verbatim and stall the turn. `parseTextToolCalls` rescues them
+// into structured ToolCalls and returns the text with EXACTLY the matched
+// spans removed. It is deliberately conservative: only COMPLETE closed tags
+// match, candidates inside fenced/inline code are skipped, and a dialect that
+// cannot be parsed is stripped (never fabricated into a phantom call).
+// ---------------------------------------------------------------------------
+// deepseek DSML opening marker — the exact U+FF5C ('｜') form observed leaking.
+export const DSML_MARKER = '<\uFF5CDSML\uFF5Cfunction_calls';
+function genToolUseId() {
+    return `tool_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+/**
+ * Compute char ranges that are inside fenced code blocks (``` ... ```) or
+ * inline code spans (` ... `). Candidates overlapping any of these are skipped
+ * so a model *explaining* or *showing* tool-call syntax is never executed.
+ */
+function computeCodeRanges(text) {
+    const ranges = [];
+    const fence = /```[\s\S]*?```/g;
+    let m;
+    while ((m = fence.exec(text)) !== null) {
+        ranges.push([m.index, m.index + m[0].length]);
+    }
+    const inFence = (i) => ranges.some(([s, e]) => i >= s && i < e);
+    const inline = /`[^`\n]+`/g;
+    while ((m = inline.exec(text)) !== null) {
+        if (!inFence(m.index))
+            ranges.push([m.index, m.index + m[0].length]);
+    }
+    return ranges;
+}
+function overlapsCode(start, end, codeRanges) {
+    return codeRanges.some(([s, e]) => start < e && end > s);
+}
+function overlapsClaimed(start, end, claimed) {
+    return claimed.some(([s, e]) => start < e && end > s);
+}
+/** Parse `<parameter name="K">V</parameter>` pairs from an invoke body into an input object. */
+function parseInvokeParameters(body) {
+    const input = {};
+    const paramRe = /<parameter\s+name="([^"]+)"\s*>([\s\S]*?)<\/parameter>/g;
+    let pm;
+    while ((pm = paramRe.exec(body)) !== null) {
+        const key = pm[1];
+        const rawVal = pm[2];
+        if (key === undefined)
+            continue;
+        const val = rawVal ?? '';
+        try {
+            input[key] = JSON.parse(val);
+        }
+        catch {
+            input[key] = val;
+        }
+    }
+    return input;
+}
+/** Build a ToolCall from a single complete `<invoke name="...">...</invoke>` block. */
+function toolCallFromInvoke(name, body) {
+    return {
+        toolUseId: genToolUseId(),
+        name,
+        input: parseInvokeParameters(body)
+    };
+}
+/**
+ * Match complete Anthropic XML dialects:
+ *   - `<function_calls>...(invoke)+...</function_calls>` blocks
+ *   - standalone `<invoke name="X">...</invoke>` NOT inside a function_calls block
+ * Skips candidates inside code and records claimed ranges to avoid double-match.
+ */
+function matchAnthropicXml(text, codeRanges, claimed) {
+    const matches = [];
+    // (1) complete <function_calls>...</function_calls> blocks
+    const blockRe = /<function_calls>[\s\S]*?<\/function_calls>/g;
+    let bm;
+    while ((bm = blockRe.exec(text)) !== null) {
+        const start = bm.index;
+        const end = start + bm[0].length;
+        if (overlapsCode(start, end, codeRanges))
+            continue;
+        const invokeRe = /<invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/invoke>/g;
+        const toolCalls = [];
+        let im;
+        while ((im = invokeRe.exec(bm[0])) !== null) {
+            const name = im[1];
+            if (!name)
+                continue;
+            toolCalls.push(toolCallFromInvoke(name, im[2] ?? ''));
+        }
+        // Only treat as a tool-call span if at least one invoke parsed; otherwise
+        // it is not a real dialect payload — leave the text untouched.
+        if (toolCalls.length === 0)
+            continue;
+        matches.push({ start, end, toolCalls });
+        claimed.push([start, end]);
+    }
+    // (2) standalone complete <invoke ...>...</invoke> not inside a claimed block
+    const invokeRe = /<invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/invoke>/g;
+    let sm;
+    while ((sm = invokeRe.exec(text)) !== null) {
+        const start = sm.index;
+        const end = start + sm[0].length;
+        const name = sm[1];
+        if (!name)
+            continue;
+        if (overlapsCode(start, end, codeRanges))
+            continue;
+        if (overlapsClaimed(start, end, claimed))
+            continue;
+        matches.push({ start, end, toolCalls: [toolCallFromInvoke(name, sm[2] ?? '')] });
+        claimed.push([start, end]);
+    }
+    return matches;
+}
+/**
+ * Match the deepseek DSML dialect. The strip span runs from the exact U+FF5C
+ * marker to its closing counterpart if one exists, else to end-of-text (the
+ * observed trailing leak). Best-effort recovery of name/args; if not cleanly
+ * recoverable the span is stripped WITHOUT fabricating a call.
+ */
+function matchDsml(text, codeRanges, claimed) {
+    const matches = [];
+    let from = 0;
+    for (;;) {
+        const start = text.indexOf(DSML_MARKER, from);
+        if (start === -1)
+            break;
+        // Closing counterpart: a DSML end token (U+FF5C ... end ... U+FF5C) after
+        // the marker, else consume to end-of-text.
+        const rest = text.slice(start + DSML_MARKER.length);
+        const closeRe = /<\uFF5C[^>]*?end[^>]*?>|<\/\uFF5CDSML[^>]*?>/;
+        const cm = closeRe.exec(rest);
+        const end = cm !== null ? start + DSML_MARKER.length + cm.index + cm[0].length : text.length;
+        from = end;
+        if (overlapsCode(start, end, codeRanges))
+            continue;
+        if (overlapsClaimed(start, end, claimed))
+            continue;
+        // Best-effort recovery — only fires on a clean name + JSON args pair.
+        const span = text.slice(start, end);
+        const toolCalls = [];
+        const nameM = /name["\uFF5C=:\s]+["']?([A-Za-z0-9_]+)/.exec(span);
+        const jsonM = /(\{[\s\S]*\})/.exec(span);
+        if (nameM?.[1] && jsonM?.[1]) {
+            try {
+                toolCalls.push({
+                    toolUseId: genToolUseId(),
+                    name: nameM[1],
+                    input: JSON.parse(jsonM[1])
+                });
+            }
+            catch {
+                // fall through to strip-only
+            }
+        }
+        matches.push({ start, end, toolCalls });
+        claimed.push([start, end]);
+    }
+    return matches;
+}
+/**
+ * Match legacy `[Called X with args:{...}]` spans (for cleanedText) and their
+ * tool calls, skipping candidates inside code.
+ */
+function matchBracket(text, codeRanges, claimed) {
+    const matches = [];
+    const pattern = /\[Called\s+(\w+)\s+with\s+args:\s*(\{[^}]*(?:\{[^}]*\}[^}]*)*\})\]/gs;
+    let m;
+    while ((m = pattern.exec(text)) !== null) {
+        const start = m.index;
+        const end = start + m[0].length;
+        const name = m[1];
+        const argsStr = m[2];
+        if (!name || !argsStr)
+            continue;
+        if (overlapsCode(start, end, codeRanges))
+            continue;
+        if (overlapsClaimed(start, end, claimed))
+            continue;
+        let input;
+        try {
+            input = JSON.parse(argsStr);
+        }
+        catch {
+            continue;
+        }
+        matches.push({
+            start,
+            end,
+            toolCalls: [{ toolUseId: genToolUseId(), name, input }]
+        });
+        claimed.push([start, end]);
+    }
+    return matches;
+}
+/**
+ * Recognize Anthropic XML, deepseek DSML, and legacy bracket tool-call dialects
+ * in `text`. Returns the parsed tool calls plus `cleanedText` with EXACTLY the
+ * matched dialect spans removed (all other text preserved verbatim).
+ *
+ * Phantom-execution guards:
+ *  - only COMPLETE closed tags match (an unclosed `<invoke name="x">` is text);
+ *  - candidates inside fenced/inline code are skipped;
+ *  - a dialect that yields no parseable call is stripped, never fabricated.
+ */
+export function parseTextToolCalls(text) {
+    if (!text)
+        return { toolCalls: [], cleanedText: text };
+    const codeRanges = computeCodeRanges(text);
+    const claimed = [];
+    const matches = [
+        ...matchAnthropicXml(text, codeRanges, claimed),
+        ...matchDsml(text, codeRanges, claimed),
+        ...matchBracket(text, codeRanges, claimed)
+    ];
+    if (matches.length === 0)
+        return { toolCalls: [], cleanedText: text };
+    matches.sort((a, b) => a.start - b.start);
+    const toolCalls = [];
+    let cleanedText = '';
+    let cursor = 0;
+    for (const mt of matches) {
+        if (mt.start < cursor)
+            continue; // defensive against any residual overlap
+        cleanedText += text.slice(cursor, mt.start);
+        cursor = mt.end;
+        toolCalls.push(...mt.toolCalls);
+    }
+    cleanedText += text.slice(cursor);
+    return { toolCalls, cleanedText };
+}

package/dist/plugin/request.js

@@ -7,6 +7,28 @@ import { convertToolsToCodeWhisperer, deduplicateToolResults } from '../infrastr
 import { getEffectiveEffort, resolveEffort } from './effort.js';
 import { convertImagesToKiroFormat, extractAllImages, extractTextFromParts } from './image-handler.js';
 import { resolveModelVariant } from './models.js';
+function jsonSchemaTypeOf(value) {
+    if (Array.isArray(value))
+        return 'array';
+    if (value === null)
+        return 'string';
+    const t = typeof value;
+    if (t === 'number' || t === 'boolean' || t === 'string' || t === 'object')
+        return t;
+    return 'string';
+}
+// No `required` fields are inferred: fabricated required keys risk a 400.
+function inferToolSpecFromHistory(name, toolUsesInHistory) {
+    const sample = toolUsesInHistory.find((tu) => tu.name === name && tu.input && typeof tu.input === 'object' && !Array.isArray(tu.input));
+    const properties = {};
+    if (sample && sample.input) {
+        for (const [key, val] of Object.entries(sample.input)) {
+            properties[key] = { type: jsonSchemaTypeOf(val) };
+        }
+    }
+    const json = Object.keys(properties).length > 0 ? { type: 'object', properties } : { type: 'object' };
+    return { name, description: `Tool ${name}`, inputSchema: { json } };
+}
 function buildCodeWhispererRequest(body, model, auth, think = false, budget = 20000, showToast) {
     const req = typeof body === 'string' ? JSON.parse(body) : body;
     const { messages, tools, system } = req;
@@ -228,13 +250,10 @@ function buildCodeWhispererRequest(body, model, auth, think = false, budget = 20
                 const existingToolNames = new Set(existingTools.map((t) => t.toolSpecification?.name).filter(Boolean));
                 const missingToolNames = Array.from(toolNamesInHistory).filter((name) => !existingToolNames.has(name));
                 if (missingToolNames.length > 0) {
-                    const placeholderTools = missingToolNames.map((name) => ({
-                        toolSpecification: {
-                            name,
-                            description: 'Tool',
-                            inputSchema: { json: { type: 'object', properties: {} } }
-                        }
-                    }));
+                    const placeholderTools = missingToolNames.map((name) => {
+                        const inferred = inferToolSpecFromHistory(name, toolUsesInHistory);
+                        return { toolSpecification: inferred };
+                    });
                     if (!uim.userInputMessageContext)
                         uim.userInputMessageContext = {};
                     uim.userInputMessageContext.tools = [...existingTools, ...placeholderTools];

package/dist/plugin/streaming/dialect-gate.d.ts

@@ -0,0 +1,29 @@
+import type { ToolCall } from '../types.js';
+/**
+ * Streaming suppression gate for text-dialect tool calls.
+ *
+ * Visible assistant reply text is pushed through the gate as it streams. While
+ * no dialect opening marker has appeared, the gate returns the safe prefix to
+ * stream (holding back only a possible partial-marker tail). Once a marker
+ * appears, everything from the marker onward is withheld. At finalization,
+ * `finalize()` parses the full accumulated text into structured tool calls and
+ * returns the remaining non-dialect text (dialect spans removed) that still
+ * needs to be emitted.
+ */
+export declare class DialectGate {
+    private accumulated;
+    private emitted;
+    private markerSeen;
+    /** Append a visible-text chunk; returns the substring safe to emit now. */
+    push(text: string): string;
+    /** True once a dialect opening marker has been observed (streaming suppressed). */
+    get suppressing(): boolean;
+    /**
+     * Finalize: parse the full accumulated text into structured tool calls and
+     * return the non-dialect text that was buffered but not yet emitted.
+     */
+    finalize(): {
+        toolCalls: ToolCall[];
+        remainderText: string;
+    };
+}

package/dist/plugin/streaming/dialect-gate.js

@@ -0,0 +1,92 @@
+import { DSML_MARKER, parseTextToolCalls } from '../../infrastructure/transformers/tool-call-parser.js';
+// Opening markers that signal a text-dialect tool call may be starting. Once
+// any of these appears in the accumulated visible text, we stop streaming
+// further visible text (buffer it) so a dialect span is never emitted as
+// visible `delta.content`. Authoritative parsing happens only at finalization
+// on the FULL accumulated text (never per-fragment).
+const OPENING_MARKERS = ['<function_calls', '<invoke name=', DSML_MARKER];
+const MAX_MARKER_LEN = Math.max(...OPENING_MARKERS.map((m) => m.length));
+/** Earliest index of any opening marker in `text`, or -1. */
+function firstMarkerIndex(text) {
+    let earliest = -1;
+    for (const marker of OPENING_MARKERS) {
+        const idx = text.indexOf(marker);
+        if (idx !== -1 && (earliest === -1 || idx < earliest))
+            earliest = idx;
+    }
+    return earliest;
+}
+/**
+ * Length of the longest suffix of `text` that is a proper prefix of some
+ * opening marker — i.e. the tail might be the start of a marker split across
+ * chunks. That tail is reserved (not emitted yet) to avoid streaming half a
+ * marker as visible text.
+ */
+function partialMarkerTail(text) {
+    const maxLook = Math.min(text.length, MAX_MARKER_LEN - 1);
+    for (let len = maxLook; len > 0; len--) {
+        const tail = text.slice(text.length - len);
+        for (const marker of OPENING_MARKERS) {
+            if (marker.length > len && marker.startsWith(tail))
+                return len;
+        }
+    }
+    return 0;
+}
+/**
+ * Streaming suppression gate for text-dialect tool calls.
+ *
+ * Visible assistant reply text is pushed through the gate as it streams. While
+ * no dialect opening marker has appeared, the gate returns the safe prefix to
+ * stream (holding back only a possible partial-marker tail). Once a marker
+ * appears, everything from the marker onward is withheld. At finalization,
+ * `finalize()` parses the full accumulated text into structured tool calls and
+ * returns the remaining non-dialect text (dialect spans removed) that still
+ * needs to be emitted.
+ */
+export class DialectGate {
+    accumulated = '';
+    emitted = 0;
+    markerSeen = false;
+    /** Append a visible-text chunk; returns the substring safe to emit now. */
+    push(text) {
+        if (!text)
+            return '';
+        this.accumulated += text;
+        if (!this.markerSeen) {
+            const markerIdx = firstMarkerIndex(this.accumulated);
+            if (markerIdx !== -1)
+                this.markerSeen = true;
+        }
+        let safeEnd;
+        if (this.markerSeen) {
+            safeEnd = firstMarkerIndex(this.accumulated);
+            if (safeEnd === -1)
+                safeEnd = this.accumulated.length;
+        }
+        else {
+            // No marker yet — but the tail could be the start of one; reserve it.
+            safeEnd = this.accumulated.length - partialMarkerTail(this.accumulated);
+        }
+        if (safeEnd <= this.emitted)
+            return '';
+        const out = this.accumulated.slice(this.emitted, safeEnd);
+        this.emitted = safeEnd;
+        return out;
+    }
+    /** True once a dialect opening marker has been observed (streaming suppressed). */
+    get suppressing() {
+        return this.markerSeen;
+    }
+    /**
+     * Finalize: parse the full accumulated text into structured tool calls and
+     * return the non-dialect text that was buffered but not yet emitted.
+     */
+    finalize() {
+        const { toolCalls, cleanedText } = parseTextToolCalls(this.accumulated);
+        // Text before the first marker was already emitted verbatim and is never
+        // part of a dialect span, so cleanedText[0..emitted) == what we emitted.
+        const remainderText = cleanedText.length > this.emitted ? cleanedText.slice(this.emitted) : '';
+        return { toolCalls, remainderText };
+    }
+}

package/dist/plugin/streaming/sdk-stream-transformer.js

@@ -1,6 +1,6 @@
-import { parseBracketToolCalls } from '../../infrastructure/transformers/tool-call-parser.js';
 import { getContextWindowSize } from '../models.js';
 import { estimateTokens } from '../response.js';
+import { DialectGate } from './dialect-gate.js';
 import { convertToOpenAI } from './openai-converter.js';
 import { findRealTag } from './stream-parser.js';
 import { createTextDeltaEvents, createThinkingDeltaEvents, stopBlock } from './stream-state.js';
@@ -24,6 +24,19 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
     let contextUsagePercentage = null;
     const toolCalls = [];
     let currentToolCall = null;
+    // Text deltas route through the gate so a dialect span is withheld from the
+    // visible stream once its opening marker appears (recovered at finalization).
+    const dialectGate = new DialectGate();
+    const toChunk = (ev) => {
+        if (ev.type === 'content_block_delta' && ev.delta?.type === 'text_delta') {
+            const safe = dialectGate.push(ev.delta.text ?? '');
+            if (!safe)
+                return null;
+            const gated = { ...ev, delta: { ...ev.delta, text: safe } };
+            return convertToOpenAI(gated, conversationId, model);
+        }
+        return convertToOpenAI(ev, conversationId, model);
+    };
     // Probe (opus-4.8): reasoning streams via `reasoningContentEvent{text,signature}` as a
     // contiguous run BEFORE `assistantResponseEvent.content`; no `<thinking>` tags emitted.
     // signature is metadata and ignored for rendering.
@@ -65,7 +78,7 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
                 }
                 if (reasoningStarted) {
                     for (const ev of createTextDeltaEvents(text, streamState)) {
-                        const _c = convertToOpenAI(ev, conversationId, model);
+                        const _c = toChunk(ev);
                         if (_c !== null)
                             yield _c;
                     }
@@ -74,7 +87,7 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
                 if (!thinkingRequested) {
                     for (const ev of createTextDeltaEvents(text, streamState)) {
                         {
-                            const _c = convertToOpenAI(ev, conversationId, model);
+                            const _c = toChunk(ev);
                             if (_c !== null)
                                 yield _c;
                         }
@@ -142,7 +155,7 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
                     }
                 }
                 for (const ev of deltaEvents) {
-                    const chunk = convertToOpenAI(ev, conversationId, model);
+                    const chunk = toChunk(ev);
                     if (chunk !== null)
                         yield chunk;
                 }
@@ -218,21 +231,28 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
             }
             else {
                 for (const ev of createTextDeltaEvents(streamState.buffer, streamState)) {
-                    const _c = convertToOpenAI(ev, conversationId, model);
+                    const _c = toChunk(ev);
                     if (_c !== null)
                         yield _c;
                 }
                 streamState.buffer = '';
             }
         }
+        const { toolCalls: dialectToolCalls, remainderText } = dialectGate.finalize();
+        if (remainderText) {
+            for (const ev of createTextDeltaEvents(remainderText, streamState)) {
+                const _c = convertToOpenAI(ev, conversationId, model);
+                if (_c !== null)
+                    yield _c;
+            }
+        }
         for (const ev of stopBlock(streamState.textBlockIndex, streamState)) {
             const _c = convertToOpenAI(ev, conversationId, model);
             if (_c !== null)
                 yield _c;
         }
-        const bracketToolCalls = parseBracketToolCalls(totalContent);
-        if (bracketToolCalls.length > 0) {
-            for (const btc of bracketToolCalls) {
+        if (dialectToolCalls.length > 0) {
+            for (const btc of dialectToolCalls) {
                 toolCalls.push({
                     toolUseId: btc.toolUseId,
                     name: btc.name,
@@ -241,12 +261,14 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
             }
         }
         if (toolCalls.length > 0) {
-            const baseIndex = streamState.nextBlockIndex;
+            // OpenAI tool_calls[].index must be the tool call's own 0-based ordinal,
+            // NOT the Anthropic content_block global index (offset by reasoning/text
+            // blocks) — a global index misaligns the AI-SDK accumulator and drops the call.
             for (let i = 0; i < toolCalls.length; i++) {
                 const tc = toolCalls[i];
                 if (!tc)
                     continue;
-                const blockIndex = baseIndex + i;
+                const blockIndex = i;
                 {
                     const _c = convertToOpenAI({
                         type: 'content_block_start',

package/dist/plugin/streaming/stream-transformer.js

@@ -216,12 +216,14 @@ export async function* transformKiroStream(response, model, conversationId) {
             }
         }
         if (toolCalls.length > 0) {
-            const baseIndex = streamState.nextBlockIndex;
+            // OpenAI tool_calls[].index must be the tool call's own 0-based ordinal,
+            // NOT the Anthropic content_block global index (offset by reasoning/text
+            // blocks) — a global index misaligns the AI-SDK accumulator and drops the call.
             for (let i = 0; i < toolCalls.length; i++) {
                 const tc = toolCalls[i];
                 if (!tc)
                     continue;
-                const blockIndex = baseIndex + i;
+                const blockIndex = i;
                 {
                     const _c = convertToOpenAI({
                         type: 'content_block_start',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sunerpy/opencode-kiro-auth",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",