@langchain/openai 1.1.2 → 1.2.0-dev-1765431816670

package/dist/tools/codeInterpreter.cjs

@@ -0,0 +1,95 @@
+
+//#region src/tools/codeInterpreter.ts
+/**
+* Converts container options to the API format.
+*/
+function convertContainer(container) {
+	if (typeof container === "string") return container;
+	return {
+		type: "auto",
+		file_ids: container?.fileIds,
+		memory_limit: container?.memoryLimit
+	};
+}
+/**
+* Creates a Code Interpreter tool that allows models to write and run Python code
+* in a sandboxed environment to solve complex problems.
+*
+* Use Code Interpreter for:
+* - **Data analysis**: Processing files with diverse data and formatting
+* - **File generation**: Creating files with data and images of graphs
+* - **Iterative coding**: Writing and running code iteratively to solve problems
+* - **Visual intelligence**: Cropping, zooming, rotating, and transforming images
+*
+* The tool runs in a container, which is a fully sandboxed virtual machine.
+* Containers can be created automatically (auto mode) or explicitly via the
+* `/v1/containers` endpoint.
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}
+*
+* @param options - Configuration options for the Code Interpreter tool
+* @returns A Code Interpreter tool definition to be passed to the OpenAI Responses API
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+*
+* const model = new ChatOpenAI({ model: "gpt-4.1" });
+*
+* // Basic usage with auto container (default 1GB memory)
+* const response = await model.invoke(
+*   "Solve the equation 3x + 11 = 14",
+*   { tools: [tools.codeInterpreter()] }
+* );
+*
+* // With increased memory limit for larger computations
+* const response = await model.invoke(
+*   "Analyze this large dataset and create visualizations",
+*   {
+*     tools: [tools.codeInterpreter({
+*       container: { memoryLimit: "4g" }
+*     })]
+*   }
+* );
+*
+* // With specific files available to the code
+* const response = await model.invoke(
+*   "Process the uploaded CSV file",
+*   {
+*     tools: [tools.codeInterpreter({
+*       container: {
+*         memoryLimit: "4g",
+*         fileIds: ["file-abc123", "file-def456"]
+*       }
+*     })]
+*   }
+* );
+*
+* // Using an explicit container ID (created via /v1/containers)
+* const response = await model.invoke(
+*   "Continue working with the data",
+*   {
+*     tools: [tools.codeInterpreter({
+*       container: "cntr_abc123"
+*     })]
+*   }
+* );
+* ```
+*
+* @remarks
+* - Containers expire after 20 minutes of inactivity
+* - While called "Code Interpreter", the model knows it as the "python tool"
+* - For explicit prompting, ask for "the python tool" in your prompts
+* - Files in model input are automatically uploaded to the container
+* - Generated files are returned as `container_file_citation` annotations
+*/
+function codeInterpreter(options) {
+	return {
+		type: "code_interpreter",
+		container: convertContainer(options?.container)
+	};
+}
+
+//#endregion
+exports.codeInterpreter = codeInterpreter;
+//# sourceMappingURL=codeInterpreter.cjs.map

