@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/servertool/stop-gateway-context.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext } from '../conversion/hub/types/chat-envelope.js';
+export interface StopGatewayContext {
+    observed: boolean;
+    eligible: boolean;
+    source: 'chat' | 'responses' | 'none';
+    reason: string;
+    choiceIndex?: number;
+    hasToolCalls?: boolean;
+}
+export declare function inspectStopGatewaySignal(base: unknown): StopGatewayContext;
+export declare function attachStopGatewayContext(adapterContext: AdapterContext, context: StopGatewayContext): void;
+export declare function readStopGatewayContext(adapterContext: unknown): StopGatewayContext | undefined;
+export declare function resolveStopGatewayContext(base: unknown, adapterContext?: unknown): StopGatewayContext;
+export declare function isStopEligibleForServerTool(base: unknown, adapterContext?: unknown): boolean;

package/vendor/llmswitch-core/dist/servertool/stop-gateway-context.js

@@ -0,0 +1,167 @@
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../conversion/runtime-metadata.js';
+export function inspectStopGatewaySignal(base) {
+    if (!base || typeof base !== 'object' || Array.isArray(base)) {
+        return {
+            observed: false,
+            eligible: false,
+            source: 'none',
+            reason: 'invalid_payload'
+        };
+    }
+    const payload = base;
+    const choicesRaw = payload.choices;
+    if (Array.isArray(choicesRaw) && choicesRaw.length) {
+        for (let idx = 0; idx < choicesRaw.length; idx += 1) {
+            const choice = choicesRaw[idx];
+            if (!choice || typeof choice !== 'object' || Array.isArray(choice)) {
+                continue;
+            }
+            const finishReasonRaw = choice.finish_reason;
+            const finishReason = typeof finishReasonRaw === 'string' && finishReasonRaw.trim()
+                ? finishReasonRaw.trim().toLowerCase()
+                : '';
+            if (!finishReason || finishReason === 'tool_calls') {
+                continue;
+            }
+            if (finishReason !== 'stop' && finishReason !== 'length') {
+                continue;
+            }
+            const message = choice.message &&
+                typeof choice.message === 'object' &&
+                !Array.isArray(choice.message)
+                ? choice.message
+                : null;
+            const toolCalls = message && Array.isArray(message.tool_calls) ? message.tool_calls : [];
+            const hasToolCalls = toolCalls.length > 0;
+            return {
+                observed: true,
+                eligible: !hasToolCalls,
+                source: 'chat',
+                reason: `finish_reason_${finishReason}`,
+                choiceIndex: idx,
+                hasToolCalls
+            };
+        }
+        return {
+            observed: false,
+            eligible: false,
+            source: 'chat',
+            reason: 'no_stop_finish_reason'
+        };
+    }
+    const statusRaw = typeof payload.status === 'string' ? payload.status.trim().toLowerCase() : '';
+    if (statusRaw && statusRaw !== 'completed') {
+        return {
+            observed: false,
+            eligible: false,
+            source: 'responses',
+            reason: `status_${statusRaw}`
+        };
+    }
+    const hasRequiredAction = Boolean(payload.required_action && typeof payload.required_action === 'object');
+    const outputRaw = Array.isArray(payload.output) ? payload.output : [];
+    if (!statusRaw && outputRaw.length === 0) {
+        return {
+            observed: false,
+            eligible: false,
+            source: 'responses',
+            reason: 'no_status_or_output'
+        };
+    }
+    if (outputRaw.some((item) => hasToolLikeOutput(item))) {
+        return {
+            observed: true,
+            eligible: false,
+            source: 'responses',
+            reason: 'responses_tool_like_output'
+        };
+    }
+    if (hasRequiredAction) {
+        return {
+            observed: true,
+            eligible: false,
+            source: 'responses',
+            reason: 'responses_required_action'
+        };
+    }
+    return {
+        observed: true,
+        eligible: true,
+        source: 'responses',
+        reason: statusRaw ? `status_${statusRaw}` : 'responses_output_completed'
+    };
+}
+export function attachStopGatewayContext(adapterContext, context) {
+    try {
+        const rt = ensureRuntimeMetadata(adapterContext);
+        rt.stopGatewayContext = {
+            observed: context.observed,
+            eligible: context.eligible,
+            source: context.source,
+            reason: context.reason,
+            ...(typeof context.choiceIndex === 'number' ? { choiceIndex: context.choiceIndex } : {}),
+            ...(typeof context.hasToolCalls === 'boolean' ? { hasToolCalls: context.hasToolCalls } : {})
+        };
+    }
+    catch {
+        // ignore metadata write failures
+    }
+}
+export function readStopGatewayContext(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return undefined;
+    }
+    const rt = readRuntimeMetadata(adapterContext);
+    const raw = rt && typeof rt === 'object' ? rt.stopGatewayContext : undefined;
+    return normalizeStopGatewayContext(raw);
+}
+export function resolveStopGatewayContext(base, adapterContext) {
+    const fromMetadata = readStopGatewayContext(adapterContext);
+    if (fromMetadata) {
+        return fromMetadata;
+    }
+    return inspectStopGatewaySignal(base);
+}
+export function isStopEligibleForServerTool(base, adapterContext) {
+    return resolveStopGatewayContext(base, adapterContext).eligible;
+}
+function normalizeStopGatewayContext(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    if (typeof record.observed !== 'boolean' || typeof record.eligible !== 'boolean') {
+        return undefined;
+    }
+    const sourceRaw = typeof record.source === 'string' ? record.source.trim().toLowerCase() : '';
+    const source = sourceRaw === 'chat' || sourceRaw === 'responses' || sourceRaw === 'none'
+        ? sourceRaw
+        : 'none';
+    const reason = typeof record.reason === 'string' && record.reason.trim() ? record.reason.trim() : 'unknown';
+    const choiceIndex = typeof record.choiceIndex === 'number' && Number.isFinite(record.choiceIndex)
+        ? Math.floor(record.choiceIndex)
+        : undefined;
+    const hasToolCalls = typeof record.hasToolCalls === 'boolean' ? record.hasToolCalls : undefined;
+    return {
+        observed: record.observed,
+        eligible: record.eligible,
+        source,
+        reason,
+        ...(typeof choiceIndex === 'number' ? { choiceIndex } : {}),
+        ...(typeof hasToolCalls === 'boolean' ? { hasToolCalls } : {})
+    };
+}
+function hasToolLikeOutput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const typeRaw = value.type;
+    const type = typeof typeRaw === 'string' ? typeRaw.trim().toLowerCase() : '';
+    if (!type) {
+        return false;
+    }
+    return (type === 'tool_call' ||
+        type === 'tool_use' ||
+        type === 'function_call' ||
+        type.includes('tool'));
+}

