@langchain/openai 1.2.13 → 1.3.0-dev-1773709997654

package/dist/tools/shell.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"shell.cjs","names":["z"],"sources":["../../src/tools/shell.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { tool, type DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * Re-export action type from OpenAI SDK for convenience.\n * The action contains command details like commands array, timeout, and max output length.\n */\nexport type ShellAction =\n  OpenAIClient.Responses.ResponseFunctionShellToolCall.Action;\n\n// Zod schema for shell action\nexport const ShellActionSchema = z.object({\n  commands: z.array(z.string()).describe(\"Array of shell commands to execute\"),\n  timeout_ms: z\n    .number()\n    .optional()\n    .describe(\"Optional timeout in milliseconds for the commands\"),\n  max_output_length: z\n    .number()\n    .optional()\n    .describe(\n      \"Optional maximum number of characters to return from each command\"\n    ),\n});\n\n/**\n * Result of a single shell command execution.\n * Contains stdout, stderr, and the outcome (exit code or timeout).\n */\nexport type ShellCommandOutput =\n  OpenAIClient.Responses.ResponseFunctionShellCallOutputContent;\n\n/**\n * Outcome type for shell command execution - either exit with code or timeout.\n */\nexport type ShellCallOutcome = ShellCommandOutput[\"outcome\"];\n\n/**\n * Result of executing shell commands.\n * Contains an array of outputs (one per command) and the max_output_length parameter.\n */\nexport interface ShellResult {\n  /**\n   * Array of command outputs. Each entry corresponds to a command from the action.\n   * The order should match the order of commands in the action.\n   */\n  output: ShellCommandOutput[];\n  /**\n   * The max_output_length from the action, which must be passed back to the API.\n   * If not provided in the action, can be omitted.\n   */\n  maxOutputLength?: number | null;\n}\n\n/**\n * Options for the Shell tool.\n */\nexport interface ShellOptions {\n  /**\n   * Execute function that handles shell command execution.\n   * This function receives the action input containing the commands and limits,\n   * and should return a ShellResult with stdout, stderr, and outcome for each command.\n   *\n   * @example\n   * ```typescript\n   * execute: async (action) => {\n   *   const outputs = await Promise.all(\n   *     action.commands.map(async (cmd) => {\n   *       try {\n   *         const { stdout, stderr } = await exec(cmd, {\n   *           timeout: action.timeout_ms ?? undefined,\n   *         });\n   *         return {\n   *           stdout,\n   *           stderr,\n   *           outcome: { type: \"exit\" as const, exit_code: 0 },\n   *         };\n   *       } catch (error) {\n   *         const timedOut = error.killed && error.signal === \"SIGTERM\";\n   *         return {\n   *           stdout: error.stdout ?? \"\",\n   *           stderr: error.stderr ?? String(error),\n   *           outcome: timedOut\n   *             ? { type: \"timeout\" as const }\n   *             : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n   *         };\n   *       }\n   *     })\n   *   );\n   *   return {\n   *     output: outputs,\n   *     maxOutputLength: action.max_output_length,\n   *   };\n   * }\n   * ```\n   */\n  execute: (action: ShellAction) => ShellResult | Promise<ShellResult>;\n}\n\n/**\n * OpenAI Shell tool type for the Responses API.\n */\nexport type ShellTool = OpenAIClient.Responses.FunctionShellTool;\n\nconst TOOL_NAME = \"shell\";\n\n/**\n * Creates a Shell tool that allows models to run shell commands through your integration.\n *\n * The shell tool allows the model to interact with your local computer through a controlled\n * command-line interface. The model proposes shell commands; your integration executes them\n * and returns the outputs. This creates a simple plan-execute loop that lets models inspect\n * the system, run utilities, and gather data until they can finish the task.\n *\n * **Important**: The shell tool is available through the Responses API for use with `GPT-5.1`.\n * It is not available on other models, or via the Chat Completions API.\n *\n * **When to use**:\n * - **Automating filesystem or process diagnostics** – For example, \"find the largest PDF\n *   under ~/Documents\" or \"show running gunicorn processes.\"\n * - **Extending the model's capabilities** – Using built-in UNIX utilities, python runtime\n *   and other CLIs in your environment.\n * - **Running multi-step build and test flows** – Chaining commands like `pip install` and `pytest`.\n * - **Complex agentic coding workflows** – Using other tools like `apply_patch` to complete\n *   workflows that involve complex file operations.\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends shell commands (`shell_call` with `commands` array)\n * 2. Your code executes the commands (can be concurrent)\n * 3. You return stdout, stderr, and outcome for each command\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Running arbitrary shell commands can be dangerous.\n * Always sandbox execution or add strict allow/deny-lists before forwarding\n * a command to the system shell.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-shell | OpenAI Shell Documentation}\n * @see {@link https://github.com/openai/codex | Codex CLI} for reference implementation.\n *\n * @param options - Configuration for the Shell tool\n * @returns A Shell tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { exec } from \"child_process/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic command handling\n * const shellTool = tools.shell({\n *   execute: async (action) => {\n *     const outputs = await Promise.all(\n *       action.commands.map(async (cmd) => {\n *         try {\n *           const { stdout, stderr } = await exec(cmd, {\n *             timeout: action.timeout_ms ?? undefined,\n *           });\n *           return {\n *             stdout,\n *             stderr,\n *             outcome: { type: \"exit\" as const, exit_code: 0 },\n *           };\n *         } catch (error) {\n *           const timedOut = error.killed && error.signal === \"SIGTERM\";\n *           return {\n *             stdout: error.stdout ?? \"\",\n *             stderr: error.stderr ?? String(error),\n *             outcome: timedOut\n *               ? { type: \"timeout\" as const }\n *               : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n *           };\n *         }\n *       })\n *     );\n *     return {\n *       output: outputs,\n *       maxOutputLength: action.max_output_length,\n *     };\n *   },\n * });\n *\n * const llmWithShell = model.bindTools([shellTool]);\n * const response = await llmWithShell.invoke(\n *   \"Find the largest PDF file in ~/Documents\"\n * );\n * ```\n *\n * @example\n * ```typescript\n * // Full shell loop example\n * async function shellLoop(model, task) {\n *   let response = await model.invoke(task, {\n *     tools: [tools.shell({ execute: myExecutor })],\n *   });\n *\n *   while (true) {\n *     const shellCall = response.additional_kwargs.tool_outputs?.find(\n *       (output) => output.type === \"shell_call\"\n *     );\n *\n *     if (!shellCall) break;\n *\n *     // Execute commands (with proper sandboxing!)\n *     const result = await executeCommands(shellCall.action);\n *\n *     // Send output back to model\n *     response = await model.invoke([\n *       response,\n *       {\n *         type: \"shell_call_output\",\n *         call_id: shellCall.call_id,\n *         output: result.output,\n *         max_output_length: result.maxOutputLength,\n *       },\n *     ], {\n *       tools: [tools.shell({ execute: myExecutor })],\n *     });\n *   }\n *\n *   return response;\n * }\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Commands are provided as an array of strings that can be executed concurrently\n * - Action includes: `commands`, `timeout_ms`, `max_output_length`\n * - Always sandbox or validate commands before execution\n * - The `timeout_ms` from the model is only a hint—enforce your own limits\n * - If `max_output_length` exists in the action, always pass it back in the output\n * - Many CLI tools return non-zero exit codes for warnings; still capture stdout/stderr\n */\nexport function shell(options: ShellOptions) {\n  // Wrapper that converts ShellResult to string for LangChain tool compatibility\n  const executeWrapper = async (action: ShellAction): Promise<string> => {\n    const result = await options.execute(action);\n    // Return a JSON string representation for the tool result\n    return JSON.stringify({\n      output: result.output,\n      max_output_length: result.maxOutputLength,\n    });\n  };\n\n  const shellTool = tool(executeWrapper, {\n    name: TOOL_NAME,\n    description:\n      \"Execute shell commands in a managed environment. Commands can be run concurrently.\",\n    schema: ShellActionSchema,\n  });\n\n  shellTool.extras = {\n    ...(shellTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"shell\",\n    } satisfies ShellTool,\n  };\n\n  return shellTool as DynamicStructuredTool<\n    typeof ShellActionSchema,\n    ShellAction,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;;AAYA,MAAa,oBAAoBA,SAAE,OAAO;CACxC,UAAUA,SAAE,MAAMA,SAAE,QAAQ,CAAC,CAAC,SAAS,qCAAqC;CAC5E,YAAYA,SACT,QAAQ,CACR,UAAU,CACV,SAAS,oDAAoD;CAChE,mBAAmBA,SAChB,QAAQ,CACR,UAAU,CACV,SACC,oEACD;CACJ,CAAC;AAiFF,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIlB,SAAgB,MAAM,SAAuB;CAE3C,MAAM,iBAAiB,OAAO,WAAyC;EACrE,MAAM,SAAS,MAAM,QAAQ,QAAQ,OAAO;AAE5C,SAAO,KAAK,UAAU;GACpB,QAAQ,OAAO;GACf,mBAAmB,OAAO;GAC3B,CAAC;;CAGJ,MAAM,4CAAiB,gBAAgB;EACrC,MAAM;EACN,aACE;EACF,QAAQ;EACT,CAAC;AAEF,WAAU,SAAS;EACjB,GAAI,UAAU,UAAU,EAAE;EAC1B,wBAAwB,EACtB,MAAM,SACP;EACF;AAED,QAAO"}
+{"version":3,"file":"shell.cjs","names":["z"],"sources":["../../src/tools/shell.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { tool, type DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * Re-export action type from OpenAI SDK for convenience.\n * The action contains command details like commands array, timeout, and max output length.\n */\nexport type ShellAction =\n  OpenAIClient.Responses.ResponseFunctionShellToolCall.Action;\n\n// Zod schema for shell action\nexport const ShellActionSchema = z.object({\n  commands: z.array(z.string()).describe(\"Array of shell commands to execute\"),\n  timeout_ms: z\n    .number()\n    .optional()\n    .describe(\"Optional timeout in milliseconds for the commands\"),\n  max_output_length: z\n    .number()\n    .optional()\n    .describe(\n      \"Optional maximum number of characters to return from each command\"\n    ),\n});\n\n/**\n * Result of a single shell command execution.\n * Contains stdout, stderr, and the outcome (exit code or timeout).\n */\nexport type ShellCommandOutput =\n  OpenAIClient.Responses.ResponseFunctionShellCallOutputContent;\n\n/**\n * Outcome type for shell command execution - either exit with code or timeout.\n */\nexport type ShellCallOutcome = ShellCommandOutput[\"outcome\"];\n\n/**\n * Result of executing shell commands.\n * Contains an array of outputs (one per command) and the max_output_length parameter.\n */\nexport interface ShellResult {\n  /**\n   * Array of command outputs. Each entry corresponds to a command from the action.\n   * The order should match the order of commands in the action.\n   */\n  output: ShellCommandOutput[];\n  /**\n   * The max_output_length from the action, which must be passed back to the API.\n   * If not provided in the action, can be omitted.\n   */\n  maxOutputLength?: number | null;\n}\n\n/**\n * Options for the Shell tool.\n */\nexport interface ShellOptions {\n  /**\n   * Execute function that handles shell command execution.\n   * This function receives the action input containing the commands and limits,\n   * and should return a ShellResult with stdout, stderr, and outcome for each command.\n   *\n   * @example\n   * ```typescript\n   * execute: async (action) => {\n   *   const outputs = await Promise.all(\n   *     action.commands.map(async (cmd) => {\n   *       try {\n   *         const { stdout, stderr } = await exec(cmd, {\n   *           timeout: action.timeout_ms ?? undefined,\n   *         });\n   *         return {\n   *           stdout,\n   *           stderr,\n   *           outcome: { type: \"exit\" as const, exit_code: 0 },\n   *         };\n   *       } catch (error) {\n   *         const timedOut = error.killed && error.signal === \"SIGTERM\";\n   *         return {\n   *           stdout: error.stdout ?? \"\",\n   *           stderr: error.stderr ?? String(error),\n   *           outcome: timedOut\n   *             ? { type: \"timeout\" as const }\n   *             : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n   *         };\n   *       }\n   *     })\n   *   );\n   *   return {\n   *     output: outputs,\n   *     maxOutputLength: action.max_output_length,\n   *   };\n   * }\n   * ```\n   */\n  execute: (action: ShellAction) => ShellResult | Promise<ShellResult>;\n}\n\n/**\n * OpenAI Shell tool type for the Responses API.\n */\nexport type ShellTool = OpenAIClient.Responses.FunctionShellTool;\n\nconst TOOL_NAME = \"shell\";\n\n/**\n * Creates a Shell tool that allows models to run shell commands through your integration.\n *\n * The shell tool allows the model to interact with your local computer through a controlled\n * command-line interface. The model proposes shell commands; your integration executes them\n * and returns the outputs. This creates a simple plan-execute loop that lets models inspect\n * the system, run utilities, and gather data until they can finish the task.\n *\n * **Important**: The shell tool is available through the Responses API for use with `GPT-5.1`.\n * It is not available on other models, or via the Chat Completions API.\n *\n * **When to use**:\n * - **Automating filesystem or process diagnostics** – For example, \"find the largest PDF\n *   under ~/Documents\" or \"show running gunicorn processes.\"\n * - **Extending the model's capabilities** – Using built-in UNIX utilities, python runtime\n *   and other CLIs in your environment.\n * - **Running multi-step build and test flows** – Chaining commands like `pip install` and `pytest`.\n * - **Complex agentic coding workflows** – Using other tools like `apply_patch` to complete\n *   workflows that involve complex file operations.\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends shell commands (`shell_call` with `commands` array)\n * 2. Your code executes the commands (can be concurrent)\n * 3. You return stdout, stderr, and outcome for each command\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Running arbitrary shell commands can be dangerous.\n * Always sandbox execution or add strict allow/deny-lists before forwarding\n * a command to the system shell.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-shell | OpenAI Shell Documentation}\n * @see {@link https://github.com/openai/codex | Codex CLI} for reference implementation.\n *\n * @param options - Configuration for the Shell tool\n * @returns A Shell tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { exec } from \"child_process/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic command handling\n * const shellTool = tools.shell({\n *   execute: async (action) => {\n *     const outputs = await Promise.all(\n *       action.commands.map(async (cmd) => {\n *         try {\n *           const { stdout, stderr } = await exec(cmd, {\n *             timeout: action.timeout_ms ?? undefined,\n *           });\n *           return {\n *             stdout,\n *             stderr,\n *             outcome: { type: \"exit\" as const, exit_code: 0 },\n *           };\n *         } catch (error) {\n *           const timedOut = error.killed && error.signal === \"SIGTERM\";\n *           return {\n *             stdout: error.stdout ?? \"\",\n *             stderr: error.stderr ?? String(error),\n *             outcome: timedOut\n *               ? { type: \"timeout\" as const }\n *               : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n *           };\n *         }\n *       })\n *     );\n *     return {\n *       output: outputs,\n *       maxOutputLength: action.max_output_length,\n *     };\n *   },\n * });\n *\n * const llmWithShell = model.bindTools([shellTool]);\n * const response = await llmWithShell.invoke(\n *   \"Find the largest PDF file in ~/Documents\"\n * );\n * ```\n *\n * @example\n * ```typescript\n * // Full shell loop example\n * async function shellLoop(model, task) {\n *   let response = await model.invoke(task, {\n *     tools: [tools.shell({ execute: myExecutor })],\n *   });\n *\n *   while (true) {\n *     const shellCall = response.additional_kwargs.tool_outputs?.find(\n *       (output) => output.type === \"shell_call\"\n *     );\n *\n *     if (!shellCall) break;\n *\n *     // Execute commands (with proper sandboxing!)\n *     const result = await executeCommands(shellCall.action);\n *\n *     // Send output back to model\n *     response = await model.invoke([\n *       response,\n *       {\n *         type: \"shell_call_output\",\n *         call_id: shellCall.call_id,\n *         output: result.output,\n *         max_output_length: result.maxOutputLength,\n *       },\n *     ], {\n *       tools: [tools.shell({ execute: myExecutor })],\n *     });\n *   }\n *\n *   return response;\n * }\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Commands are provided as an array of strings that can be executed concurrently\n * - Action includes: `commands`, `timeout_ms`, `max_output_length`\n * - Always sandbox or validate commands before execution\n * - The `timeout_ms` from the model is only a hint—enforce your own limits\n * - If `max_output_length` exists in the action, always pass it back in the output\n * - Many CLI tools return non-zero exit codes for warnings; still capture stdout/stderr\n */\nexport function shell(options: ShellOptions) {\n  // Wrapper that converts ShellResult to string for LangChain tool compatibility\n  const executeWrapper = async (action: ShellAction): Promise<string> => {\n    const result = await options.execute(action);\n    // Return a JSON string representation for the tool result\n    return JSON.stringify({\n      output: result.output,\n      max_output_length: result.maxOutputLength,\n    });\n  };\n\n  const shellTool = tool(executeWrapper, {\n    name: TOOL_NAME,\n    description:\n      \"Execute shell commands in a managed environment. Commands can be run concurrently.\",\n    schema: ShellActionSchema,\n  });\n\n  shellTool.extras = {\n    ...(shellTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"shell\",\n    } satisfies ShellTool,\n  };\n\n  return shellTool as DynamicStructuredTool<\n    typeof ShellActionSchema,\n    ShellAction,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;AAYA,MAAa,oBAAoBA,OAAAA,EAAE,OAAO;CACxC,UAAUA,OAAAA,EAAE,MAAMA,OAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,qCAAqC;CAC5E,YAAYA,OAAAA,EACT,QAAQ,CACR,UAAU,CACV,SAAS,oDAAoD;CAChE,mBAAmBA,OAAAA,EAChB,QAAQ,CACR,UAAU,CACV,SACC,oEACD;CACJ,CAAC;AAiFF,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIlB,SAAgB,MAAM,SAAuB;CAE3C,MAAM,iBAAiB,OAAO,WAAyC;EACrE,MAAM,SAAS,MAAM,QAAQ,QAAQ,OAAO;AAE5C,SAAO,KAAK,UAAU;GACpB,QAAQ,OAAO;GACf,mBAAmB,OAAO;GAC3B,CAAC;;CAGJ,MAAM,aAAA,GAAA,sBAAA,MAAiB,gBAAgB;EACrC,MAAM;EACN,aACE;EACF,QAAQ;EACT,CAAC;AAEF,WAAU,SAAS;EACjB,GAAI,UAAU,UAAU,EAAE;EAC1B,wBAAwB,EACtB,MAAM,SACP;EACF;AAED,QAAO"}

package/dist/tools/shell.d.cts

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAI$1 } from "openai";
+import { OpenAI } from "openai";
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { z } from "zod/v4";
 
