@jsonstudio/llms 0.4.2

package/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -0,0 +1,26 @@
+export interface StreamingToolCall {
+    id?: string;
+    type: 'function';
+    function: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export interface StreamingToolExtractorOptions {
+    idPrefix?: string;
+}
+export declare class StreamingTextToolExtractor {
+    private opts;
+    private buffer;
+    private idCounter;
+    private pendingPatch;
+    constructor(opts?: StreamingToolExtractorOptions);
+    reset(): void;
+    feedText(text: string): StreamingToolCall[];
+    private genId;
+    private toToolCall;
+    private tryExtractUnifiedDiffBlocks;
+    private tryExtractFunctionExecuteBlocks;
+    private splitCommand;
+}
+export declare function createStreamingToolExtractor(opts?: StreamingToolExtractorOptions): StreamingTextToolExtractor;

package/dist/conversion/shared/streaming-text-extractor.js

@@ -0,0 +1,145 @@
+// Streaming textual tool intent extractor (对齐)
+// Detects <function=execute> blocks and unified diff patches
+// and converts them into OpenAI tool_calls incrementally.
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+export class StreamingTextToolExtractor {
+    opts;
+    buffer = '';
+    idCounter = 0;
+    pendingPatch = { active: false, lines: [] };
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    reset() {
+        this.buffer = '';
+        this.idCounter = 0;
+        this.pendingPatch = { active: false, lines: [] };
+    }
+    feedText(text) {
+        const out = [];
+        if (typeof text !== 'string' || !text)
+            return out;
+        this.buffer += text;
+        // 1) Unified diff apply_patch block detection (*** Begin Patch ... *** End Patch)
+        out.push(...this.tryExtractUnifiedDiffBlocks());
+        // 2) <function=execute> compact blocks detection
+        out.push(...this.tryExtractFunctionExecuteBlocks());
+        return out;
+    }
+    genId() {
+        const p = this.opts.idPrefix || 'call';
+        return `${p}_${Date.now()}_${(++this.idCounter).toString(36)}`;
+    }
+    toToolCall(name, argsObj) {
+        let argStr = '{}';
+        try {
+            argStr = JSON.stringify(argsObj ?? {});
+        }
+        catch {
+            argStr = '{}';
+        }
+        return { id: this.genId(), type: 'function', function: { name, arguments: argStr } };
+    }
+    tryExtractUnifiedDiffBlocks() {
+        const out = [];
+        // Stream-friendly: if we see Begin Patch, start accumulating until End Patch
+        const beginIdx = this.buffer.indexOf('*** Begin Patch');
+        if (beginIdx >= 0) {
+            // Start patch if not already active
+            if (!this.pendingPatch.active) {
+                this.pendingPatch.active = true;
+                this.pendingPatch.lines = [];
+                this.pendingPatch.lines.push(this.buffer.slice(beginIdx));
+                // trim buffer before begin to reduce size
+                this.buffer = this.buffer.slice(beginIdx);
+            }
+            else {
+                // append new data
+                this.pendingPatch.lines.push(this.buffer);
+            }
+        }
+        if (this.pendingPatch.active) {
+            const joined = this.pendingPatch.lines.join('');
+            const endIdx = joined.indexOf('*** End Patch');
+            if (endIdx >= 0) {
+                const patchEnd = endIdx + '*** End Patch'.length;
+                const patchText = joined.slice(0, patchEnd);
+                out.push(this.toToolCall('apply_patch', { patch: patchText }));
+                // consume used part
+                const remainder = joined.slice(patchEnd);
+                this.pendingPatch = { active: false, lines: [] };
+                this.buffer = remainder;
+            }
+            else {
+                // keep accumulating, but limit memory
+                if (joined.length > 200000) {
+                    this.pendingPatch.lines = [joined.slice(-100000)];
+                }
+            }
+        }
+        return out;
+    }
+    // rcc.tool.v1 JSON detection removed
+    tryExtractFunctionExecuteBlocks() {
+        const out = [];
+        // Very lightweight parser for <function=execute> <parameter=command>...</parameter>
+        const execRe = /<function=execute>[\s\S]*?<parameter=command>([\s\S]*?)<\/parameter>[\s\S]*?<\/function=execute>/gi;
+        let m;
+        while ((m = execRe.exec(this.buffer)) !== null) {
+            const cmd = (m[1] || '').trim();
+            if (cmd) {
+                // split a shell command string into argv best-effort
+                const argv = this.splitCommand(cmd);
+                out.push(this.toToolCall('shell', { command: argv }));
+            }
+        }
+        if (out.length > 0) {
+            this.buffer = this.buffer.replace(execRe, '');
+        }
+        return out;
+    }
+    splitCommand(s) {
+        try {
+            // basic quotes-aware split
+            const out = [];
+            let cur = '';
+            let quote = null;
+            for (let i = 0; i < s.length; i++) {
+                const ch = s[i];
+                if (quote) {
+                    if (ch === quote) {
+                        quote = null;
+                    }
+                    else {
+                        cur += ch;
+                    }
+                }
+                else {
+                    if (ch === '"' || ch === '\'') {
+                        quote = ch;
+                    }
+                    else if (/\s/.test(ch)) {
+                        if (cur) {
+                            out.push(cur);
+                            cur = '';
+                        }
+                    }
+                    else {
+                        cur += ch;
+                    }
+                }
+            }
+            if (cur)
+                out.push(cur);
+            return out;
+        }
+        catch {
+            return [s];
+        }
+    }
+}
+export function createStreamingToolExtractor(opts) {
+    return new StreamingTextToolExtractor(opts);
+}

package/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -0,0 +1,9 @@
+export type ToolCallLite = {
+    id?: string;
+    name: string;
+    args: string;
+};
+export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;
+export declare function extractExecuteBlocksFromText(text: string): ToolCallLite[] | null;
+export declare function extractXMLToolCallsFromText(text: string): ToolCallLite[] | null;
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>): Record<string, any>;

