@ljoukov/llm 7.0.11 → 7.0.12

package/README.md

@@ -628,20 +628,22 @@ Architecture note:
 
 ### Provider-Native Tools (`generateText()`)
 
-Use this when the model provider executes the tool remotely (for example search/code-exec style tools).
+Use this when the model provider executes the tool remotely (for example search/code-exec/shell style tools).
 
 ```ts
 import { generateText } from "@ljoukov/llm";
 
 const result = await generateText({
-  model: "gpt-5.4-mini",
-  input: "Find 3 relevant sources about X and summarize them.",
-  tools: [{ type: "web-search", mode: "live" }, { type: "code-execution" }],
+  model: "gpt-5.5",
+  input: "Run python --version in a hosted shell and summarize the result.",
+  tools: [{ type: "shell" }],
 });
 
 console.log(result.text);
 ```
 
+`{ type: "shell" }` uses OpenAI hosted shell containers by default. It is only supported for OpenAI API models; ChatGPT-authenticated, Gemini, and Fireworks providers reject it.
+
 ### Runtime Tools (`runToolLoop()`)
 
 Use this when the model should call your local runtime functions.

package/dist/index.cjs

@@ -6197,12 +6197,40 @@ function toGeminiTools(tools) {
         return { googleSearch: {} };
       case "code-execution":
         return { codeExecution: {} };
+      case "shell":
+        throw new Error("Gemini provider does not support the OpenAI shell tool.");
       default:
         throw new Error("Unsupported tool configuration");
     }
   });
 }
