@langchain/openai 1.1.3 → 1.2.0-dev-1765432861398

package/dist/tools/fileSearch.js

@@ -0,0 +1,136 @@
+//#region src/tools/fileSearch.ts
+/**
+* Converts ranking options to the API format.
+*/
+function convertRankingOptions(options) {
+	if (!options) return void 0;
+	return {
+		ranker: options.ranker,
+		score_threshold: options.scoreThreshold,
+		hybrid_search: options.hybridSearch ? {
+			embedding_weight: options.hybridSearch.embeddingWeight,
+			text_weight: options.hybridSearch.textWeight
+		} : void 0
+	};
+}
+/**
+* Creates a File Search tool that allows models to search your files
+* for relevant information using semantic and keyword search.
+*
+* File Search enables models to retrieve information from a knowledge base
+* of previously uploaded files stored in vector stores. This is a hosted tool
+* managed by OpenAI - you don't need to implement the search execution yourself.
+*
+* **Prerequisites**: Before using File Search, you must:
+* 1. Upload files to the File API with `purpose: "assistants"`
+* 2. Create a vector store
+* 3. Add files to the vector store
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-file-search | OpenAI File Search Documentation}
+*
+* @param options - Configuration options for the File Search tool
+* @returns A File Search 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 a vector store
+* const response = await model.invoke(
+*   "What is deep research by OpenAI?",
+*   {
+*     tools: [tools.fileSearch({
+*       vectorStoreIds: ["vs_abc123"]
+*     })]
+*   }
+* );
+*
+* // Limit the number of results for lower latency
+* const response = await model.invoke(
+*   "Find information about pricing",
+*   {
+*     tools: [tools.fileSearch({
+*       vectorStoreIds: ["vs_abc123"],
+*       maxNumResults: 5
+*     })]
+*   }
+* );
+*
+* // With metadata filtering
+* const response = await model.invoke(
+*   "Find recent blog posts about AI",
+*   {
+*     tools: [tools.fileSearch({
+*       vectorStoreIds: ["vs_abc123"],
+*       filters: {
+*         type: "eq",
+*         key: "category",
+*         value: "blog"
+*       }
+*     })]
+*   }
+* );
+*
+* // With compound filters (AND/OR)
+* const response = await model.invoke(
+*   "Find technical docs from 2024",
+*   {
+*     tools: [tools.fileSearch({
+*       vectorStoreIds: ["vs_abc123"],
+*       filters: {
+*         type: "and",
+*         filters: [
+*           { type: "eq", key: "category", value: "technical" },
+*           { type: "gte", key: "year", value: 2024 }
+*         ]
+*       }
+*     })]
+*   }
+* );
+*
+* // With ranking options for more relevant results
+* const response = await model.invoke(
+*   "Find the most relevant information",
+*   {
+*     tools: [tools.fileSearch({
+*       vectorStoreIds: ["vs_abc123"],
+*       rankingOptions: {
+*         scoreThreshold: 0.8,
+*         ranker: "auto"
+*       }
+*     })]
+*   }
+* );
+*
+* // Search multiple vector stores
+* const response = await model.invoke(
+*   "Search across all knowledge bases",
+*   {
+*     tools: [tools.fileSearch({
+*       vectorStoreIds: ["vs_abc123", "vs_def456"]
+*     })]
+*   }
+* );
+* ```
+*
+* @remarks
+* - Vector stores must be created and populated before using this tool
+* - The tool returns file citations in the response annotations
+* - Use `include: ["file_search_call.results"]` in the API call to get search results
+* - Supported file types include PDF, DOCX, TXT, MD, and many code file formats
+*/
+function fileSearch(options) {
+	return {
+		type: "file_search",
+		vector_store_ids: options.vectorStoreIds,
+		max_num_results: options.maxNumResults,
+		filters: options.filters,
+		ranking_options: convertRankingOptions(options.rankingOptions)
+	};
+}
+
+//#endregion
+export { fileSearch };
+//# sourceMappingURL=fileSearch.js.map