package/dist/conversion/shared/text-markup-normalizer.js

@@ -0,0 +1,319 @@
+// Normalize textual markup into OpenAI tool_calls shape.
+// Gated by RCC_TEXT_MARKUP_COMPAT=1 to avoid overreach.
+import { isImagePath } from './media.js';
+// Strict allowlist for tool names and their argument keys to avoid picking up
+// stray markup or free-form text as JSON keys (reduces false positives).
+const KNOWN_TOOLS = new Set([
+    'shell',
+    'apply_patch',
+    'update_plan',
+    'view_image',
+    'list_mcp_resources',
+    'read_mcp_resource',
+    'list_mcp_resource_templates'
+]);
+const ALLOWED_KEYS = {
+    shell: new Set(['command', 'justification', 'timeout_ms', 'with_escalated_permissions', 'workdir']),
+    apply_patch: new Set(['patch']),
+    update_plan: new Set(['explanation', 'plan']),
+    view_image: new Set(['path']),
+    list_mcp_resources: new Set(['server', 'cursor', 'filter', 'root']),
+    read_mcp_resource: new Set(['server', 'uri', 'cursor']),
+    list_mcp_resource_templates: new Set(['server', 'cursor'])
+};
+function normalizeKey(raw) {
+    try {
+        const t = String(raw || '').trim();
+        if (!t)
+            return '';
+        // Pick the last alphanumeric/underscore token (e.g., '空的\n<tool_call>command' -> 'command')
+        const m = t.match(/([A-Za-z_][A-Za-z0-9_]*)$/);
+        return m ? m[1] : t;
+    }
+    catch {
+        return String(raw || '');
+    }
+}
+function filterArgsForTool(name, args) {
+    try {
+        const nm = String(name || '').toLowerCase();
+        const allow = ALLOWED_KEYS[nm];
+        if (!allow) {
+            // Unknown tool; be conservative: keep only simple safe keys if present
+            const safe = new Set(['command', 'patch', 'plan', 'explanation', 'path', 'server', 'uri', 'cursor', 'filter', 'root']);
+            const out = {};
+            for (const [k, v] of Object.entries(args || {})) {
+                const key = normalizeKey(k);
+                if (safe.has(key))
+                    out[key] = v;
+            }
+            return out;
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(args || {})) {
+            const key = normalizeKey(k);
+            if (allow.has(key))
+                out[key] = v;
+        }
+        return out;
+    }
+    catch {
+        return args;
+    }
+}
+function enabled() {
+    try {
+        return String(process?.env?.RCC_TEXT_MARKUP_COMPAT ?? '1').trim() !== '0';
+    }
+    catch {
+        return true;
+    }
+}
+// 已移除所有 rcc.tool.v1 相关处理：不再识别或剥离 rcc 封装
+export function extractApplyPatchCallsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const candidates = [];
+        const fenceRe = /```(?:patch)?\s*([\s\S]*?)\s*```/gi;
+        let fm;
+        while ((fm = fenceRe.exec(text)) !== null) {
+            const body = fm[1] || '';
+            if (/\*\*\*\s+Begin Patch[\s\S]*?\*\*\*\s+End Patch/.test(body))
+                candidates.push(body);
+        }
+        if (/\*\*\*\s+Begin Patch[\s\S]*?\*\*\*\s+End Patch/.test(text))
+            candidates.push(text);
+        const genId = () => `call_${Math.random().toString(36).slice(2, 10)}`;
+        for (const src of candidates) {
+            const pg = /\*\*\*\s+Begin Patch[\s\S]*?\*\*\*\s+End Patch/gm;
+            let pm;
+            while ((pm = pg.exec(src)) !== null) {
+                const patch = pm[0];
+                if (!patch || patch.length < 32)
+                    continue;
+                let argsStr = '{}';
+                try {
+                    argsStr = JSON.stringify({ patch });
+                }
+                catch {
+                    argsStr = '{"patch":""}';
+                }
+                out.push({ id: genId(), name: 'apply_patch', args: argsStr });
+            }
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractExecuteBlocksFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const re = /<function=execute>\s*<parameter=command>([\s\S]*?)<\/parameter>\s*<\/function>/gi;
+        const out = [];
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const commandRaw = (m[1] || '').trim();
+            if (!commandRaw)
+                continue;
+            let args = '{}';
+            try {
+                args = JSON.stringify({ command: commandRaw });
+            }
+            catch {
+                args = '{"command":""}';
+            }
+            out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name: 'shell', args });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Extract XML-like <tool_call> blocks used by some agents:
+// Example:
+//   <tool_call>
+//     shell
+//     <arg_key>command</arg_key>
+//     <arg_value>["cat","codex-protocol/README.md"]</arg_value>
+//   </tool_call>
+export function extractXMLToolCallsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const blockRe = /<tool_call[\s\S]*?>([\s\S]*?)<\/tool_call>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const inner = (bm[1] || '').trim();
+            if (!inner)
+                continue;
+            // 1) try function/name tags
+            let name = '';
+            const fnTag = inner.match(/<\s*(?:function|name)\s*>\s*([a-zA-Z0-9_\-\.]+)\s*<\/(?:function|name)\s*>/i);
+            if (fnTag && fnTag[1]) {
+                name = String(fnTag[1]).trim();
+            }
+            else {
+                // 2) else pick the first non-empty line without tags as the name
+                const lines = inner.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+                const candidate = lines.find(l => !l.startsWith('<') && /^[a-zA-Z0-9_\-\.]+$/.test(l));
+                if (candidate)
+                    name = candidate;
+            }
+            if (!name)
+                continue;
+            // Guard unknown tool names early if clearly invalid
+            const lname = String(name).toLowerCase();
+            if (!KNOWN_TOOLS.has(lname)) {
+                // still allow through, but later key filtering will drastically reduce noise
+            }
+            // Collect arg_key/arg_value pairs
+            const argRe = /<\s*arg_key\s*>\s*([^<]+?)\s*<\/(?:arg_key)\s*>\s*<\s*arg_value\s*>\s*([\s\S]*?)\s*<\/(?:arg_value)\s*>/gi;
+            let am;
+            const argsObj = {};
+            while ((am = argRe.exec(inner)) !== null) {
+                const k = normalizeKey((am[1] || '').trim());
+                let vRaw = (am[2] || '').trim();
+                if (!k)
+                    continue;
+                // If value looks like JSON array/object, parse; else keep as string
+                let v = vRaw;
+                if ((vRaw.startsWith('[') && vRaw.endsWith(']')) || (vRaw.startsWith('{') && vRaw.endsWith('}'))) {
+                    try {
+                        v = JSON.parse(vRaw);
+                    }
+                    catch {
+                        v = vRaw;
+                    }
+                }
+                argsObj[k] = v;
+            }
+            // If no args collected but inner contains JSON object, try as whole arguments
+            const hasAnyArg = Object.keys(argsObj).length > 0;
+            if (!hasAnyArg) {
+                const jsonMatch = inner.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+                if (jsonMatch) {
+                    try {
+                        const val = JSON.parse(jsonMatch[0]);
+                        argsObj.arguments = val;
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            // Drop keys not allowed for this tool to prevent noise (e.g., '空的<tool_call>command')
+            const filtered = filterArgsForTool(lname, argsObj);
+            // Guard: view_image must have a valid image path
+            try {
+                if (lname === 'view_image') {
+                    const p = (filtered && typeof filtered === 'object') ? filtered.path : undefined;
+                    if (!isImagePath(p)) {
+                        continue;
+                    }
+                }
+            }
+            catch { /* ignore guard errors */ }
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name, args: argsStr });
+        }
+        // Fallback: loose XML variant (missing <tool_call> start), e.g.:
+        //   shell\n<arg_key>command</arg_key>\n<arg_value>["ls","-la"]</arg_value>\n</tool_call>
+        try {
+            const pairRe = /<\s*arg_key\s*>\s*([^<]+?)\s*<\/\s*arg_key\s*>\s*<\s*arg_value\s*>\s*([\s\S]*?)\s*<\/\s*arg_value\s*>/gi;
+            let pm;
+            while ((pm = pairRe.exec(text)) !== null) {
+                const start = pm.index;
+                // find a likely function name on the immediately preceding non-empty line
+                let name = '';
+                try {
+                    const before = text.slice(0, start);
+                    const lines = before.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+                    const cand = lines.length ? lines[lines.length - 1] : '';
+                    if (/^[a-zA-Z0-9_\-\.]{2,}$/.test(cand))
+                        name = cand;
+                }
+                catch { /* ignore */ }
+                if (!name)
+                    continue;
+                const k = normalizeKey((pm[1] || '').trim());
+                let vRaw = (pm[2] || '').trim();
+                const argsObj = {};
+                if (k) {
+                    let v = vRaw;
+                    if ((vRaw.startsWith('[') && vRaw.endsWith(']')) || (vRaw.startsWith('{') && vRaw.endsWith('}'))) {
+                        try {
+                            v = JSON.parse(vRaw);
+                        }
+                        catch {
+                            v = vRaw;
+                        }
+                    }
+                    argsObj[k] = v;
+                }
+                const lname2 = String(name || '').toLowerCase();
+                const filtered2 = filterArgsForTool(lname2, argsObj);
+                // Guard: view_image must have a valid image path
+                try {
+                    if (lname2 === 'view_image') {
+                        const p = (filtered2 && typeof filtered2 === 'object') ? filtered2.path : undefined;
+                        if (!isImagePath(p)) {
+                            continue;
+                        }
+                    }
+                }
+                catch { /* ignore guard errors */ }
+                let argsStr = '{}';
+                try {
+                    argsStr = JSON.stringify(filtered2);
+                }
+                catch {
+                    argsStr = '{}';
+                }
+                out.push({ id: `call_${Math.random().toString(36).slice(2, 10)}`, name, args: argsStr });
+            }
+        }
+        catch { /* ignore */ }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeAssistantTextToToolCalls(message) {
+    if (!enabled())
+        return message;
+    try {
+        if (!message || typeof message !== 'object')
+            return message;
+        if (Array.isArray(message.tool_calls) && message.tool_calls.length)
+            return message;
+        const content = message.content;
+        const text = typeof content === 'string' ? content : null;
+        if (!text)
+            return message;
+        // Order: xml-like tool_call → apply_patch → execute blocks
+        const calls = (extractXMLToolCallsFromText(text) ||
+            extractApplyPatchCallsFromText(text) ||
+            extractExecuteBlocksFromText(text));
+        if (calls && calls.length) {
+            const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));
+            const copy = { ...message };
+            copy.tool_calls = toolCalls;
+            copy.content = '';
+            return copy;
+        }
+    }
+    catch { /* ignore */ }
+    return message;
+}