package/dist/tools/codeInterpreter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeInterpreter.cjs","names":["container: string | CodeInterpreterAutoContainer | undefined","options?: CodeInterpreterOptions"],"sources":["../../src/tools/codeInterpreter.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\n/**\n * Memory limit options for the Code Interpreter container.\n * Higher tiers offer more RAM and are billed at different rates.\n */\nexport type CodeInterpreterMemoryLimit = \"1g\" | \"4g\" | \"16g\" | \"64g\";\n\n/**\n * Auto container configuration for Code Interpreter.\n * Creates a new container automatically or reuses an active one.\n */\nexport interface CodeInterpreterAutoContainer {\n  /**\n   * Memory limit for the container.\n   * - `\"1g\"` (default): 1 GB RAM\n   * - `\"4g\"`: 4 GB RAM\n   * - `\"16g\"`: 16 GB RAM\n   * - `\"64g\"`: 64 GB RAM\n   */\n  memoryLimit?: CodeInterpreterMemoryLimit;\n  /**\n   * Optional list of uploaded file IDs to make available to the code.\n   * Files in the model input are automatically uploaded, so this is only\n   * needed for additional files.\n   */\n  fileIds?: string[];\n}\n\n/**\n * Options for the Code Interpreter tool.\n */\nexport interface CodeInterpreterOptions {\n  /**\n   * The container configuration for the Code Interpreter.\n   *\n   * Can be either:\n   * - A string container ID for explicit mode (created via `/v1/containers` endpoint)\n   * - An auto configuration object that creates/reuses containers automatically\n   *\n   * If not provided, defaults to auto mode with default settings.\n   */\n  container?: string | CodeInterpreterAutoContainer;\n}\n\n/**\n * OpenAI Code Interpreter tool type for the Responses API.\n */\nexport type CodeInterpreterTool = OpenAIClient.Responses.Tool.CodeInterpreter;\n\n/**\n * Converts container options to the API format.\n */\nfunction convertContainer(\n  container: string | CodeInterpreterAutoContainer | undefined\n):\n  | string\n  | OpenAIClient.Responses.Tool.CodeInterpreter.CodeInterpreterToolAuto {\n  // If a string container ID is provided, use it directly\n  if (typeof container === \"string\") {\n    return container;\n  }\n\n  // Auto mode configuration\n  return {\n    type: \"auto\",\n    file_ids: container?.fileIds,\n    memory_limit: container?.memoryLimit,\n  };\n}\n\n/**\n * Creates a Code Interpreter tool that allows models to write and run Python code\n * in a sandboxed environment to solve complex problems.\n *\n * Use Code Interpreter for:\n * - **Data analysis**: Processing files with diverse data and formatting\n * - **File generation**: Creating files with data and images of graphs\n * - **Iterative coding**: Writing and running code iteratively to solve problems\n * - **Visual intelligence**: Cropping, zooming, rotating, and transforming images\n *\n * The tool runs in a container, which is a fully sandboxed virtual machine.\n * Containers can be created automatically (auto mode) or explicitly via the\n * `/v1/containers` endpoint.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}\n *\n * @param options - Configuration options for the Code Interpreter tool\n * @returns A Code Interpreter 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({ model: \"gpt-4.1\" });\n *\n * // Basic usage with auto container (default 1GB memory)\n * const response = await model.invoke(\n *   \"Solve the equation 3x + 11 = 14\",\n *   { tools: [tools.codeInterpreter()] }\n * );\n *\n * // With increased memory limit for larger computations\n * const response = await model.invoke(\n *   \"Analyze this large dataset and create visualizations\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: { memoryLimit: \"4g\" }\n *     })]\n *   }\n * );\n *\n * // With specific files available to the code\n * const response = await model.invoke(\n *   \"Process the uploaded CSV file\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: {\n *         memoryLimit: \"4g\",\n *         fileIds: [\"file-abc123\", \"file-def456\"]\n *       }\n *     })]\n *   }\n * );\n *\n * // Using an explicit container ID (created via /v1/containers)\n * const response = await model.invoke(\n *   \"Continue working with the data\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: \"cntr_abc123\"\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Containers expire after 20 minutes of inactivity\n * - While called \"Code Interpreter\", the model knows it as the \"python tool\"\n * - For explicit prompting, ask for \"the python tool\" in your prompts\n * - Files in model input are automatically uploaded to the container\n * - Generated files are returned as `container_file_citation` annotations\n */\nexport function codeInterpreter(options?: CodeInterpreterOptions): ServerTool {\n  return {\n    type: \"code_interpreter\",\n    container: convertContainer(options?.container),\n  } satisfies CodeInterpreterTool;\n}\n"],"mappings":";;;;;AAsDA,SAAS,iBACPA,WAGsE;AAEtE,KAAI,OAAO,cAAc,SACvB,QAAO;AAIT,QAAO;EACL,MAAM;EACN,UAAU,WAAW;EACrB,cAAc,WAAW;CAC1B;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0ED,SAAgB,gBAAgBC,SAA8C;AAC5E,QAAO;EACL,MAAM;EACN,WAAW,iBAAiB,SAAS,UAAU;CAChD;AACF"}

package/dist/tools/codeInterpreter.d.cts