package/dist/tools/fileSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSearch.js","names":["options: FileSearchRankingOptions | undefined","options: FileSearchOptions"],"sources":["../../src/tools/fileSearch.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\n/**\n * Comparison operators for file attribute filtering.\n */\nexport type FileSearchComparisonType =\n  | \"eq\"\n  | \"ne\"\n  | \"gt\"\n  | \"gte\"\n  | \"lt\"\n  | \"lte\";\n\n/**\n * A filter used to compare a specified attribute key to a given value.\n */\nexport interface FileSearchComparisonFilter {\n  /**\n   * The comparison operator to use.\n   * - `eq`: equals\n   * - `ne`: not equal\n   * - `gt`: greater than\n   * - `gte`: greater than or equal\n   * - `lt`: less than\n   * - `lte`: less than or equal\n   */\n  type: FileSearchComparisonType;\n  /**\n   * The attribute key to compare against.\n   */\n  key: string;\n  /**\n   * The value to compare against the attribute key.\n   * Supports string, number, boolean, or array of strings/numbers.\n   */\n  value: string | number | boolean | Array<string | number>;\n}\n\n/**\n * Combine multiple filters using `and` or `or`.\n */\nexport interface FileSearchCompoundFilter {\n  /**\n   * Type of operation: `and` or `or`.\n   */\n  type: \"and\" | \"or\";\n  /**\n   * Array of filters to combine.\n   */\n  filters: Array<FileSearchComparisonFilter | FileSearchCompoundFilter>;\n}\n\n/**\n * Filter type for file search - can be a comparison or compound filter.\n */\nexport type FileSearchFilter =\n  | FileSearchComparisonFilter\n  | FileSearchCompoundFilter;\n\n/**\n * Weights for hybrid search balancing semantic and keyword matches.\n */\nexport interface FileSearchHybridSearchWeights {\n  /**\n   * The weight of semantic embedding matches (0-1).\n   */\n  embeddingWeight: number;\n  /**\n   * The weight of keyword/text matches (0-1).\n   */\n  textWeight: number;\n}\n\n/**\n * Ranking options for file search results.\n */\nexport interface FileSearchRankingOptions {\n  /**\n   * The ranker to use for the file search.\n   * - `auto`: Automatically select the best ranker\n   * - `default-2024-11-15`: Default ranker as of November 2024\n   */\n  ranker?: \"auto\" | \"default-2024-11-15\";\n  /**\n   * The score threshold for results (0-1).\n   * Numbers closer to 1 return only the most relevant results but may return fewer.\n   */\n  scoreThreshold?: number;\n  /**\n   * Weights that control how reciprocal rank fusion balances semantic\n   * embedding matches versus sparse keyword matches when hybrid search is enabled.\n   */\n  hybridSearch?: FileSearchHybridSearchWeights;\n}\n\n/**\n * Options for the File Search tool.\n */\nexport interface FileSearchOptions {\n  /**\n   * The IDs of the vector stores to search.\n   * You must have previously created vector stores and uploaded files to them.\n   */\n  vectorStoreIds: string[];\n  /**\n   * The maximum number of results to return.\n   * Must be between 1 and 50 inclusive.\n   */\n  maxNumResults?: number;\n  /**\n   * A filter to apply based on file attributes/metadata.\n   * Use this to narrow down search results to specific categories or file types.\n   */\n  filters?: FileSearchFilter;\n  /**\n   * Ranking options to customize how results are scored and ordered.\n   */\n  rankingOptions?: FileSearchRankingOptions;\n}\n\n/**\n * OpenAI File Search tool type for the Responses API.\n */\nexport type FileSearchTool = OpenAIClient.Responses.FileSearchTool;\n\n/**\n * Converts ranking options to the API format.\n */\nfunction convertRankingOptions(\n  options: FileSearchRankingOptions | undefined\n): OpenAIClient.Responses.FileSearchTool.RankingOptions | undefined {\n  if (!options) return undefined;\n  return {\n    ranker: options.ranker,\n    score_threshold: options.scoreThreshold,\n    hybrid_search: options.hybridSearch\n      ? {\n          embedding_weight: options.hybridSearch.embeddingWeight,\n          text_weight: options.hybridSearch.textWeight,\n        }\n      : undefined,\n  };\n}\n\n/**\n * Creates a File Search tool that allows models to search your files\n * for relevant information using semantic and keyword search.\n *\n * File Search enables models to retrieve information from a knowledge base\n * of previously uploaded files stored in vector stores. This is a hosted tool\n * managed by OpenAI - you don't need to implement the search execution yourself.\n *\n * **Prerequisites**: Before using File Search, you must:\n * 1. Upload files to the File API with `purpose: \"assistants\"`\n * 2. Create a vector store\n * 3. Add files to the vector store\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-file-search | OpenAI File Search Documentation}\n *\n * @param options - Configuration options for the File Search tool\n * @returns A File 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({ model: \"gpt-4.1\" });\n *\n * // Basic usage with a vector store\n * const response = await model.invoke(\n *   \"What is deep research by OpenAI?\",\n *   {\n *     tools: [tools.fileSearch({\n *       vectorStoreIds: [\"vs_abc123\"]\n *     })]\n *   }\n * );\n *\n * // Limit the number of results for lower latency\n * const response = await model.invoke(\n *   \"Find information about pricing\",\n *   {\n *     tools: [tools.fileSearch({\n *       vectorStoreIds: [\"vs_abc123\"],\n *       maxNumResults: 5\n *     })]\n *   }\n * );\n *\n * // With metadata filtering\n * const response = await model.invoke(\n *   \"Find recent blog posts about AI\",\n *   {\n *     tools: [tools.fileSearch({\n *       vectorStoreIds: [\"vs_abc123\"],\n *       filters: {\n *         type: \"eq\",\n *         key: \"category\",\n *         value: \"blog\"\n *       }\n *     })]\n *   }\n * );\n *\n * // With compound filters (AND/OR)\n * const response = await model.invoke(\n *   \"Find technical docs from 2024\",\n *   {\n *     tools: [tools.fileSearch({\n *       vectorStoreIds: [\"vs_abc123\"],\n *       filters: {\n *         type: \"and\",\n *         filters: [\n *           { type: \"eq\", key: \"category\", value: \"technical\" },\n *           { type: \"gte\", key: \"year\", value: 2024 }\n *         ]\n *       }\n *     })]\n *   }\n * );\n *\n * // With ranking options for more relevant results\n * const response = await model.invoke(\n *   \"Find the most relevant information\",\n *   {\n *     tools: [tools.fileSearch({\n *       vectorStoreIds: [\"vs_abc123\"],\n *       rankingOptions: {\n *         scoreThreshold: 0.8,\n *         ranker: \"auto\"\n *       }\n *     })]\n *   }\n * );\n *\n * // Search multiple vector stores\n * const response = await model.invoke(\n *   \"Search across all knowledge bases\",\n *   {\n *     tools: [tools.fileSearch({\n *       vectorStoreIds: [\"vs_abc123\", \"vs_def456\"]\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Vector stores must be created and populated before using this tool\n * - The tool returns file citations in the response annotations\n * - Use `include: [\"file_search_call.results\"]` in the API call to get search results\n * - Supported file types include PDF, DOCX, TXT, MD, and many code file formats\n */\nexport function fileSearch(options: FileSearchOptions): ServerTool {\n  return {\n    type: \"file_search\",\n    vector_store_ids: options.vectorStoreIds,\n    max_num_results: options.maxNumResults,\n    filters: options.filters as FileSearchTool[\"filters\"],\n    ranking_options: convertRankingOptions(options.rankingOptions),\n  } satisfies FileSearchTool;\n}\n"],"mappings":";;;;AAiIA,SAAS,sBACPA,SACkE;AAClE,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO;EACL,QAAQ,QAAQ;EAChB,iBAAiB,QAAQ;EACzB,eAAe,QAAQ,eACnB;GACE,kBAAkB,QAAQ,aAAa;GACvC,aAAa,QAAQ,aAAa;EACnC,IACD;CACL;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8GD,SAAgB,WAAWC,SAAwC;AACjE,QAAO;EACL,MAAM;EACN,kBAAkB,QAAQ;EAC1B,iBAAiB,QAAQ;EACzB,SAAS,QAAQ;EACjB,iBAAiB,sBAAsB,QAAQ,eAAe;CAC/D;AACF"}