@@ -7,12 +7,12 @@ import { z } from "zod/v4";
  * Re-export action type from OpenAI SDK for convenience.
  * The action contains command details like commands array, timeout, and max output length.
  */
-type ShellAction = OpenAI$1.Responses.ResponseFunctionShellToolCall.Action;
+type ShellAction = OpenAI.Responses.ResponseFunctionShellToolCall.Action;
 /**
  * Result of a single shell command execution.
  * Contains stdout, stderr, and the outcome (exit code or timeout).
  */
-type ShellCommandOutput = OpenAI$1.Responses.ResponseFunctionShellCallOutputContent;
+type ShellCommandOutput = OpenAI.Responses.ResponseFunctionShellCallOutputContent;
 /**
  * Outcome type for shell command execution - either exit with code or timeout.
  */
@@ -80,7 +80,7 @@ interface ShellOptions {
 /**
  * OpenAI Shell tool type for the Responses API.
  */
-type ShellTool = OpenAI$1.Responses.FunctionShellTool;
+type ShellTool = OpenAI.Responses.FunctionShellTool;
 /**
  * Creates a Shell tool that allows models to run shell commands through your integration.
  *
@@ -214,7 +214,7 @@ declare function shell(options: ShellOptions): DynamicStructuredTool<z.ZodObject
   commands: z.ZodArray<z.ZodString>;
   timeout_ms: z.ZodOptional<z.ZodNumber>;
   max_output_length: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, OpenAI$1.Responses.ResponseFunctionShellToolCall.Action, unknown, string, unknown, string>;
+}, z.core.$strip>, OpenAI.Responses.ResponseFunctionShellToolCall.Action, unknown, string, unknown, string>;
 //#endregion
 export { ShellAction, ShellCallOutcome, ShellCommandOutput, ShellOptions, ShellResult, ShellTool, shell };
 //# sourceMappingURL=shell.d.cts.map

package/dist/tools/shell.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"shell.d.cts","names":[],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;AAQA;;KAAY,WAAA,GACV,QAAA,CAAa,SAAA,CAAU,6BAAA,CAA8B,MAAA;;;AAqBvD;;KAAY,kBAAA,GACV,QAAA,CAAa,SAAA,CAAU,sCAAA;;;;KAKb,gBAAA,GAAmB,kBAAA;;;AAA/B;;UAMiB,WAAA;EANc;;AAM/B;;EAKE,MAAA,EAAQ,kBAAA;EAAkB;;;;EAK1B,eAAA;AAAA;AAMF;;;AAAA,UAAiB,YAAA;EAuCmB;;;;;;;;;;;;;AAMpC;;;;;;;;;AAqIA;;;;;;;;;;;;;;;;EA3IE,OAAA,GAAU,MAAA,EAAQ,WAAA,KAAgB,WAAA,GAAc,OAAA,CAAQ,WAAA;AAAA;;;;KAM9C,SAAA,GAAY,QAAA,CAAa,SAAA,CAAU,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqI/B,KAAA,CAAM,OAAA,EAAS,YAAA,GAAY,qBAAA,CAAA,CAAA,CAAA,SAAA"}
+{"version":3,"file":"shell.d.cts","names":[],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;AAQA;;KAAY,WAAA,GACV,MAAA,CAAa,SAAA,CAAU,6BAAA,CAA8B,MAAA;;;AAqBvD;;KAAY,kBAAA,GACV,MAAA,CAAa,SAAA,CAAU,sCAAA;;;;KAKb,gBAAA,GAAmB,kBAAA;;;AAA/B;;UAMiB,WAAA;EANc;;AAM/B;;EAKE,MAAA,EAAQ,kBAAA;EAAkB;;;;EAK1B,eAAA;AAAA;AAMF;;;AAAA,UAAiB,YAAA;EAuCmB;;;;;;;;;;;;;AAMpC;;;;;;;;;AAqIA;;;;;;;;;;;;;;;;EA3IE,OAAA,GAAU,MAAA,EAAQ,WAAA,KAAgB,WAAA,GAAc,OAAA,CAAQ,WAAA;AAAA;;;;KAM9C,SAAA,GAAY,MAAA,CAAa,SAAA,CAAU,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqI/B,KAAA,CAAM,OAAA,EAAS,YAAA,GAAY,qBAAA,CAAA,CAAA,CAAA,SAAA"}

package/dist/tools/shell.d.ts

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAI$1 } from "openai";
+import { OpenAI } from "openai";
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { z } from "zod/v4";
 
@@ -7,12 +7,12 @@ import { z } from "zod/v4";
  * Re-export action type from OpenAI SDK for convenience.
  * The action contains command details like commands array, timeout, and max output length.
  */
-type ShellAction = OpenAI$1.Responses.ResponseFunctionShellToolCall.Action;
+type ShellAction = OpenAI.Responses.ResponseFunctionShellToolCall.Action;
 /**
  * Result of a single shell command execution.
  * Contains stdout, stderr, and the outcome (exit code or timeout).
  */
-type ShellCommandOutput = OpenAI$1.Responses.ResponseFunctionShellCallOutputContent;
+type ShellCommandOutput = OpenAI.Responses.ResponseFunctionShellCallOutputContent;
 /**
  * Outcome type for shell command execution - either exit with code or timeout.
  */
@@ -80,7 +80,7 @@ interface ShellOptions {
 /**
  * OpenAI Shell tool type for the Responses API.
  */
-type ShellTool = OpenAI$1.Responses.FunctionShellTool;
+type ShellTool = OpenAI.Responses.FunctionShellTool;
 /**
  * Creates a Shell tool that allows models to run shell commands through your integration.
  *
@@ -214,7 +214,7 @@ declare function shell(options: ShellOptions): DynamicStructuredTool<z.ZodObject
   commands: z.ZodArray<z.ZodString>;
   timeout_ms: z.ZodOptional<z.ZodNumber>;
   max_output_length: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, OpenAI$1.Responses.ResponseFunctionShellToolCall.Action, unknown, string, unknown, string>;
+}, z.core.$strip>, OpenAI.Responses.ResponseFunctionShellToolCall.Action, unknown, string, unknown, string>;
 //#endregion
 export { ShellAction, ShellCallOutcome, ShellCommandOutput, ShellOptions, ShellResult, ShellTool, shell };
 //# sourceMappingURL=shell.d.ts.map

package/dist/tools/shell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shell.d.ts","names":[],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;AAQA;;KAAY,WAAA,GACV,QAAA,CAAa,SAAA,CAAU,6BAAA,CAA8B,MAAA;;;AAqBvD;;KAAY,kBAAA,GACV,QAAA,CAAa,SAAA,CAAU,sCAAA;;;;KAKb,gBAAA,GAAmB,kBAAA;;;AAA/B;;UAMiB,WAAA;EANc;;AAM/B;;EAKE,MAAA,EAAQ,kBAAA;EAAkB;;;;EAK1B,eAAA;AAAA;AAMF;;;AAAA,UAAiB,YAAA;EAuCmB;;;;;;;;;;;;;AAMpC;;;;;;;;;AAqIA;;;;;;;;;;;;;;;;EA3IE,OAAA,GAAU,MAAA,EAAQ,WAAA,KAAgB,WAAA,GAAc,OAAA,CAAQ,WAAA;AAAA;;;;KAM9C,SAAA,GAAY,QAAA,CAAa,SAAA,CAAU,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqI/B,KAAA,CAAM,OAAA,EAAS,YAAA,GAAY,qBAAA,CAAA,CAAA,CAAA,SAAA"}
+{"version":3,"file":"shell.d.ts","names":[],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;AAQA;;KAAY,WAAA,GACV,MAAA,CAAa,SAAA,CAAU,6BAAA,CAA8B,MAAA;;;AAqBvD;;KAAY,kBAAA,GACV,MAAA,CAAa,SAAA,CAAU,sCAAA;;;;KAKb,gBAAA,GAAmB,kBAAA;;;AAA/B;;UAMiB,WAAA;EANc;;AAM/B;;EAKE,MAAA,EAAQ,kBAAA;EAAkB;;;;EAK1B,eAAA;AAAA;AAMF;;;AAAA,UAAiB,YAAA;EAuCmB;;;;;;;;;;;;;AAMpC;;;;;;;;;AAqIA;;;;;;;;;;;;;;;;EA3IE,OAAA,GAAU,MAAA,EAAQ,WAAA,KAAgB,WAAA,GAAc,OAAA,CAAQ,WAAA;AAAA;;;;KAM9C,SAAA,GAAY,MAAA,CAAa,SAAA,CAAU,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqI/B,KAAA,CAAM,OAAA,EAAS,YAAA,GAAY,qBAAA,CAAA,CAAA,CAAA,SAAA"}

package/dist/tools/shell.js

@@ -1,6 +1,5 @@
 import { tool } from "@langchain/core/tools";
 import { z } from "zod/v4";
-
 //#region src/tools/shell.ts
 const ShellActionSchema = z.object({
 	commands: z.array(z.string()).describe("Array of shell commands to execute"),
@@ -156,7 +155,7 @@ function shell(options) {
 	};
 	return shellTool;
 }
-
 //#endregion
 export { shell };
+
 //# sourceMappingURL=shell.js.map

package/dist/tools/shell.js.map

@@ -1 +1 @@
-{"version":3,"file":"shell.js","names":[],"sources":["../../src/tools/shell.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { tool, type DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * Re-export action type from OpenAI SDK for convenience.\n * The action contains command details like commands array, timeout, and max output length.\n */\nexport type ShellAction =\n  OpenAIClient.Responses.ResponseFunctionShellToolCall.Action;\n\n// Zod schema for shell action\nexport const ShellActionSchema = z.object({\n  commands: z.array(z.string()).describe(\"Array of shell commands to execute\"),\n  timeout_ms: z\n    .number()\n    .optional()\n    .describe(\"Optional timeout in milliseconds for the commands\"),\n  max_output_length: z\n    .number()\n    .optional()\n    .describe(\n      \"Optional maximum number of characters to return from each command\"\n    ),\n});\n\n/**\n * Result of a single shell command execution.\n * Contains stdout, stderr, and the outcome (exit code or timeout).\n */\nexport type ShellCommandOutput =\n  OpenAIClient.Responses.ResponseFunctionShellCallOutputContent;\n\n/**\n * Outcome type for shell command execution - either exit with code or timeout.\n */\nexport type ShellCallOutcome = ShellCommandOutput[\"outcome\"];\n\n/**\n * Result of executing shell commands.\n * Contains an array of outputs (one per command) and the max_output_length parameter.\n */\nexport interface ShellResult {\n  /**\n   * Array of command outputs. Each entry corresponds to a command from the action.\n   * The order should match the order of commands in the action.\n   */\n  output: ShellCommandOutput[];\n  /**\n   * The max_output_length from the action, which must be passed back to the API.\n   * If not provided in the action, can be omitted.\n   */\n  maxOutputLength?: number | null;\n}\n\n/**\n * Options for the Shell tool.\n */\nexport interface ShellOptions {\n  /**\n   * Execute function that handles shell command execution.\n   * This function receives the action input containing the commands and limits,\n   * and should return a ShellResult with stdout, stderr, and outcome for each command.\n   *\n   * @example\n   * ```typescript\n   * execute: async (action) => {\n   *   const outputs = await Promise.all(\n   *     action.commands.map(async (cmd) => {\n   *       try {\n   *         const { stdout, stderr } = await exec(cmd, {\n   *           timeout: action.timeout_ms ?? undefined,\n   *         });\n   *         return {\n   *           stdout,\n   *           stderr,\n   *           outcome: { type: \"exit\" as const, exit_code: 0 },\n   *         };\n   *       } catch (error) {\n   *         const timedOut = error.killed && error.signal === \"SIGTERM\";\n   *         return {\n   *           stdout: error.stdout ?? \"\",\n   *           stderr: error.stderr ?? String(error),\n   *           outcome: timedOut\n   *             ? { type: \"timeout\" as const }\n   *             : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n   *         };\n   *       }\n   *     })\n   *   );\n   *   return {\n   *     output: outputs,\n   *     maxOutputLength: action.max_output_length,\n   *   };\n   * }\n   * ```\n   */\n  execute: (action: ShellAction) => ShellResult | Promise<ShellResult>;\n}\n\n/**\n * OpenAI Shell tool type for the Responses API.\n */\nexport type ShellTool = OpenAIClient.Responses.FunctionShellTool;\n\nconst TOOL_NAME = \"shell\";\n\n/**\n * Creates a Shell tool that allows models to run shell commands through your integration.\n *\n * The shell tool allows the model to interact with your local computer through a controlled\n * command-line interface. The model proposes shell commands; your integration executes them\n * and returns the outputs. This creates a simple plan-execute loop that lets models inspect\n * the system, run utilities, and gather data until they can finish the task.\n *\n * **Important**: The shell tool is available through the Responses API for use with `GPT-5.1`.\n * It is not available on other models, or via the Chat Completions API.\n *\n * **When to use**:\n * - **Automating filesystem or process diagnostics** – For example, \"find the largest PDF\n *   under ~/Documents\" or \"show running gunicorn processes.\"\n * - **Extending the model's capabilities** – Using built-in UNIX utilities, python runtime\n *   and other CLIs in your environment.\n * - **Running multi-step build and test flows** – Chaining commands like `pip install` and `pytest`.\n * - **Complex agentic coding workflows** – Using other tools like `apply_patch` to complete\n *   workflows that involve complex file operations.\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends shell commands (`shell_call` with `commands` array)\n * 2. Your code executes the commands (can be concurrent)\n * 3. You return stdout, stderr, and outcome for each command\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Running arbitrary shell commands can be dangerous.\n * Always sandbox execution or add strict allow/deny-lists before forwarding\n * a command to the system shell.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-shell | OpenAI Shell Documentation}\n * @see {@link https://github.com/openai/codex | Codex CLI} for reference implementation.\n *\n * @param options - Configuration for the Shell tool\n * @returns A Shell tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { exec } from \"child_process/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic command handling\n * const shellTool = tools.shell({\n *   execute: async (action) => {\n *     const outputs = await Promise.all(\n *       action.commands.map(async (cmd) => {\n *         try {\n *           const { stdout, stderr } = await exec(cmd, {\n *             timeout: action.timeout_ms ?? undefined,\n *           });\n *           return {\n *             stdout,\n *             stderr,\n *             outcome: { type: \"exit\" as const, exit_code: 0 },\n *           };\n *         } catch (error) {\n *           const timedOut = error.killed && error.signal === \"SIGTERM\";\n *           return {\n *             stdout: error.stdout ?? \"\",\n *             stderr: error.stderr ?? String(error),\n *             outcome: timedOut\n *               ? { type: \"timeout\" as const }\n *               : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n *           };\n *         }\n *       })\n *     );\n *     return {\n *       output: outputs,\n *       maxOutputLength: action.max_output_length,\n *     };\n *   },\n * });\n *\n * const llmWithShell = model.bindTools([shellTool]);\n * const response = await llmWithShell.invoke(\n *   \"Find the largest PDF file in ~/Documents\"\n * );\n * ```\n *\n * @example\n * ```typescript\n * // Full shell loop example\n * async function shellLoop(model, task) {\n *   let response = await model.invoke(task, {\n *     tools: [tools.shell({ execute: myExecutor })],\n *   });\n *\n *   while (true) {\n *     const shellCall = response.additional_kwargs.tool_outputs?.find(\n *       (output) => output.type === \"shell_call\"\n *     );\n *\n *     if (!shellCall) break;\n *\n *     // Execute commands (with proper sandboxing!)\n *     const result = await executeCommands(shellCall.action);\n *\n *     // Send output back to model\n *     response = await model.invoke([\n *       response,\n *       {\n *         type: \"shell_call_output\",\n *         call_id: shellCall.call_id,\n *         output: result.output,\n *         max_output_length: result.maxOutputLength,\n *       },\n *     ], {\n *       tools: [tools.shell({ execute: myExecutor })],\n *     });\n *   }\n *\n *   return response;\n * }\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Commands are provided as an array of strings that can be executed concurrently\n * - Action includes: `commands`, `timeout_ms`, `max_output_length`\n * - Always sandbox or validate commands before execution\n * - The `timeout_ms` from the model is only a hint—enforce your own limits\n * - If `max_output_length` exists in the action, always pass it back in the output\n * - Many CLI tools return non-zero exit codes for warnings; still capture stdout/stderr\n */\nexport function shell(options: ShellOptions) {\n  // Wrapper that converts ShellResult to string for LangChain tool compatibility\n  const executeWrapper = async (action: ShellAction): Promise<string> => {\n    const result = await options.execute(action);\n    // Return a JSON string representation for the tool result\n    return JSON.stringify({\n      output: result.output,\n      max_output_length: result.maxOutputLength,\n    });\n  };\n\n  const shellTool = tool(executeWrapper, {\n    name: TOOL_NAME,\n    description:\n      \"Execute shell commands in a managed environment. Commands can be run concurrently.\",\n    schema: ShellActionSchema,\n  });\n\n  shellTool.extras = {\n    ...(shellTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"shell\",\n    } satisfies ShellTool,\n  };\n\n  return shellTool as DynamicStructuredTool<\n    typeof ShellActionSchema,\n    ShellAction,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;;AAYA,MAAa,oBAAoB,EAAE,OAAO;CACxC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS,qCAAqC;CAC5E,YAAY,EACT,QAAQ,CACR,UAAU,CACV,SAAS,oDAAoD;CAChE,mBAAmB,EAChB,QAAQ,CACR,UAAU,CACV,SACC,oEACD;CACJ,CAAC;AAiFF,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIlB,SAAgB,MAAM,SAAuB;CAE3C,MAAM,iBAAiB,OAAO,WAAyC;EACrE,MAAM,SAAS,MAAM,QAAQ,QAAQ,OAAO;AAE5C,SAAO,KAAK,UAAU;GACpB,QAAQ,OAAO;GACf,mBAAmB,OAAO;GAC3B,CAAC;;CAGJ,MAAM,YAAY,KAAK,gBAAgB;EACrC,MAAM;EACN,aACE;EACF,QAAQ;EACT,CAAC;AAEF,WAAU,SAAS;EACjB,GAAI,UAAU,UAAU,EAAE;EAC1B,wBAAwB,EACtB,MAAM,SACP;EACF;AAED,QAAO"}
+{"version":3,"file":"shell.js","names":[],"sources":["../../src/tools/shell.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { tool, type DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * Re-export action type from OpenAI SDK for convenience.\n * The action contains command details like commands array, timeout, and max output length.\n */\nexport type ShellAction =\n  OpenAIClient.Responses.ResponseFunctionShellToolCall.Action;\n\n// Zod schema for shell action\nexport const ShellActionSchema = z.object({\n  commands: z.array(z.string()).describe(\"Array of shell commands to execute\"),\n  timeout_ms: z\n    .number()\n    .optional()\n    .describe(\"Optional timeout in milliseconds for the commands\"),\n  max_output_length: z\n    .number()\n    .optional()\n    .describe(\n      \"Optional maximum number of characters to return from each command\"\n    ),\n});\n\n/**\n * Result of a single shell command execution.\n * Contains stdout, stderr, and the outcome (exit code or timeout).\n */\nexport type ShellCommandOutput =\n  OpenAIClient.Responses.ResponseFunctionShellCallOutputContent;\n\n/**\n * Outcome type for shell command execution - either exit with code or timeout.\n */\nexport type ShellCallOutcome = ShellCommandOutput[\"outcome\"];\n\n/**\n * Result of executing shell commands.\n * Contains an array of outputs (one per command) and the max_output_length parameter.\n */\nexport interface ShellResult {\n  /**\n   * Array of command outputs. Each entry corresponds to a command from the action.\n   * The order should match the order of commands in the action.\n   */\n  output: ShellCommandOutput[];\n  /**\n   * The max_output_length from the action, which must be passed back to the API.\n   * If not provided in the action, can be omitted.\n   */\n  maxOutputLength?: number | null;\n}\n\n/**\n * Options for the Shell tool.\n */\nexport interface ShellOptions {\n  /**\n   * Execute function that handles shell command execution.\n   * This function receives the action input containing the commands and limits,\n   * and should return a ShellResult with stdout, stderr, and outcome for each command.\n   *\n   * @example\n   * ```typescript\n   * execute: async (action) => {\n   *   const outputs = await Promise.all(\n   *     action.commands.map(async (cmd) => {\n   *       try {\n   *         const { stdout, stderr } = await exec(cmd, {\n   *           timeout: action.timeout_ms ?? undefined,\n   *         });\n   *         return {\n   *           stdout,\n   *           stderr,\n   *           outcome: { type: \"exit\" as const, exit_code: 0 },\n   *         };\n   *       } catch (error) {\n   *         const timedOut = error.killed && error.signal === \"SIGTERM\";\n   *         return {\n   *           stdout: error.stdout ?? \"\",\n   *           stderr: error.stderr ?? String(error),\n   *           outcome: timedOut\n   *             ? { type: \"timeout\" as const }\n   *             : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n   *         };\n   *       }\n   *     })\n   *   );\n   *   return {\n   *     output: outputs,\n   *     maxOutputLength: action.max_output_length,\n   *   };\n   * }\n   * ```\n   */\n  execute: (action: ShellAction) => ShellResult | Promise<ShellResult>;\n}\n\n/**\n * OpenAI Shell tool type for the Responses API.\n */\nexport type ShellTool = OpenAIClient.Responses.FunctionShellTool;\n\nconst TOOL_NAME = \"shell\";\n\n/**\n * Creates a Shell tool that allows models to run shell commands through your integration.\n *\n * The shell tool allows the model to interact with your local computer through a controlled\n * command-line interface. The model proposes shell commands; your integration executes them\n * and returns the outputs. This creates a simple plan-execute loop that lets models inspect\n * the system, run utilities, and gather data until they can finish the task.\n *\n * **Important**: The shell tool is available through the Responses API for use with `GPT-5.1`.\n * It is not available on other models, or via the Chat Completions API.\n *\n * **When to use**:\n * - **Automating filesystem or process diagnostics** – For example, \"find the largest PDF\n *   under ~/Documents\" or \"show running gunicorn processes.\"\n * - **Extending the model's capabilities** – Using built-in UNIX utilities, python runtime\n *   and other CLIs in your environment.\n * - **Running multi-step build and test flows** – Chaining commands like `pip install` and `pytest`.\n * - **Complex agentic coding workflows** – Using other tools like `apply_patch` to complete\n *   workflows that involve complex file operations.\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends shell commands (`shell_call` with `commands` array)\n * 2. Your code executes the commands (can be concurrent)\n * 3. You return stdout, stderr, and outcome for each command\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Running arbitrary shell commands can be dangerous.\n * Always sandbox execution or add strict allow/deny-lists before forwarding\n * a command to the system shell.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-shell | OpenAI Shell Documentation}\n * @see {@link https://github.com/openai/codex | Codex CLI} for reference implementation.\n *\n * @param options - Configuration for the Shell tool\n * @returns A Shell tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { exec } from \"child_process/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic command handling\n * const shellTool = tools.shell({\n *   execute: async (action) => {\n *     const outputs = await Promise.all(\n *       action.commands.map(async (cmd) => {\n *         try {\n *           const { stdout, stderr } = await exec(cmd, {\n *             timeout: action.timeout_ms ?? undefined,\n *           });\n *           return {\n *             stdout,\n *             stderr,\n *             outcome: { type: \"exit\" as const, exit_code: 0 },\n *           };\n *         } catch (error) {\n *           const timedOut = error.killed && error.signal === \"SIGTERM\";\n *           return {\n *             stdout: error.stdout ?? \"\",\n *             stderr: error.stderr ?? String(error),\n *             outcome: timedOut\n *               ? { type: \"timeout\" as const }\n *               : { type: \"exit\" as const, exit_code: error.code ?? 1 },\n *           };\n *         }\n *       })\n *     );\n *     return {\n *       output: outputs,\n *       maxOutputLength: action.max_output_length,\n *     };\n *   },\n * });\n *\n * const llmWithShell = model.bindTools([shellTool]);\n * const response = await llmWithShell.invoke(\n *   \"Find the largest PDF file in ~/Documents\"\n * );\n * ```\n *\n * @example\n * ```typescript\n * // Full shell loop example\n * async function shellLoop(model, task) {\n *   let response = await model.invoke(task, {\n *     tools: [tools.shell({ execute: myExecutor })],\n *   });\n *\n *   while (true) {\n *     const shellCall = response.additional_kwargs.tool_outputs?.find(\n *       (output) => output.type === \"shell_call\"\n *     );\n *\n *     if (!shellCall) break;\n *\n *     // Execute commands (with proper sandboxing!)\n *     const result = await executeCommands(shellCall.action);\n *\n *     // Send output back to model\n *     response = await model.invoke([\n *       response,\n *       {\n *         type: \"shell_call_output\",\n *         call_id: shellCall.call_id,\n *         output: result.output,\n *         max_output_length: result.maxOutputLength,\n *       },\n *     ], {\n *       tools: [tools.shell({ execute: myExecutor })],\n *     });\n *   }\n *\n *   return response;\n * }\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Commands are provided as an array of strings that can be executed concurrently\n * - Action includes: `commands`, `timeout_ms`, `max_output_length`\n * - Always sandbox or validate commands before execution\n * - The `timeout_ms` from the model is only a hint—enforce your own limits\n * - If `max_output_length` exists in the action, always pass it back in the output\n * - Many CLI tools return non-zero exit codes for warnings; still capture stdout/stderr\n */\nexport function shell(options: ShellOptions) {\n  // Wrapper that converts ShellResult to string for LangChain tool compatibility\n  const executeWrapper = async (action: ShellAction): Promise<string> => {\n    const result = await options.execute(action);\n    // Return a JSON string representation for the tool result\n    return JSON.stringify({\n      output: result.output,\n      max_output_length: result.maxOutputLength,\n    });\n  };\n\n  const shellTool = tool(executeWrapper, {\n    name: TOOL_NAME,\n    description:\n      \"Execute shell commands in a managed environment. Commands can be run concurrently.\",\n    schema: ShellActionSchema,\n  });\n\n  shellTool.extras = {\n    ...(shellTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"shell\",\n    } satisfies ShellTool,\n  };\n\n  return shellTool as DynamicStructuredTool<\n    typeof ShellActionSchema,\n    ShellAction,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;AAYA,MAAa,oBAAoB,EAAE,OAAO;CACxC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS,qCAAqC;CAC5E,YAAY,EACT,QAAQ,CACR,UAAU,CACV,SAAS,oDAAoD;CAChE,mBAAmB,EAChB,QAAQ,CACR,UAAU,CACV,SACC,oEACD;CACJ,CAAC;AAiFF,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIlB,SAAgB,MAAM,SAAuB;CAE3C,MAAM,iBAAiB,OAAO,WAAyC;EACrE,MAAM,SAAS,MAAM,QAAQ,QAAQ,OAAO;AAE5C,SAAO,KAAK,UAAU;GACpB,QAAQ,OAAO;GACf,mBAAmB,OAAO;GAC3B,CAAC;;CAGJ,MAAM,YAAY,KAAK,gBAAgB;EACrC,MAAM;EACN,aACE;EACF,QAAQ;EACT,CAAC;AAEF,WAAU,SAAS;EACjB,GAAI,UAAU,UAAU,EAAE;EAC1B,wBAAwB,EACtB,MAAM,SACP;EACF;AAED,QAAO"}

package/dist/tools/toolSearch.cjs

@@ -0,0 +1,67 @@
+//#region src/tools/toolSearch.ts
+/**
+* Creates a tool search tool that enables OpenAI models to dynamically discover
+* and load tools on-demand from a large pool, rather than requiring all tool
+* definitions to be sent in every request.
+*
+* Tool search works with tools that have `defer_loading: true` set (either
+* directly in the tool definition or via `extras: { defer_loading: true }` on
+* LangChain tools). When the model needs a deferred tool, it issues a tool
+* search call, discovers matching tools, and then makes the actual function call.
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-tool-search | OpenAI Tool Search Documentation}
+* @param options - Configuration options for the tool search tool
+* @returns A tool search tool definition to be passed to the OpenAI Responses API
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+*
+* const model = new ChatOpenAI({ model: "gpt-5.3" });
+*
+* const getWeather = tool(
+*   async (input) => `Weather in ${input.location}: sunny, 72°F`,
+*   {
+*     name: "get_weather",
+*     description: "Get the current weather for a location",
+*     schema: z.object({ location: z.string() }),
+*     extras: { defer_loading: true },
+*   }
+* );
+*
+* // Server-executed tool search (default)
+* const response = await model.invoke("What is the weather in SF?", {
+*   tools: [tools.toolSearch(), getWeather],
+* });
+*
+* // Client-executed tool search
+* const clientResponse = await model.invoke("What is the weather in SF?", {
+*   tools: [
+*     tools.toolSearch({
+*       execution: "client",
+*       description: "Search for available tools",
+*       parameters: {
+*         type: "object",
+*         properties: { goal: { type: "string" } },
+*         required: ["goal"],
+*       },
+*     }),
+*     getWeather,
+*   ],
+* });
+* ```
+*/
+function toolSearch(options) {
+	return {
+		type: "tool_search",
+		...options?.execution ? { execution: options.execution } : {},
+		...options?.description ? { description: options.description } : {},
+		...options?.parameters !== void 0 ? { parameters: options.parameters } : {}
+	};
+}
+//#endregion
+exports.toolSearch = toolSearch;
+
+//# sourceMappingURL=toolSearch.cjs.map

package/dist/tools/toolSearch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolSearch.cjs","names":[],"sources":["../../src/tools/toolSearch.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\nexport interface ToolSearchOptions {\n  /**\n   * Whether tool search is executed by the server or by the client.\n   * - `\"server\"` (default): OpenAI's servers handle the search internally.\n   * - `\"client\"`: The client provides results via agent middleware.\n   */\n  execution?: \"server\" | \"client\";\n  /**\n   * Description shown to the model for a client-executed tool search tool.\n   */\n  description?: string;\n  /**\n   * Parameter schema for a client-executed tool search tool.\n   */\n  parameters?: unknown;\n}\n\nexport type ToolSearchTool = OpenAIClient.Responses.ToolSearchTool;\n\n/**\n * Creates a tool search tool that enables OpenAI models to dynamically discover\n * and load tools on-demand from a large pool, rather than requiring all tool\n * definitions to be sent in every request.\n *\n * Tool search works with tools that have `defer_loading: true` set (either\n * directly in the tool definition or via `extras: { defer_loading: true }` on\n * LangChain tools). When the model needs a deferred tool, it issues a tool\n * search call, discovers matching tools, and then makes the actual function call.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-tool-search | OpenAI Tool Search Documentation}\n * @param options - Configuration options for the tool search tool\n * @returns A tool search tool definition to be passed to the OpenAI Responses API\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.3\" });\n *\n * const getWeather = tool(\n *   async (input) => `Weather in ${input.location}: sunny, 72°F`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the current weather for a location\",\n *     schema: z.object({ location: z.string() }),\n *     extras: { defer_loading: true },\n *   }\n * );\n *\n * // Server-executed tool search (default)\n * const response = await model.invoke(\"What is the weather in SF?\", {\n *   tools: [tools.toolSearch(), getWeather],\n * });\n *\n * // Client-executed tool search\n * const clientResponse = await model.invoke(\"What is the weather in SF?\", {\n *   tools: [\n *     tools.toolSearch({\n *       execution: \"client\",\n *       description: \"Search for available tools\",\n *       parameters: {\n *         type: \"object\",\n *         properties: { goal: { type: \"string\" } },\n *         required: [\"goal\"],\n *       },\n *     }),\n *     getWeather,\n *   ],\n * });\n * ```\n */\nexport function toolSearch(options?: ToolSearchOptions): ServerTool {\n  return {\n    type: \"tool_search\",\n    ...(options?.execution ? { execution: options.execution } : {}),\n    ...(options?.description ? { description: options.description } : {}),\n    ...(options?.parameters !== undefined\n      ? { parameters: options.parameters }\n      : {}),\n  } satisfies ToolSearchTool;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,SAAgB,WAAW,SAAyC;AAClE,QAAO;EACL,MAAM;EACN,GAAI,SAAS,YAAY,EAAE,WAAW,QAAQ,WAAW,GAAG,EAAE;EAC9D,GAAI,SAAS,cAAc,EAAE,aAAa,QAAQ,aAAa,GAAG,EAAE;EACpE,GAAI,SAAS,eAAe,KAAA,IACxB,EAAE,YAAY,QAAQ,YAAY,GAClC,EAAE;EACP"}

package/dist/tools/toolSearch.d.cts

@@ -0,0 +1,79 @@
+import { OpenAI } from "openai";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/toolSearch.d.ts
+interface ToolSearchOptions {
+  /**
+   * Whether tool search is executed by the server or by the client.
+   * - `"server"` (default): OpenAI's servers handle the search internally.
+   * - `"client"`: The client provides results via agent middleware.
+   */
+  execution?: "server" | "client";
+  /**
+   * Description shown to the model for a client-executed tool search tool.
+   */
+  description?: string;
+  /**
+   * Parameter schema for a client-executed tool search tool.
+   */
+  parameters?: unknown;
+}
+type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
+/**
+ * Creates a tool search tool that enables OpenAI models to dynamically discover
+ * and load tools on-demand from a large pool, rather than requiring all tool
+ * definitions to be sent in every request.
+ *
+ * Tool search works with tools that have `defer_loading: true` set (either
+ * directly in the tool definition or via `extras: { defer_loading: true }` on
+ * LangChain tools). When the model needs a deferred tool, it issues a tool
+ * search call, discovers matching tools, and then makes the actual function call.
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-tool-search | OpenAI Tool Search Documentation}
+ * @param options - Configuration options for the tool search tool
+ * @returns A tool search tool definition to be passed to the OpenAI Responses API
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-5.3" });
+ *
+ * const getWeather = tool(
+ *   async (input) => `Weather in ${input.location}: sunny, 72°F`,
+ *   {
+ *     name: "get_weather",
+ *     description: "Get the current weather for a location",
+ *     schema: z.object({ location: z.string() }),
+ *     extras: { defer_loading: true },
+ *   }
+ * );
+ *
+ * // Server-executed tool search (default)
+ * const response = await model.invoke("What is the weather in SF?", {
+ *   tools: [tools.toolSearch(), getWeather],
+ * });
+ *
+ * // Client-executed tool search
+ * const clientResponse = await model.invoke("What is the weather in SF?", {
+ *   tools: [
+ *     tools.toolSearch({
+ *       execution: "client",
+ *       description: "Search for available tools",
+ *       parameters: {
+ *         type: "object",
+ *         properties: { goal: { type: "string" } },
+ *         required: ["goal"],
+ *       },
+ *     }),
+ *     getWeather,
+ *   ],
+ * });
+ * ```
+ */
+declare function toolSearch(options?: ToolSearchOptions): ServerTool;
+//#endregion
+export { ToolSearchOptions, ToolSearchTool, toolSearch };
+//# sourceMappingURL=toolSearch.d.cts.map

package/dist/tools/toolSearch.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolSearch.d.cts","names":[],"sources":["../../src/tools/toolSearch.ts"],"mappings":";;;;UAGiB,iBAAA;;AAAjB;;;;EAME,SAAA;EAIA;;;EAAA,WAAA;EAOU;;;EAHV,UAAA;AAAA;AAAA,KAGU,cAAA,GAAiB,MAAA,CAAa,SAAA,CAAU,cAAA;;;;AAwDpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,UAAA,CAAW,OAAA,GAAU,iBAAA,GAAoB,UAAA"}

package/dist/tools/toolSearch.d.ts

@@ -0,0 +1,79 @@
+import { OpenAI } from "openai";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/toolSearch.d.ts
+interface ToolSearchOptions {
+  /**
+   * Whether tool search is executed by the server or by the client.
+   * - `"server"` (default): OpenAI's servers handle the search internally.
+   * - `"client"`: The client provides results via agent middleware.
+   */
+  execution?: "server" | "client";
+  /**
+   * Description shown to the model for a client-executed tool search tool.
+   */
+  description?: string;
+  /**
+   * Parameter schema for a client-executed tool search tool.
+   */
+  parameters?: unknown;
+}
+type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
+/**
+ * Creates a tool search tool that enables OpenAI models to dynamically discover
+ * and load tools on-demand from a large pool, rather than requiring all tool
+ * definitions to be sent in every request.
+ *
+ * Tool search works with tools that have `defer_loading: true` set (either
+ * directly in the tool definition or via `extras: { defer_loading: true }` on
+ * LangChain tools). When the model needs a deferred tool, it issues a tool
+ * search call, discovers matching tools, and then makes the actual function call.
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-tool-search | OpenAI Tool Search Documentation}
+ * @param options - Configuration options for the tool search tool
+ * @returns A tool search tool definition to be passed to the OpenAI Responses API
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-5.3" });
+ *
+ * const getWeather = tool(
+ *   async (input) => `Weather in ${input.location}: sunny, 72°F`,
+ *   {
+ *     name: "get_weather",
+ *     description: "Get the current weather for a location",
+ *     schema: z.object({ location: z.string() }),
+ *     extras: { defer_loading: true },
+ *   }
+ * );
+ *
+ * // Server-executed tool search (default)
+ * const response = await model.invoke("What is the weather in SF?", {
+ *   tools: [tools.toolSearch(), getWeather],
+ * });
+ *
+ * // Client-executed tool search
+ * const clientResponse = await model.invoke("What is the weather in SF?", {
+ *   tools: [
+ *     tools.toolSearch({
+ *       execution: "client",
+ *       description: "Search for available tools",
+ *       parameters: {
+ *         type: "object",
+ *         properties: { goal: { type: "string" } },
+ *         required: ["goal"],
+ *       },
+ *     }),
+ *     getWeather,
+ *   ],
+ * });
+ * ```
+ */
+declare function toolSearch(options?: ToolSearchOptions): ServerTool;
+//#endregion
+export { ToolSearchOptions, ToolSearchTool, toolSearch };
+//# sourceMappingURL=toolSearch.d.ts.map

package/dist/tools/toolSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolSearch.d.ts","names":[],"sources":["../../src/tools/toolSearch.ts"],"mappings":";;;;UAGiB,iBAAA;;AAAjB;;;;EAME,SAAA;EAIA;;;EAAA,WAAA;EAOU;;;EAHV,UAAA;AAAA;AAAA,KAGU,cAAA,GAAiB,MAAA,CAAa,SAAA,CAAU,cAAA;;;;AAwDpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,UAAA,CAAW,OAAA,GAAU,iBAAA,GAAoB,UAAA"}

package/dist/tools/toolSearch.js

@@ -0,0 +1,67 @@
+//#region src/tools/toolSearch.ts
+/**
+* Creates a tool search tool that enables OpenAI models to dynamically discover
+* and load tools on-demand from a large pool, rather than requiring all tool
+* definitions to be sent in every request.
+*
+* Tool search works with tools that have `defer_loading: true` set (either
+* directly in the tool definition or via `extras: { defer_loading: true }` on
+* LangChain tools). When the model needs a deferred tool, it issues a tool
+* search call, discovers matching tools, and then makes the actual function call.
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-tool-search | OpenAI Tool Search Documentation}
+* @param options - Configuration options for the tool search tool
+* @returns A tool search tool definition to be passed to the OpenAI Responses API
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+*
+* const model = new ChatOpenAI({ model: "gpt-5.3" });
+*
+* const getWeather = tool(
+*   async (input) => `Weather in ${input.location}: sunny, 72°F`,
+*   {
+*     name: "get_weather",
+*     description: "Get the current weather for a location",
+*     schema: z.object({ location: z.string() }),
+*     extras: { defer_loading: true },
+*   }
+* );
+*
+* // Server-executed tool search (default)
+* const response = await model.invoke("What is the weather in SF?", {
+*   tools: [tools.toolSearch(), getWeather],
+* });
+*
+* // Client-executed tool search
+* const clientResponse = await model.invoke("What is the weather in SF?", {
+*   tools: [
+*     tools.toolSearch({
+*       execution: "client",
+*       description: "Search for available tools",
+*       parameters: {
+*         type: "object",
+*         properties: { goal: { type: "string" } },
+*         required: ["goal"],
+*       },
+*     }),
+*     getWeather,
+*   ],
+* });
+* ```
+*/
+function toolSearch(options) {
+	return {
+		type: "tool_search",
+		...options?.execution ? { execution: options.execution } : {},
+		...options?.description ? { description: options.description } : {},
+		...options?.parameters !== void 0 ? { parameters: options.parameters } : {}
+	};
+}
+//#endregion
+export { toolSearch };
+
+//# sourceMappingURL=toolSearch.js.map

package/dist/tools/toolSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolSearch.js","names":[],"sources":["../../src/tools/toolSearch.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\nexport interface ToolSearchOptions {\n  /**\n   * Whether tool search is executed by the server or by the client.\n   * - `\"server\"` (default): OpenAI's servers handle the search internally.\n   * - `\"client\"`: The client provides results via agent middleware.\n   */\n  execution?: \"server\" | \"client\";\n  /**\n   * Description shown to the model for a client-executed tool search tool.\n   */\n  description?: string;\n  /**\n   * Parameter schema for a client-executed tool search tool.\n   */\n  parameters?: unknown;\n}\n\nexport type ToolSearchTool = OpenAIClient.Responses.ToolSearchTool;\n\n/**\n * Creates a tool search tool that enables OpenAI models to dynamically discover\n * and load tools on-demand from a large pool, rather than requiring all tool\n * definitions to be sent in every request.\n *\n * Tool search works with tools that have `defer_loading: true` set (either\n * directly in the tool definition or via `extras: { defer_loading: true }` on\n * LangChain tools). When the model needs a deferred tool, it issues a tool\n * search call, discovers matching tools, and then makes the actual function call.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-tool-search | OpenAI Tool Search Documentation}\n * @param options - Configuration options for the tool search tool\n * @returns A tool search tool definition to be passed to the OpenAI Responses API\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.3\" });\n *\n * const getWeather = tool(\n *   async (input) => `Weather in ${input.location}: sunny, 72°F`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the current weather for a location\",\n *     schema: z.object({ location: z.string() }),\n *     extras: { defer_loading: true },\n *   }\n * );\n *\n * // Server-executed tool search (default)\n * const response = await model.invoke(\"What is the weather in SF?\", {\n *   tools: [tools.toolSearch(), getWeather],\n * });\n *\n * // Client-executed tool search\n * const clientResponse = await model.invoke(\"What is the weather in SF?\", {\n *   tools: [\n *     tools.toolSearch({\n *       execution: \"client\",\n *       description: \"Search for available tools\",\n *       parameters: {\n *         type: \"object\",\n *         properties: { goal: { type: \"string\" } },\n *         required: [\"goal\"],\n *       },\n *     }),\n *     getWeather,\n *   ],\n * });\n * ```\n */\nexport function toolSearch(options?: ToolSearchOptions): ServerTool {\n  return {\n    type: \"tool_search\",\n    ...(options?.execution ? { execution: options.execution } : {}),\n    ...(options?.description ? { description: options.description } : {}),\n    ...(options?.parameters !== undefined\n      ? { parameters: options.parameters }\n      : {}),\n  } satisfies ToolSearchTool;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,SAAgB,WAAW,SAAyC;AAClE,QAAO;EACL,MAAM;EACN,GAAI,SAAS,YAAY,EAAE,WAAW,QAAQ,WAAW,GAAG,EAAE;EAC9D,GAAI,SAAS,cAAc,EAAE,aAAa,QAAQ,aAAa,GAAG,EAAE;EACpE,GAAI,SAAS,eAAe,KAAA,IACxB,EAAE,YAAY,QAAQ,YAAY,GAClC,EAAE;EACP"}

package/dist/tools/webSearch.cjs

@@ -1,4 +1,3 @@
-
 //#region src/tools/webSearch.ts
 /**
 * Creates a web search tool that allows OpenAI models to search the web
@@ -67,7 +66,7 @@ function webSearch(options) {
 		search_context_size: options?.search_context_size
 	};
 }
-
 //#endregion
 exports.webSearch = webSearch;
+
 //# sourceMappingURL=webSearch.cjs.map

package/dist/tools/webSearch.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"webSearch.cjs","names":[],"sources":["../../src/tools/webSearch.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\n/**\n * User location configuration for geographic search refinement.\n */\nexport interface WebSearchUserLocation {\n  /**\n   * The type of location. Currently only \"approximate\" is supported.\n   */\n  type: \"approximate\";\n  /**\n   * Two-letter ISO country code (e.g., \"US\", \"GB\").\n   * @see https://en.wikipedia.org/wiki/ISO_3166-1\n   */\n  country?: string;\n  /**\n   * City name (e.g., \"San Francisco\", \"London\").\n   */\n  city?: string;\n  /**\n   * Region or state name (e.g., \"California\", \"London\").\n   */\n  region?: string;\n  /**\n   * IANA timezone (e.g., \"America/Los_Angeles\", \"Europe/London\").\n   * @see https://timeapi.io/documentation/iana-timezones\n   */\n  timezone?: string;\n}\n\n/**\n * Domain filtering configuration for web search.\n */\nexport interface WebSearchFilters {\n  /**\n   * Allow-list of up to 100 domains to limit search results.\n   * Omit the HTTP/HTTPS prefix (e.g., \"openai.com\" instead of \"https://openai.com/\").\n   * Includes subdomains automatically.\n   */\n  allowedDomains?: string[];\n}\n\n/**\n * Options for the OpenAI web search tool.\n */\nexport interface WebSearchOptions {\n  /**\n   * Domain filtering configuration.\n   * Limit results to a specific set of up to 100 domains.\n   */\n  filters?: WebSearchFilters;\n  /**\n   * Approximate user location for geographic search refinement.\n   * Not supported for deep research models.\n   */\n  userLocation?: WebSearchUserLocation;\n  /**\n   * High level guidance for the amount of context window space to use for the\n   * search. One of `low`, `medium`, or `high`. `medium` is the default.\n   */\n  search_context_size?: \"low\" | \"medium\" | \"high\";\n}\n\n/**\n * OpenAI web search tool type for the Responses API.\n */\nexport type WebSearchTool = OpenAIClient.Responses.WebSearchTool;\n\n/**\n * Creates a web search tool that allows OpenAI models to search the web\n * for up-to-date information before generating a response.\n *\n * Web search supports three main types:\n * 1. **Non-reasoning web search**: Quick lookups where the model passes queries\n *    directly to the search tool.\n * 2. **Agentic search with reasoning models**: The model actively manages the\n *    search process, analyzing results and deciding whether to keep searching.\n * 3. **Deep research**: Extended investigations using models like `o3-deep-research`\n *    or `gpt-5` with high reasoning effort.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-web-search | OpenAI Web Search Documentation}\n * @param options - Configuration options for the web search tool\n * @returns A web search tool definition to be passed to the OpenAI Responses API\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n *\n * const model = new ChatOpenAI({\n *   model: \"gpt-4o\",\n * });\n *\n * // Basic usage\n * const response = await model.invoke(\"What was a positive news story from today?\", {\n *   tools: [tools.webSearch()],\n * });\n *\n * // With domain filtering\n * const filteredResponse = await model.invoke(\"Latest AI research news\", {\n *   tools: [tools.webSearch({\n *     filters: {\n *       allowedDomains: [\"arxiv.org\", \"nature.com\", \"science.org\"],\n *     },\n *   })],\n * });\n *\n * // With user location for geographic relevance\n * const localResponse = await model.invoke(\"What are the best restaurants near me?\", {\n *   tools: [tools.webSearch({\n *     userLocation: {\n *       type: \"approximate\",\n *       country: \"US\",\n *       city: \"San Francisco\",\n *       region: \"California\",\n *       timezone: \"America/Los_Angeles\",\n *     },\n *   })],\n * });\n *\n * // Cache-only mode (no live internet access)\n * const cachedResponse = await model.invoke(\"Find information about OpenAI\", {\n *   tools: [tools.webSearch({\n *     externalWebAccess: false,\n *   })],\n * });\n * ```\n */\nexport function webSearch(options?: WebSearchOptions): ServerTool {\n  return {\n    type: \"web_search\",\n    filters: options?.filters?.allowedDomains\n      ? { allowed_domains: options.filters.allowedDomains }\n      : undefined,\n    user_location: options?.userLocation,\n    search_context_size: options?.search_context_size,\n  } satisfies WebSearchTool;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgIA,SAAgB,UAAU,SAAwC;AAChE,QAAO;EACL,MAAM;EACN,SAAS,SAAS,SAAS,iBACvB,EAAE,iBAAiB,QAAQ,QAAQ,gBAAgB,GACnD;EACJ,eAAe,SAAS;EACxB,qBAAqB,SAAS;EAC/B"}
+{"version":3,"file":"webSearch.cjs","names":[],"sources":["../../src/tools/webSearch.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\n/**\n * User location configuration for geographic search refinement.\n */\nexport interface WebSearchUserLocation {\n  /**\n   * The type of location. Currently only \"approximate\" is supported.\n   */\n  type: \"approximate\";\n  /**\n   * Two-letter ISO country code (e.g., \"US\", \"GB\").\n   * @see https://en.wikipedia.org/wiki/ISO_3166-1\n   */\n  country?: string;\n  /**\n   * City name (e.g., \"San Francisco\", \"London\").\n   */\n  city?: string;\n  /**\n   * Region or state name (e.g., \"California\", \"London\").\n   */\n  region?: string;\n  /**\n   * IANA timezone (e.g., \"America/Los_Angeles\", \"Europe/London\").\n   * @see https://timeapi.io/documentation/iana-timezones\n   */\n  timezone?: string;\n}\n\n/**\n * Domain filtering configuration for web search.\n */\nexport interface WebSearchFilters {\n  /**\n   * Allow-list of up to 100 domains to limit search results.\n   * Omit the HTTP/HTTPS prefix (e.g., \"openai.com\" instead of \"https://openai.com/\").\n   * Includes subdomains automatically.\n   */\n  allowedDomains?: string[];\n}\n\n/**\n * Options for the OpenAI web search tool.\n */\nexport interface WebSearchOptions {\n  /**\n   * Domain filtering configuration.\n   * Limit results to a specific set of up to 100 domains.\n   */\n  filters?: WebSearchFilters;\n  /**\n   * Approximate user location for geographic search refinement.\n   * Not supported for deep research models.\n   */\n  userLocation?: WebSearchUserLocation;\n  /**\n   * High level guidance for the amount of context window space to use for the\n   * search. One of `low`, `medium`, or `high`. `medium` is the default.\n   */\n  search_context_size?: \"low\" | \"medium\" | \"high\";\n}\n\n/**\n * OpenAI web search tool type for the Responses API.\n */\nexport type WebSearchTool = OpenAIClient.Responses.WebSearchTool;\n\n/**\n * Creates a web search tool that allows OpenAI models to search the web\n * for up-to-date information before generating a response.\n *\n * Web search supports three main types:\n * 1. **Non-reasoning web search**: Quick lookups where the model passes queries\n *    directly to the search tool.\n * 2. **Agentic search with reasoning models**: The model actively manages the\n *    search process, analyzing results and deciding whether to keep searching.\n * 3. **Deep research**: Extended investigations using models like `o3-deep-research`\n *    or `gpt-5` with high reasoning effort.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-web-search | OpenAI Web Search Documentation}\n * @param options - Configuration options for the web search tool\n * @returns A web search tool definition to be passed to the OpenAI Responses API\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n *\n * const model = new ChatOpenAI({\n *   model: \"gpt-4o\",\n * });\n *\n * // Basic usage\n * const response = await model.invoke(\"What was a positive news story from today?\", {\n *   tools: [tools.webSearch()],\n * });\n *\n * // With domain filtering\n * const filteredResponse = await model.invoke(\"Latest AI research news\", {\n *   tools: [tools.webSearch({\n *     filters: {\n *       allowedDomains: [\"arxiv.org\", \"nature.com\", \"science.org\"],\n *     },\n *   })],\n * });\n *\n * // With user location for geographic relevance\n * const localResponse = await model.invoke(\"What are the best restaurants near me?\", {\n *   tools: [tools.webSearch({\n *     userLocation: {\n *       type: \"approximate\",\n *       country: \"US\",\n *       city: \"San Francisco\",\n *       region: \"California\",\n *       timezone: \"America/Los_Angeles\",\n *     },\n *   })],\n * });\n *\n * // Cache-only mode (no live internet access)\n * const cachedResponse = await model.invoke(\"Find information about OpenAI\", {\n *   tools: [tools.webSearch({\n *     externalWebAccess: false,\n *   })],\n * });\n * ```\n */\nexport function webSearch(options?: WebSearchOptions): ServerTool {\n  return {\n    type: \"web_search\",\n    filters: options?.filters?.allowedDomains\n      ? { allowed_domains: options.filters.allowedDomains }\n      : undefined,\n    user_location: options?.userLocation,\n    search_context_size: options?.search_context_size,\n  } satisfies WebSearchTool;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgIA,SAAgB,UAAU,SAAwC;AAChE,QAAO;EACL,MAAM;EACN,SAAS,SAAS,SAAS,iBACvB,EAAE,iBAAiB,QAAQ,QAAQ,gBAAgB,GACnD,KAAA;EACJ,eAAe,SAAS;EACxB,qBAAqB,SAAS;EAC/B"}

package/dist/tools/webSearch.d.cts

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAI$1 } from "openai";
+import { OpenAI } from "openai";
 import { ServerTool } from "@langchain/core/tools";
 
 //#region src/tools/webSearch.d.ts
@@ -63,7 +63,7 @@ interface WebSearchOptions {
 /**
  * OpenAI web search tool type for the Responses API.
  */
-type WebSearchTool = OpenAI$1.Responses.WebSearchTool;
+type WebSearchTool = OpenAI.Responses.WebSearchTool;
 /**
  * Creates a web search tool that allows OpenAI models to search the web
  * for up-to-date information before generating a response.

package/dist/tools/webSearch.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"webSearch.d.cts","names":[],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;AAMA;UAAiB,qBAAA;;;;EAIf,IAAA;EASA;;;;EAJA,OAAA;EAmBe;;;EAff,IAAA;EAqBc;AAMhB;;EAvBE,MAAA;EAiCoC;;;;EA5BpC,QAAA;AAAA;;;AAuCF;UAjCiB,gBAAA;;;;;;EAMf,cAAA;AAAA;AAwFF;;;AAAA,UAlFiB,gBAAA;EAkFmB;;;;EA7ElC,OAAA,GAAU,gBAAA;;;;;EAKV,YAAA,GAAe,qBAAA;;;;;EAKf,mBAAA;AAAA;;;;KAMU,aAAA,GAAgB,QAAA,CAAa,SAAA,CAAU,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnC,SAAA,CAAU,OAAA,GAAU,gBAAA,GAAmB,UAAA"}
+{"version":3,"file":"webSearch.d.cts","names":[],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;AAMA;UAAiB,qBAAA;;;;EAIf,IAAA;EASA;;;;EAJA,OAAA;EAmBe;;;EAff,IAAA;EAqBc;AAMhB;;EAvBE,MAAA;EAiCoC;;;;EA5BpC,QAAA;AAAA;;;AAuCF;UAjCiB,gBAAA;;;;;;EAMf,cAAA;AAAA;AAwFF;;;AAAA,UAlFiB,gBAAA;EAkFmB;;;;EA7ElC,OAAA,GAAU,gBAAA;;;;;EAKV,YAAA,GAAe,qBAAA;;;;;EAKf,mBAAA;AAAA;;;;KAMU,aAAA,GAAgB,MAAA,CAAa,SAAA,CAAU,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnC,SAAA,CAAU,OAAA,GAAU,gBAAA,GAAmB,UAAA"}

package/dist/tools/webSearch.d.ts

@@ -1,4 +1,4 @@
-import { OpenAI as OpenAI$1 } from "openai";
+import { OpenAI } from "openai";
 import { ServerTool } from "@langchain/core/tools";
 
 //#region src/tools/webSearch.d.ts
@@ -63,7 +63,7 @@ interface WebSearchOptions {
 /**
  * OpenAI web search tool type for the Responses API.
  */
-type WebSearchTool = OpenAI$1.Responses.WebSearchTool;
+type WebSearchTool = OpenAI.Responses.WebSearchTool;
 /**
  * Creates a web search tool that allows OpenAI models to search the web
  * for up-to-date information before generating a response.

package/dist/tools/webSearch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webSearch.d.ts","names":[],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;AAMA;UAAiB,qBAAA;;;;EAIf,IAAA;EASA;;;;EAJA,OAAA;EAmBe;;;EAff,IAAA;EAqBc;AAMhB;;EAvBE,MAAA;EAiCoC;;;;EA5BpC,QAAA;AAAA;;;AAuCF;UAjCiB,gBAAA;;;;;;EAMf,cAAA;AAAA;AAwFF;;;AAAA,UAlFiB,gBAAA;EAkFmB;;;;EA7ElC,OAAA,GAAU,gBAAA;;;;;EAKV,YAAA,GAAe,qBAAA;;;;;EAKf,mBAAA;AAAA;;;;KAMU,aAAA,GAAgB,QAAA,CAAa,SAAA,CAAU,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnC,SAAA,CAAU,OAAA,GAAU,gBAAA,GAAmB,UAAA"}
+{"version":3,"file":"webSearch.d.ts","names":[],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;AAMA;UAAiB,qBAAA;;;;EAIf,IAAA;EASA;;;;EAJA,OAAA;EAmBe;;;EAff,IAAA;EAqBc;AAMhB;;EAvBE,MAAA;EAiCoC;;;;EA5BpC,QAAA;AAAA;;;AAuCF;UAjCiB,gBAAA;;;;;;EAMf,cAAA;AAAA;AAwFF;;;AAAA,UAlFiB,gBAAA;EAkFmB;;;;EA7ElC,OAAA,GAAU,gBAAA;;;;;EAKV,YAAA,GAAe,qBAAA;;;;;EAKf,mBAAA;AAAA;;;;KAMU,aAAA,GAAgB,MAAA,CAAa,SAAA,CAAU,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnC,SAAA,CAAU,OAAA,GAAU,gBAAA,GAAmB,UAAA"}

package/dist/tools/webSearch.js

@@ -66,7 +66,7 @@ function webSearch(options) {
 		search_context_size: options?.search_context_size
 	};
 }
-
 //#endregion
 export { webSearch };
+
 //# sourceMappingURL=webSearch.js.map