-function toOpenAiTools(tools) {
+function toOpenAiShellEnvironment(environment) {
+  if (environment?.type === "container-reference") {
+    return {
+      type: "container_reference",
+      container_id: environment.containerId
+    };
+  }
+  return {
+    type: "container_auto",
+    ...environment?.fileIds ? { file_ids: Array.from(environment.fileIds) } : {},
+    ...environment?.memoryLimit !== void 0 ? { memory_limit: environment.memoryLimit } : {},
+    ...environment?.networkPolicy ? {
+      network_policy: environment.networkPolicy.type === "allowlist" ? {
+        type: "allowlist",
+        allowed_domains: Array.from(environment.networkPolicy.allowedDomains),
+        ...environment.networkPolicy.domainSecrets ? {
+          domain_secrets: environment.networkPolicy.domainSecrets.map((secret) => ({
+            domain: secret.domain,
+            name: secret.name,
+            value: secret.value
+          }))
+        } : {}
+      } : { type: "disabled" }
+    } : {}
+  };
+}
+function toOpenAiTools(tools, options) {
   if (!tools || tools.length === 0) {
     return void 0;
   }
@@ -6215,6 +6243,15 @@ function toOpenAiTools(tools) {
       case "code-execution": {
         return { type: "code_interpreter", container: { type: "auto" } };
       }
+      case "shell": {
+        if (options.provider !== "openai") {
+          throw new Error("OpenAI shell tool is only supported for OpenAI API models.");
+        }
+        return {
+          type: "shell",
+          environment: toOpenAiShellEnvironment(tool2.environment)
+        };
+      }
       default:
         throw new Error("Unsupported tool configuration");
     }
@@ -7813,6 +7850,8 @@ async function runTextCall(params) {
   let responseRole;
   let latestUsage;
   let responseImages = 0;
+  let sawResponseDelta = false;
+  let sawThoughtDelta = false;
   const pushEvent = (event) => {
     queue.push(event);
     params.onEvent?.(event);
@@ -7823,8 +7862,10 @@ async function runTextCall(params) {
     }
     responseParts.push({ type: "text", text, ...channel === "thought" ? { thought: true } : {} });
     if (channel === "thought") {
+      sawThoughtDelta = true;
       callLogger?.appendThoughtDelta(text);
     } else {
+      sawResponseDelta = true;
       callLogger?.appendResponseDelta(text);
     }
     pushEvent({ type: "delta", channel, text });
@@ -7864,7 +7905,7 @@ async function runTextCall(params) {
           }),
           { model: request.model, provider: "openai" }
         );
-        const openAiTools = toOpenAiTools(request.tools);
+        const openAiTools = toOpenAiTools(request.tools, { provider: "openai" });
         const reasoningEffort = resolveOpenAiReasoningEffort(
           modelForProvider,
           request.thinkingLevel
@@ -7925,12 +7966,17 @@ async function runTextCall(params) {
             );
           }
           latestUsage = extractOpenAiUsageTokens(finalResponse.usage);
-          if (responseParts.length === 0) {
+          if (!sawResponseDelta || !sawThoughtDelta) {
+            const needsResponseFallback = !sawResponseDelta;
+            const needsThoughtFallback = !sawThoughtDelta;
             const fallback = extractOpenAiResponseParts(finalResponse);
             blocked = blocked || fallback.blocked;
             for (const part of fallback.parts) {
               if (part.type === "text") {
-                pushDelta(part.thought === true ? "thought" : "response", part.text);
+                const channel = part.thought === true ? "thought" : "response";
+                if (channel === "response" && needsResponseFallback || channel === "thought" && needsThoughtFallback) {
+                  pushDelta(channel, part.text);
+                }
               } else if (part.type === "inlineData") {
                 pushInline(part.data, part.mimeType);
               }
@@ -7947,7 +7993,7 @@ async function runTextCall(params) {
           provider: "chatgpt"
         });
         const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
-        const openAiTools = toOpenAiTools(request.tools);
+        const openAiTools = toOpenAiTools(request.tools, { provider: "chatgpt" });
         const requestPayload = {
           model: modelForProvider,
           store: false,
@@ -7966,18 +8012,18 @@ async function runTextCall(params) {
           },
           ...openAiTools ? { tools: openAiTools } : {}
         };
-        let sawResponseDelta = false;
-        let sawThoughtDelta = false;
+        let sawResponseDelta2 = false;
+        let sawThoughtDelta2 = false;
         const result2 = await collectChatGptCodexResponseWithRetry({
           request: requestPayload,
           signal,
           onDelta: (delta) => {
             if (delta.thoughtDelta) {
-              sawThoughtDelta = true;
+              sawThoughtDelta2 = true;
               pushDelta("thought", delta.thoughtDelta);
             }
             if (delta.textDelta) {
-              sawResponseDelta = true;
+              sawResponseDelta2 = true;
               pushDelta("response", delta.textDelta);
             }
           }
@@ -7993,10 +8039,10 @@ async function runTextCall(params) {
         latestUsage = extractChatGptUsageTokens(result2.usage);
         const fallbackText = typeof result2.text === "string" ? result2.text : "";
         const fallbackThoughts = typeof result2.reasoningSummaryText === "string" && result2.reasoningSummaryText.length > 0 ? result2.reasoningSummaryText : typeof result2.reasoningText === "string" ? result2.reasoningText : "";
-        if (!sawThoughtDelta && fallbackThoughts.length > 0) {
+        if (!sawThoughtDelta2 && fallbackThoughts.length > 0) {
           pushDelta("thought", fallbackThoughts);
         }
-        if (!sawResponseDelta && fallbackText.length > 0) {
+        if (!sawResponseDelta2 && fallbackText.length > 0) {
           pushDelta("response", fallbackText);
         }
       } else if (provider === "fireworks") {
@@ -8716,7 +8762,7 @@ async function runToolLoop(request) {
   try {
     if (providerInfo.provider === "openai") {
       const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
-      const openAiNativeTools = toOpenAiTools(request.modelTools);
+      const openAiNativeTools = toOpenAiTools(request.modelTools, { provider: "openai" });
       const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
       const reasoningEffort = resolveOpenAiReasoningEffort(
         providerInfo.model,
@@ -9119,7 +9165,7 @@ async function runToolLoop(request) {
     }
     if (providerInfo.provider === "chatgpt") {
       const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
-      const openAiNativeTools = toOpenAiTools(request.modelTools);
+      const openAiNativeTools = toOpenAiTools(request.modelTools, { provider: "chatgpt" });
       const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
       const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
       const toolLoopInput = toChatGptInput(contents, {