package/dist/tools/imageGeneration.cjs

@@ -0,0 +1,128 @@
+
+//#region src/tools/imageGeneration.ts
+/**
+* Converts input mask options to the API format.
+*/
+function convertInputImageMask(mask) {
+	if (!mask) return void 0;
+	return {
+		image_url: mask.imageUrl,
+		file_id: mask.fileId
+	};
+}
+/**
+* Creates an Image Generation tool that allows models to generate or edit images
+* using text prompts and optional image inputs.
+*
+* The image generation tool leverages the GPT Image model and automatically
+* optimizes text inputs for improved performance. When included in a request,
+* the model can decide when and how to generate images as part of the conversation.
+*
+* **Key Features**:
+* - Generate images from text descriptions
+* - Edit existing images with text instructions
+* - Multi-turn image editing by referencing previous responses
+* - Configurable output options (size, quality, format)
+* - Streaming support for partial image generation
+*
+* **Prompting Tips**:
+* - Use terms like "draw" or "edit" in your prompt for best results
+* - For combining images, say "edit the first image by adding this element" instead of "combine"
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-image-generation | OpenAI Image Generation Documentation}
+*
+* @param options - Configuration options for the Image Generation tool
+* @returns An Image Generation tool definition to be passed to the OpenAI Responses API
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+*
+* const model = new ChatOpenAI({ model: "gpt-4o" });
+*
+* // Basic usage - generate an image
+* const response = await model.invoke(
+*   "Generate an image of a gray tabby cat hugging an otter with an orange scarf",
+*   { tools: [tools.imageGeneration()] }
+* );
+*
+* // Access the generated image
+* const imageData = response.additional_kwargs.tool_outputs?.find(
+*   (output) => output.type === "image_generation_call"
+* );
+* if (imageData?.result) {
+*   // imageData.result contains the base64-encoded image
+*   const fs = await import("fs");
+*   fs.writeFileSync("output.png", Buffer.from(imageData.result, "base64"));
+* }
+*
+* // With custom options
+* const response = await model.invoke(
+*   "Draw a beautiful sunset over mountains",
+*   {
+*     tools: [tools.imageGeneration({
+*       size: "1536x1024",      // Landscape format
+*       quality: "high",        // Higher quality output
+*       outputFormat: "jpeg",   // JPEG format
+*       outputCompression: 90,  // 90% compression
+*     })]
+*   }
+* );
+*
+* // With transparent background
+* const response = await model.invoke(
+*   "Create a logo with a transparent background",
+*   {
+*     tools: [tools.imageGeneration({
+*       background: "transparent",
+*       outputFormat: "png",
+*     })]
+*   }
+* );
+*
+* // Force the model to use image generation
+* const response = await model.invoke(
+*   "A serene lake at dawn",
+*   {
+*     tools: [tools.imageGeneration()],
+*     tool_choice: { type: "image_generation" },
+*   }
+* );
+*
+* // Enable streaming with partial images
+* const response = await model.invoke(
+*   "Draw a detailed fantasy castle",
+*   {
+*     tools: [tools.imageGeneration({
+*       partialImages: 2,  // Get 2 partial images during generation
+*     })]
+*   }
+* );
+* ```
+*
+* @remarks
+* - Supported models: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3
+* - The image generation process always uses `gpt-image-1` model internally
+* - The model will automatically revise prompts for improved performance
+* - Access the revised prompt via `revised_prompt` field in the output
+* - Multi-turn editing is supported by passing previous response messages
+*/
+function imageGeneration(options) {
+	return {
+		type: "image_generation",
+		background: options?.background,
+		input_fidelity: options?.inputFidelity,
+		input_image_mask: convertInputImageMask(options?.inputImageMask),
+		model: options?.model,
+		moderation: options?.moderation,
+		output_compression: options?.outputCompression,
+		output_format: options?.outputFormat,
+		partial_images: options?.partialImages,
+		quality: options?.quality,
+		size: options?.size
+	};
+}
+
+//#endregion
+exports.imageGeneration = imageGeneration;
+//# sourceMappingURL=imageGeneration.cjs.map