package/vendor/llmswitch-core/dist/servertool/stop-message-compare-context.d.ts

@@ -0,0 +1,24 @@
+export interface StopMessageCompareContext {
+    armed: boolean;
+    mode: 'off' | 'on' | 'auto';
+    allowModeOnly: boolean;
+    textLength: number;
+    maxRepeats: number;
+    used: number;
+    remaining: number;
+    active: boolean;
+    stopEligible: boolean;
+    hasCapturedRequest: boolean;
+    compactionRequest: boolean;
+    hasSeed: boolean;
+    decision: 'trigger' | 'skip';
+    reason: string;
+    stage?: string;
+    bdWorkState?: string;
+    observationHash?: string;
+    observationStableCount?: number;
+    toolSignatureHash?: string;
+}
+export declare function attachStopMessageCompareContext(adapterContext: unknown, context: StopMessageCompareContext): void;
+export declare function readStopMessageCompareContext(adapterContext: unknown): StopMessageCompareContext | undefined;
+export declare function formatStopMessageCompareContext(context: StopMessageCompareContext | undefined): string;

package/vendor/llmswitch-core/dist/servertool/stop-message-compare-context.js

@@ -0,0 +1,133 @@
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../conversion/runtime-metadata.js';
+const STOP_MESSAGE_COMPARE_KEY = 'stopMessageCompareContext';
+export function attachStopMessageCompareContext(adapterContext, context) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return;
+    }
+    try {
+        const runtime = ensureRuntimeMetadata(adapterContext);
+        runtime[STOP_MESSAGE_COMPARE_KEY] = {
+            armed: context.armed,
+            mode: context.mode,
+            allowModeOnly: context.allowModeOnly,
+            textLength: context.textLength,
+            maxRepeats: context.maxRepeats,
+            used: context.used,
+            remaining: context.remaining,
+            active: context.active,
+            stopEligible: context.stopEligible,
+            hasCapturedRequest: context.hasCapturedRequest,
+            compactionRequest: context.compactionRequest,
+            hasSeed: context.hasSeed,
+            decision: context.decision,
+            reason: context.reason,
+            ...(typeof context.stage === 'string' && context.stage.trim() ? { stage: context.stage.trim() } : {}),
+            ...(typeof context.bdWorkState === 'string' && context.bdWorkState.trim()
+                ? { bdWorkState: context.bdWorkState.trim() }
+                : {}),
+            ...(typeof context.observationHash === 'string' && context.observationHash.trim()
+                ? { observationHash: context.observationHash.trim() }
+                : {}),
+            ...(typeof context.observationStableCount === 'number' && Number.isFinite(context.observationStableCount)
+                ? { observationStableCount: Math.max(0, Math.floor(context.observationStableCount)) }
+                : {}),
+            ...(typeof context.toolSignatureHash === 'string' && context.toolSignatureHash.trim()
+                ? { toolSignatureHash: context.toolSignatureHash.trim() }
+                : {})
+        };
+    }
+    catch {
+        // ignore metadata write failures
+    }
+}
+export function readStopMessageCompareContext(adapterContext) {
+    if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {
+        return undefined;
+    }
+    const runtime = readRuntimeMetadata(adapterContext);
+    const raw = runtime && typeof runtime === 'object' ? runtime[STOP_MESSAGE_COMPARE_KEY] : undefined;
+    return normalizeStopMessageCompareContext(raw);
+}
+export function formatStopMessageCompareContext(context) {
+    if (!context) {
+        return 'decision=unknown reason=no_context';
+    }
+    return [
+        `decision=${context.decision}`,
+        `reason=${context.reason}`,
+        `armed=${context.armed}`,
+        `mode=${context.mode}`,
+        `allowModeOnly=${context.allowModeOnly}`,
+        `max=${context.maxRepeats}`,
+        `used=${context.used}`,
+        `left=${context.remaining}`,
+        `active=${context.active}`,
+        `stopEligible=${context.stopEligible}`,
+        `captured=${context.hasCapturedRequest}`,
+        `compaction=${context.compactionRequest}`,
+        `seed=${context.hasSeed}`,
+        ...(typeof context.stage === 'string' && context.stage ? [`stage=${context.stage}`] : []),
+        ...(typeof context.bdWorkState === 'string' && context.bdWorkState ? [`bd=${context.bdWorkState}`] : []),
+        `obs=${typeof context.observationHash === 'string' && context.observationHash ? context.observationHash : 'none'}`,
+        `stable=${typeof context.observationStableCount === 'number' && Number.isFinite(context.observationStableCount)
+            ? Math.max(0, Math.floor(context.observationStableCount))
+            : 'n/a'}`,
+        `toolSig=${typeof context.toolSignatureHash === 'string' && context.toolSignatureHash ? context.toolSignatureHash : 'none'}`
+    ].join(' ');
+}
+function normalizeStopMessageCompareContext(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    const decisionRaw = typeof record.decision === 'string' ? record.decision.trim().toLowerCase() : '';
+    if (decisionRaw !== 'trigger' && decisionRaw !== 'skip') {
+        return undefined;
+    }
+    const modeRaw = typeof record.mode === 'string' ? record.mode.trim().toLowerCase() : '';
+    const mode = modeRaw === 'on' || modeRaw === 'auto' || modeRaw === 'off'
+        ? modeRaw
+        : 'off';
+    const reason = typeof record.reason === 'string' && record.reason.trim() ? record.reason.trim() : 'unknown';
+    const textLength = typeof record.textLength === 'number' && Number.isFinite(record.textLength)
+        ? Math.max(0, Math.floor(record.textLength))
+        : 0;
+    const maxRepeats = typeof record.maxRepeats === 'number' && Number.isFinite(record.maxRepeats)
+        ? Math.max(0, Math.floor(record.maxRepeats))
+        : 0;
+    const used = typeof record.used === 'number' && Number.isFinite(record.used)
+        ? Math.max(0, Math.floor(record.used))
+        : 0;
+    const remaining = typeof record.remaining === 'number' && Number.isFinite(record.remaining)
+        ? Math.max(0, Math.floor(record.remaining))
+        : Math.max(0, maxRepeats - used);
+    return {
+        armed: Boolean(record.armed),
+        mode,
+        allowModeOnly: Boolean(record.allowModeOnly),
+        textLength,
+        maxRepeats,
+        used,
+        remaining,
+        active: Boolean(record.active),
+        stopEligible: Boolean(record.stopEligible),
+        hasCapturedRequest: Boolean(record.hasCapturedRequest),
+        compactionRequest: Boolean(record.compactionRequest),
+        hasSeed: Boolean(record.hasSeed),
+        decision: decisionRaw,
+        reason,
+        ...(typeof record.stage === 'string' && record.stage.trim() ? { stage: record.stage.trim() } : {}),
+        ...(typeof record.bdWorkState === 'string' && record.bdWorkState.trim()
+            ? { bdWorkState: record.bdWorkState.trim() }
+            : {}),
+        ...(typeof record.observationHash === 'string' && record.observationHash.trim()
+            ? { observationHash: record.observationHash.trim() }
+            : {}),
+        ...(typeof record.observationStableCount === 'number' && Number.isFinite(record.observationStableCount)
+            ? { observationStableCount: Math.max(0, Math.floor(record.observationStableCount)) }
+            : {}),
+        ...(typeof record.toolSignatureHash === 'string' && record.toolSignatureHash.trim()
+            ? { toolSignatureHash: record.toolSignatureHash.trim() }
+            : {})
+    };
+}

