@sunerpy/opencode-kiro-auth 0.5.1 → 0.6.0

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/accounts.d.ts

@@ -6,8 +6,18 @@ export declare class AccountManager {
     private strategy;
     private lastToastTime;
     private lastUsageToastTime;
-    constructor(accounts: ManagedAccount[], strategy?: AccountSelectionStrategy);
-    static loadFromDisk(strategy?: AccountSelectionStrategy): Promise<AccountManager>;
+    private rrCursor;
+    private stickyId?;
+    private quotaAvoidanceEnabled;
+    private quotaReserveThreshold;
+    constructor(accounts: ManagedAccount[], strategy?: AccountSelectionStrategy, opts?: {
+        quotaAvoidanceEnabled?: boolean;
+        quotaReserveThreshold?: number;
+    });
+    static loadFromDisk(strategy?: AccountSelectionStrategy, opts?: {
+        quotaAvoidanceEnabled?: boolean;
+        quotaReserveThreshold?: number;
+    }): Promise<AccountManager>;
     getAccountCount(): number;
     getAccounts(): ManagedAccount[];
     shouldShowToast(debounce?: number): boolean;

package/dist/plugin/accounts.js

@@ -15,12 +15,18 @@ export class AccountManager {
     strategy;
     lastToastTime = 0;
     lastUsageToastTime = 0;
-    constructor(accounts, strategy = 'sticky') {
+    rrCursor = 0;
+    stickyId;
+    quotaAvoidanceEnabled;
+    quotaReserveThreshold;
+    constructor(accounts, strategy = 'sticky', opts) {
         this.accounts = accounts;
         this.cursor = 0;
         this.strategy = strategy;
+        this.quotaAvoidanceEnabled = opts?.quotaAvoidanceEnabled ?? true;
+        this.quotaReserveThreshold = opts?.quotaReserveThreshold ?? 0.95;
     }
-    static async loadFromDisk(strategy) {
+    static async loadFromDisk(strategy, opts) {
         const rows = kiroDb.getAccounts();
         const accounts = rows.map((r) => ({
             id: r.id,
@@ -44,7 +50,7 @@ export class AccountManager {
             usedCount: r.used_count,
             limitCount: r.limit_count
         }));
-        return new AccountManager(accounts, strategy || 'sticky');
+        return new AccountManager(accounts, strategy || 'sticky', opts);
     }
     getAccountCount() {
         return this.accounts.length;
@@ -86,17 +92,29 @@ export class AccountManager {
             }
             return !(a.rateLimitResetTime && now < a.rateLimitResetTime);
         });
+        let candidatePool = available;
+        if (this.accounts.length > 1 && this.quotaAvoidanceEnabled) {
+            const ratio = (a) => a.limitCount && a.limitCount > 0 ? (a.usedCount || 0) / a.limitCount : 0;
+            const ample = available.filter((a) => ratio(a) < this.quotaReserveThreshold);
+            // used>=limit stays in nearFull (soft/drainable, NOT hard-excluded): the
+            // real 402 is the authoritative exhaustion signal and already
+            // hard-switches accounts in error-handler.
+            const nearFull = available.filter((a) => ratio(a) >= this.quotaReserveThreshold);
+            candidatePool = ample.length > 0 ? ample : nearFull;
+        }
         let selected;
-        if (available.length > 0) {
+        if (candidatePool.length > 0) {
             if (this.strategy === 'sticky') {
-                selected = available.find((_, i) => i === this.cursor) || available[0];
+                selected = candidatePool.find((a) => a.id === this.stickyId) || candidatePool[0];
+                if (selected)
+                    this.stickyId = selected.id;
             }
             else if (this.strategy === 'round-robin') {
-                selected = available[this.cursor % available.length];
-                this.cursor = (this.cursor + 1) % available.length;
+                selected = candidatePool[this.rrCursor % candidatePool.length];
+                this.rrCursor++;
             }
             else if (this.strategy === 'lowest-usage') {
-                selected = [...available].sort((a, b) => (a.usedCount || 0) - (b.usedCount || 0) || (a.lastUsed || 0) - (b.lastUsed || 0))[0];
+                selected = [...candidatePool].sort((a, b) => (a.usedCount || 0) - (b.usedCount || 0) || (a.lastUsed || 0) - (b.lastUsed || 0))[0];
             }
         }
         if (!selected) {
@@ -113,7 +131,6 @@ export class AccountManager {
         if (selected) {
             selected.lastUsed = now;
             selected.usedCount = (selected.usedCount || 0) + 1;
-            this.cursor = this.accounts.indexOf(selected);
             return selected;
         }
         return null;

package/dist/plugin/config/loader.js

@@ -90,6 +90,8 @@ function applyEnvOverrides(config) {
         account_selection_strategy: env.KIRO_ACCOUNT_SELECTION_STRATEGY
             ? AccountSelectionStrategySchema.catch('lowest-usage').parse(env.KIRO_ACCOUNT_SELECTION_STRATEGY)
             : config.account_selection_strategy,
+        quota_avoidance_enabled: parseBooleanEnv(env.KIRO_QUOTA_AVOIDANCE_ENABLED, config.quota_avoidance_enabled),
+        quota_reserve_threshold: parseNumberEnv(env.KIRO_QUOTA_RESERVE_THRESHOLD, config.quota_reserve_threshold),
         default_region: env.KIRO_DEFAULT_REGION
             ? RegionSchema.catch('us-east-1').parse(env.KIRO_DEFAULT_REGION)
             : config.default_region,

package/dist/plugin/config/schema.d.ts

@@ -19,6 +19,19 @@ export declare const KiroConfigSchema: z.ZodObject<{
     idc_region: z.ZodOptional<z.ZodEnum<["us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-5", "ap-southeast-4", "ap-south-1", "ap-southeast-6", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-east-2", "ap-southeast-7", "ap-northeast-1", "ca-central-1", "ca-west-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "il-central-1", "mx-central-1", "me-south-1", "me-central-1", "sa-east-1"]>>;
     idc_profile_arn: z.ZodOptional<z.ZodString>;
     account_selection_strategy: z.ZodDefault<z.ZodEnum<["sticky", "round-robin", "lowest-usage"]>>;
+    /**
+     * Softly avoid accounts whose usage ratio is at/above
+     * `quota_reserve_threshold` when other accounts still have room. When ALL
+     * healthy accounts are near-full they are drained anyway (the real 402 in
+     * error-handler is the authoritative hard-switch). Only affects
+     * multi-account selection; single-account behavior is unchanged.
+     */
+    quota_avoidance_enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Usage ratio (used/limit) at/above which an account is considered
+     * near-full and softly avoided. Default 0.95 (95%).
+     */
+    quota_reserve_threshold: z.ZodDefault<z.ZodNumber>;
     default_region: z.ZodDefault<z.ZodEnum<["us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-5", "ap-southeast-4", "ap-south-1", "ap-southeast-6", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-east-2", "ap-southeast-7", "ap-northeast-1", "ca-central-1", "ca-west-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "il-central-1", "mx-central-1", "me-south-1", "me-central-1", "sa-east-1"]>>;
     rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
     rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
@@ -52,6 +65,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     auto_effort_mapping: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     account_selection_strategy: "sticky" | "round-robin" | "lowest-usage";
+    quota_avoidance_enabled: boolean;
+    quota_reserve_threshold: number;
     default_region: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1";
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
@@ -77,6 +92,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     idc_region?: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1" | undefined;
     idc_profile_arn?: string | undefined;
     account_selection_strategy?: "sticky" | "round-robin" | "lowest-usage" | undefined;
+    quota_avoidance_enabled?: boolean | undefined;
+    quota_reserve_threshold?: number | undefined;
     default_region?: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1" | undefined;
     rate_limit_retry_delay_ms?: number | undefined;
     rate_limit_max_retries?: number | undefined;

package/dist/plugin/config/schema.js

@@ -51,6 +51,19 @@ export const KiroConfigSchema = z.object({
     idc_region: RegionSchema.optional(),
     idc_profile_arn: z.string().optional(),
     account_selection_strategy: AccountSelectionStrategySchema.default('lowest-usage'),
+    /**
+     * Softly avoid accounts whose usage ratio is at/above
+     * `quota_reserve_threshold` when other accounts still have room. When ALL
+     * healthy accounts are near-full they are drained anyway (the real 402 in
+     * error-handler is the authoritative hard-switch). Only affects
+     * multi-account selection; single-account behavior is unchanged.
+     */
+    quota_avoidance_enabled: z.boolean().default(true),
+    /**
+     * Usage ratio (used/limit) at/above which an account is considered
+     * near-full and softly avoided. Default 0.95 (95%).
+     */
+    quota_reserve_threshold: z.number().min(0).max(1).default(0.95),
     default_region: RegionSchema.default('us-east-1'),
     rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
     rate_limit_max_retries: z.number().min(0).max(10).default(3),
@@ -85,6 +98,8 @@ export const KiroConfigSchema = z.object({
 });
 export const DEFAULT_CONFIG = {
     account_selection_strategy: 'lowest-usage',
+    quota_avoidance_enabled: true,
+    quota_reserve_threshold: 0.95,
     default_region: 'us-east-1',
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,

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,

package/dist/plugin.js

@@ -15,7 +15,10 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
     const cache = new AccountCache(60000);
     const repository = new AccountRepository(cache);
     const authHandler = new AuthHandler(config, repository);
-    const accountManager = await AccountManager.loadFromDisk(config.account_selection_strategy);
+    const accountManager = await AccountManager.loadFromDisk(config.account_selection_strategy, {
+        quotaAvoidanceEnabled: config.quota_avoidance_enabled,
+        quotaReserveThreshold: config.quota_reserve_threshold
+    });
     authHandler.setAccountManager(accountManager);
     const requestHandler = new RequestHandler(accountManager, config, repository, client);
     // Compute the base URL once so both the config hook and auth loader use the same value

package/package.json

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