graphlit-client 1.0.20260408010 → 1.0.20260408012

package/README.md

@@ -16,6 +16,15 @@ Graphlit is a cloud platform that handles the complex parts of building AI appli
 
 ## What's New
 
+### OpenAI Responses API Support
+
+- **Automatic Responses API Routing** - GPT-5.4 and eligible OpenAI models are automatically routed through the [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses) for improved intelligence, fewer reasoning tokens, higher cache hit rates, and lower latency. Disable with `useResponsesApi: false` in `StreamAgentOptions`.
+- **Reasoning Effort** - Reasoning effort (e.g. `medium`, `high`) is read from the specification's `openAI.reasoningEffort` field and passed through to the Responses API.
+- **GPT-5.4 Temperature Handling** - Temperature is only sent when reasoning effort is `none` (the GPT-5.4 default). Other reasoning levels don't support temperature per the OpenAI docs.
+- **`phase` on Assistant Messages** - Conversation history replayed to the Responses API includes `phase: "commentary"` on assistant messages that preceded tool calls, and `phase: "final_answer"` on terminal messages, per GPT-5.4 best practices.
+- **Tool Call ID Remapping** - Tool call IDs are automatically remapped between `call_` (Chat Completions) and `fc_` (Responses API) formats, enabling mid-conversation model switches without errors.
+- **First-Round Tool Engagement** - When tools are provided, the SDK sends `tool_choice: "required"` on the first API request to ensure the model engages with available tools, then reverts to `auto` for subsequent rounds. This addresses GPT-5.4's tendency to skip tool use under the default `auto` setting. This behavior is internal to the Responses API path and not exposed as a caller option.
+
 ### Streaming Provider Resilience
 
 - **Automatic Retry for Provider Errors** - `streamAgent` and `runAgent` now retry transient LLM provider errors (HTTP 500, 503, 429, network failures) with exponential backoff (up to 3 retries)
