mcp-compression-proxy 1.0.2 → 1.1.0

package/dist/index.js

@@ -3,6 +3,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { MCPClientManager } from './mcp/client-manager.js';
+import { callToolWithAuthRecovery } from './mcp/tool-call-executor.js';
 import { CompressionCache } from './services/compression-cache.js';
 import { SessionManager } from './services/session-manager.js';
 import { loadJSONServersCached, matchesIgnorePattern } from './config/loader.js';
@@ -12,6 +13,9 @@ import pino from 'pino';
 import { StatsService } from './services/stats-service.js';
 import { CompressionSampler } from './services/compression-sampler.js';
 import { SERVER_NAME, VERSION } from './version.js';
+import { DEFAULT_PAYLOAD_THRESHOLD, PayloadStore } from './cli/payload-interceptor.js';
+import { runCallScript } from './mcp/call-script.js';
+import { getDaemonRuntimePaths } from './cli/runtime-paths.js';
 /**
  * MCP Server that aggregates tools from multiple MCP servers
  * with LLM-based description compression
@@ -31,6 +35,10 @@ const logger = pino({
 });
 // Initialize services
 const clientManager = new MCPClientManager(logger);
+const payloadStore = new PayloadStore({
+    directory: getDaemonRuntimePaths().payloadDir,
+    removeDirectoryOnDestroy: false,
+});
 const compressionCache = new CompressionCache(logger);
 const sessionManager = new SessionManager(logger);
 const statsService = new StatsService(logger, clientManager, compressionCache, sessionManager);
@@ -50,17 +58,51 @@ const compressionSampler = new CompressionSampler(logger, {
     getClientCapabilities: () => server.getClientCapabilities(),
     createMessage: (params) => server.createMessage(params),
 });
+function toolResultText(result) {
+    return result.content
+        .flatMap((item) => (item.type === 'text' && item.text ? [item.text] : []))
+        .join('\n');
+}
+async function executeBackendTool(serverName, toolName, args) {
+    const result = await callToolWithAuthRecovery(clientManager, logger, serverName, toolName, args);
+    return { result, output: toolResultText(result) };
+}
+/**
+ * How long a backend tool snapshot stays reusable.
+ *
+ * `tools/list` runs on every client refresh and the compression tools each
+ * trigger their own fan-out, so without this a single agent turn can issue
+ * several `listTools` round-trips per backend. Short enough that a genuinely
+ * changed backend surfaces almost immediately.
+ */
+const TOOL_CACHE_TTL_MS = 3000;
+let toolCache;
 /**
  * Fetch every tool from every connected backend server, once.
  *
  * Callers that need both the tool list and derived counts should reuse a single
  * snapshot rather than calling `listTools` per tool.
+ *
+ * Excluded tools are dropped here rather than only at the `tools/list` edge:
+ * every consumer of this snapshot - the compression tools included - must agree
+ * on which tools exist, or the proxy asks the model to spend calls compressing
+ * tools it will never advertise and reports coverage percentages that disagree
+ * with what the client actually sees.
  */
 async function fetchAllBackendTools() {
-    const clients = clientManager.getConnectedClients();
-    const perServer = await Promise.all(clients.map(async ({ name, client }) => {
+    const serverNames = clientManager.getConfiguredServerNames();
+    const excludePatterns = loadJSONServersCached()?.excludePatterns || [];
+    // Keyed on the connected set and the exclude patterns as well as the clock.
+    // Hot-reload can add or drop a backend between ticks and an edited
+    // servers.json can change what is filtered; serving either from a stale
+    // snapshot would contradict what tools/list reports.
+    const cacheKey = JSON.stringify([excludePatterns, [...serverNames].sort()]);
+    if (toolCache && toolCache.expiresAt > Date.now() && toolCache.key === cacheKey) {
+        return toolCache.tools;
+    }
+    const perServer = await Promise.all(serverNames.map(async (name) => {
         try {
-            const result = await client.listTools();
+            const result = await clientManager.withClient(name, async ({ client }) => client.listTools());
             return result.tools.map((tool) => ({
                 serverName: name,
                 toolName: tool.name,
@@ -73,12 +115,51 @@ async function fetchAllBackendTools() {
             return [];
         }
     }));
-    return perServer.flat();
+    const tools = perServer
+        .flat()
+        .filter((tool) => !matchesIgnorePattern(`${tool.serverName}__${tool.toolName}`, excludePatterns));
+    toolCache = { expiresAt: Date.now() + TOOL_CACHE_TTL_MS, key: cacheKey, tools };
+    return tools;
+}
+/**
+ * Whether a tool still needs compressing: never compressed, or compressed from
+ * a description the backend has since changed.
+ */
+function needsCompression(tool) {
+    return (!compressionCache.hasCompressed(tool.serverName, tool.toolName) ||
+        compressionCache.isStale(tool.serverName, tool.toolName, tool.description));
+}
+/** Tools returned per `tools/list` page when the client does not stop early. */
+const DEFAULT_TOOLS_PAGE_SIZE = 100;
+/**
+ * Page size, overridable so a test can force pagination without standing up a
+ * backend that exposes hundreds of tools. Anything unparseable or non-positive
+ * falls back rather than producing an empty page forever.
+ */
+function toolsPageSize() {
+    const configured = Number.parseInt(process.env.MCP_TOOLS_PAGE_SIZE ?? '', 10);
+    return Number.isInteger(configured) && configured > 0 ? configured : DEFAULT_TOOLS_PAGE_SIZE;
+}
+/**
+ * Decode a pagination cursor into an offset.
+ *
+ * Cursors are opaque to the client but are just offsets here - this is a local
+ * 1:1 stdio transport, so there is nothing to tamper-proof against. Returns
+ * `undefined` for a cursor that cannot be honoured, which the caller reports
+ * rather than treating as "start over".
+ */
+function parseCursor(cursor) {
+    if (cursor === undefined)
+        return 0;
+    if (typeof cursor !== 'string')
+        return undefined;
+    const offset = Number.parseInt(cursor, 10);
+    return Number.isInteger(offset) && offset >= 0 && String(offset) === cursor ? offset : undefined;
 }
 /**
  * List all tools from aggregated MCP servers + management tools
  */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+server.setRequestHandler(ListToolsRequestSchema, async (request) => {
     logger.debug('Handling tools/list request');
     // Fetch backend tools first so the management tools can advertise live
     // coverage numbers derived from this same snapshot.
@@ -177,6 +258,24 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 },
             },
         },
+        {
+            name: 'mcp-compression-proxy__invalidate_tool_cache',
+            description: "Drop one tool's cached compressed description so it is compressed again. Use when a compression lost something important; descriptions that merely went stale are re-queued automatically.",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    serverName: {
+                        type: 'string',
+                        description: 'Server name (e.g., "filesystem")',
+                    },
+                    toolName: {
+                        type: 'string',
+                        description: 'Tool name (e.g., "read_file")',
+                    },
+                },
+                required: ['serverName', 'toolName'],
+            },
+        },
         {
             name: 'mcp-compression-proxy__expand_tool',
             description: 'Expand a tool to show its full original description (session-specific)',
@@ -248,6 +347,61 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 },
             },
         },
+        {
+            name: 'mcp-compression-proxy__read_output',
+            description: 'Read a cached large tool output by payload ID. Reads 10K characters by default; use offset/length to page or all=true to return the remainder.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string', description: 'Payload ID returned by a tool call' },
+                    offset: { type: 'number', minimum: 0, default: 0 },
+                    length: { type: 'number', minimum: 1, default: 10000 },
+                    all: { type: 'boolean', default: false },
+                },
+                required: ['id'],
+            },
+        },
+        {
+            name: 'mcp-compression-proxy__find_output',
+            description: 'Find literal text inside a cached large tool output without loading the full payload into context.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string', description: 'Payload ID returned by a tool call' },
+                    query: { type: 'string', minLength: 1 },
+                    caseSensitive: { type: 'boolean', default: false },
+                    maxMatches: { type: 'number', minimum: 1, maximum: 100, default: 20 },
+                    contextChars: { type: 'number', minimum: 0, maximum: 2000, default: 200 },
+                },
+                required: ['id', 'query'],
+            },
+        },
+        {
+            name: 'mcp-compression-proxy__run_script',
+            description: 'Run up to 20 MCP calls sequentially. Later arguments may reference prior JSON output with {"$ref":"stepId#/json/pointer"}. This is declarative and does not execute shell or JavaScript.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    steps: {
+                        type: 'array',
+                        minItems: 1,
+                        maxItems: 20,
+                        items: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', minLength: 1 },
+                                server: { type: 'string', minLength: 1 },
+                                tool: { type: 'string', minLength: 1 },
+                                arguments: { type: 'object' },
+                                continueOnError: { type: 'boolean', default: false },
+                            },
+                            required: ['id', 'server', 'tool'],
+                        },
+                    },
+                },
+                required: ['steps'],
+            },
+        },
     ];
     const aggregatedTools = backendTools.map((tool) => {
         // Check if tool is expanded in current session
@@ -264,7 +418,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     // Apply exclude patterns to filter out tools
     const config = loadJSONServersCached();
     const excludePatterns = config?.excludePatterns || [];
-    const filteredTools = allTools.filter(tool => {
+    const filteredTools = allTools.filter((tool) => {
         const isExcluded = matchesIgnorePattern(tool.name, excludePatterns);
         if (isExcluded) {
             logger.debug({ tool: tool.name }, 'Tool excluded by pattern');
@@ -272,7 +426,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         return !isExcluded;
     });
     logger.debug({ count: filteredTools.length, excluded: allTools.length - filteredTools.length }, 'Returning tools');
-    return { tools: filteredTools };
+    // Paginate over the post-exclude list: a cursor pointing into the unfiltered
+    // set would drift as patterns change, and would leak excluded tools at the
+    // page boundaries.
+    const offset = parseCursor(request.params?.cursor);
+    if (offset === undefined) {
+        return {
+            tools: [],
+            // The spec has no error channel here, so an unusable cursor returns
+            // nothing rather than silently restarting from the top - a caller
+            // looping on nextCursor would otherwise never terminate.
+            _meta: { error: `Invalid cursor: ${String(request.params?.cursor)}` },
+        };
+    }
+    const pageSize = toolsPageSize();
+    const page = filteredTools.slice(offset, offset + pageSize);
+    const nextOffset = offset + page.length;
+    return {
+        tools: page,
+        ...(nextOffset < filteredTools.length ? { nextCursor: String(nextOffset) } : {}),
+    };
 });
 /**
  * Call a tool (either management tool or aggregated MCP tool)
@@ -365,8 +538,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const backendTools = await fetchAllBackendTools();
         const coverage = statsService.computeCoverage(backendTools);
         const liveStats = statsService.formatCoverage(coverage);
+        // Stale entries rejoin the queue alongside never-compressed ones, so a
+        // backend that rewrites a description is picked up by the existing
+        // compress -> cache loop without the caller learning a new concept.
         const allUncompressedTools = backendTools
-            .filter((tool) => !compressionCache.hasCompressed(tool.serverName, tool.toolName))
+            .filter((tool) => needsCompression(tool))
             .map((tool) => ({
             serverName: tool.serverName,
             toolName: tool.toolName,
@@ -521,6 +697,43 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             ],
         };
     }
+    if (name === 'mcp-compression-proxy__invalidate_tool_cache') {
+        const { serverName, toolName } = args;
+        const removed = compressionCache.invalidate(serverName, toolName);
+        if (!removed) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No cached compression found for ${serverName}:${toolName}. Nothing to invalidate.`,
+                    },
+                ],
+            };
+        }
+        try {
+            await compressionCache.saveToDisk();
+        }
+        catch (error) {
+            logger.error({ error, serverName, toolName }, 'Failed to persist cache after invalidation');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Invalidated ${serverName}:${toolName} in memory, but persisting the cache failed: ${error instanceof Error ? error.message : 'Unknown error'}. The entry will come back on restart.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Invalidated the cached compression for ${serverName}:${toolName}.\n\nIt will be offered again by mcp-compression-proxy__get_uncompressed_tools.`,
+                },
+            ],
+        };
+    }
     if (name === 'mcp-compression-proxy__expand_tool') {
         const { serverName, toolName } = args;
         if (!currentSessionId) {
@@ -597,7 +810,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const backendTools = await fetchAllBackendTools();
         const coverageBefore = statsService.computeCoverage(backendTools);
         const uncompressed = backendTools
-            .filter((tool) => !compressionCache.hasCompressed(tool.serverName, tool.toolName))
+            .filter((tool) => needsCompression(tool))
             .slice(0, actualLimit);
         if (uncompressed.length === 0) {
             return {
@@ -663,6 +876,77 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
     }
+    if (name === 'mcp-compression-proxy__read_output') {
+        const { id, offset, length, all } = args;
+        try {
+            const result = payloadStore.read(id, { offset, length, all });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    if (name === 'mcp-compression-proxy__find_output') {
+        const { id, query, caseSensitive, maxMatches, contextChars } = args;
+        try {
+            const result = payloadStore.find(id, query, {
+                caseSensitive,
+                maxMatches,
+                contextChars,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    if (name === 'mcp-compression-proxy__run_script') {
+        const { steps } = args;
+        try {
+            const config = loadJSONServersCached();
+            const result = await runCallScript(steps, async (serverName, toolName, stepArgs) => {
+                const executed = await executeBackendTool(serverName, toolName, stepArgs);
+                return {
+                    output: executed.output,
+                    isError: executed.result.isError,
+                };
+            }, payloadStore, config?.cli?.payloadThreshold ?? DEFAULT_PAYLOAD_THRESHOLD);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
     // Aggregated MCP tool call
     // Tool name format: "serverName__toolName". Split on the first separator
     // only - backend tools are free to have "__" in their own names.
@@ -680,25 +964,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     const serverName = name.slice(0, separatorIndex);
     const toolName = name.slice(separatorIndex + 2);
-    const client = clientManager.getClient(serverName);
-    if (!client) {
+    try {
+        const executed = await executeBackendTool(serverName, toolName, (args || {}));
+        const threshold = loadJSONServersCached()?.cli?.payloadThreshold ?? DEFAULT_PAYLOAD_THRESHOLD;
+        const captured = payloadStore.capture(executed.output, threshold);
+        if (!captured.reference) {
+            return executed.result;
+        }
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: Server '${serverName}' not found or not connected`,
-                },
-            ],
-            isError: true,
+            content: [{ type: 'text', text: captured.output }],
+            isError: executed.result.isError,
+            structuredContent: { payload: captured.reference },
         };
     }
-    try {
-        const result = await client.callTool({
-            name: toolName,
-            arguments: args || {},
-        });
-        return result;
-    }
     catch (error) {
         logger.error({ serverName, toolName, error }, 'Tool call failed');
         return {
@@ -737,6 +1015,7 @@ async function shutdown(reason, exitCode = 0) {
         logger.debug({ error }, 'Error while closing server transport');
     }
     sessionManager.destroy();
+    payloadStore.destroy();
     process.exit(exitCode);
 }
 /**
@@ -782,24 +1061,36 @@ async function main() {
         compressionCache.setNoCompressPatterns(config.noCompressPatterns);
         compressionCache.setFallbackBehavior(config.compressionFallbackBehavior ?? 'original');
         // Initialize MCP clients (only enabled servers)
-        const enabledServers = config.servers.filter(server => {
+        const enabledServers = config.servers.filter((server) => {
             // Server is enabled if enabled field is not explicitly false
             return server.enabled !== false;
         });
         logger.info({
             total: config.servers.length,
             enabled: enabledServers.length,
-            servers: enabledServers.map(s => s.name)
+            servers: enabledServers.map((s) => s.name),
         }, 'Initializing backend MCP servers with timeout protection');
         // Wait for all servers to initialize or timeout before reporting ready
         try {
-            await clientManager.initializeServers(enabledServers, config.defaultTimeout, config.inheritEnv);
+            await clientManager.initializeServers(enabledServers, config.defaultTimeout, config.inheritEnv, {
+                softMaxConnectionAgeSeconds: config.softMaxConnectionAgeSeconds,
+                hardMaxConnectionAgeSeconds: config.hardMaxConnectionAgeSeconds,
+                authErrorPatterns: config.authErrorPatterns,
+                authRetryTools: config.authRetryTools,
+            });
             logger.info('Backend MCP servers initialization complete');
         }
         catch (error) {
             logger.error({ error }, 'Error during backend server initialization');
         }
     }
+    // Outside the branch above on purpose: the fingerprint the watch polls counts
+    // a missing config file, so a user who writes their first servers.json after
+    // starting the proxy gets their servers without restarting the MCP client.
+    clientManager.startConfigWatch(loadJSONServersCached, undefined, (reloaded) => {
+        compressionCache.setNoCompressPatterns(reloaded.noCompressPatterns);
+        compressionCache.setFallbackBehavior(reloaded.compressionFallbackBehavior ?? 'original');
+    });
     // Now connect to the MCP client - all backend servers are ready (or timed out)
     const transport = new StdioServerTransport();
     // When the client disconnects, take the backend servers down with us.

package/dist/mcp/call-script.d.ts

@@ -0,0 +1,33 @@
+import { type PayloadReference, type PayloadStore } from '../cli/payload-interceptor.js';
+export declare const MAX_CALL_SCRIPT_STEPS = 20;
+export interface CallScriptStep {
+    id: string;
+    server: string;
+    tool: string;
+    arguments?: Record<string, unknown>;
+    continueOnError?: boolean;
+}
+export interface CallScriptStepResult {
+    id: string;
+    server: string;
+    tool: string;
+    output: string;
+    isError?: boolean;
+    payload?: PayloadReference;
+}
+export interface CallScriptResult {
+    steps: CallScriptStepResult[];
+    stoppedAt?: string;
+}
+export type ScriptCallExecutor = (server: string, tool: string, args: Record<string, unknown>) => Promise<{
+    output: string;
+    isError?: boolean;
+}>;
+/**
+ * Execute a bounded, declarative call chain.
+ *
+ * References use {"$ref":"stepId#/json/pointer"} and can only target earlier
+ * steps. No arbitrary JavaScript or shell is evaluated.
+ */
+export declare function runCallScript(steps: CallScriptStep[], execute: ScriptCallExecutor, payloadStore: PayloadStore, payloadThreshold?: number): Promise<CallScriptResult>;
+//# sourceMappingURL=call-script.d.ts.map

package/dist/mcp/call-script.js

@@ -0,0 +1,153 @@
+import { DEFAULT_PAYLOAD_THRESHOLD, } from '../cli/payload-interceptor.js';
+export const MAX_CALL_SCRIPT_STEPS = 20;
+function decodePointerSegment(segment) {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+function resolveJsonPointer(value, pointer) {
+    if (pointer === '')
+        return value;
+    if (!pointer.startsWith('/')) {
+        throw new Error(`JSON Pointer must be empty or start with "/": "${pointer}"`);
+    }
+    let current = value;
+    for (const rawSegment of pointer.slice(1).split('/')) {
+        const segment = decodePointerSegment(rawSegment);
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9]\d*)$/.test(segment)) {
+                throw new Error(`JSON Pointer array index is invalid: "${segment}"`);
+            }
+            const index = Number(segment);
+            if (index >= current.length) {
+                throw new Error(`JSON Pointer array index is out of range: ${index}`);
+            }
+            current = current[index];
+            continue;
+        }
+        if (typeof current === 'object' && current !== null) {
+            if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+                throw new Error(`JSON Pointer property not found: "${segment}"`);
+            }
+            current = current[segment];
+            continue;
+        }
+        throw new Error(`JSON Pointer cannot traverse through "${segment}"`);
+    }
+    return current;
+}
+function resolveReference(reference, priorResults) {
+    const hashIndex = reference.indexOf('#');
+    const stepId = hashIndex === -1 ? reference : reference.slice(0, hashIndex);
+    const pointer = hashIndex === -1 ? '' : reference.slice(hashIndex + 1);
+    if (!priorResults.has(stepId)) {
+        throw new Error(`Unknown prior step "${stepId}" in reference "${reference}"`);
+    }
+    return resolveJsonPointer(priorResults.get(stepId), pointer);
+}
+function resolveReferences(value, priorResults) {
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveReferences(item, priorResults));
+    }
+    if (typeof value === 'object' && value !== null) {
+        const entries = Object.entries(value);
+        if (entries.length === 1 &&
+            entries[0][0] === '$ref' &&
+            typeof entries[0][1] === 'string') {
+            return resolveReference(entries[0][1], priorResults);
+        }
+        return Object.fromEntries(entries.map(([key, nested]) => [
+            key,
+            resolveReferences(nested, priorResults),
+        ]));
+    }
+    return value;
+}
+function parseOutput(output) {
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        return output;
+    }
+}
+/**
+ * Execute a bounded, declarative call chain.
+ *
+ * References use {"$ref":"stepId#/json/pointer"} and can only target earlier
+ * steps. No arbitrary JavaScript or shell is evaluated.
+ */
+export async function runCallScript(steps, execute, payloadStore, payloadThreshold = DEFAULT_PAYLOAD_THRESHOLD) {
+    if (steps.length > MAX_CALL_SCRIPT_STEPS) {
+        throw new Error(`Call scripts may contain at most ${MAX_CALL_SCRIPT_STEPS} steps`);
+    }
+    const ids = new Set();
+    for (const step of steps) {
+        if (!step.id) {
+            throw new Error('Every call script step requires a non-empty id');
+        }
+        if (ids.has(step.id)) {
+            throw new Error(`Duplicate script step id: "${step.id}"`);
+        }
+        ids.add(step.id);
+    }
+    const priorResults = new Map();
+    const results = [];
+    for (const step of steps) {
+        let resolvedArguments;
+        try {
+            const resolved = resolveReferences(step.arguments ?? {}, priorResults);
+            if (typeof resolved !== 'object' ||
+                resolved === null ||
+                Array.isArray(resolved)) {
+                throw new Error(`Arguments for step "${step.id}" must resolve to an object`);
+            }
+            resolvedArguments = resolved;
+        }
+        catch (error) {
+            const output = error instanceof Error ? error.message : String(error);
+            results.push({
+                id: step.id,
+                server: step.server,
+                tool: step.tool,
+                output,
+                isError: true,
+            });
+            if (!step.continueOnError) {
+                return { steps: results, stoppedAt: step.id };
+            }
+            priorResults.set(step.id, output);
+            continue;
+        }
+        try {
+            const callResult = await execute(step.server, step.tool, resolvedArguments);
+            priorResults.set(step.id, parseOutput(callResult.output));
+            const captured = payloadStore.capture(callResult.output, payloadThreshold);
+            results.push({
+                id: step.id,
+                server: step.server,
+                tool: step.tool,
+                output: captured.output,
+                isError: callResult.isError,
+                payload: captured.reference,
+            });
+            if (callResult.isError && !step.continueOnError) {
+                return { steps: results, stoppedAt: step.id };
+            }
+        }
+        catch (error) {
+            const output = error instanceof Error ? error.message : String(error);
+            results.push({
+                id: step.id,
+                server: step.server,
+                tool: step.tool,
+                output,
+                isError: true,
+            });
+            if (!step.continueOnError) {
+                return { steps: results, stoppedAt: step.id };
+            }
+            priorResults.set(step.id, output);
+        }
+    }
+    return { steps: results };
+}
+//# sourceMappingURL=call-script.js.map