@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-argument-repairer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tool Argument Repairer
+ *
+ * Tool calls require `function.arguments` to be a JSON string. Models often emit JSON-ish
+ * payloads (single quotes, fenced blocks, comments, trailing commas, etc.).
+ *
+ * This module provides a deterministic, best-effort repair surface that returns a JSON string
+ * or `{}` and never throws.
+ */
+export interface RepairResult {
+    repaired: string;
+    success: boolean;
+    error?: string;
+}
+export declare class ToolArgumentRepairer {
+    repairToString(args: unknown): string;
+    validateAndRepair(toolName: string, args: unknown): RepairResult;
+    /**
+     * 批量修复工具参数
+     *
+     * @param toolCalls - 工具调用列表
+     * @returns 修复后的工具调用列表
+     */
+    repairToolCalls(toolCalls: Array<{
+        name?: string;
+        arguments?: unknown;
+    }>): Array<{
+        name?: string;
+        arguments: string;
+    }>;
+}
+/**
+ * 快捷函数：修复工具参数
+ */
+export declare function repairToolArguments(args: unknown): string;
+/**
+ * 快捷函数：验证并修复工具参数
+ */
+export declare function validateToolArguments(toolName: string, args: unknown): RepairResult;

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-argument-repairer.js

@@ -0,0 +1,53 @@
+/**
+ * Tool Argument Repairer
+ *
+ * Tool calls require `function.arguments` to be a JSON string. Models often emit JSON-ish
+ * payloads (single quotes, fenced blocks, comments, trailing commas, etc.).
+ *
+ * This module provides a deterministic, best-effort repair surface that returns a JSON string
+ * or `{}` and never throws.
+ */
+import { repairArgumentsToStringWithNative, repairToolCallsWithNative, validateToolArgumentsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export class ToolArgumentRepairer {
+    repairToString(args) {
+        if (typeof repairArgumentsToStringWithNative !== 'function') {
+            throw new Error('[tool-argument-repairer] native bindings unavailable');
+        }
+        return repairArgumentsToStringWithNative(args);
+    }
+    validateAndRepair(toolName, args) {
+        if (typeof validateToolArgumentsWithNative !== 'function') {
+            throw new Error('[tool-argument-repairer] native bindings unavailable');
+        }
+        const output = validateToolArgumentsWithNative(toolName, args);
+        return {
+            repaired: output.repaired,
+            success: output.success,
+            ...(output.error ? { error: output.error } : {})
+        };
+    }
+    /**
+     * 批量修复工具参数
+     *
+     * @param toolCalls - 工具调用列表
+     * @returns 修复后的工具调用列表
+     */
+    repairToolCalls(toolCalls) {
+        if (typeof repairToolCallsWithNative !== 'function') {
+            throw new Error('[tool-argument-repairer] native bindings unavailable');
+        }
+        return repairToolCallsWithNative(toolCalls);
+    }
+}
+/**
+ * 快捷函数：修复工具参数
+ */
+export function repairToolArguments(args) {
+    return new ToolArgumentRepairer().repairToString(args);
+}
+/**
+ * 快捷函数：验证并修复工具参数
+ */
+export function validateToolArguments(toolName, args) {
+    return new ToolArgumentRepairer().validateAndRepair(toolName, args);
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-id-manager.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Tool Call ID Manager
+ *
+ * 提供统一的工具调用 ID 生成、规范化和风格管理功能。
+ * 支持 'fc' (function call) 和 'preserve' 两种风格。
+ */
+import type { JsonObject } from '../hub/types/json.js';
+export type ToolCallIdStyle = 'fc' | 'preserve';
+export interface ToolCallIdManagerOptions {
+    /**
+     * ID 风格
+     * - 'fc': 使用 fc_ 前缀的短 ID（如 fc_abc123）
+     * - 'preserve': 保留原始 ID
+     */
+    style?: ToolCallIdStyle;
+    /**
+     * ID 前缀（仅用于 'fc' 风格）
+     * 默认 'fc_'
+     */
+    prefix?: string;
+    /**
+     * ID 长度（仅用于 'fc' 风格）
+     * 默认 8
+     */
+    idLength?: number;
+}
+/**
+ * 工具调用 ID 管理器
+ */
+export declare class ToolCallIdManager {
+    private options;
+    private state;
+    constructor(options?: ToolCallIdManagerOptions);
+    /**
+     * 生成新的工具调用 ID
+     */
+    generateId(): string;
+    /**
+     * 规范化工具调用 ID
+     *
+     * @param id - 原始 ID
+     * @returns 规范化后的 ID
+     */
+    normalizeId(id: string | undefined | null): string;
+    /**
+     * 规范化工具调用 ID（带别名注册）
+     *
+     * @param id - 原始 ID
+     * @param aliasMap - 别名映射（用于 preserve 风格）
+     * @returns 规范化后的 ID
+     */
+    normalizeIdWithAlias(id: string | undefined | null, aliasMap?: Map<string, string>): string;
+    /**
+     * 批量规范化工具调用 ID
+     *
+     * @param ids - ID 列表
+     * @returns 规范化后的 ID 列表
+     */
+    normalizeIds(ids: (string | undefined | null)[]): string[];
+    /**
+     * 检查 ID 是否为有效的 fc_ 风格
+     */
+    isValidFcStyle(id: string): boolean;
+    /**
+     * 从 ID 中提取基础部分（移除前缀）
+     */
+    extractBaseId(id: string): string;
+    /**
+     * 重置计数器
+     */
+    resetCounter(): void;
+    /**
+     * 获取当前配置
+     */
+    getOptions(): ToolCallIdManagerOptions;
+    /**
+     * 更新配置
+     */
+    updateOptions(options: Partial<ToolCallIdManagerOptions>): void;
+}
+/**
+ * 规范化工具调用 ID 值
+ *
+ * @param value - ID 值（可能是字符串或其他类型）
+ * @param forceGenerate - 如果为 true，总是生成新 ID
+ * @returns 规范化后的 ID 字符串
+ */
+export declare function normalizeIdValue(value: unknown, forceGenerate?: boolean): string;
+/**
+ * 从对象中提取工具调用 ID
+ *
+ * @param obj - 包含 ID 的对象
+ * @returns 提取的 ID
+ */
+export declare function extractToolCallId(obj: unknown): string | undefined;
+/**
+ * 创建工具调用 ID 转换器（用于 Responses 格式）
+ *
+ * @param style - ID 风格
+ * @returns 转换器函数
+ */
+export declare function createToolCallIdTransformer(style: ToolCallIdStyle): ((id: string) => string) | null;
+/**
+ * 在消息列表中强制应用工具调用 ID 风格
+ *
+ * @param messages - 消息列表
+ * @param transformer - ID 转换器
+ */
+export declare function enforceToolCallIdStyle(messages: JsonObject[], transformer: (id: string) => string): void;

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-id-manager.js

@@ -0,0 +1,202 @@
+/**
+ * Tool Call ID Manager
+ *
+ * 提供统一的工具调用 ID 生成、规范化和风格管理功能。
+ * 支持 'fc' (function call) 和 'preserve' 两种风格。
+ */
+import { createToolCallIdTransformerWithNative, enforceToolCallIdStyleWithNative, extractToolCallIdWithNative, normalizeIdValueWithNative, transformToolCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+const DEFAULT_OPTIONS = {
+    style: 'fc',
+    prefix: 'fc_',
+    idLength: 8
+};
+function assertToolCallIdManagerNativeAvailable() {
+    if (typeof normalizeIdValueWithNative !== 'function' ||
+        typeof extractToolCallIdWithNative !== 'function' ||
+        typeof createToolCallIdTransformerWithNative !== 'function' ||
+        typeof transformToolCallIdWithNative !== 'function' ||
+        typeof enforceToolCallIdStyleWithNative !== 'function') {
+        throw new Error('[tool-call-id-manager] native bindings unavailable');
+    }
+}
+/**
+ * 工具调用 ID 管理器
+ */
+export class ToolCallIdManager {
+    options;
+    state;
+    constructor(options) {
+        assertToolCallIdManagerNativeAvailable();
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.state = createToolCallIdTransformerWithNative(this.options.style);
+    }
+    /**
+     * 生成新的工具调用 ID
+     */
+    generateId() {
+        assertToolCallIdManagerNativeAvailable();
+        const output = transformToolCallIdWithNative(this.state, '');
+        this.state = output.state;
+        return output.id;
+    }
+    /**
+     * 规范化工具调用 ID
+     *
+     * @param id - 原始 ID
+     * @returns 规范化后的 ID
+     */
+    normalizeId(id) {
+        assertToolCallIdManagerNativeAvailable();
+        const raw = typeof id === 'string' ? id : '';
+        const output = transformToolCallIdWithNative(this.state, raw);
+        this.state = output.state;
+        return output.id;
+    }
+    /**
+     * 规范化工具调用 ID（带别名注册）
+     *
+     * @param id - 原始 ID
+     * @param aliasMap - 别名映射（用于 preserve 风格）
+     * @returns 规范化后的 ID
+     */
+    normalizeIdWithAlias(id, aliasMap) {
+        assertToolCallIdManagerNativeAvailable();
+        const raw = typeof id === 'string' ? id : '';
+        const trimmed = raw.trim();
+        if (this.options.style === 'preserve' && trimmed && aliasMap?.has(trimmed)) {
+            const existing = aliasMap.get(trimmed);
+            const aliasState = this.state.aliasMap;
+            if (aliasState && typeof aliasState === 'object') {
+                aliasState[trimmed] = existing;
+            }
+            return existing;
+        }
+        const output = transformToolCallIdWithNative(this.state, raw);
+        this.state = output.state;
+        if (this.options.style === 'preserve' && trimmed && aliasMap) {
+            aliasMap.set(trimmed, output.id);
+        }
+        return output.id;
+    }
+    /**
+     * 批量规范化工具调用 ID
+     *
+     * @param ids - ID 列表
+     * @returns 规范化后的 ID 列表
+     */
+    normalizeIds(ids) {
+        return ids.map((id) => this.normalizeId(id));
+    }
+    /**
+     * 检查 ID 是否为有效的 fc_ 风格
+     */
+    isValidFcStyle(id) {
+        return /^fc_[a-z0-9]+$/i.test(id);
+    }
+    /**
+     * 从 ID 中提取基础部分（移除前缀）
+     */
+    extractBaseId(id) {
+        if (this.options.style === 'fc') {
+            const match = id.match(/^fc_(.+)$/i);
+            return match ? match[1] : id;
+        }
+        return id;
+    }
+    /**
+     * 重置计数器
+     */
+    resetCounter() {
+        this.state = createToolCallIdTransformerWithNative(this.options.style);
+    }
+    /**
+     * 获取当前配置
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+    /**
+     * 更新配置
+     */
+    updateOptions(options) {
+        this.options = { ...this.options, ...options };
+        this.state = createToolCallIdTransformerWithNative(this.options.style);
+    }
+}
+/**
+ * 规范化工具调用 ID 值
+ *
+ * @param value - ID 值（可能是字符串或其他类型）
+ * @param forceGenerate - 如果为 true，总是生成新 ID
+ * @returns 规范化后的 ID 字符串
+ */
+export function normalizeIdValue(value, forceGenerate = false) {
+    assertToolCallIdManagerNativeAvailable();
+    return normalizeIdValueWithNative(value, forceGenerate);
+}
+/**
+ * 从对象中提取工具调用 ID
+ *
+ * @param obj - 包含 ID 的对象
+ * @returns 提取的 ID
+ */
+export function extractToolCallId(obj) {
+    assertToolCallIdManagerNativeAvailable();
+    return extractToolCallIdWithNative(obj);
+}
+/**
+ * 创建工具调用 ID 转换器（用于 Responses 格式）
+ *
+ * @param style - ID 风格
+ * @returns 转换器函数
+ */
+export function createToolCallIdTransformer(style) {
+    assertToolCallIdManagerNativeAvailable();
+    if (style !== 'fc' && style !== 'preserve')
+        return null;
+    const state = createToolCallIdTransformerWithNative(style);
+    return (id) => {
+        const output = transformToolCallIdWithNative(state, id);
+        Object.assign(state, output.state);
+        return output.id;
+    };
+}
+/**
+ * 在消息列表中强制应用工具调用 ID 风格
+ *
+ * @param messages - 消息列表
+ * @param transformer - ID 转换器
+ */
+export function enforceToolCallIdStyle(messages, transformer) {
+    assertToolCallIdManagerNativeAvailable();
+    if (!messages || !Array.isArray(messages)) {
+        return;
+    }
+    const state = createToolCallIdTransformerWithNative('fc');
+    const updated = enforceToolCallIdStyleWithNative(messages, state);
+    const nextMessages = updated.messages;
+    if (transformer && typeof transformer === 'function') {
+        for (const message of nextMessages) {
+            if (!message || typeof message !== 'object')
+                continue;
+            const role = message.role;
+            if (role === 'assistant' && Array.isArray(message.tool_calls)) {
+                for (const call of message.tool_calls) {
+                    if (!call || typeof call !== 'object')
+                        continue;
+                    const id = extractToolCallId(call);
+                    if (id) {
+                        call.id = transformer(id);
+                    }
+                }
+            }
+            if (role === 'tool') {
+                const id = extractToolCallId(message);
+                if (id) {
+                    message.tool_call_id = transformer(id);
+                }
+            }
+        }
+    }
+    messages.splice(0, messages.length, ...nextMessages);
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-utils.d.ts

@@ -0,0 +1,11 @@
+type UnknownRecord = Record<string, unknown>;
+/**
+ * Derive a deterministic key for a tool call by combining the normalized
+ * function name and serialized arguments. Used to deduplicate inferred calls.
+ */
+export declare function deriveToolCallKey(call: UnknownRecord | null | undefined): string | null;
+/**
+ * Merge tool call entries with deduplication (by derived key). Returns the new array.
+ */
+export declare function mergeToolCalls(existing: UnknownRecord[] | undefined, additions: UnknownRecord[] | undefined): UnknownRecord[];
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-utils.js

@@ -0,0 +1,14 @@
+import { deriveToolCallKeyWithNative, mergeToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+/**
+ * Derive a deterministic key for a tool call by combining the normalized
+ * function name and serialized arguments. Used to deduplicate inferred calls.
+ */
+export function deriveToolCallKey(call) {
+    return deriveToolCallKeyWithNative(call);
+}
+/**
+ * Merge tool call entries with deduplication (by derived key). Returns the new array.
+ */
+export function mergeToolCalls(existing, additions) {
+    return mergeToolCallsWithNative(existing, additions);
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-filter-pipeline.d.ts

@@ -0,0 +1,21 @@
+import type { ToolFilterHints } from '../../filters/index.js';
+interface RequestFilterOptions {
+    entryEndpoint?: string;
+    requestId?: string;
+    model?: string;
+    profile?: string;
+    stream?: boolean;
+    toolFilterHints?: ToolFilterHints;
+    /**
+     * Optional raw payload snapshot for local tool governance (e.g. view_image exposure).
+     */
+    rawPayload?: Record<string, unknown>;
+}
+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/vendor/@jsonstudio/llms/dist/conversion/shared/tool-filter-pipeline.js

@@ -0,0 +1,171 @@
+import { FilterEngine } from '../../filters/index.js';
+import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+import { createSnapshotWriter } from '../snapshot-utils.js';
+import { normalizeChatResponseReasoningToolsWithNative as normalizeChatResponseReasoningTools } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+const REQUEST_FILTER_STAGES = [
+    'request_pre',
+    'request_map',
+    'request_post',
+    'request_finalize'
+];
+const RESPONSE_FILTER_STAGES = [
+    'response_pre',
+    'response_map',
+    'response_post',
+    'response_finalize'
+];
+function assertStageCoverage(label, registeredStages, skeletonStages) {
+    const allowed = new Set(skeletonStages);
+    const uncovered = [];
+    for (const stage of registeredStages) {
+        if (!allowed.has(stage)) {
+            uncovered.push(stage);
+        }
+    }
+    if (uncovered.length) {
+        throw new Error(`[tool-filter-pipeline] ${label}: registered filter stage(s) not covered by skeleton: ${uncovered.join(', ')}`);
+    }
+}
+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 snapshot = createSnapshotWriter({
+        requestId: reqCtxBase.requestId,
+        endpoint: reqCtxBase.endpoint,
+        folderHint: 'openai-chat'
+    });
+    const recordStage = (stage, payload) => {
+        if (!snapshot)
+            return;
+        snapshot(stage, payload);
+    };
+    const preFiltered = applyLocalToolGovernance(chatRequest, options.rawPayload);
+    recordStage('req_process_tool_filters_input', preFiltered);
+    const engine = new FilterEngine();
+    const registeredStages = new Set();
+    const register = (filter) => {
+        registeredStages.add(filter.stage);
+        engine.registerFilter(filter);
+    };
+    const profile = (reqCtxBase.profile || '').toLowerCase();
+    const endpoint = (reqCtxBase.endpoint || '').toLowerCase();
+    const isAnthropic = profile === 'anthropic-messages' || endpoint.includes('/v1/messages');
+    if (!isAnthropic) {
+        try {
+            const { RequestToolListFilter } = await import('../../filters/index.js');
+            register(new RequestToolListFilter());
+        }
+        catch {
+            /* optional */
+        }
+    }
+    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
+    register(new RequestToolCallsStringifyFilter());
+    if (!isAnthropic) {
+        register(new RequestToolChoicePolicyFilter());
+    }
+    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 */ }
+    try {
+        const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
+        register(new RequestOpenAIToolsNormalizeFilter());
+        register(new ToolPostConstraintsFilter('request_finalize'));
+    }
+    catch {
+        // optional; keep prior behavior when filter not available
+    }
+    assertStageCoverage('request', registeredStages, REQUEST_FILTER_STAGES);
+    let staged = preFiltered;
+    for (const stage of REQUEST_FILTER_STAGES) {
+        staged = await engine.run(stage, staged, reqCtxBase);
+        recordStage(`req_process_tool_filters_${stage}`, staged);
+    }
+    recordStage('req_process_tool_filters_output', staged);
+    return staged;
+}
+function applyLocalToolGovernance(chatRequest, _rawPayload) {
+    if (!chatRequest || typeof chatRequest !== 'object') {
+        return chatRequest;
+    }
+    return chatRequest;
+}
+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 snapshot = createSnapshotWriter({
+        requestId: resCtxBase.requestId,
+        endpoint: resCtxBase.endpoint,
+        folderHint: 'openai-chat'
+    });
+    const recordStage = (stage, payload) => {
+        if (!snapshot)
+            return;
+        snapshot(stage, payload);
+    };
+    recordStage('resp_process_tool_filters_input', chatJson);
+    try {
+        if (chatJson && typeof chatJson === 'object') {
+            chatJson = normalizeChatResponseReasoningTools(chatJson, 'reasoning_choice');
+        }
+    }
+    catch {
+        // best-effort; do not block response flow on reasoning parsing issues
+    }
+    const engine = new FilterEngine();
+    const registeredStages = new Set();
+    const register = (filter) => {
+        registeredStages.add(filter.stage);
+        engine.registerFilter(filter);
+    };
+    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
+    register(new ResponseToolTextCanonicalizeFilter());
+    try {
+        register(new ResponseToolArgumentsSchemaConvergeFilter());
+    }
+    catch { /* optional */ }
+    register(new ResponseToolArgumentsBlacklistFilter());
+    register(new ResponseToolArgumentsStringifyFilter());
+    register(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 */ }
+    assertStageCoverage('response', registeredStages, RESPONSE_FILTER_STAGES);
+    let staged = chatJson;
+    for (const stage of RESPONSE_FILTER_STAGES) {
+        staged = await engine.run(stage, staged, resCtxBase);
+        recordStage(`resp_process_tool_filters_${stage}`, staged);
+    }
+    recordStage('resp_process_tool_filters_output', staged);
+    return staged;
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-governor.d.ts

@@ -0,0 +1,29 @@
+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 structured tool_calls; set content=null when applicable
+ */
+export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
+export declare function normalizeApplyPatchToolCallsOnResponse(chat: Unknown): Unknown;
+export declare function normalizeApplyPatchToolCallsOnRequest(request: Unknown): 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 {};