@@ -77,6 +86,7 @@ Graphlit is a cloud platform that handles the complex parts of building AI appli
 - [Quick Start](#quick-start)
 - [Installation](#installation)
 - [Setting Up](#setting-up)
+- [OpenAI Responses API Support](#openai-responses-api-support)
 - [Migrating from @google/generative-ai](#migrating-from-google-generative-ai) 🔄
 - [Reasoning Support (New!)](#reasoning-support-new) 🧠
 - [Stream Cancellation (New!)](#stream-cancellation-new) 🛑
@@ -546,7 +556,7 @@ The Graphlit SDK supports real-time streaming responses from 9 different LLM pro
 
 | Provider        | Models                                        | SDK Required                      | API Key             |
 | --------------- | --------------------------------------------- | --------------------------------- | ------------------- |
-| **OpenAI**      | GPT-4, GPT-4o, GPT-4.1, O1, O3, O4            | `openai`                          | `OPENAI_API_KEY`    |
+| **OpenAI**      | GPT-5.4, GPT-4.1, GPT-4o, O1, O3, O4          | `openai`                          | `OPENAI_API_KEY`    |
 | **Anthropic**   | Claude 3, Claude 3.5, Claude 3.7, Claude 4    | `@anthropic-ai/sdk`               | `ANTHROPIC_API_KEY` |
 | **Google**      | Gemini 1.5, Gemini 2.0, Gemini 2.5            | `@google/genai`                   | `GOOGLE_API_KEY`    |
 | **Groq**        | Llama 4, Llama 3.3, Mixtral, Deepseek R1      | `groq-sdk`                        | `GROQ_API_KEY`      |
@@ -597,7 +607,8 @@ const spec = await client.createSpecification({
 
 ### Provider-Specific Notes
 
-- **OpenAI-Compatible**: Groq, Cerebras, and Deepseek use OpenAI-compatible APIs
+- **OpenAI GPT-5.4**: Automatically uses the Responses API for chain-of-thought passback, 1M context, and improved tool calling. The SDK sends `tool_choice: "required"` on the first round when tools are provided, then `auto` on subsequent rounds. Set `useResponsesApi: false` in options to force legacy Chat Completions.
+- **OpenAI-Compatible**: Groq, Cerebras, Deepseek, and xAI use OpenAI-compatible APIs
 - **AWS Bedrock**: Requires AWS credentials and uses the Converse API for streaming
 - **Cohere**: Supports both chat and tool calling with Command models
 - **Google**: Includes advanced multimodal capabilities with Gemini models

package/dist/client.js

@@ -5654,7 +5654,7 @@ class Graphlit {
                 });
                 // Start the streaming conversation
                 // fullSpec is guaranteed non-null here — the !fullSpec check above returns early
-                await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, options?.contextStrategy, options?.useResponsesApi, options?.toolChoice, options?.toolStrict, options?.instructions, options?.scratchpad, options?.skills);
+                await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, options?.contextStrategy, options?.useResponsesApi, options?.instructions, options?.scratchpad, options?.skills);
             }, abortSignal);
         }
         catch (error) {
@@ -5700,7 +5700,7 @@ class Graphlit {
     /**
      * Execute the streaming agent workflow with tool calling loop
      */
-    async executeStreamingAgent(prompt, conversationId, specification, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, contextStrategy, useResponsesApi, toolChoice, toolStrict, instructions, scratchpad, skills) {
+    async executeStreamingAgent(prompt, conversationId, specification, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, contextStrategy, useResponsesApi, instructions, scratchpad, skills) {
         // Collects artifact content IDs from tool handlers (e.g. code_execution).
         // Handlers register async ingestion promises; we await all of them before
         // completeConversation so the IDs are available without blocking the LLM.
@@ -5873,8 +5873,6 @@ class Graphlit {
             maxRounds,
             abortSignal,
             useResponsesApi,
-            toolChoice,
-            toolStrict,
             correlationId,
             persona,
             mimeType,
@@ -5935,7 +5933,7 @@ class Graphlit {
      * Shared between streamAgent (single turn) and runAgent (multi-turn harness).
      */
     async executeStreamingLoop(config) {
-        const { conversationId, specification, tools, toolHandlers, uiAdapter, budgetTracker, contextStrategy: { toolResultTokenLimit, toolRoundLimit, rebudgetThreshold }, maxRounds, abortSignal, useResponsesApi, toolChoice, toolStrict, mimeType, data, correlationId, persona, } = config;
+        const { conversationId, specification, tools, toolHandlers, uiAdapter, budgetTracker, contextStrategy: { toolResultTokenLimit, toolRoundLimit, rebudgetThreshold }, maxRounds, abortSignal, useResponsesApi, mimeType, data, correlationId, persona, } = config;
         let messages = config.messages;
         let currentRound = 0;
         let fullMessage = "";
@@ -6048,7 +6046,7 @@ class Graphlit {
                             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                                 console.log(`🔍 [OpenAI Responses] Sending ${openAIResponsesState.initialInput.length} initial items and ${openAIResponsesState.continuationItems.length} continuation items`);
                             }
-                            const responsesResult = await this.streamWithOpenAIResponses(specification, messages, openAIResponsesPendingToolMessages, tools, uiAdapter, abortSignal, openAIResponsesState, toolChoice, toolStrict);
+                            const responsesResult = await this.streamWithOpenAIResponses(specification, messages, openAIResponsesPendingToolMessages, tools, uiAdapter, abortSignal, openAIResponsesState, (currentRound === 0 && tools?.length) ? "required" : undefined);
                             roundMessage = responsesResult.message;
                             toolCalls = responsesResult.toolCalls;
                             openAIResponsesState = responsesResult.state;
@@ -6069,7 +6067,7 @@ class Graphlit {
                                 if (usage) {
                                     uiAdapter.setUsageData(usage);
                                 }
-                            }, abortSignal, toolChoice, toolStrict);
+                            }, abortSignal);
                         }
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] OpenAI ${useOpenAIResponses ? "Responses" : "native"} streaming completed (Round ${currentRound})`);
@@ -6091,7 +6089,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Anthropic native streaming completed (Round ${currentRound})`);
                         }
@@ -6112,7 +6110,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Google native streaming completed (Round ${currentRound})`);
                         }
@@ -6133,7 +6131,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Groq native streaming completed (Round ${currentRound})`);
                         }
@@ -6154,7 +6152,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Cerebras native streaming completed (Round ${currentRound})`);
                         }
@@ -6174,7 +6172,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Cohere native streaming completed (Round ${currentRound})`);
                         }