package/vendor/llmswitch-core/dist/servertool/strip-servertool-calls.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../conversion/hub/types/json.js';
+export declare function filterOutExecutedServerToolCalls(finalizedPayload: JsonObject, orchestrationPayload: JsonObject): JsonObject;

package/vendor/llmswitch-core/dist/servertool/strip-servertool-calls.js

@@ -0,0 +1,75 @@
+function collectExecutedServerToolCallIds(payload) {
+    const ids = new Set();
+    const toolOutputs = Array.isArray(payload.tool_outputs) ? payload.tool_outputs : [];
+    for (const entry of toolOutputs) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const name = typeof entry.name === 'string' ? String(entry.name).trim() : '';
+        const toolCallId = typeof entry.tool_call_id === 'string' ? String(entry.tool_call_id).trim() : '';
+        if (!name || !toolCallId)
+            continue;
+        // Only strip servertool continue_execution tool calls.
+        if (name !== 'continue_execution')
+            continue;
+        ids.add(toolCallId);
+    }
+    return ids;
+}
+function filterToolCallsInMessage(message, executedIds) {
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    if (!toolCalls.length)
+        return;
+    const next = toolCalls.filter((tc) => {
+        if (!tc || typeof tc !== 'object' || Array.isArray(tc))
+            return true;
+        const id = typeof tc.id === 'string' ? String(tc.id).trim() : '';
+        if (!id)
+            return true;
+        return !executedIds.has(id);
+    });
+    message.tool_calls = next;
+}
+function stripFromChoices(payload, executedIds) {
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    for (const choice of choices) {
+        if (!choice || typeof choice !== 'object' || Array.isArray(choice))
+            continue;
+        const message = choice.message;
+        if (!message || typeof message !== 'object' || Array.isArray(message))
+            continue;
+        filterToolCallsInMessage(message, executedIds);
+    }
+}
+function stripFromMessages(payload, executedIds) {
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object' || Array.isArray(msg))
+            continue;
+        const role = msg.role;
+        if (role !== 'assistant')
+            continue;
+        filterToolCallsInMessage(msg, executedIds);
+    }
+}
+export function filterOutExecutedServerToolCalls(finalizedPayload, orchestrationPayload) {
+    const executedIds = collectExecutedServerToolCallIds(orchestrationPayload);
+    if (executedIds.size === 0)
+        return finalizedPayload;
+    const cloned = JSON.parse(JSON.stringify(finalizedPayload));
+    stripFromChoices(cloned, executedIds);
+    stripFromMessages(cloned, executedIds);
+    // If tool_calls are removed, ensure finish_reason/content consistency for chat choices.
+    const choices = Array.isArray(cloned.choices) ? cloned.choices : [];
+    for (const choice of choices) {
+        if (!choice || typeof choice !== 'object' || Array.isArray(choice))
+            continue;
+        const message = choice.message;
+        if (!message || typeof message !== 'object' || Array.isArray(message))
+            continue;
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (toolCalls.length === 0 && choice.finish_reason === 'tool_calls') {
+            choice.finish_reason = 'stop';
+        }
+    }
+    return cloned;
+}