package/dist/tools/imageGeneration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageGeneration.cjs","names":["mask: ImageGenerationInputMask | undefined","options?: ImageGenerationOptions"],"sources":["../../src/tools/imageGeneration.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n\n/**\n * Optional mask for inpainting. Allows you to specify areas of the image\n * that should be regenerated.\n */\nexport interface ImageGenerationInputMask {\n  /**\n   * Base64-encoded mask image URL.\n   */\n  imageUrl?: string;\n  /**\n   * File ID for the mask image (uploaded via OpenAI File API).\n   */\n  fileId?: string;\n}\n\n/**\n * Options for the Image Generation tool.\n */\nexport interface ImageGenerationOptions {\n  /**\n   * Background type for the generated image.\n   * - `transparent`: Generate image with transparent background\n   * - `opaque`: Generate image with opaque background\n   * - `auto`: Let the model decide based on the prompt\n   * @default \"auto\"\n   */\n  background?: \"transparent\" | \"opaque\" | \"auto\";\n\n  /**\n   * Control how much effort the model will exert to match the style and features,\n   * especially facial features, of input images. This parameter is only supported\n   * for `gpt-image-1`. Unsupported for `gpt-image-1-mini`.\n   * - `high`: Higher fidelity to input images\n   * - `low`: Lower fidelity to input images\n   * @default \"low\"\n   */\n  inputFidelity?: \"high\" | \"low\";\n\n  /**\n   * Optional mask for inpainting. Use this to specify areas of an image\n   * that should be regenerated.\n   */\n  inputImageMask?: ImageGenerationInputMask;\n\n  /**\n   * The image generation model to use.\n   * @default \"gpt-image-1\"\n   */\n  model?: \"gpt-image-1\" | \"gpt-image-1-mini\";\n\n  /**\n   * Moderation level for the generated image.\n   * - `auto`: Standard moderation\n   * - `low`: Less restrictive moderation\n   * @default \"auto\"\n   */\n  moderation?: \"auto\" | \"low\";\n\n  /**\n   * Compression level for the output image (0-100).\n   * Only applies to JPEG and WebP formats.\n   * @default 100\n   */\n  outputCompression?: number;\n\n  /**\n   * The output format of the generated image.\n   * @default \"png\"\n   */\n  outputFormat?: \"png\" | \"webp\" | \"jpeg\";\n\n  /**\n   * Number of partial images to generate in streaming mode (0-3).\n   * When set, the model will return partial images as they are generated,\n   * providing faster visual feedback.\n   * @default 0\n   */\n  partialImages?: number;\n\n  /**\n   * The quality of the generated image.\n   * - `low`: Faster generation, lower quality\n   * - `medium`: Balanced generation time and quality\n   * - `high`: Slower generation, higher quality\n   * - `auto`: Let the model decide based on the prompt\n   * @default \"auto\"\n   */\n  quality?: \"low\" | \"medium\" | \"high\" | \"auto\";\n\n  /**\n   * The size of the generated image.\n   * - `1024x1024`: Square format\n   * - `1024x1536`: Portrait format\n   * - `1536x1024`: Landscape format\n   * - `auto`: Let the model decide based on the prompt\n   * @default \"auto\"\n   */\n  size?: \"1024x1024\" | \"1024x1536\" | \"1536x1024\" | \"auto\";\n}\n\n/**\n * OpenAI Image Generation tool type for the Responses API.\n */\nexport type ImageGenerationTool = OpenAIClient.Responses.Tool.ImageGeneration;\n\n/**\n * Converts input mask options to the API format.\n */\nfunction convertInputImageMask(\n  mask: ImageGenerationInputMask | undefined\n): ImageGenerationTool[\"input_image_mask\"] {\n  if (!mask) return undefined;\n  return {\n    image_url: mask.imageUrl,\n    file_id: mask.fileId,\n  };\n}\n\n/**\n * Creates an Image Generation tool that allows models to generate or edit images\n * using text prompts and optional image inputs.\n *\n * The image generation tool leverages the GPT Image model and automatically\n * optimizes text inputs for improved performance. When included in a request,\n * the model can decide when and how to generate images as part of the conversation.\n *\n * **Key Features**:\n * - Generate images from text descriptions\n * - Edit existing images with text instructions\n * - Multi-turn image editing by referencing previous responses\n * - Configurable output options (size, quality, format)\n * - Streaming support for partial image generation\n *\n * **Prompting Tips**:\n * - Use terms like \"draw\" or \"edit\" in your prompt for best results\n * - For combining images, say \"edit the first image by adding this element\" instead of \"combine\"\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-image-generation | OpenAI Image Generation Documentation}\n *\n * @param options - Configuration options for the Image Generation tool\n * @returns An Image Generation 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-4o\" });\n *\n * // Basic usage - generate an image\n * const response = await model.invoke(\n *   \"Generate an image of a gray tabby cat hugging an otter with an orange scarf\",\n *   { tools: [tools.imageGeneration()] }\n * );\n *\n * // Access the generated image\n * const imageData = response.additional_kwargs.tool_outputs?.find(\n *   (output) => output.type === \"image_generation_call\"\n * );\n * if (imageData?.result) {\n *   // imageData.result contains the base64-encoded image\n *   const fs = await import(\"fs\");\n *   fs.writeFileSync(\"output.png\", Buffer.from(imageData.result, \"base64\"));\n * }\n *\n * // With custom options\n * const response = await model.invoke(\n *   \"Draw a beautiful sunset over mountains\",\n *   {\n *     tools: [tools.imageGeneration({\n *       size: \"1536x1024\",      // Landscape format\n *       quality: \"high\",        // Higher quality output\n *       outputFormat: \"jpeg\",   // JPEG format\n *       outputCompression: 90,  // 90% compression\n *     })]\n *   }\n * );\n *\n * // With transparent background\n * const response = await model.invoke(\n *   \"Create a logo with a transparent background\",\n *   {\n *     tools: [tools.imageGeneration({\n *       background: \"transparent\",\n *       outputFormat: \"png\",\n *     })]\n *   }\n * );\n *\n * // Force the model to use image generation\n * const response = await model.invoke(\n *   \"A serene lake at dawn\",\n *   {\n *     tools: [tools.imageGeneration()],\n *     tool_choice: { type: \"image_generation\" },\n *   }\n * );\n *\n * // Enable streaming with partial images\n * const response = await model.invoke(\n *   \"Draw a detailed fantasy castle\",\n *   {\n *     tools: [tools.imageGeneration({\n *       partialImages: 2,  // Get 2 partial images during generation\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Supported models: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3\n * - The image generation process always uses `gpt-image-1` model internally\n * - The model will automatically revise prompts for improved performance\n * - Access the revised prompt via `revised_prompt` field in the output\n * - Multi-turn editing is supported by passing previous response messages\n */\nexport function imageGeneration(options?: ImageGenerationOptions): ServerTool {\n  return {\n    type: \"image_generation\",\n    background: options?.background,\n    input_fidelity: options?.inputFidelity,\n    input_image_mask: convertInputImageMask(options?.inputImageMask),\n    model: options?.model,\n    moderation: options?.moderation,\n    output_compression: options?.outputCompression,\n    output_format: options?.outputFormat,\n    partial_images: options?.partialImages,\n    quality: options?.quality,\n    size: options?.size,\n  } satisfies ImageGenerationTool;\n}\n"],"mappings":";;;;;AA+GA,SAAS,sBACPA,MACyC;AACzC,KAAI,CAAC,KAAM,QAAO;AAClB,QAAO;EACL,WAAW,KAAK;EAChB,SAAS,KAAK;CACf;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGD,SAAgB,gBAAgBC,SAA8C;AAC5E,QAAO;EACL,MAAM;EACN,YAAY,SAAS;EACrB,gBAAgB,SAAS;EACzB,kBAAkB,sBAAsB,SAAS,eAAe;EAChE,OAAO,SAAS;EAChB,YAAY,SAAS;EACrB,oBAAoB,SAAS;EAC7B,eAAe,SAAS;EACxB,gBAAgB,SAAS;EACzB,SAAS,SAAS;EAClB,MAAM,SAAS;CAChB;AACF"}

