@openrouter/sdk 0.9.11 → 0.10.2

package/esm/lib/sdks.d.ts

@@ -1,5 +1,5 @@
 import { SDKHooks } from "../hooks/hooks.js";
-import type { HookContext } from "../hooks/types.js";
+import { HookContext } from "../hooks/types.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
 import { Result } from "../types/fp.js";
 import { SDKOptions } from "./config.js";

package/esm/lib/sdks.js

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ClientSDK_instances, _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger, _ClientSDK_registerHook;
+var _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger;
 import { SDKHooks } from "../hooks/hooks.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError, } from "../models/errors/httpclienterrors.js";
 import { ERR, OK } from "../types/fp.js";
@@ -33,22 +33,18 @@ const isBrowserLike = webWorkerLike
     || (typeof window === "object" && typeof window.document !== "undefined");
 export class ClientSDK {
     constructor(options = {}) {
-        _ClientSDK_instances.add(this);
         _ClientSDK_httpClient.set(this, void 0);
         _ClientSDK_hooks.set(this, void 0);
         _ClientSDK_logger.set(this, void 0);
-        // Reuse existing SDKHooks if passed (for sub-SDKs)
-        if (options.hooks instanceof SDKHooks) {
-            __classPrivateFieldSet(this, _ClientSDK_hooks, options.hooks, "f");
+        const opt = options;
+        if (typeof opt === "object"
+            && opt != null
+            && "hooks" in opt
+            && opt.hooks instanceof SDKHooks) {
+            __classPrivateFieldSet(this, _ClientSDK_hooks, opt.hooks, "f");
         }
         else {
             __classPrivateFieldSet(this, _ClientSDK_hooks, new SDKHooks(), "f");
-            if (options.hooks) {
-                const hooksArray = Array.isArray(options.hooks) ? options.hooks : [options.hooks];
-                for (const hook of hooksArray) {
-                    __classPrivateFieldGet(this, _ClientSDK_instances, "m", _ClientSDK_registerHook).call(this, hook);
-                }
-            }
         }
         const defaultHttpClient = new HTTPClient();
         options.httpClient = options.httpClient || defaultHttpClient;
@@ -189,23 +185,7 @@ export class ClientSDK {
         });
     }
 }