package/vendor/llmswitch-core/dist/servertool/types.d.ts

@@ -0,0 +1,235 @@
+import type { AdapterContext } from '../conversion/hub/types/chat-envelope.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+/**
+ * ProviderInvoker 由 Host 注入，用于在 llmswitch-core 内部发起二次 provider 请求。
+ * 该接口对 ServerTool 框架是抽象的，不关心 HTTP 细节。
+ */
+export type ProviderInvoker = (options: {
+    providerKey: string;
+    providerType?: string;
+    modelId?: string;
+    providerProtocol: string;
+    payload: JsonObject;
+    entryEndpoint: string;
+    requestId: string;
+    /**
+     * 可选的路由提示，用于在 Host 侧强制通过虚拟路由命中特定 route
+     *（例如 web_search），保持所有二次请求仍然走标准 HubPipeline。
+     */
+    routeHint?: string;
+}) => Promise<{
+    providerResponse: JsonObject;
+}>;
+/**
+ * ToolCall：对齐 OpenAI style 的工具调用表示。
+ */
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface ServerToolAutoHookTraceEvent {
+    hookId: string;
+    phase: string;
+    priority: number;
+    queue: 'A_optional' | 'B_mandatory';
+    queueIndex: number;
+    queueTotal: number;
+    result: 'miss' | 'match' | 'error';
+    reason: string;
+    flowId?: string;
+}
+/**
+ * ServerSideToolEngineOptions：ServerTool 引擎入参（ChatCompletion 视角）。
+ */
+export interface ServerSideToolEngineOptions {
+    chatResponse: JsonObject;
+    adapterContext: AdapterContext;
+    entryEndpoint: string;
+    requestId: string;
+    providerProtocol: string;
+    disableToolCallHandlers?: boolean;
+    includeAutoHookIds?: string[];
+    excludeAutoHookIds?: string[];
+    includeToolCallHandlerNames?: string[];
+    excludeToolCallHandlerNames?: string[];
+    providerInvoker?: ProviderInvoker;
+    reenterPipeline?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        body?: JsonObject;
+        __sse_responses?: unknown;
+        format?: string;
+    }>;
+    clientInjectDispatch?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body?: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    onAutoHookTrace?: (event: ServerToolAutoHookTraceEvent) => void;
+}
+export type ServerToolFollowupInjectionOp = {
+    op: 'preserve_tools';
+} | {
+    op: 'ensure_standard_tools';
+} | {
+    op: 'append_assistant_message';
+    required?: boolean;
+} | {
+    op: 'append_tool_messages_from_tool_outputs';
+    required?: boolean;
+} | {
+    op: 'inject_system_text';
+    text: string;
+} | {
+    op: 'append_user_text';
+    text: string;
+} | {
+    op: 'drop_tool_by_name';
+    name: string;
+} | {
+    op: 'inject_vision_summary';
+    summary: string;
+} | {
+    op: 'trim_openai_messages';
+    maxNonSystemMessages: number;
+} | {
+    op: 'compact_tool_content';
+    maxChars: number;
+};
+export type ServerToolFollowupInjectionPlan = {
+    ops: ServerToolFollowupInjectionOp[];
+};
+export type ServerToolFollowupPlan = {
+    requestIdSuffix: string;
+    payload: JsonObject;
+    metadata?: JsonObject;
+    entryEndpoint?: string;
+} | {
+    requestIdSuffix: string;
+    injection: ServerToolFollowupInjectionPlan;
+    metadata?: JsonObject;
+    entryEndpoint?: string;
+} | {
+    requestIdSuffix: string;
+    metadata?: JsonObject;
+};
+export type ServerToolBackendPlan = {
+    kind: 'vision_analysis';
+    requestIdSuffix: string;
+    entryEndpoint: string;
+    payload: JsonObject;
+} | {
+    kind: 'web_search';
+    requestIdSuffix: string;
+    query: string;
+    recency?: string;
+    resultCount: number;
+    engines: {
+        id: string;
+        providerKey: string;
+        description?: string;
+        default?: boolean;
+        executionMode?: 'servertool' | 'direct';
+        directActivation?: 'route' | 'builtin';
+        modelId?: string;
+        maxUses?: number;
+        serverToolsDisabled?: boolean;
+        searchEngineList?: string[];
+    }[];
+};
+export type ServerToolBackendResult = {
+    kind: 'vision_analysis';
+    response: {
+        body?: JsonObject;
+        __sse_responses?: unknown;
+        format?: string;
+    };
+} | {
+    kind: 'web_search';
+    chosenEngine?: {
+        id: string;
+        providerKey: string;
+    };
+    result: {
+        ok: boolean;
+        summary: string;
+        hits: {
+            title?: string;
+            link: string;
+            media?: string;
+            publish_date?: string;
+            content?: string;
+            refer?: string;
+        }[];
+    };
+};
+export interface ServerToolHandlerPlan {
+    flowId: string;
+    backend?: ServerToolBackendPlan;
+    finalize: (args: {
+        backendResult?: ServerToolBackendResult;
+    }) => Promise<ServerToolHandlerResult | null>;
+}
+export interface ServerToolExecution {
+    flowId: string;
+    followup?: ServerToolFollowupPlan;
+    /**
+     * Optional tool-specific context for the execution result.
+     * For example, web_search handler may attach { web_search: { engineId, providerKey, summary } }
+     * so that orchestration layer can decorate final Chat response without touching host code.
+     */
+    context?: JsonObject;
+}
+/**
+ * ServerSideToolEngineResult：ServerTool 引擎出参。
+ */
+export interface ServerSideToolEngineResult {
+    mode: 'passthrough' | 'tool_flow';
+    finalChatResponse: JsonObject;
+    execution?: ServerToolExecution;
+    /**
+     * When present, indicates a "mixed tools" flow:
+     * - servertools were executed and their tool results are persisted
+     * - remaining (non-servertool) tool_calls must be returned to client
+     * - on next request, servertool results will be injected after client tool results
+     */
+    pendingInjection?: {
+        sessionId: string;
+        afterToolCallIds: string[];
+        messages: JsonObject[];
+    };
+}
+/**
+ * ServerToolHandlerContext：单个工具 handler 的上下文入参。
+ */
+export interface ServerToolHandlerContext {
+    base: JsonObject;
+    toolCall?: ToolCall;
+    toolCalls: ToolCall[];
+    adapterContext: AdapterContext;
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: string;
+    capabilities: {
+        reenterPipeline: boolean;
+        providerInvoker: boolean;
+    };
+}
+export interface ServerToolHandlerResult {
+    chatResponse: JsonObject;
+    execution: ServerToolExecution;
+}
+/**
+ * ServerToolHandler：统一的 ServerTool handler 接口。
+ * 后续 web_search / vision / 其它工具都会以 handler 形式挂载到注册表。
+ */
+export type ServerToolHandler = (ctx: ServerToolHandlerContext) => Promise<ServerToolHandlerPlan | null>;
+export type { JsonObject, JsonValue } from '../conversion/hub/types/json.js';

package/vendor/llmswitch-core/dist/servertool/types.js

@@ -0,0 +1 @@
+export {};