@@ -6216,7 +6214,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Mistral native streaming completed (Round ${currentRound})`);
                         }
@@ -6237,7 +6235,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Bedrock native streaming completed (Round ${currentRound})`);
                         }
@@ -6258,7 +6256,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] Deepseek native streaming completed (Round ${currentRound})`);
                         }
@@ -6279,7 +6277,7 @@ class Graphlit {
                             if (usage) {
                                 uiAdapter.setUsageData(usage);
                             }
-                        }, abortSignal, toolChoice);
+                        }, abortSignal);
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                             console.log(`\n🏁 [Streaming] xAI native streaming completed (Round ${currentRound})`);
                         }
@@ -7119,8 +7117,6 @@ class Graphlit {
                         maxRounds: DEFAULT_MAX_TOOL_ROUNDS,
                         abortSignal,
                         useResponsesApi: options?.useResponsesApi,
-                        toolChoice: options?.toolChoice,
-                        toolStrict: options?.toolStrict,
                         correlationId: options?.correlationId,
                         persona: options?.persona,
                     });
@@ -7608,7 +7604,7 @@ class Graphlit {
     /**
      * Stream with OpenAI client
      */
-    async streamWithOpenAIResponses(specification, messages, toolMessages, tools, uiAdapter, abortSignal, state, toolChoice, toolStrict) {
+    async streamWithOpenAIResponses(specification, messages, toolMessages, tools, uiAdapter, abortSignal, state, toolChoice) {
         if (!OpenAI && !this.openaiClient) {
             throw new Error("OpenAI client not available");
         }
@@ -7623,7 +7619,7 @@ class Graphlit {
                     throw new Error("OpenAI module not available");
                 })());
         const reasoningEffort = specification.openAI?.reasoningEffort || undefined;
-        const toolDefinitions = formatToolsForOpenAIResponses(tools, toolStrict);
+        const toolDefinitions = formatToolsForOpenAIResponses(tools);
         const baseState = state || {
             instructions: extractInstructionsForOpenAIResponses(messages),
             initialInput: formatMessagesForOpenAIResponsesInitialRound(messages),
@@ -7654,7 +7650,7 @@ class Graphlit {
     /**
      * Stream with OpenAI client
      */
-    async streamWithOpenAI(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice, toolStrict) {
+    async streamWithOpenAI(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the OpenAI module or a provided client
         if (!OpenAI && !this.openaiClient) {
             throw new Error("OpenAI client not available");
@@ -7678,12 +7674,12 @@ class Graphlit {
         if (reasoningEffort && process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🧠 [Graphlit SDK] OpenAI reasoning effort: ${reasoningEffort}`);
         }
-        await streamWithOpenAI(specification, messages, tools, openaiClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, reasoningEffort, toolChoice, toolStrict);
+        await streamWithOpenAI(specification, messages, tools, openaiClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, reasoningEffort);
     }
     /**
      * Stream with Anthropic client
      */
-    async streamWithAnthropic(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithAnthropic(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Anthropic module or a provided client
         if (!Anthropic && !this.anthropicClient) {
             throw new Error("Anthropic client not available");
@@ -7707,7 +7703,7 @@ class Graphlit {
         if (thinkingConfig && process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🧠 [Graphlit SDK] Anthropic thinking enabled | Budget: ${thinkingConfig.budget_tokens} tokens`);
         }
-        await streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, thinkingConfig, toolChoice);
+        await streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, thinkingConfig);
     }
     /**
      * Extract thinking configuration from specification
@@ -7738,7 +7734,7 @@ class Graphlit {
     /**
      * Stream with Google client
      */
-    async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Google module or a provided client
         if (!GoogleGenAI && !this.googleClient) {
             throw new Error("Google GenerativeAI client not available");
@@ -7758,12 +7754,12 @@ class Graphlit {
         if (thinkingConfig && process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🧠 [Graphlit SDK] Google thinking enabled | Budget: ${thinkingConfig.budget_tokens} tokens`);
         }
-        await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, thinkingConfig, toolChoice);
+        await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, thinkingConfig);
     }
     /**
      * Stream with Groq client (OpenAI-compatible)
      */