@@ -0,0 +1,125 @@
+import { OpenAI as OpenAI$1 } from "openai";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/codeInterpreter.d.ts
+
+/**
+ * Memory limit options for the Code Interpreter container.
+ * Higher tiers offer more RAM and are billed at different rates.
+ */
+type CodeInterpreterMemoryLimit = "1g" | "4g" | "16g" | "64g";
+/**
+ * Auto container configuration for Code Interpreter.
+ * Creates a new container automatically or reuses an active one.
+ */
+interface CodeInterpreterAutoContainer {
+  /**
+   * Memory limit for the container.
+   * - `"1g"` (default): 1 GB RAM
+   * - `"4g"`: 4 GB RAM
+   * - `"16g"`: 16 GB RAM
+   * - `"64g"`: 64 GB RAM
+   */
+  memoryLimit?: CodeInterpreterMemoryLimit;
+  /**
+   * Optional list of uploaded file IDs to make available to the code.
+   * Files in the model input are automatically uploaded, so this is only
+   * needed for additional files.
+   */
+  fileIds?: string[];
+}
+/**
+ * Options for the Code Interpreter tool.
+ */
+interface CodeInterpreterOptions {
+  /**
+   * The container configuration for the Code Interpreter.
+   *
+   * Can be either:
+   * - A string container ID for explicit mode (created via `/v1/containers` endpoint)
+   * - An auto configuration object that creates/reuses containers automatically
+   *
+   * If not provided, defaults to auto mode with default settings.
+   */
+  container?: string | CodeInterpreterAutoContainer;
+}
+/**
+ * OpenAI Code Interpreter tool type for the Responses API.
+ */
+type CodeInterpreterTool = OpenAI$1.Responses.Tool.CodeInterpreter;
+/**
+ * Creates a Code Interpreter tool that allows models to write and run Python code
+ * in a sandboxed environment to solve complex problems.
+ *
+ * Use Code Interpreter for:
+ * - **Data analysis**: Processing files with diverse data and formatting
+ * - **File generation**: Creating files with data and images of graphs
+ * - **Iterative coding**: Writing and running code iteratively to solve problems
+ * - **Visual intelligence**: Cropping, zooming, rotating, and transforming images
+ *
+ * The tool runs in a container, which is a fully sandboxed virtual machine.
+ * Containers can be created automatically (auto mode) or explicitly via the
+ * `/v1/containers` endpoint.
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}
+ *
+ * @param options - Configuration options for the Code Interpreter tool
+ * @returns A Code Interpreter tool definition to be passed to the OpenAI Responses API
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-4.1" });
+ *
+ * // Basic usage with auto container (default 1GB memory)
+ * const response = await model.invoke(
+ *   "Solve the equation 3x + 11 = 14",
+ *   { tools: [tools.codeInterpreter()] }
+ * );
+ *
+ * // With increased memory limit for larger computations
+ * const response = await model.invoke(
+ *   "Analyze this large dataset and create visualizations",
+ *   {
+ *     tools: [tools.codeInterpreter({
+ *       container: { memoryLimit: "4g" }
+ *     })]
+ *   }
+ * );
+ *
+ * // With specific files available to the code
+ * const response = await model.invoke(
+ *   "Process the uploaded CSV file",
+ *   {
+ *     tools: [tools.codeInterpreter({
+ *       container: {
+ *         memoryLimit: "4g",
+ *         fileIds: ["file-abc123", "file-def456"]
+ *       }
+ *     })]
+ *   }
+ * );
+ *
+ * // Using an explicit container ID (created via /v1/containers)
+ * const response = await model.invoke(
+ *   "Continue working with the data",
+ *   {
+ *     tools: [tools.codeInterpreter({
+ *       container: "cntr_abc123"
+ *     })]
+ *   }
+ * );
+ * ```
+ *
+ * @remarks
+ * - Containers expire after 20 minutes of inactivity
+ * - While called "Code Interpreter", the model knows it as the "python tool"
+ * - For explicit prompting, ask for "the python tool" in your prompts
+ * - Files in model input are automatically uploaded to the container
+ * - Generated files are returned as `container_file_citation` annotations
+ */
+declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;
+//#endregion
+export { CodeInterpreterAutoContainer, CodeInterpreterMemoryLimit, CodeInterpreterOptions, CodeInterpreterTool, codeInterpreter };
+//# sourceMappingURL=codeInterpreter.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codeInterpreter.d.cts","names":["OpenAI","OpenAIClient","ServerTool","CodeInterpreterMemoryLimit","CodeInterpreterAutoContainer","CodeInterpreterOptions","CodeInterpreterTool","Responses","Tool","CodeInterpreter","codeInterpreter"],"sources":["../../src/tools/codeInterpreter.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n/**\n * Memory limit options for the Code Interpreter container.\n * Higher tiers offer more RAM and are billed at different rates.\n */\nexport type CodeInterpreterMemoryLimit = \"1g\" | \"4g\" | \"16g\" | \"64g\";\n/**\n * Auto container configuration for Code Interpreter.\n * Creates a new container automatically or reuses an active one.\n */\nexport interface CodeInterpreterAutoContainer {\n    /**\n     * Memory limit for the container.\n     * - `\"1g\"` (default): 1 GB RAM\n     * - `\"4g\"`: 4 GB RAM\n     * - `\"16g\"`: 16 GB RAM\n     * - `\"64g\"`: 64 GB RAM\n     */\n    memoryLimit?: CodeInterpreterMemoryLimit;\n    /**\n     * Optional list of uploaded file IDs to make available to the code.\n     * Files in the model input are automatically uploaded, so this is only\n     * needed for additional files.\n     */\n    fileIds?: string[];\n}\n/**\n * Options for the Code Interpreter tool.\n */\nexport interface CodeInterpreterOptions {\n    /**\n     * The container configuration for the Code Interpreter.\n     *\n     * Can be either:\n     * - A string container ID for explicit mode (created via `/v1/containers` endpoint)\n     * - An auto configuration object that creates/reuses containers automatically\n     *\n     * If not provided, defaults to auto mode with default settings.\n     */\n    container?: string | CodeInterpreterAutoContainer;\n}\n/**\n * OpenAI Code Interpreter tool type for the Responses API.\n */\nexport type CodeInterpreterTool = OpenAIClient.Responses.Tool.CodeInterpreter;\n/**\n * Creates a Code Interpreter tool that allows models to write and run Python code\n * in a sandboxed environment to solve complex problems.\n *\n * Use Code Interpreter for:\n * - **Data analysis**: Processing files with diverse data and formatting\n * - **File generation**: Creating files with data and images of graphs\n * - **Iterative coding**: Writing and running code iteratively to solve problems\n * - **Visual intelligence**: Cropping, zooming, rotating, and transforming images\n *\n * The tool runs in a container, which is a fully sandboxed virtual machine.\n * Containers can be created automatically (auto mode) or explicitly via the\n * `/v1/containers` endpoint.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}\n *\n * @param options - Configuration options for the Code Interpreter tool\n * @returns A Code Interpreter 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({ model: \"gpt-4.1\" });\n *\n * // Basic usage with auto container (default 1GB memory)\n * const response = await model.invoke(\n *   \"Solve the equation 3x + 11 = 14\",\n *   { tools: [tools.codeInterpreter()] }\n * );\n *\n * // With increased memory limit for larger computations\n * const response = await model.invoke(\n *   \"Analyze this large dataset and create visualizations\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: { memoryLimit: \"4g\" }\n *     })]\n *   }\n * );\n *\n * // With specific files available to the code\n * const response = await model.invoke(\n *   \"Process the uploaded CSV file\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: {\n *         memoryLimit: \"4g\",\n *         fileIds: [\"file-abc123\", \"file-def456\"]\n *       }\n *     })]\n *   }\n * );\n *\n * // Using an explicit container ID (created via /v1/containers)\n * const response = await model.invoke(\n *   \"Continue working with the data\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: \"cntr_abc123\"\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Containers expire after 20 minutes of inactivity\n * - While called \"Code Interpreter\", the model knows it as the \"python tool\"\n * - For explicit prompting, ask for \"the python tool\" in your prompts\n * - Files in model input are automatically uploaded to the container\n * - Generated files are returned as `container_file_citation` annotations\n */\nexport declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;\n//# sourceMappingURL=codeInterpreter.d.ts.map"],"mappings":";;;;;;;AAMA;AAKA;AAmBiBK,KAxBLF,0BAAAA,GAwB2B,IAUdC,GAAAA,IAAAA,GAAAA,KAAAA,GAAAA,KAAAA;AAKzB;AAyEA;;;UA3GiBA,4BAAAA;;;;;;;;gBAQCD;;;;;;;;;;;UAWDE,sBAAAA;;;;;;;;;;uBAUQD;;;;;KAKbE,mBAAAA,GAAsBL,QAAAA,CAAaM,SAAAA,CAAUC,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyEtCC,eAAAA,WAA0BL,yBAAyBH"}