package/dist/tools/imageGeneration.d.cts

@@ -0,0 +1,199 @@
+import { OpenAI as OpenAI$1 } from "openai";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/imageGeneration.d.ts
+
+/**
+ * Optional mask for inpainting. Allows you to specify areas of the image
+ * that should be regenerated.
+ */
+interface ImageGenerationInputMask {
+  /**
+   * Base64-encoded mask image URL.
+   */
+  imageUrl?: string;
+  /**
+   * File ID for the mask image (uploaded via OpenAI File API).
+   */
+  fileId?: string;
+}
+/**
+ * Options for the Image Generation tool.
+ */
+interface ImageGenerationOptions {
+  /**
+   * Background type for the generated image.
+   * - `transparent`: Generate image with transparent background
+   * - `opaque`: Generate image with opaque background
+   * - `auto`: Let the model decide based on the prompt
+   * @default "auto"
+   */
+  background?: "transparent" | "opaque" | "auto";
+  /**
+   * Control how much effort the model will exert to match the style and features,
+   * especially facial features, of input images. This parameter is only supported
+   * for `gpt-image-1`. Unsupported for `gpt-image-1-mini`.
+   * - `high`: Higher fidelity to input images
+   * - `low`: Lower fidelity to input images
+   * @default "low"
+   */
+  inputFidelity?: "high" | "low";
+  /**
+   * Optional mask for inpainting. Use this to specify areas of an image
+   * that should be regenerated.
+   */
+  inputImageMask?: ImageGenerationInputMask;
+  /**
+   * The image generation model to use.
+   * @default "gpt-image-1"
+   */
+  model?: "gpt-image-1" | "gpt-image-1-mini";
+  /**
+   * Moderation level for the generated image.
+   * - `auto`: Standard moderation
+   * - `low`: Less restrictive moderation
+   * @default "auto"
+   */
+  moderation?: "auto" | "low";
+  /**
+   * Compression level for the output image (0-100).
+   * Only applies to JPEG and WebP formats.
+   * @default 100
+   */
+  outputCompression?: number;
+  /**
+   * The output format of the generated image.
+   * @default "png"
+   */
+  outputFormat?: "png" | "webp" | "jpeg";
+  /**
+   * Number of partial images to generate in streaming mode (0-3).
+   * When set, the model will return partial images as they are generated,
+   * providing faster visual feedback.
+   * @default 0
+   */
+  partialImages?: number;
+  /**
+   * The quality of the generated image.
+   * - `low`: Faster generation, lower quality
+   * - `medium`: Balanced generation time and quality
+   * - `high`: Slower generation, higher quality
+   * - `auto`: Let the model decide based on the prompt
+   * @default "auto"
+   */
+  quality?: "low" | "medium" | "high" | "auto";
+  /**
+   * The size of the generated image.
+   * - `1024x1024`: Square format
+   * - `1024x1536`: Portrait format
+   * - `1536x1024`: Landscape format
+   * - `auto`: Let the model decide based on the prompt
+   * @default "auto"
+   */
+  size?: "1024x1024" | "1024x1536" | "1536x1024" | "auto";
+}
+/**
+ * OpenAI Image Generation tool type for the Responses API.
+ */
+type ImageGenerationTool = OpenAI$1.Responses.Tool.ImageGeneration;
+/**
+ * Creates an Image Generation tool that allows models to generate or edit images
+ * using text prompts and optional image inputs.
+ *
+ * The image generation tool leverages the GPT Image model and automatically
+ * optimizes text inputs for improved performance. When included in a request,
+ * the model can decide when and how to generate images as part of the conversation.
+ *
+ * **Key Features**:
+ * - Generate images from text descriptions
+ * - Edit existing images with text instructions
+ * - Multi-turn image editing by referencing previous responses
+ * - Configurable output options (size, quality, format)
+ * - Streaming support for partial image generation
+ *
+ * **Prompting Tips**:
+ * - Use terms like "draw" or "edit" in your prompt for best results
+ * - For combining images, say "edit the first image by adding this element" instead of "combine"
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-image-generation | OpenAI Image Generation Documentation}
+ *
+ * @param options - Configuration options for the Image Generation tool
+ * @returns An Image Generation tool definition to be passed to the OpenAI Responses API
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-4o" });
+ *
+ * // Basic usage - generate an image
+ * const response = await model.invoke(
+ *   "Generate an image of a gray tabby cat hugging an otter with an orange scarf",
+ *   { tools: [tools.imageGeneration()] }
+ * );
+ *
+ * // Access the generated image
+ * const imageData = response.additional_kwargs.tool_outputs?.find(
+ *   (output) => output.type === "image_generation_call"
+ * );
+ * if (imageData?.result) {
+ *   // imageData.result contains the base64-encoded image
+ *   const fs = await import("fs");
+ *   fs.writeFileSync("output.png", Buffer.from(imageData.result, "base64"));
+ * }
+ *
+ * // With custom options
+ * const response = await model.invoke(
+ *   "Draw a beautiful sunset over mountains",
+ *   {
+ *     tools: [tools.imageGeneration({
+ *       size: "1536x1024",      // Landscape format
+ *       quality: "high",        // Higher quality output
+ *       outputFormat: "jpeg",   // JPEG format
+ *       outputCompression: 90,  // 90% compression
+ *     })]
+ *   }
+ * );
+ *
+ * // With transparent background
+ * const response = await model.invoke(
+ *   "Create a logo with a transparent background",
+ *   {
+ *     tools: [tools.imageGeneration({
+ *       background: "transparent",
+ *       outputFormat: "png",
+ *     })]
+ *   }
+ * );
+ *
+ * // Force the model to use image generation
+ * const response = await model.invoke(
+ *   "A serene lake at dawn",
+ *   {
+ *     tools: [tools.imageGeneration()],
+ *     tool_choice: { type: "image_generation" },
+ *   }
+ * );
+ *
+ * // Enable streaming with partial images
+ * const response = await model.invoke(
+ *   "Draw a detailed fantasy castle",
+ *   {
+ *     tools: [tools.imageGeneration({
+ *       partialImages: 2,  // Get 2 partial images during generation
+ *     })]
+ *   }
+ * );
+ * ```
+ *
+ * @remarks
+ * - Supported models: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3
+ * - The image generation process always uses `gpt-image-1` model internally
+ * - The model will automatically revise prompts for improved performance
+ * - Access the revised prompt via `revised_prompt` field in the output
+ * - Multi-turn editing is supported by passing previous response messages
+ */
+declare function imageGeneration(options?: ImageGenerationOptions): ServerTool;
+//#endregion
+export { ImageGenerationInputMask, ImageGenerationOptions, ImageGenerationTool, imageGeneration };
+//# sourceMappingURL=imageGeneration.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"imageGeneration.d.cts","names":["OpenAI","OpenAIClient","ServerTool","ImageGenerationInputMask","ImageGenerationOptions","ImageGenerationTool","Responses","Tool","ImageGeneration","imageGeneration"],"sources":["../../src/tools/imageGeneration.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport type { ServerTool } from \"@langchain/core/tools\";\n/**\n * Optional mask for inpainting. Allows you to specify areas of the image\n * that should be regenerated.\n */\nexport interface ImageGenerationInputMask {\n    /**\n     * Base64-encoded mask image URL.\n     */\n    imageUrl?: string;\n    /**\n     * File ID for the mask image (uploaded via OpenAI File API).\n     */\n    fileId?: string;\n}\n/**\n * Options for the Image Generation tool.\n */\nexport interface ImageGenerationOptions {\n    /**\n     * Background type for the generated image.\n     * - `transparent`: Generate image with transparent background\n     * - `opaque`: Generate image with opaque background\n     * - `auto`: Let the model decide based on the prompt\n     * @default \"auto\"\n     */\n    background?: \"transparent\" | \"opaque\" | \"auto\";\n    /**\n     * Control how much effort the model will exert to match the style and features,\n     * especially facial features, of input images. This parameter is only supported\n     * for `gpt-image-1`. Unsupported for `gpt-image-1-mini`.\n     * - `high`: Higher fidelity to input images\n     * - `low`: Lower fidelity to input images\n     * @default \"low\"\n     */\n    inputFidelity?: \"high\" | \"low\";\n    /**\n     * Optional mask for inpainting. Use this to specify areas of an image\n     * that should be regenerated.\n     */\n    inputImageMask?: ImageGenerationInputMask;\n    /**\n     * The image generation model to use.\n     * @default \"gpt-image-1\"\n     */\n    model?: \"gpt-image-1\" | \"gpt-image-1-mini\";\n    /**\n     * Moderation level for the generated image.\n     * - `auto`: Standard moderation\n     * - `low`: Less restrictive moderation\n     * @default \"auto\"\n     */\n    moderation?: \"auto\" | \"low\";\n    /**\n     * Compression level for the output image (0-100).\n     * Only applies to JPEG and WebP formats.\n     * @default 100\n     */\n    outputCompression?: number;\n    /**\n     * The output format of the generated image.\n     * @default \"png\"\n     */\n    outputFormat?: \"png\" | \"webp\" | \"jpeg\";\n    /**\n     * Number of partial images to generate in streaming mode (0-3).\n     * When set, the model will return partial images as they are generated,\n     * providing faster visual feedback.\n     * @default 0\n     */\n    partialImages?: number;\n    /**\n     * The quality of the generated image.\n     * - `low`: Faster generation, lower quality\n     * - `medium`: Balanced generation time and quality\n     * - `high`: Slower generation, higher quality\n     * - `auto`: Let the model decide based on the prompt\n     * @default \"auto\"\n     */\n    quality?: \"low\" | \"medium\" | \"high\" | \"auto\";\n    /**\n     * The size of the generated image.\n     * - `1024x1024`: Square format\n     * - `1024x1536`: Portrait format\n     * - `1536x1024`: Landscape format\n     * - `auto`: Let the model decide based on the prompt\n     * @default \"auto\"\n     */\n    size?: \"1024x1024\" | \"1024x1536\" | \"1536x1024\" | \"auto\";\n}\n/**\n * OpenAI Image Generation tool type for the Responses API.\n */\nexport type ImageGenerationTool = OpenAIClient.Responses.Tool.ImageGeneration;\n/**\n * Creates an Image Generation tool that allows models to generate or edit images\n * using text prompts and optional image inputs.\n *\n * The image generation tool leverages the GPT Image model and automatically\n * optimizes text inputs for improved performance. When included in a request,\n * the model can decide when and how to generate images as part of the conversation.\n *\n * **Key Features**:\n * - Generate images from text descriptions\n * - Edit existing images with text instructions\n * - Multi-turn image editing by referencing previous responses\n * - Configurable output options (size, quality, format)\n * - Streaming support for partial image generation\n *\n * **Prompting Tips**:\n * - Use terms like \"draw\" or \"edit\" in your prompt for best results\n * - For combining images, say \"edit the first image by adding this element\" instead of \"combine\"\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-image-generation | OpenAI Image Generation Documentation}\n *\n * @param options - Configuration options for the Image Generation tool\n * @returns An Image Generation 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-4o\" });\n *\n * // Basic usage - generate an image\n * const response = await model.invoke(\n *   \"Generate an image of a gray tabby cat hugging an otter with an orange scarf\",\n *   { tools: [tools.imageGeneration()] }\n * );\n *\n * // Access the generated image\n * const imageData = response.additional_kwargs.tool_outputs?.find(\n *   (output) => output.type === \"image_generation_call\"\n * );\n * if (imageData?.result) {\n *   // imageData.result contains the base64-encoded image\n *   const fs = await import(\"fs\");\n *   fs.writeFileSync(\"output.png\", Buffer.from(imageData.result, \"base64\"));\n * }\n *\n * // With custom options\n * const response = await model.invoke(\n *   \"Draw a beautiful sunset over mountains\",\n *   {\n *     tools: [tools.imageGeneration({\n *       size: \"1536x1024\",      // Landscape format\n *       quality: \"high\",        // Higher quality output\n *       outputFormat: \"jpeg\",   // JPEG format\n *       outputCompression: 90,  // 90% compression\n *     })]\n *   }\n * );\n *\n * // With transparent background\n * const response = await model.invoke(\n *   \"Create a logo with a transparent background\",\n *   {\n *     tools: [tools.imageGeneration({\n *       background: \"transparent\",\n *       outputFormat: \"png\",\n *     })]\n *   }\n * );\n *\n * // Force the model to use image generation\n * const response = await model.invoke(\n *   \"A serene lake at dawn\",\n *   {\n *     tools: [tools.imageGeneration()],\n *     tool_choice: { type: \"image_generation\" },\n *   }\n * );\n *\n * // Enable streaming with partial images\n * const response = await model.invoke(\n *   \"Draw a detailed fantasy castle\",\n *   {\n *     tools: [tools.imageGeneration({\n *       partialImages: 2,  // Get 2 partial images during generation\n *     })]\n *   }\n * );\n * ```\n *\n * @remarks\n * - Supported models: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3\n * - The image generation process always uses `gpt-image-1` model internally\n * - The model will automatically revise prompts for improved performance\n * - Access the revised prompt via `revised_prompt` field in the output\n * - Multi-turn editing is supported by passing previous response messages\n */\nexport declare function imageGeneration(options?: ImageGenerationOptions): ServerTool;\n//# sourceMappingURL=imageGeneration.d.ts.map"],"mappings":";;;;;;;AAMA;AAaA;AA2EYK,UAxFKF,wBAAAA,CAwFiBF;EAkGVQ;;;;;;;;;;;;UA7KPL,sBAAAA;;;;;;;;;;;;;;;;;;;;;;mBAsBID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqDTE,mBAAAA,GAAsBJ,QAAAA,CAAaK,SAAAA,CAAUC,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkGtCC,eAAAA,WAA0BL,yBAAyBF"}