-    async streamWithGroq(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithGroq(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Groq module or a provided client
         if (!Groq && !this.groqClient) {
             throw new Error("Groq client not available");
@@ -7778,12 +7774,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Groq streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithGroq(specification, messages, tools, groqClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithGroq(specification, messages, tools, groqClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Cerebras client (native SDK)
      */
-    async streamWithCerebras(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithCerebras(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Cerebras module or a provided client
         if (!Cerebras && !this.cerebrasClient) {
             throw new Error("Cerebras client not available");
@@ -7802,12 +7798,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Cerebras streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithCerebras(specification, messages, tools, cerebrasClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithCerebras(specification, messages, tools, cerebrasClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Cohere client
      */
-    async streamWithCohere(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithCohere(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Cohere module or a provided client
         if (!CohereClient && !CohereClientV2 && !this.cohereClient) {
             throw new Error("Cohere client not available");
@@ -7824,12 +7820,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Cohere streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithCohere(specification, messages, tools, cohereClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithCohere(specification, messages, tools, cohereClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Mistral client
      */
-    async streamWithMistral(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithMistral(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Mistral module or a provided client
         if (!Mistral && !this.mistralClient) {
             throw new Error("Mistral client not available");
@@ -7862,12 +7858,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Mistral streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithMistral(specification, messages, tools, mistralClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithMistral(specification, messages, tools, mistralClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Bedrock client
      */
-    async streamWithBedrock(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithBedrock(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Bedrock module or a provided client
         if (!BedrockRuntimeClient && !this.bedrockClient) {
             throw new Error("Bedrock client not available");
@@ -7884,12 +7880,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Bedrock streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0} | SystemPrompt: ${systemPrompt ? "Yes" : "No"}`);
         }
-        await streamWithBedrock(specification, messages, systemPrompt, tools, bedrockClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithBedrock(specification, messages, systemPrompt, tools, bedrockClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Deepseek client
      */
-    async streamWithDeepseek(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithDeepseek(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the OpenAI module or a provided Deepseek client
         if (!OpenAI && !this.deepseekClient) {
             throw new Error("Deepseek client not available (requires OpenAI SDK)");
@@ -7910,9 +7906,9 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Deepseek streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithDeepseek(specification, messages, tools, deepseekClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithDeepseek(specification, messages, tools, deepseekClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
-    async streamWithXai(specification, messages, tools, uiAdapter, onComplete, abortSignal, toolChoice) {
+    async streamWithXai(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the OpenAI module or a provided xAI client
         if (!OpenAI && !this.xaiClient) {
             throw new Error("xAI client not available (requires OpenAI SDK)");
@@ -7933,7 +7929,7 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to xAI streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithXai(specification, messages, tools, xaiClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, toolChoice);
+        await streamWithXai(specification, messages, tools, xaiClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     // Helper method to execute tools for promptAgent
     async executeToolsForPromptAgent(toolCalls, toolHandlers, allToolCalls, signal, toolResultTokenLimit = DEFAULT_CONTEXT_STRATEGY.toolResultTokenLimit) {

package/dist/streaming/llm-formatters.d.ts

@@ -56,7 +56,7 @@ export interface OpenAIResponsesToolDefinition {
     name: string;
     description?: string;
     parameters: Record<string, unknown>;
-    strict: boolean;
+    strict: false;
 }
 /**
  * Anthropic message format
@@ -119,7 +119,7 @@ export declare function formatToolsForOpenAIResponses(tools: Array<{
     name: string;
     description?: string | null;
     schema?: string | null;
-}> | undefined, strict?: boolean): OpenAIResponsesToolDefinition[] | undefined;
+}> | undefined): OpenAIResponsesToolDefinition[] | undefined;
 /**
  * Format GraphQL conversation messages for Anthropic SDK
  */

package/dist/streaming/llm-formatters.js

@@ -137,7 +137,7 @@ export function formatMessagesForOpenAI(messages) {
                     assistantMessage.tool_calls = message.toolCalls
                         .filter((tc) => tc !== null)
                         .map((toolCall) => ({
-                        id: toolCall.id,
+                        id: toChatCompletionsCallId(toolCall.id),
                         type: "function",
                         function: {
                             name: toolCall.name,
@@ -151,7 +151,7 @@ export function formatMessagesForOpenAI(messages) {
                 formattedMessages.push({
                     role: "tool",
                     content: stripImagesToText(trimmedMessage),
-                    tool_call_id: message.toolCallId || "",
+                    tool_call_id: toChatCompletionsCallId(message.toolCallId || ""),
                 });
                 break;
             default: // User messages
@@ -199,6 +199,22 @@ export function extractInstructionsForOpenAIResponses(messages) {
         ? systemMessages.join("\n\n")
         : undefined;
 }
+// Remap tool call IDs to Responses API format (must start with 'fc_')
+function toResponsesCallId(id) {
+    if (id.startsWith("fc_"))
+        return id;
+    if (id.startsWith("call_"))
+        return "fc_" + id.slice(5);
+    return "fc_" + id;
+}
+// Remap tool call IDs to Chat Completions format (must start with 'call_')
+function toChatCompletionsCallId(id) {
+    if (id.startsWith("call_"))
+        return id;
+    if (id.startsWith("fc_"))
+        return "call_" + id.slice(3);
+    return "call_" + id;
+}
 export function formatMessagesForOpenAIResponsesInitialRound(messages) {
     const formattedMessages = [];
     for (const message of messages) {
@@ -228,10 +244,11 @@ export function formatMessagesForOpenAIResponsesInitialRound(messages) {
                         if (!toolCall) {
                             continue;
                         }
+                        const callId = toResponsesCallId(toolCall.id);
                         formattedMessages.push({
                             type: "function_call",
-                            id: toolCall.id,
-                            call_id: toolCall.id,
+                            id: callId,
+                            call_id: callId,
                             name: toolCall.name,
                             arguments: toolCall.arguments,
                         });
@@ -245,7 +262,7 @@ export function formatMessagesForOpenAIResponsesInitialRound(messages) {
                 }
                 formattedMessages.push({
                     type: "function_call_output",
-                    call_id: message.toolCallId,
+                    call_id: toResponsesCallId(message.toolCallId),
                     output: stripImagesToText(trimmedMessage),
                 });
                 break;
@@ -290,12 +307,12 @@ export function buildResponsesFunctionCallOutputItems(toolMessages) {
         message.toolCallId.length > 0)
         .map((message) => ({
         type: "function_call_output",
-        call_id: message.toolCallId,
+        call_id: toResponsesCallId(message.toolCallId),
         output: stripImagesToText(message.message?.trim() || ""),
     }));
 }
 export const buildOpenAIResponsesFunctionCallOutputItems = buildResponsesFunctionCallOutputItems;
-export function formatToolsForOpenAIResponses(tools, strict) {
+export function formatToolsForOpenAIResponses(tools) {
     if (!tools?.length) {
         return undefined;
     }
@@ -314,7 +331,7 @@ export function formatToolsForOpenAIResponses(tools, strict) {
             name: tool.name,
             description: tool.description || undefined,
             parameters,
-            strict: strict ?? false,
+            strict: false,
         };
     });
 }

package/dist/streaming/openai-responses.js

@@ -6,7 +6,7 @@ function isFunctionCallOutputItem(item) {
         item.type === "function_call");
 }
 function toToolCallId(item, outputIndex) {
-    return item.call_id || item.id || `tool_${Date.now()}_${outputIndex}`;
+    return item.call_id || item.id || `fc_${Date.now()}_${outputIndex}`;
 }
 export async function streamWithOpenAIResponses(specification, instructions, input, tools, openaiClient, onEvent, abortSignal, reasoningEffort, toolChoice) {
     let fullMessage = "";

package/dist/streaming/providers.d.ts

@@ -6,8 +6,7 @@ import { ReasoningMetadata } from "../types/ui-events.js";
  * Stream with OpenAI SDK
  */
 export declare function streamWithOpenAI(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, openaiClient: any, // OpenAI client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, reasoningEffort?: string, // OpenAI reasoning effort level (low, medium, high)
-toolChoice?: "auto" | "required" | "none", toolStrict?: boolean): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, reasoningEffort?: string): Promise<void>;
 /**
  * Stream with Anthropic SDK
  */
@@ -16,7 +15,7 @@ export declare function streamWithAnthropic(specification: Specification, messag
 onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, thinkingConfig?: {
     type: "enabled";
     budget_tokens: number;
-}, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+}): Promise<void>;
 /**
  * Stream with Google SDK
  */
@@ -24,37 +23,37 @@ export declare function streamWithGoogle(specification: Specification, messages:
 onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, thinkingConfig?: {
     type: "enabled";
     budget_tokens: number;
-}, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+}): Promise<void>;
 /**
  * Stream with Groq SDK (OpenAI-compatible)
  */
 export declare function streamWithGroq(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, groqClient: any, // Groq client instance (OpenAI-compatible)
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Cerebras native SDK
  */
 export declare function streamWithCerebras(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, cerebrasClient: any, // Cerebras native client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Deepseek SDK (OpenAI-compatible)
  */
 export declare function streamWithDeepseek(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, deepseekClient: any, // OpenAI client instance configured for Deepseek
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Cohere SDK
  */
 export declare function streamWithCohere(specification: Specification, messages: ConversationMessage[], tools: ToolDefinitionInput[] | undefined, cohereClient: any, // CohereClient instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Mistral SDK
  */
 export declare function streamWithMistral(specification: Specification, messages: MistralMessage[], tools: ToolDefinitionInput[] | undefined, mistralClient: any, // Mistral client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Bedrock SDK (for Claude models)
  */
 export declare function streamWithBedrock(specification: Specification, messages: BedrockMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, bedrockClient: any, // BedrockRuntimeClient instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 export declare function streamWithXai(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, xaiClient: any, // OpenAI client instance configured for xAI
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, toolChoice?: "auto" | "required" | "none"): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal): Promise<void>;
 export {};

package/dist/streaming/providers.js

@@ -77,8 +77,7 @@ function cleanSchemaForGoogle(schema) {
  * Stream with OpenAI SDK
  */
 export async function streamWithOpenAI(specification, messages, tools, openaiClient, // OpenAI client instance
-onEvent, onComplete, abortSignal, reasoningEffort, // OpenAI reasoning effort level (low, medium, high)
-toolChoice, toolStrict) {
+onEvent, onComplete, abortSignal, reasoningEffort) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -130,12 +129,8 @@ toolChoice, toolStrict) {
                     name: tool.name,
                     description: tool.description,
                     parameters: tool.schema ? JSON.parse(tool.schema) : {},
-                    ...(toolStrict !== undefined && { strict: toolStrict }),
                 },
             }));
-            if (toolChoice) {
-                streamConfig.tool_choice = toolChoice;
-            }
         }
         // Add reasoning effort for o1 models
         if (reasoningEffort) {
@@ -427,7 +422,7 @@ toolChoice, toolStrict) {
     }
 }
 export async function streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, // Properly typed Anthropic client
-onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
+onEvent, onComplete, abortSignal, thinkingConfig) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -493,17 +488,6 @@ onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
                 description: tool.description,
                 input_schema: tool.schema ? JSON.parse(tool.schema) : {},
             }));
-            if (toolChoice) {
-                // Anthropic uses { type: "auto" }, { type: "any" } (for required), or { type: "none" } (tool_choice not supported for none - omit tools instead)
-                const anthropicToolChoice = toolChoice === "required"
-                    ? { type: "any" }
-                    : toolChoice === "none"
-                        ? undefined // Anthropic doesn't support { type: "none" } - handled by not passing tools
-                        : { type: "auto" };
-                if (anthropicToolChoice) {
-                    streamConfig.tool_choice = anthropicToolChoice;
-                }
-            }
         }
         // Check if this is a 1M context model (beta flag, same underlying model ID)
         const is1MContext = specification.anthropic?.model ===
@@ -973,7 +957,7 @@ onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
  * Stream with Google SDK
  */
 export async function streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, // Google GenerativeAI client instance
-onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
+onEvent, onComplete, abortSignal, thinkingConfig) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -1096,19 +1080,6 @@ onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
         // Add tools to config if provided
         if (googleTools) {
             config.tools = googleTools;
-            if (toolChoice) {
-                // Google uses functionCallingConfig.mode with values AUTO, ANY (for required), NONE
-                const googleMode = toolChoice === "required"
-                    ? "ANY"
-                    : toolChoice === "none"
-                        ? "NONE"
-                        : "AUTO";
-                config.toolConfig = {
-                    functionCallingConfig: {
-                        mode: googleMode,
-                    },
-                };
-            }
         }
         // Call generateContentStream with conversation history
         const streamResponse = await googleClient.models.generateContentStream({
@@ -1439,7 +1410,7 @@ onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
  * Stream with Groq SDK (OpenAI-compatible)
  */
 export async function streamWithGroq(specification, messages, tools, groqClient, // Groq client instance (OpenAI-compatible)
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     try {
         const modelName = getModelName(specification);
         // Filter or simplify tools for Groq models that have issues
@@ -1480,8 +1451,7 @@ onEvent, onComplete, abortSignal, toolChoice) {
             }
         }
         // Groq uses the same API as OpenAI, so we can reuse the OpenAI streaming logic
-        return await streamWithOpenAI(specification, messages, groqTools, groqClient, onEvent, onComplete, abortSignal, undefined, // reasoningEffort
-        toolChoice);
+        return await streamWithOpenAI(specification, messages, groqTools, groqClient, onEvent, onComplete, abortSignal, undefined);
     }
     catch (error) {
         // Normalize Groq errors into ProviderError
@@ -1531,7 +1501,7 @@ onEvent, onComplete, abortSignal, toolChoice) {
  * Stream with Cerebras native SDK
  */
 export async function streamWithCerebras(specification, messages, tools, cerebrasClient, // Cerebras native client instance
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -1638,9 +1608,6 @@ onEvent, onComplete, abortSignal, toolChoice) {
         // Add tools if available
         if (cerebrasTools) {
             streamConfig.tools = cerebrasTools;
-            if (toolChoice) {
-                streamConfig.tool_choice = toolChoice;
-            }
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`⏱️ [Cerebras] Starting LLM call at: ${new Date().toISOString()}`);
@@ -1823,7 +1790,7 @@ onEvent, onComplete, abortSignal, toolChoice) {
  * Stream with Deepseek SDK (OpenAI-compatible)
  */
 export async function streamWithDeepseek(specification, messages, tools, deepseekClient, // OpenAI client instance configured for Deepseek
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -1903,9 +1870,6 @@ onEvent, onComplete, abortSignal, toolChoice) {
                     parameters: tool.schema ? JSON.parse(tool.schema) : {},
                 },
             }));
-            if (toolChoice) {
-                streamConfig.tool_choice = toolChoice;
-            }
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`⏱️ [Deepseek] Starting LLM call at: ${new Date().toISOString()}`);
@@ -2170,7 +2134,7 @@ onEvent, onComplete, abortSignal, toolChoice) {
  * Stream with Cohere SDK
  */
 export async function streamWithCohere(specification, messages, tools, cohereClient, // CohereClient instance
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -2273,9 +2237,6 @@ onEvent, onComplete, abortSignal, toolChoice) {
                     parameters: tool.schema ? JSON.parse(tool.schema) : {},
                 },
             }));
-            if (toolChoice) {
-                streamConfig.tool_choice = toolChoice;
-            }
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🔍 [Cohere] Final stream config:`, JSON.stringify(streamConfig, null, 2));
@@ -2494,7 +2455,7 @@ onEvent, onComplete, abortSignal, toolChoice) {
  * Stream with Mistral SDK
  */
 export async function streamWithMistral(specification, messages, tools, mistralClient, // Mistral client instance
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -2539,11 +2500,6 @@ onEvent, onComplete, abortSignal, toolChoice) {
                     parameters: tool.schema ? JSON.parse(tool.schema) : {},
                 },
             }));
-            if (toolChoice) {
-                // Mistral uses tool_choice with values "auto", "any" (for required), "none"
-                const mistralToolChoice = toolChoice === "required" ? "any" : toolChoice;
-                streamConfig.tool_choice = mistralToolChoice;
-            }
         }
         else {
             console.log(`[Mistral] No tools provided - tools parameter is ${tools === undefined ? "undefined" : "empty array"}`);
@@ -2801,7 +2757,7 @@ onEvent, onComplete, abortSignal, toolChoice) {
  * Stream with Bedrock SDK (for Claude models)
  */
 export async function streamWithBedrock(specification, messages, systemPrompt, tools, bedrockClient, // BedrockRuntimeClient instance
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     let fullMessage = "";
     let toolCalls = [];
     let usageData = null;
@@ -2881,17 +2837,6 @@ onEvent, onComplete, abortSignal, toolChoice) {
                     },
                 })),
             };
-            if (toolChoice) {
-                // Bedrock uses toolChoice with format { auto: {} }, { any: {} }, or { none: {} } (not supported - omit)
-                const bedrockToolChoice = toolChoice === "required"
-                    ? { any: {} }
-                    : toolChoice === "auto"
-                        ? { auto: {} }
-                        : undefined; // Bedrock doesn't support "none" for toolChoice
-                if (bedrockToolChoice) {
-                    request.toolConfig.toolChoice = bedrockToolChoice;
-                }
-            }
         }
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🔍 [Bedrock] Converse request:`, JSON.stringify(request, null, 2));
@@ -3125,14 +3070,13 @@ onEvent, onComplete, abortSignal, toolChoice) {
     }
 }
 export async function streamWithXai(specification, messages, tools, xaiClient, // OpenAI client instance configured for xAI
-onEvent, onComplete, abortSignal, toolChoice) {
+onEvent, onComplete, abortSignal) {
     try {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [xAI] Starting stream | Model: ${getModelName(specification)} | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
         // xAI uses the same API as OpenAI, so we can reuse the OpenAI streaming logic
-        return await streamWithOpenAI(specification, messages, tools, xaiClient, onEvent, onComplete, abortSignal, undefined, // reasoningEffort
-        toolChoice);
+        return await streamWithOpenAI(specification, messages, tools, xaiClient, onEvent, onComplete, abortSignal, undefined);
     }
     catch (error) {
         // Normalize xAI errors into ProviderError

package/dist/types/agent.d.ts

@@ -21,10 +21,6 @@ export interface AgentOptions {
     maxToolRounds?: number;
     timeout?: number;
     contextStrategy?: ContextStrategy;
-    /** Controls whether the model must call a tool. Default: "auto". */
-    toolChoice?: "auto" | "required" | "none";
-    /** Enforce strict schema adherence for tool call arguments (OpenAI only). Default: false. */
-    toolStrict?: boolean;
 }
 export interface AgentMetrics {
     totalTime: number;
@@ -72,10 +68,6 @@ export interface StreamAgentOptions {
     contextStrategy?: ContextStrategy;
     /** Default eligible OpenAI GPT-5.4+ models to Responses; false forces legacy Chat Completions. */
     useResponsesApi?: boolean;
-    /** Controls whether the model must call a tool. Default: "auto". */
-    toolChoice?: "auto" | "required" | "none";
-    /** Enforce strict schema adherence for tool call arguments (OpenAI only). Default: false. */
-    toolStrict?: boolean;
     /** Harness-injected instructions appended to the formatted conversation (e.g. wind-down, stuck intervention). */
     instructions?: string;
     /** Harness-injected scratchpad text, merged with conversation scratchpad. Placed right before user-prompt. */
@@ -168,10 +160,6 @@ export interface RunAgentOptions {
     chunkingStrategy?: "character" | "word" | "sentence";
     smoothingDelay?: number;
     useResponsesApi?: boolean;
-    /** Controls whether the model must call a tool. Default: "auto". */
-    toolChoice?: "auto" | "required" | "none";
-    /** Enforce strict schema adherence for tool call arguments (OpenAI only). Default: false. */
-    toolStrict?: boolean;
     /** Skill references to inject into the agent's context window. Retrieved via querySkills, passed by reference. */
     skills?: EntityReferenceInput[];
 }
@@ -221,8 +209,6 @@ export interface StreamingLoopConfig {
     maxRounds: number;
     abortSignal: AbortSignal | undefined;
     useResponsesApi?: boolean;
-    toolChoice?: "auto" | "required" | "none";
-    toolStrict?: boolean;
     correlationId?: string;
     persona?: EntityReferenceInput;
     mimeType?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20260408010",
+  "version": "1.0.20260408012",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",