package/dist/tools/codeInterpreter.d.ts

@@ -0,0 +1,125 @@
+import { OpenAI as OpenAI$1 } from "openai";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/codeInterpreter.d.ts
+
+/**
+ * Memory limit options for the Code Interpreter container.
+ * Higher tiers offer more RAM and are billed at different rates.
+ */
+type CodeInterpreterMemoryLimit = "1g" | "4g" | "16g" | "64g";
+/**
+ * Auto container configuration for Code Interpreter.
+ * Creates a new container automatically or reuses an active one.
+ */
+interface CodeInterpreterAutoContainer {
+  /**
+   * Memory limit for the container.
+   * - `"1g"` (default): 1 GB RAM
+   * - `"4g"`: 4 GB RAM
+   * - `"16g"`: 16 GB RAM
+   * - `"64g"`: 64 GB RAM
+   */
+  memoryLimit?: CodeInterpreterMemoryLimit;
+  /**
+   * Optional list of uploaded file IDs to make available to the code.
+   * Files in the model input are automatically uploaded, so this is only
+   * needed for additional files.
+   */
+  fileIds?: string[];
+}
+/**
+ * Options for the Code Interpreter tool.
+ */
+interface CodeInterpreterOptions {
+  /**
+   * The container configuration for the Code Interpreter.
+   *
+   * Can be either:
+   * - A string container ID for explicit mode (created via `/v1/containers` endpoint)
+   * - An auto configuration object that creates/reuses containers automatically
+   *
+   * If not provided, defaults to auto mode with default settings.
+   */
+  container?: string | CodeInterpreterAutoContainer;
+}
+/**
+ * OpenAI Code Interpreter tool type for the Responses API.
+ */
+type CodeInterpreterTool = OpenAI$1.Responses.Tool.CodeInterpreter;
+/**
+ * Creates a Code Interpreter tool that allows models to write and run Python code
+ * in a sandboxed environment to solve complex problems.
+ *
+ * Use Code Interpreter for:
+ * - **Data analysis**: Processing files with diverse data and formatting
+ * - **File generation**: Creating files with data and images of graphs
+ * - **Iterative coding**: Writing and running code iteratively to solve problems
+ * - **Visual intelligence**: Cropping, zooming, rotating, and transforming images
+ *
+ * The tool runs in a container, which is a fully sandboxed virtual machine.
+ * Containers can be created automatically (auto mode) or explicitly via the
+ * `/v1/containers` endpoint.
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}
+ *
+ * @param options - Configuration options for the Code Interpreter tool
+ * @returns A Code Interpreter tool definition to be passed to the OpenAI Responses API
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-4.1" });
+ *
+ * // Basic usage with auto container (default 1GB memory)
+ * const response = await model.invoke(
+ *   "Solve the equation 3x + 11 = 14",
+ *   { tools: [tools.codeInterpreter()] }
+ * );
+ *
+ * // With increased memory limit for larger computations
+ * const response = await model.invoke(
+ *   "Analyze this large dataset and create visualizations",
+ *   {
+ *     tools: [tools.codeInterpreter({
+ *       container: { memoryLimit: "4g" }
+ *     })]
+ *   }
+ * );
+ *
+ * // With specific files available to the code
+ * const response = await model.invoke(
+ *   "Process the uploaded CSV file",
+ *   {
+ *     tools: [tools.codeInterpreter({
+ *       container: {
+ *         memoryLimit: "4g",
+ *         fileIds: ["file-abc123", "file-def456"]
+ *       }
+ *     })]
+ *   }
+ * );
+ *
+ * // Using an explicit container ID (created via /v1/containers)
+ * const response = await model.invoke(
+ *   "Continue working with the data",
+ *   {
+ *     tools: [tools.codeInterpreter({
+ *       container: "cntr_abc123"
+ *     })]
+ *   }
+ * );
+ * ```
+ *
+ * @remarks
+ * - Containers expire after 20 minutes of inactivity
+ * - While called "Code Interpreter", the model knows it as the "python tool"
+ * - For explicit prompting, ask for "the python tool" in your prompts
+ * - Files in model input are automatically uploaded to the container
+ * - Generated files are returned as `container_file_citation` annotations
+ */
+declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;
+//#endregion
+export { CodeInterpreterAutoContainer, CodeInterpreterMemoryLimit, CodeInterpreterOptions, CodeInterpreterTool, codeInterpreter };
+//# sourceMappingURL=codeInterpreter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codeInterpreter.d.ts","names":["OpenAI","OpenAIClient","ServerTool","CodeInterpreterMemoryLimit","CodeInterpreterAutoContainer","CodeInterpreterOptions","CodeInterpreterTool","Responses","Tool","CodeInterpreter","codeInterpreter"],"sources":["../../src/tools/codeInterpreter.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n/**\n * Memory limit options for the Code Interpreter container.\n * Higher tiers offer more RAM and are billed at different rates.\n */\nexport type CodeInterpreterMemoryLimit = \"1g\" | \"4g\" | \"16g\" | \"64g\";\n/**\n * Auto container configuration for Code Interpreter.\n * Creates a new container automatically or reuses an active one.\n */\nexport interface CodeInterpreterAutoContainer {\n    /**\n     * Memory limit for the container.\n     * - `\"1g\"` (default): 1 GB RAM\n     * - `\"4g\"`: 4 GB RAM\n     * - `\"16g\"`: 16 GB RAM\n     * - `\"64g\"`: 64 GB RAM\n     */\n    memoryLimit?: CodeInterpreterMemoryLimit;\n    /**\n     * Optional list of uploaded file IDs to make available to the code.\n     * Files in the model input are automatically uploaded, so this is only\n     * needed for additional files.\n     */\n    fileIds?: string[];\n}\n/**\n * Options for the Code Interpreter tool.\n */\nexport interface CodeInterpreterOptions {\n    /**\n     * The container configuration for the Code Interpreter.\n     *\n     * Can be either:\n     * - A string container ID for explicit mode (created via `/v1/containers` endpoint)\n     * - An auto configuration object that creates/reuses containers automatically\n     *\n     * If not provided, defaults to auto mode with default settings.\n     */\n    container?: string | CodeInterpreterAutoContainer;\n}\n/**\n * OpenAI Code Interpreter tool type for the Responses API.\n */\nexport type CodeInterpreterTool = OpenAIClient.Responses.Tool.CodeInterpreter;\n/**\n * Creates a Code Interpreter tool that allows models to write and run Python code\n * in a sandboxed environment to solve complex problems.\n *\n * Use Code Interpreter for:\n * - **Data analysis**: Processing files with diverse data and formatting\n * - **File generation**: Creating files with data and images of graphs\n * - **Iterative coding**: Writing and running code iteratively to solve problems\n * - **Visual intelligence**: Cropping, zooming, rotating, and transforming images\n *\n * The tool runs in a container, which is a fully sandboxed virtual machine.\n * Containers can be created automatically (auto mode) or explicitly via the\n * `/v1/containers` endpoint.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}\n *\n * @param options - Configuration options for the Code Interpreter tool\n * @returns A Code Interpreter 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({ model: \"gpt-4.1\" });\n *\n * // Basic usage with auto container (default 1GB memory)\n * const response = await model.invoke(\n *   \"Solve the equation 3x + 11 = 14\",\n *   { tools: [tools.codeInterpreter()] }\n * );\n *\n * // With increased memory limit for larger computations\n * const response = await model.invoke(\n *   \"Analyze this large dataset and create visualizations\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: { memoryLimit: \"4g\" }\n *     })]\n *   }\n * );\n *\n * // With specific files available to the code\n * const response = await model.invoke(\n *   \"Process the uploaded CSV file\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: {\n *         memoryLimit: \"4g\",\n *         fileIds: [\"file-abc123\", \"file-def456\"]\n *       }\n *     })]\n *   }\n * );\n *\n * // Using an explicit container ID (created via /v1/containers)\n * const response = await model.invoke(\n *   \"Continue working with the data\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: \"cntr_abc123\"\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Containers expire after 20 minutes of inactivity\n * - While called \"Code Interpreter\", the model knows it as the \"python tool\"\n * - For explicit prompting, ask for \"the python tool\" in your prompts\n * - Files in model input are automatically uploaded to the container\n * - Generated files are returned as `container_file_citation` annotations\n */\nexport declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;\n//# sourceMappingURL=codeInterpreter.d.ts.map"],"mappings":";;;;;;;AAMA;AAKA;AAmBiBK,KAxBLF,0BAAAA,GAwB2B,IAUdC,GAAAA,IAAAA,GAAAA,KAAAA,GAAAA,KAAAA;AAKzB;AAyEA;;;UA3GiBA,4BAAAA;;;;;;;;gBAQCD;;;;;;;;;;;UAWDE,sBAAAA;;;;;;;;;;uBAUQD;;;;;KAKbE,mBAAAA,GAAsBL,QAAAA,CAAaM,SAAAA,CAAUC,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyEtCC,eAAAA,WAA0BL,yBAAyBH"}