package/dist/conversion/shared/tool-canonicalizer.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalizeChatResponseTools(payload: unknown): unknown;
+export default canonicalizeChatResponseTools;

package/dist/conversion/shared/tool-canonicalizer.js

@@ -0,0 +1,50 @@
+// Minimal canonicalizer to ensure tool_calls invariants without altering semantics
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function repairArgumentsToString(args) {
+    if (typeof args === 'string')
+        return args;
+    try {
+        return JSON.stringify(args ?? {});
+    }
+    catch {
+        return String(args);
+    }
+}
+export function canonicalizeChatResponseTools(payload) {
+    try {
+        const out = isObject(payload) ? JSON.parse(JSON.stringify(payload)) : payload;
+        const choices = Array.isArray(out?.choices) ? out.choices : [];
+        for (const ch of choices) {
+            const msg = ch && ch.message ? ch.message : undefined;
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+            if (!tcs || !tcs.length)
+                continue;
+            // ensure arguments is string and content is null when tool_calls present
+            try {
+                if (!ch.finish_reason)
+                    ch.finish_reason = 'tool_calls';
+            }
+            catch { /* ignore */ }
+            try {
+                if (msg && typeof msg === 'object')
+                    msg.content = null;
+            }
+            catch { /* ignore */ }
+            for (const tc of tcs) {
+                try {
+                    const fn = tc && tc.function ? tc.function : undefined;
+                    if (fn)
+                        fn.arguments = repairArgumentsToString(fn.arguments);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return out;
+    }
+    catch {
+        return payload;
+    }
+}
+export default canonicalizeChatResponseTools;

package/dist/conversion/shared/tool-filter-pipeline.d.ts

@@ -0,0 +1,17 @@
+import { ToolFilterHints } from '../../filters/index.js';
+interface RequestFilterOptions {
+    entryEndpoint?: string;
+    requestId?: string;
+    model?: string;
+    profile?: string;
+    stream?: boolean;
+    toolFilterHints?: ToolFilterHints;
+}
+interface ResponseFilterOptions {
+    entryEndpoint?: string;
+    requestId?: string;
+    profile?: string;
+}
+export declare function runChatRequestToolFilters(chatRequest: any, options?: RequestFilterOptions): Promise<any>;
+export declare function runChatResponseToolFilters(chatJson: any, options?: ResponseFilterOptions): Promise<any>;
+export {};

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -0,0 +1,79 @@
+import { FilterEngine } from '../../filters/index.js';
+import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+export async function runChatRequestToolFilters(chatRequest, options = {}) {
+    const reqCtxBase = {
+        requestId: options.requestId ?? `req_${Date.now()}`,
+        model: typeof options.model === 'string' ? options.model : (chatRequest && typeof chatRequest === 'object' && typeof chatRequest.model === 'string' ? String(chatRequest.model) : 'unknown'),
+        endpoint: options.entryEndpoint || '/v1/chat/completions',
+        profile: options.profile || 'openai-chat',
+        stream: options.stream === true,
+        toolFilterHints: options.toolFilterHints,
+        debug: { emit: () => { } }
+    };
+    const engine = new FilterEngine();
+    try {
+        const { RequestToolListFilter } = await import('../../filters/index.js');
+        engine.registerFilter(new RequestToolListFilter());
+    }
+    catch { /* optional */ }
+    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } = await import('../../filters/index.js');
+    engine.registerFilter(new RequestToolCallsStringifyFilter());
+    engine.registerFilter(new RequestToolChoicePolicyFilter());
+    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
+    try {
+        const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
+        if (cfg)
+            engine.setFieldMap(cfg);
+        engine.registerTransform('stringifyJson', (v) => (typeof v === 'string') ? v : (() => { try {
+            return JSON.stringify(v ?? {});
+        }
+        catch {
+            return '{}';
+        } })());
+    }
+    catch { /* ignore */ }
+    let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
+    staged = await engine.run('request_map', staged, reqCtxBase);
+    staged = await engine.run('request_post', staged, reqCtxBase);
+    return staged;
+}
+export async function runChatResponseToolFilters(chatJson, options = {}) {
+    const resCtxBase = {
+        requestId: options.requestId ?? `req_${Date.now()}`,
+        model: undefined,
+        endpoint: options.entryEndpoint || '/v1/chat/completions',
+        profile: options.profile || 'openai-chat',
+        debug: { emit: () => { } }
+    };
+    const engine = new FilterEngine();
+    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
+    engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
+    try {
+        const { ResponseToolArgumentsToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
+        engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter());
+        try {
+            engine.registerFilter(new ResponseToolArgumentsSchemaConvergeFilter());
+        }
+        catch { /* optional */ }
+        engine.registerFilter(new ResponseToolArgumentsBlacklistFilter());
+    }
+    catch { /* optional */ }
+    engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
+    engine.registerFilter(new ResponseFinishInvariantsFilter());
+    try {
+        const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
+        if (cfg)
+            engine.setFieldMap(cfg);
+        engine.registerTransform('stringifyJson', (v) => (typeof v === 'string') ? v : (() => { try {
+            return JSON.stringify(v ?? {});
+        }
+        catch {
+            return '{}';
+        } })());
+    }
+    catch { /* ignore */ }
+    let staged = await engine.run('response_pre', chatJson, resCtxBase);
+    staged = await engine.run('response_map', staged, resCtxBase);
+    staged = await engine.run('response_post', staged, resCtxBase);
+    return staged;
+}

package/dist/conversion/shared/tool-governor.d.ts

@@ -0,0 +1,27 @@
+type Unknown = Record<string, unknown>;
+export interface ToolGovernanceOptions {
+    injectGuidance?: boolean;
+    snapshot?: {
+        enabled?: boolean;
+        endpoint?: string;
+        requestId?: string;
+        baseDir?: string;
+    };
+}
+/**
+ * Process OpenAI Chat request (messages/tools) with unified 标准 governance.
+ * - Augment tools (strict schemas)
+ * - Inject/Refine system tool guidance (idempotent)
+ * - Canonicalize textual tool markup to tool_calls; set content=null when applicable
+ */
+export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
+export declare function processChatResponseTools(resp: Unknown): Unknown;
+export interface GovernContext extends ToolGovernanceOptions {
+    phase: 'request' | 'response';
+    endpoint?: 'chat' | 'responses' | 'messages';
+    stream?: boolean;
+    produceRequiredAction?: boolean;
+    requestId?: string;
+}
+export declare function governTools(payload: Unknown, ctx: GovernContext): Unknown;
+export {};