@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/token-file-scanner.d.ts

@@ -0,0 +1,15 @@
+export interface OAuthTokenFileMatch {
+    filePath: string;
+    sequence: number;
+    alias: string;
+}
+/**
+ * 扫描本地 RouteCodex auth 目录中的 OAuth token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: <provider>-oauth-<sequence>[-<alias>].json
+ *
+ * 仅在 Node 环境下使用；如果环境不满足，返回空列表。
+ */
+export declare function scanOAuthTokenFiles(oauthProviderId: string, authDir?: string): OAuthTokenFileMatch[];

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/token-file-scanner.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const TOKEN_FILE_PATTERN = /^([a-z0-9_-]+)-oauth-(\d+)(?:-(.+))?\.json$/i;
+/**
+ * 扫描本地 RouteCodex auth 目录中的 OAuth token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: <provider>-oauth-<sequence>[-<alias>].json
+ *
+ * 仅在 Node 环境下使用；如果环境不满足，返回空列表。
+ */
+export function scanOAuthTokenFiles(oauthProviderId, authDir) {
+    if (!isNodeEnvironment()) {
+        return [];
+    }
+    const provider = oauthProviderId.trim().toLowerCase();
+    if (!provider) {
+        return [];
+    }
+    const baseDir = authDir && authDir.trim()
+        ? authDir.trim()
+        : path.join(os.homedir(), '.routecodex', 'auth');
+    let entries;
+    try {
+        entries = fs.readdirSync(baseDir);
+    }
+    catch {
+        return [];
+    }
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const match = entry.match(TOKEN_FILE_PATTERN);
+        if (!match)
+            continue;
+        const [, providerPrefix, sequenceStr, alias] = match;
+        if (providerPrefix.toLowerCase() !== provider)
+            continue;
+        const sequence = parseInt(sequenceStr, 10);
+        if (!Number.isFinite(sequence) || sequence <= 0)
+            continue;
+        matches.push({
+            filePath: path.join(baseDir, entry),
+            sequence,
+            alias: alias || 'default'
+        });
+    }
+    matches.sort((a, b) => a.sequence - b.sequence);
+    return matches;
+}
+function isNodeEnvironment() {
+    return typeof process !== 'undefined' && !!process.release && process.release.name === 'node';
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/tool-signals.d.ts

@@ -0,0 +1,13 @@
+import type { StandardizedMessage, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export type ToolCategory = 'read' | 'write' | 'search' | 'other';
+export type ToolClassification = {
+    category: ToolCategory;
+    name: string;
+    commandSnippet?: string;
+};
+export declare function detectVisionTool(request: StandardizedRequest): boolean;
+export declare function detectCodingTool(request: StandardizedRequest): boolean;
+export declare function detectWebTool(request: StandardizedRequest): boolean;
+export declare function extractMeaningfulDeclaredToolNames(tools: StandardizedRequest['tools'] | undefined): string[];
+export declare function detectLastAssistantToolCategory(messages: StandardizedMessage[]): ToolClassification | undefined;
+export declare function canonicalizeToolName(rawName: string): string;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/tool-signals.js

@@ -0,0 +1,403 @@
+const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
+const READ_TOOL_EXACT = new Set([
+    'read_file',
+    'read_text',
+    'view_file',
+    'view_code',
+    'view_document',
+    'open_file',
+    'get_file',
+    'download_file',
+    'describe_current_request',
+    'list_dir',
+    'list_directory',
+    'list_files',
+    'list_documents',
+    'list_resources',
+    'search_files',
+    'find_files'
+]);
+const WRITE_TOOL_EXACT = new Set([
+    'apply_patch',
+    'write_file',
+    'create_file',
+    'modify_file',
+    'edit_file',
+    'update_file',
+    'save_file',
+    'append_file',
+    'replace_file',
+    'delete_file',
+    'remove_file',
+    'rename_file',
+    'move_file',
+    'copy_file',
+    'mkdir',
+    'rmdir'
+]);
+const SEARCH_TOOL_EXACT = new Set(['websearch', 'web_search', 'search_web', 'internet_search', 'webfetch', 'web_fetch']);
+const READ_TOOL_KEYWORDS = ['read', 'list', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
+const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'delete', 'remove'];
+const SEARCH_TOOL_KEYWORDS = ['search', 'websearch', 'web_fetch', 'webfetch', 'web-request', 'web_request', 'internet'];
+const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
+const DECLARED_TOOL_IGNORE = new Set(['exec_command']);
+const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
+const SHELL_WRITE_PATTERNS = [
+    'apply_patch',
+    'sed -i',
+    'perl -pi',
+    'tee ',
+    'cat <<',
+    'cat >',
+    'printf >',
+    'touch ',
+    'truncate',
+    'mkdir',
+    'mktemp',
+    'rmdir',
+    'rm ',
+    'rm-',
+    'unlink',
+    'mv ',
+    'cp ',
+    'ln -',
+    'chmod',
+    'chown',
+    'chgrp',
+    'tar ',
+    'git add',
+    'git commit',
+    'git apply',
+    'git am',
+    'git rebase',
+    'git checkout',
+    'git merge',
+    'patch <<',
+    'npm install',
+    'pnpm install',
+    'yarn add',
+    'yarn install',
+    'pip install',
+    'pip3 install',
+    'brew install',
+    'cargo add',
+    'cargo install',
+    'go install',
+    'make install'
+];
+const SHELL_SEARCH_PATTERNS = [
+    'rg ',
+    'rg-',
+    'grep ',
+    'grep-',
+    'ripgrep',
+    'find ',
+    'fd ',
+    'locate ',
+    'search ',
+    'ack ',
+    'ag ',
+    'where ',
+    'which ',
+    'codesearch'
+];
+const SHELL_READ_PATTERNS = [
+    'ls',
+    'dir ',
+    'pwd',
+    'cat ',
+    'type ',
+    'head ',
+    'tail ',
+    'stat',
+    'tree',
+    'wc ',
+    'du ',
+    'printf "',
+    'python - <<',
+    'python -c',
+    'node - <<',
+    'node -e'
+];
+export function detectVisionTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        return /vision|image|picture|photo/i.test(functionName) || /vision|image|picture|photo/i.test(description || '');
+    });
+}
+export function detectCodingTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool).toLowerCase();
+        const description = (extractToolDescription(tool) || '').toLowerCase();
+        if (!functionName && !description) {
+            return false;
+        }
+        if (WRITE_TOOL_EXACT.has(functionName)) {
+            return true;
+        }
+        return WRITE_TOOL_KEYWORDS.some((keyword) => functionName.includes(keyword.toLowerCase()) || description.includes(keyword.toLowerCase()));
+    });
+}
+export function detectWebTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        const normalizedName = functionName.toLowerCase();
+        const normalizedDesc = (description || '').toLowerCase();
+        return (WEB_TOOL_KEYWORDS.some((keyword) => normalizedName.includes(keyword)) ||
+            WEB_TOOL_KEYWORDS.some((keyword) => normalizedDesc.includes(keyword)));
+    });
+}
+export function extractMeaningfulDeclaredToolNames(tools) {
+    if (!Array.isArray(tools) || tools.length === 0) {
+        return [];
+    }
+    const names = [];
+    for (const tool of tools) {
+        const rawName = extractToolName(tool);
+        if (!rawName) {
+            continue;
+        }
+        const canonical = canonicalizeToolName(rawName).toLowerCase();
+        if (!canonical || DECLARED_TOOL_IGNORE.has(canonical)) {
+            continue;
+        }
+        names.push(rawName);
+    }
+    return names;
+}
+export function detectLastAssistantToolCategory(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const msg = messages[idx];
+        if (!msg || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0) {
+            continue;
+        }
+        let fallback;
+        for (const call of msg.tool_calls) {
+            const classification = classifyToolCall(call);
+            if (!classification) {
+                continue;
+            }
+            if (!fallback) {
+                fallback = classification;
+            }
+            if (classification.category !== 'other') {
+                return classification;
+            }
+        }
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return undefined;
+}
+function classifyToolCall(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const functionName = typeof call?.function?.name === 'string' && call.function.name.trim()
+        ? canonicalizeToolName(call.function.name)
+        : '';
+    if (!functionName) {
+        return undefined;
+    }
+    const argsObject = parseToolArguments(call?.function?.arguments);
+    const commandText = extractCommandText(argsObject);
+    const nameCategory = categorizeToolName(functionName);
+    const snippet = buildCommandSnippet(commandText);
+    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
+        return { category: nameCategory, name: functionName, commandSnippet: snippet };
+    }
+    if (SHELL_TOOL_NAMES.has(functionName)) {
+        const shellCategory = classifyShellCommand(commandText);
+        return { category: shellCategory, name: functionName, commandSnippet: snippet };
+    }
+    if (commandText) {
+        const derivedCategory = classifyShellCommand(commandText);
+        if (derivedCategory !== 'other') {
+            return { category: derivedCategory, name: functionName, commandSnippet: snippet };
+        }
+    }
+    return { category: 'other', name: functionName, commandSnippet: snippet };
+}
+function extractToolName(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.name === 'string' && fromFunction.name.trim()) {
+        return fromFunction.name;
+    }
+    if (typeof candidate.name === 'string' && candidate.name.trim()) {
+        return candidate.name;
+    }
+    return '';
+}
+function extractToolDescription(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.description === 'string' && fromFunction.description.trim()) {
+        return fromFunction.description;
+    }
+    if (typeof candidate.description === 'string' && candidate.description.trim()) {
+        return candidate.description;
+    }
+    return '';
+}
+export function canonicalizeToolName(rawName) {
+    const trimmed = rawName.trim();
+    const markerIndex = trimmed.indexOf('arg_');
+    if (markerIndex > 0) {
+        return trimmed.slice(0, markerIndex);
+    }
+    return trimmed;
+}
+function parseToolArguments(rawArguments) {
+    if (!rawArguments) {
+        return undefined;
+    }
+    if (typeof rawArguments === 'string') {
+        try {
+            return JSON.parse(rawArguments);
+        }
+        catch {
+            return rawArguments;
+        }
+    }
+    if (typeof rawArguments === 'object') {
+        return rawArguments;
+    }
+    return undefined;
+}
+function extractCommandText(args) {
+    if (!args) {
+        return '';
+    }
+    if (typeof args === 'string') {
+        return args;
+    }
+    if (Array.isArray(args)) {
+        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+    }
+    if (typeof args === 'object') {
+        const record = args;
+        const stringKeys = ['command', 'cmd', 'input', 'code', 'script', 'text', 'prompt'];
+        for (const key of stringKeys) {
+            const value = record[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value;
+            }
+            if (Array.isArray(value)) {
+                const joined = value.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+                if (joined.trim()) {
+                    return joined;
+                }
+            }
+        }
+        const nestedArgs = record.args;
+        if (typeof nestedArgs === 'string' && nestedArgs.trim()) {
+            return nestedArgs;
+        }
+        if (Array.isArray(nestedArgs)) {
+            const joined = nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+            if (joined.trim()) {
+                return joined;
+            }
+        }
+    }
+    return '';
+}
+function buildCommandSnippet(commandText) {
+    if (!commandText) {
+        return undefined;
+    }
+    const collapsed = commandText.replace(/\s+/g, ' ').trim();
+    if (!collapsed) {
+        return undefined;
+    }
+    const limit = 80;
+    if (collapsed.length <= limit) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, limit)}…`;
+}
+function categorizeToolName(name) {
+    const normalized = name.toLowerCase();
+    if (SEARCH_TOOL_EXACT.has(normalized) ||
+        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'search';
+    }
+    if (READ_TOOL_EXACT.has(normalized) ||
+        READ_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'read';
+    }
+    if (WRITE_TOOL_EXACT.has(normalized) ||
+        WRITE_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'write';
+    }
+    return 'other';
+}
+function classifyShellCommand(command) {
+    if (!command) {
+        return 'other';
+    }
+    if (SHELL_HEREDOC_PATTERN.test(command)) {
+        return 'write';
+    }
+    const segments = splitCommandSegments(command).map(stripShellWrapper);
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS))) {
+        return 'write';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS))) {
+        return 'search';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
+        return 'read';
+    }
+    const stripped = stripShellWrapper(command);
+    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
+        return 'write';
+    }
+    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
+        return 'search';
+    }
+    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
+        return 'read';
+    }
+    return 'other';
+}
+function splitCommandSegments(command) {
+    return command
+        .split(/(?:\r?\n|&&|\|\||;)/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function stripShellWrapper(command) {
+    if (!command) {
+        return '';
+    }
+    const wrappers = ['bash -lc', 'sh -c', 'zsh -c'];
+    for (const wrapper of wrappers) {
+        if (command.startsWith(wrapper)) {
+            return command.slice(wrapper.length).trim();
+        }
+    }
+    return command.trim();
+}
+function matchesAnyPattern(command, patterns) {
+    return patterns.some((pattern) => command.includes(pattern));
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/types.d.ts

@@ -2,9 +2,24 @@
  * Virtual Router 类型定义
  */
 import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
-export type RoutingPools = Record<string, string[]>;
+export interface RoutePoolTier {
+    id: string;
+    targets: string[];
+    priority: number;
+    backup?: boolean;
+    /**
+     * Optional force flag for this route pool.
+     * Currently interpreted for:
+     * - routing.vision: force dedicated vision backend handling.
+     * - routing.web_search / routing.search: force server-side web_search flow.
+     */
+    force?: boolean;
+}
+export type RoutingPools = Record<string, RoutePoolTier[]>;
+export type StreamingPreference = 'auto' | 'always' | 'never';
 export interface ProviderAuthConfig {
     type: 'apiKey' | 'oauth';
     secretRef?: string;
@@ -32,6 +47,15 @@ export interface ProviderProfile {
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    maxContextTokens?: number;
+    /**
+     * When true, this provider must be skipped for any request that
+     * requires server-side tool orchestration (e.g. web_search).
+     * Normal chat routing (without servertool injection) may still
+     * use this provider as usual.
+     */
+    serverToolsDisabled?: boolean;
 }
 export interface ProviderRuntimeProfile {
     runtimeKey: string;
@@ -46,6 +70,17 @@ export interface ProviderRuntimeProfile {
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    modelStreaming?: Record<string, StreamingPreference>;
+    modelContextTokens?: Record<string, number>;
+    defaultContextTokens?: number;
+    maxContextTokens?: number;
+    /**
+     * Provider-level flag propagated from virtualrouter.providers[*].
+     * When true, VirtualRouterEngine will skip this runtime for any
+     * request that declares serverToolRequired=true in routing metadata.
+     */
+    serverToolsDisabled?: boolean;
 }
 export interface VirtualRouterClassifierConfig {
     longContextThresholdTokens?: number;
@@ -63,12 +98,39 @@ export interface ProviderHealthConfig {
     cooldownMs: number;
     fatalCooldownMs?: number;
 }
+export interface VirtualRouterWebSearchEngineConfig {
+    id: string;
+    providerKey: string;
+    description?: string;
+    default?: boolean;
+    /**
+     * When true, this engine will never be used by server-side tools
+     * (e.g. web_search). It will also be omitted from injected tool
+     * schemas so main models cannot select it for servertool flows.
+     */
+    serverToolsDisabled?: boolean;
+}
+export interface VirtualRouterWebSearchConfig {
+    engines: VirtualRouterWebSearchEngineConfig[];
+    injectPolicy?: 'always' | 'selective';
+    /**
+     * When true, always prefer server-side web_search orchestration
+     * over upstream builtin behaviours (e.g. OpenAI Responses builtin web_search).
+     */
+    force?: boolean;
+}
 export interface VirtualRouterConfig {
     routing: RoutingPools;
     providers: Record<string, ProviderProfile>;
     classifier: VirtualRouterClassifierConfig;
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
+    contextRouting?: VirtualRouterContextRoutingConfig;
+    webSearch?: VirtualRouterWebSearchConfig;
+}
+export interface VirtualRouterContextRoutingConfig {
+    warnRatio: number;
+    hardLimit?: boolean;
 }
 export type VirtualRouterProviderDefinition = Record<string, unknown>;
 export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
@@ -78,6 +140,8 @@ export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
     classifier?: VirtualRouterClassifierConfig;
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
+    contextRouting?: VirtualRouterContextRoutingConfig;
+    webSearch?: VirtualRouterWebSearchConfig | Record<string, unknown>;
 }
 export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
 export interface VirtualRouterBootstrapResult {
@@ -96,6 +160,13 @@ export interface RouterMetadataInput {
     providerProtocol?: string;
     stage?: 'inbound' | 'outbound' | 'response';
     routeHint?: string;
+    /**
+     * Indicates that current routing decision is for a request which
+     * expects server-side tools orchestration (e.g. web_search).
+     * Virtual Router should skip providers that opt out via
+     * serverToolsDisabled when this flag is true.
+     */
+    serverToolRequired?: boolean;
     responsesResume?: {
         previousRequestId?: string;
         restoredFromResponseId?: string;
@@ -117,7 +188,9 @@ export interface RoutingFeatures {
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
     lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
-    lastAssistantToolName?: string;
+    lastAssistantToolSnippet?: string;
+    lastAssistantToolLabel?: string;
+    latestMessageFromUser?: boolean;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {
@@ -134,6 +207,7 @@ export interface RoutingDecision {
     reasoning: string;
     fallback: boolean;
     pool: string[];
+    poolId?: string;
 }
 export interface TargetMetadata {
     providerKey: string;
@@ -144,6 +218,15 @@ export interface TargetMetadata {
     modelId: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    maxContextTokens?: number;
+    /**
+     * Route-level flags propagated from the virtual router.
+     * These are derived from routing pools and webSearch config and
+     * are used by hub pipeline/process layers (web_search / vision).
+     */
+    forceWebSearch?: boolean;
+    forceVision?: boolean;
 }
 export interface ResponsesProviderConfig {
     toolCallIdStyle?: 'fc' | 'preserve';
@@ -165,6 +248,7 @@ export interface RoutingDiagnostics {
     reasoning: string;
     fallback: boolean;
     pool: string[];
+    poolId?: string;
     confidence: number;
 }
 export interface RoutingStatusSnapshot {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/types.js

@@ -1,11 +1,13 @@
 /**
  * Virtual Router 类型定义
  */
+export const DEFAULT_MODEL_CONTEXT_TOKENS = 200_000;
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
     'vision',
     'longcontext',
-    'websearch',
+    'web_search',
+    'search',
     'coding',
     'thinking',
     'tools',

package/node_modules/@jsonstudio/llms/dist/servertool/engine.d.ts

@@ -0,0 +1,27 @@
+import type { AdapterContext } from '../conversion/hub/types/chat-envelope.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+import type { ProviderInvoker } from './types.js';
+export interface ServerToolOrchestrationOptions {
+    chat: JsonObject;
+    adapterContext: AdapterContext;
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: string;
+    reenterPipeline?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        body?: JsonObject;
+        __sse_responses?: unknown;
+        format?: string;
+    }>;
+    providerInvoker?: ProviderInvoker;
+}
+export interface ServerToolOrchestrationResult {
+    chat: JsonObject;
+    executed: boolean;
+    flowId?: string;
+}
+export declare function runServerToolOrchestration(options: ServerToolOrchestrationOptions): Promise<ServerToolOrchestrationResult>;