package/dist/tools/codeInterpreter.js

@@ -0,0 +1,94 @@
+//#region src/tools/codeInterpreter.ts
+/**
+* Converts container options to the API format.
+*/
+function convertContainer(container) {
+	if (typeof container === "string") return container;
+	return {
+		type: "auto",
+		file_ids: container?.fileIds,
+		memory_limit: container?.memoryLimit
+	};
+}
+/**
+* Creates a Code Interpreter tool that allows models to write and run Python code
+* in a sandboxed environment to solve complex problems.
+*
+* Use Code Interpreter for:
+* - **Data analysis**: Processing files with diverse data and formatting
+* - **File generation**: Creating files with data and images of graphs
+* - **Iterative coding**: Writing and running code iteratively to solve problems
+* - **Visual intelligence**: Cropping, zooming, rotating, and transforming images
+*
+* The tool runs in a container, which is a fully sandboxed virtual machine.
+* Containers can be created automatically (auto mode) or explicitly via the
+* `/v1/containers` endpoint.
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}
+*
+* @param options - Configuration options for the Code Interpreter tool
+* @returns A Code Interpreter tool definition to be passed to the OpenAI Responses API
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+*
+* const model = new ChatOpenAI({ model: "gpt-4.1" });
+*
+* // Basic usage with auto container (default 1GB memory)
+* const response = await model.invoke(
+*   "Solve the equation 3x + 11 = 14",
+*   { tools: [tools.codeInterpreter()] }
+* );
+*
+* // With increased memory limit for larger computations
+* const response = await model.invoke(
+*   "Analyze this large dataset and create visualizations",
+*   {
+*     tools: [tools.codeInterpreter({
+*       container: { memoryLimit: "4g" }
+*     })]
+*   }
+* );
+*
+* // With specific files available to the code
+* const response = await model.invoke(
+*   "Process the uploaded CSV file",
+*   {
+*     tools: [tools.codeInterpreter({
+*       container: {
+*         memoryLimit: "4g",
+*         fileIds: ["file-abc123", "file-def456"]
+*       }
+*     })]
+*   }
+* );
+*
+* // Using an explicit container ID (created via /v1/containers)
+* const response = await model.invoke(
+*   "Continue working with the data",
+*   {
+*     tools: [tools.codeInterpreter({
+*       container: "cntr_abc123"
+*     })]
+*   }
+* );
+* ```
+*
+* @remarks
+* - Containers expire after 20 minutes of inactivity
+* - While called "Code Interpreter", the model knows it as the "python tool"
+* - For explicit prompting, ask for "the python tool" in your prompts
+* - Files in model input are automatically uploaded to the container
+* - Generated files are returned as `container_file_citation` annotations
+*/
+function codeInterpreter(options) {
+	return {
+		type: "code_interpreter",
+		container: convertContainer(options?.container)
+	};
+}
+
+//#endregion
+export { codeInterpreter };
+//# sourceMappingURL=codeInterpreter.js.map