-_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap(), _ClientSDK_instances = new WeakSet(), _ClientSDK_registerHook = function _ClientSDK_registerHook(hook) {
-    if ("sdkInit" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerSDKInitHook(hook);
-    }
-    if ("beforeCreateRequest" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerBeforeCreateRequestHook(hook);
-    }
-    if ("beforeRequest" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerBeforeRequestHook(hook);
-    }
-    if ("afterSuccess" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerAfterSuccessHook(hook);
-    }
-    if ("afterError" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerAfterErrorHook(hook);
-    }
-};
+_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap();
 const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
 const jsonlLikeContentTypeRE = /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
 async function logRequest(logger, req) {

package/esm/lib/stream-transformers.d.ts

@@ -1,4 +1,5 @@
 import type * as models from '../models/index.js';
+import type { ClaudeMessage, UnsupportedContent } from '../models/claude-message.js';
 import type { ReusableReadableStream } from './reusable-stream.js';
 import type { ParsedToolCall, Tool } from './tool-types.js';
 /**
@@ -69,17 +70,17 @@ export declare function responseHasToolCalls(response: models.OpenResponsesNonSt
  * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
-export declare function convertToClaudeMessage(response: models.OpenResponsesNonStreamingResponse): models.ClaudeMessage;
+export declare function convertToClaudeMessage(response: models.OpenResponsesNonStreamingResponse): ClaudeMessage;
 /**
  * Extract unsupported content by original type
  */
-export declare function extractUnsupportedContent(message: models.ClaudeMessage, originalType: string): models.UnsupportedContent[];
+export declare function extractUnsupportedContent(message: ClaudeMessage, originalType: string): UnsupportedContent[];
 /**
  * Check if message has any unsupported content
  */
-export declare function hasUnsupportedContent(message: models.ClaudeMessage): boolean;
+export declare function hasUnsupportedContent(message: ClaudeMessage): boolean;
 /**
  * Get summary of unsupported content types
  */
-export declare function getUnsupportedContentSummary(message: models.ClaudeMessage): Record<string, number>;
+export declare function getUnsupportedContentSummary(message: ClaudeMessage): Record<string, number>;
 //# sourceMappingURL=stream-transformers.d.ts.map

package/esm/lib/stream-transformers.js

@@ -440,7 +440,8 @@ export function extractToolCallsFromResponse(response) {
     for (const item of response.output) {
         if (isFunctionCallItem(item)) {
             try {
-                const parsedArguments = JSON.parse(item.arguments);
+                const trimmedArgs = item.arguments.trim();
+                const parsedArguments = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                 toolCalls.push({
                     id: item.callId,
                     name: item.name,
@@ -475,7 +476,9 @@ export async function* buildToolCallStream(stream) {
         switch (event.type) {
             case 'response.output_item.added': {
                 if (isOutputItemAddedEvent(event) && event.item && isFunctionCallItem(event.item)) {
-                    toolCallsInProgress.set(event.item.callId, {
+                    // Use item.id if available (matches itemId in delta events), fall back to callId
+                    const itemKey = event.item.id ?? event.item.callId;
+                    toolCallsInProgress.set(itemKey, {
                         id: event.item.callId,
                         name: event.item.name,
                         argumentsAccumulated: '',
@@ -496,9 +499,10 @@ export async function* buildToolCallStream(stream) {
                 if (isFunctionCallArgumentsDoneEvent(event)) {
                     const toolCall = toolCallsInProgress.get(event.itemId);
                     if (toolCall) {
-                        // Parse complete arguments
+                        // Parse complete arguments (empty string → empty object for no-param tools)
                         try {
-                            const parsedArguments = JSON.parse(event.arguments);
+                            const trimmedArgs = event.arguments.trim();
+                            const parsedArguments = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                             yield {
                                 id: toolCall.id,
                                 name: event.name,
@@ -522,10 +526,13 @@ export async function* buildToolCallStream(stream) {
             }
             case 'response.output_item.done': {
                 if (isOutputItemDoneEvent(event) && event.item && isFunctionCallItem(event.item)) {
+                    // Use item.id if available (matches itemId in delta events), fall back to callId
+                    const itemKey = event.item.id ?? event.item.callId;
                     // Yield final tool call if we haven't already
-                    if (toolCallsInProgress.has(event.item.callId)) {
+                    if (toolCallsInProgress.has(itemKey)) {
                         try {
-                            const parsedArguments = JSON.parse(event.item.arguments);
+                            const trimmedArgs = event.item.arguments.trim();
+                            const parsedArguments = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                             yield {
                                 id: event.item.callId,
                                 name: event.item.name,
@@ -539,7 +546,7 @@ export async function* buildToolCallStream(stream) {
                                 arguments: event.item.arguments,
                             };
                         }
-                        toolCallsInProgress.delete(event.item.callId);
+                        toolCallsInProgress.delete(itemKey);
                     }
                 }
                 break;
@@ -606,14 +613,9 @@ function mapAnnotationsToCitations(annotations) {
                 }
                 break;
             }
-            default: {
-                // Exhaustiveness check - TypeScript will error if we don't handle all annotation types
-                const exhaustiveCheck = annotation;
-                // Cast to unknown for runtime debugging if type system bypassed
-                // This should never execute - throw with JSON of the unhandled value
-                throw new Error(`Unhandled annotation type. This indicates a new annotation type was added. ` +
-                    `Annotation: ${JSON.stringify(exhaustiveCheck)}`);
-            }
+            default:
+                // Unknown annotation types are skipped for forward compatibility.
+                break;
         }
     }
     return citations.length > 0 ? citations : undefined;
@@ -698,11 +700,7 @@ export function convertToClaudeMessage(response) {
                             });
                         }
                         else {
-                            // Exhaustiveness check - TypeScript will error if we don't handle all part types
-                            const exhaustiveCheck = part;
-                            // This should never execute - new content type was added
-                            throw new Error(`Unhandled message content type. This indicates a new content type was added. ` +
-                                `Part: ${JSON.stringify(exhaustiveCheck)}`);
+                            // Unknown content types are skipped for forward compatibility.
                         }
                     }
                 }
@@ -712,7 +710,8 @@ export function convertToClaudeMessage(response) {
                 if (isFunctionCallItem(item)) {
                     let parsedInput;
                     try {
-                        parsedInput = JSON.parse(item.arguments);
+                        const trimmedArgs = item.arguments.trim();
+                        parsedInput = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                     }
                     catch (error) {
                         console.warn(`Failed to parse tool call arguments for ${item.name}:`, error instanceof Error ? error.message : String(error), `\nArguments: ${item.arguments.substring(0, 100)}${item.arguments.length > 100 ? '...' : ''}`);
@@ -797,14 +796,10 @@ export function convertToClaudeMessage(response) {
                 }
                 break;
             }
-            default: {
-                // Exhaustiveness check - if a new output type is added, TypeScript will error here
-                const exhaustiveCheck = item;
-                // This line should never execute - it means a new type was added to the union
-                // Throw an error instead of silently continuing to ensure we catch new types
-                throw new Error(`Unhandled output item type. This indicates a new output type was added to the API. ` +
-                    `Item: ${JSON.stringify(exhaustiveCheck)}`);
-            }
+            default:
+                // Unknown output types (e.g. new server tools) are skipped during Claude format
+                // conversion — they round-trip natively via the Responses API input union.
+                break;
         }
     }
     return {

package/esm/lib/stream-type-guards.js

@@ -32,34 +32,19 @@ export function isFunctionCallArgumentsDoneEvent(event) {
 }
 // Output item type guards
 export function isOutputMessage(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'message');
+    return typeof item === 'object' && item !== null && 'type' in item && item.type === 'message';
 }
 export function isFunctionCallItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'function_call');
+    return (typeof item === 'object' && item !== null && 'type' in item && item.type === 'function_call');
 }
 export function isReasoningOutputItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'reasoning');
+    return typeof item === 'object' && item !== null && 'type' in item && item.type === 'reasoning';
 }
 export function isWebSearchCallOutputItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'web_search_call');
+    return (typeof item === 'object' && item !== null && 'type' in item && item.type === 'web_search_call');
 }
 export function isFileSearchCallOutputItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'file_search_call');
+    return (typeof item === 'object' && item !== null && 'type' in item && item.type === 'file_search_call');
 }
 export function isImageGenerationCallOutputItem(item) {
     return (typeof item === 'object' &&
@@ -69,16 +54,10 @@ export function isImageGenerationCallOutputItem(item) {
 }
 // Content part type guards
 export function isOutputTextPart(part) {
-    return (typeof part === 'object' &&
-        part !== null &&
-        'type' in part &&
-        part.type === 'output_text');
+    return typeof part === 'object' && part !== null && 'type' in part && part.type === 'output_text';
 }
 export function isRefusalPart(part) {
-    return (typeof part === 'object' &&
-        part !== null &&
-        'type' in part &&
-        part.type === 'refusal');
+    return typeof part === 'object' && part !== null && 'type' in part && part.type === 'refusal';
 }
 // Annotation type guards for Claude conversion
 export function isFileCitationAnnotation(annotation) {
@@ -101,9 +80,6 @@ export function isFilePathAnnotation(annotation) {
 }
 // Helper to check if output has a type property
 export function hasTypeProperty(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        typeof item.type === 'string');
+    return (typeof item === 'object' && item !== null && 'type' in item && typeof item.type === 'string');
 }
 //# sourceMappingURL=stream-type-guards.js.map

package/esm/lib/tool-context.d.ts

@@ -0,0 +1,68 @@
+import type { $ZodObject, $ZodShape } from 'zod/v4/core';
+import type { ToolExecuteContext, TurnContext } from './tool-types.js';
+/**
+ * Listener function called when context values change
+ * Receives a shallow copy of the full context store
+ */
+type ContextChangeListener = (snapshot: Record<string, Record<string, unknown>>) => void;
+/**
+ * Context input can be a static value, a sync function, or an async function
+ */
+export type ContextInput<T extends Record<string, Record<string, unknown>>> = T | ((turn: TurnContext) => T) | ((turn: TurnContext) => Promise<T>);
+/**
+ * Mutable context store shared across all tool executions within a callModel invocation.
+ * Stores context keyed by tool name: `{ get_weather: { apiKey: '...' }, db_query: { dbUrl: '...' } }`.
+ * Notifies listeners on changes.
+ */
+export declare class ToolContextStore {
+    private store;
+    private listeners;
+    constructor(initialValues?: Record<string, Record<string, unknown>>);
+    /** Subscribe to context changes. Returns an unsubscribe function. */
+    subscribe(listener: ContextChangeListener): () => void;
+    /** Get a deep-shallow copy of the full context (all tools) */
+    getSnapshot(): Record<string, Record<string, unknown>>;
+    /** Get a shallow copy of context for a specific tool */
+    getToolContext(toolName: string): Record<string, unknown>;
+    /** Set context for a specific tool and notify listeners */
+    setToolContext(toolName: string, values: Record<string, unknown>): void;
+    /** Merge partial values into a specific tool's context and notify listeners */
+    mergeToolContext(toolName: string, partial: Record<string, unknown>): void;
+    private notifyListeners;
+}
+/**
+ * Build a flat ToolExecuteContext for a specific tool.
+ * Returns a merged object with TurnContext fields, a `local` getter
+ * (reads from the store on each access), `shared` getter, and mutation methods.
+ *
+ * The `local` and `shared` getters are live — calling `setContext()` or
+ * `setSharedContext()` and then reading the property reflects updated values immediately.
+ *
+ * @param turnContext - The current turn context
+ * @param store - The shared context store (keyed by tool name)
+ * @param toolName - The tool's name
+ * @param schema - The tool's contextSchema (for validation)
+ * @param sharedSchema - The shared contextSchema (for validation)
+ * @returns A flat ToolExecuteContext
+ */
+export declare function buildToolExecuteContext<TName extends string, TContext extends Record<string, unknown>, TShared extends Record<string, unknown> = Record<string, unknown>>(turnContext: TurnContext, store: ToolContextStore | undefined, toolName: TName, schema: $ZodObject<$ZodShape> | undefined, sharedSchema?: $ZodObject<$ZodShape> | undefined): ToolExecuteContext<TName, TContext, TShared>;
+/**
+ * Resolve a context input (static value, sync function, or async function) to a plain object.
+ *
+ * @param contextInput - The context value or function from callModel
+ * @param turnContext - The current turn context for function resolution
+ * @returns The resolved context object (keyed by tool name)
+ */
+export declare function resolveContext<T extends Record<string, Record<string, unknown>>>(contextInput: ContextInput<T> | undefined, turnContext: TurnContext): Promise<T>;
+/**
+ * Extract and validate context values for a specific tool from the context store.
+ * Returns a shallow copy so the caller cannot mutate the store directly.
+ *
+ * @param store - The shared context store (keyed by tool name)
+ * @param toolName - The tool's name
+ * @param schema - The tool's contextSchema
+ * @returns A shallow copy of the validated context values for this tool
+ */
+export declare function extractToolContext(store: ToolContextStore, toolName: string, schema: $ZodObject<$ZodShape> | undefined): Record<string, unknown>;
+export {};
+//# sourceMappingURL=tool-context.d.ts.map

package/esm/lib/tool-context.js

@@ -0,0 +1,175 @@
+import * as z4 from 'zod/v4';
+import { SHARED_CONTEXT_KEY } from './tool-types.js';
+//#endregion
+//#region ToolContextStore
+/**
+ * Mutable context store shared across all tool executions within a callModel invocation.
+ * Stores context keyed by tool name: `{ get_weather: { apiKey: '...' }, db_query: { dbUrl: '...' } }`.
+ * Notifies listeners on changes.
+ */
+export class ToolContextStore {
+    constructor(initialValues = {}) {
+        this.listeners = new Set();
+        this.store = {};
+        for (const [key, value] of Object.entries(initialValues)) {
+            this.store[key] = { ...value };
+        }
+    }
+    /** Subscribe to context changes. Returns an unsubscribe function. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /** Get a deep-shallow copy of the full context (all tools) */
+    getSnapshot() {
+        const snapshot = {};
+        for (const [key, value] of Object.entries(this.store)) {
+            snapshot[key] = { ...value };
+        }
+        return snapshot;
+    }
+    /** Get a shallow copy of context for a specific tool */
+    getToolContext(toolName) {
+        const data = this.store[toolName];
+        if (!data) {
+            return {};
+        }
+        return { ...data };
+    }
+    /** Set context for a specific tool and notify listeners */
+    setToolContext(toolName, values) {
+        this.store[toolName] = { ...values };
+        this.notifyListeners();
+    }
+    /** Merge partial values into a specific tool's context and notify listeners */
+    mergeToolContext(toolName, partial) {
+        const existing = this.store[toolName] ?? {};
+        this.store[toolName] = { ...existing, ...partial };
+        this.notifyListeners();
+    }
+    notifyListeners() {
+        const snapshot = {};
+        for (const [key, value] of Object.entries(this.store)) {
+            snapshot[key] = { ...value };
+        }
+        for (const listener of this.listeners) {
+            listener(snapshot);
+        }
+    }
+}
+//#endregion
+//#region buildToolExecuteContext
+/**
+ * Validate a partial update against a schema's shape, filtering to known keys
+ * and validating each key individually. Returns the filtered partial.
+ */
+function validatePartialAgainstSchema(partial, schema) {
+    const schemaKeys = Object.keys(schema._zod.def.shape);
+    const filteredPartial = {};
+    for (const [key, value] of Object.entries(partial)) {
+        if (schemaKeys.includes(key)) {
+            filteredPartial[key] = value;
+        }
+    }
+    const shape = schema._zod.def.shape;
+    for (const [key, value] of Object.entries(filteredPartial)) {
+        const keySchema = shape[key];
+        if (keySchema) {
+            z4.parse(keySchema, value);
+        }
+    }
+    return filteredPartial;
+}
+/**
+ * Build a flat ToolExecuteContext for a specific tool.
+ * Returns a merged object with TurnContext fields, a `local` getter
+ * (reads from the store on each access), `shared` getter, and mutation methods.
+ *
+ * The `local` and `shared` getters are live — calling `setContext()` or
+ * `setSharedContext()` and then reading the property reflects updated values immediately.
+ *
+ * @param turnContext - The current turn context
+ * @param store - The shared context store (keyed by tool name)
+ * @param toolName - The tool's name
+ * @param schema - The tool's contextSchema (for validation)
+ * @param sharedSchema - The shared contextSchema (for validation)
+ * @returns A flat ToolExecuteContext
+ */
+export function buildToolExecuteContext(turnContext, store, toolName, schema, sharedSchema) {
+    // Validate initial context eagerly (throws on bad data)
+    if (store && schema) {
+        extractToolContext(store, toolName, schema);
+    }
+    if (store && sharedSchema) {
+        extractToolContext(store, SHARED_CONTEXT_KEY, sharedSchema);
+    }
+    const ctx = {
+        ...turnContext,
+        get local() {
+            const data = store ? store.getToolContext(toolName) : {};
+            return Object.freeze(data);
+        },
+        setContext(partial) {
+            if (!store || !schema) {
+                return;
+            }
+            const filteredPartial = validatePartialAgainstSchema(partial, schema);
+            store.mergeToolContext(toolName, filteredPartial);
+        },
+        get shared() {
+            const data = store ? store.getToolContext(SHARED_CONTEXT_KEY) : {};
+            return Object.freeze(data);
+        },
+        setSharedContext(partial) {
+            if (!store || !sharedSchema) {
+                return;
+            }
+            const filteredPartial = validatePartialAgainstSchema(partial, sharedSchema);
+            store.mergeToolContext(SHARED_CONTEXT_KEY, filteredPartial);
+        },
+    };
+    return ctx;
+}
+//#endregion
+//#region resolveContext
+/**
+ * Resolve a context input (static value, sync function, or async function) to a plain object.
+ *
+ * @param contextInput - The context value or function from callModel
+ * @param turnContext - The current turn context for function resolution
+ * @returns The resolved context object (keyed by tool name)
+ */
+export async function resolveContext(contextInput, turnContext) {
+    if (contextInput === undefined) {
+        return {};
+    }
+    if (typeof contextInput === 'function') {
+        return Promise.resolve(contextInput(turnContext));
+    }
+    return contextInput;
+}
+//#endregion
+//#region extractToolContext
+/**
+ * Extract and validate context values for a specific tool from the context store.
+ * Returns a shallow copy so the caller cannot mutate the store directly.
+ *
+ * @param store - The shared context store (keyed by tool name)
+ * @param toolName - The tool's name
+ * @param schema - The tool's contextSchema
+ * @returns A shallow copy of the validated context values for this tool
+ */
+export function extractToolContext(store, toolName, schema) {
+    if (!schema) {
+        return {};
+    }
+    const toolData = store.getToolContext(toolName);
+    // Validate the extracted values against the schema
+    z4.parse(schema, toolData);
+    // getToolContext already returns a shallow copy
+    return toolData;
+}
+//#endregion
+//# sourceMappingURL=tool-context.js.map

package/esm/lib/tool-executor.d.ts

@@ -1,6 +1,8 @@
 import type { $ZodType } from 'zod/v4/core';
-import type { APITool, Tool, ParsedToolCall, ToolExecutionResult, TurnContext } from './tool-types.js';
+import type { $ZodObject, $ZodShape } from 'zod/v4/core';
+import type { APITool, ParsedToolCall, Tool, ToolExecutionResult, TurnContext } from './tool-types.js';
 import * as z4 from 'zod/v4';
+import { type ToolContextStore } from './tool-context.js';
 export declare const ZodError: z4.z.core.$constructor<z4.ZodError<unknown>, z4.z.core.$ZodIssue[]>;
 /**
  * Recursively remove keys prefixed with ~ from an object.
@@ -36,25 +38,27 @@ export declare function validateToolInput<T>(schema: $ZodType<T>, args: unknown)
  */
 export declare function validateToolOutput<T>(schema: $ZodType<T>, result: unknown): T;
 /**
- * Parse tool call arguments from JSON string
+ * Parse tool call arguments from JSON string.
+ * Treats empty/whitespace-only strings as an empty object — some providers
+ * return `arguments: ""` for tools that take no parameters.
  */
 export declare function parseToolCallArguments(argumentsString: string): unknown;
 /**
  * Execute a regular (non-generator) tool
  */
-export declare function executeRegularTool(tool: Tool, toolCall: ParsedToolCall<Tool>, context: TurnContext): Promise<ToolExecutionResult<Tool>>;
+export declare function executeRegularTool(tool: Tool, toolCall: ParsedToolCall<Tool>, context: TurnContext, contextStore?: ToolContextStore, sharedSchema?: $ZodObject<$ZodShape>): Promise<ToolExecutionResult<Tool>>;
 /**
  * Execute a generator tool and collect preliminary and final results
  * - Intermediate yields are validated against eventSchema (preliminary events)
  * - Last yield is validated against outputSchema (final result sent to model)
  * - Generator must emit at least one value
  */
-export declare function executeGeneratorTool(tool: Tool, toolCall: ParsedToolCall<Tool>, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void): Promise<ToolExecutionResult<Tool>>;
+export declare function executeGeneratorTool(tool: Tool, toolCall: ParsedToolCall<Tool>, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void, contextStore?: ToolContextStore, sharedSchema?: $ZodObject<$ZodShape>): Promise<ToolExecutionResult<Tool>>;
 /**
  * Execute a tool call
  * Automatically detects if it's a regular or generator tool
  */
-export declare function executeTool(tool: Tool, toolCall: ParsedToolCall<Tool>, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void): Promise<ToolExecutionResult<Tool>>;
+export declare function executeTool(tool: Tool, toolCall: ParsedToolCall<Tool>, context: TurnContext, onPreliminaryResult?: (toolCallId: string, result: unknown) => void, contextStore?: ToolContextStore, sharedSchema?: $ZodObject<$ZodShape>): Promise<ToolExecutionResult<Tool>>;
 /**
  * Find a tool by name in the tools array
  */