package/dist/tools/codeInterpreter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeInterpreter.js","names":["container: string | CodeInterpreterAutoContainer | undefined","options?: CodeInterpreterOptions"],"sources":["../../src/tools/codeInterpreter.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\n/**\n * Memory limit options for the Code Interpreter container.\n * Higher tiers offer more RAM and are billed at different rates.\n */\nexport type CodeInterpreterMemoryLimit = \"1g\" | \"4g\" | \"16g\" | \"64g\";\n\n/**\n * Auto container configuration for Code Interpreter.\n * Creates a new container automatically or reuses an active one.\n */\nexport interface CodeInterpreterAutoContainer {\n  /**\n   * Memory limit for the container.\n   * - `\"1g\"` (default): 1 GB RAM\n   * - `\"4g\"`: 4 GB RAM\n   * - `\"16g\"`: 16 GB RAM\n   * - `\"64g\"`: 64 GB RAM\n   */\n  memoryLimit?: CodeInterpreterMemoryLimit;\n  /**\n   * Optional list of uploaded file IDs to make available to the code.\n   * Files in the model input are automatically uploaded, so this is only\n   * needed for additional files.\n   */\n  fileIds?: string[];\n}\n\n/**\n * Options for the Code Interpreter tool.\n */\nexport interface CodeInterpreterOptions {\n  /**\n   * The container configuration for the Code Interpreter.\n   *\n   * Can be either:\n   * - A string container ID for explicit mode (created via `/v1/containers` endpoint)\n   * - An auto configuration object that creates/reuses containers automatically\n   *\n   * If not provided, defaults to auto mode with default settings.\n   */\n  container?: string | CodeInterpreterAutoContainer;\n}\n\n/**\n * OpenAI Code Interpreter tool type for the Responses API.\n */\nexport type CodeInterpreterTool = OpenAIClient.Responses.Tool.CodeInterpreter;\n\n/**\n * Converts container options to the API format.\n */\nfunction convertContainer(\n  container: string | CodeInterpreterAutoContainer | undefined\n):\n  | string\n  | OpenAIClient.Responses.Tool.CodeInterpreter.CodeInterpreterToolAuto {\n  // If a string container ID is provided, use it directly\n  if (typeof container === \"string\") {\n    return container;\n  }\n\n  // Auto mode configuration\n  return {\n    type: \"auto\",\n    file_ids: container?.fileIds,\n    memory_limit: container?.memoryLimit,\n  };\n}\n\n/**\n * Creates a Code Interpreter tool that allows models to write and run Python code\n * in a sandboxed environment to solve complex problems.\n *\n * Use Code Interpreter for:\n * - **Data analysis**: Processing files with diverse data and formatting\n * - **File generation**: Creating files with data and images of graphs\n * - **Iterative coding**: Writing and running code iteratively to solve problems\n * - **Visual intelligence**: Cropping, zooming, rotating, and transforming images\n *\n * The tool runs in a container, which is a fully sandboxed virtual machine.\n * Containers can be created automatically (auto mode) or explicitly via the\n * `/v1/containers` endpoint.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-code-interpreter | OpenAI Code Interpreter Documentation}\n *\n * @param options - Configuration options for the Code Interpreter tool\n * @returns A Code Interpreter 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({ model: \"gpt-4.1\" });\n *\n * // Basic usage with auto container (default 1GB memory)\n * const response = await model.invoke(\n *   \"Solve the equation 3x + 11 = 14\",\n *   { tools: [tools.codeInterpreter()] }\n * );\n *\n * // With increased memory limit for larger computations\n * const response = await model.invoke(\n *   \"Analyze this large dataset and create visualizations\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: { memoryLimit: \"4g\" }\n *     })]\n *   }\n * );\n *\n * // With specific files available to the code\n * const response = await model.invoke(\n *   \"Process the uploaded CSV file\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: {\n *         memoryLimit: \"4g\",\n *         fileIds: [\"file-abc123\", \"file-def456\"]\n *       }\n *     })]\n *   }\n * );\n *\n * // Using an explicit container ID (created via /v1/containers)\n * const response = await model.invoke(\n *   \"Continue working with the data\",\n *   {\n *     tools: [tools.codeInterpreter({\n *       container: \"cntr_abc123\"\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Containers expire after 20 minutes of inactivity\n * - While called \"Code Interpreter\", the model knows it as the \"python tool\"\n * - For explicit prompting, ask for \"the python tool\" in your prompts\n * - Files in model input are automatically uploaded to the container\n * - Generated files are returned as `container_file_citation` annotations\n */\nexport function codeInterpreter(options?: CodeInterpreterOptions): ServerTool {\n  return {\n    type: \"code_interpreter\",\n    container: convertContainer(options?.container),\n  } satisfies CodeInterpreterTool;\n}\n"],"mappings":";;;;AAsDA,SAAS,iBACPA,WAGsE;AAEtE,KAAI,OAAO,cAAc,SACvB,QAAO;AAIT,QAAO;EACL,MAAM;EACN,UAAU,WAAW;EACrB,cAAc,WAAW;CAC1B;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0ED,SAAgB,gBAAgBC,SAA8C;AAC5E,QAAO;EACL,MAAM;EACN,WAAW,iBAAiB,SAAS,UAAU;CAChD;AACF"}