@langchain/core 1.1.20 → 1.1.22

package/dist/messages/block_translators/openai.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai.js","names":["message: AIMessage","blocks: Array<ContentBlock.Standard>","blocks: Array<ContentBlock>","convertedBlocks: Array<ContentBlock.Standard>","annotation: ContentBlock","message: AIMessageChunk","ChatOpenAITranslator: StandardContentBlockTranslator"],"sources":["../../../src/messages/block_translators/openai.ts"],"sourcesContent":["import type { ContentBlock } from \"../content/index.js\";\nimport type { AIMessageChunk, AIMessage } from \"../ai.js\";\nimport type { StandardContentBlockTranslator } from \"./index.js\";\nimport { convertToV1FromOpenAIDataBlock, isOpenAIDataBlock } from \"./data.js\";\nimport {\n  _isArray,\n  _isContentBlock,\n  _isObject,\n  _isString,\n  iife,\n} from \"./utils.js\";\n\n/**\n * Converts a ChatOpenAICompletions message to an array of v1 standard content blocks.\n *\n * This function processes an AI message from ChatOpenAICompletions API format\n * and converts it to the standardized v1 content block format. It handles both\n * string content and structured content blocks, as well as tool calls.\n *\n * @param message - The AI message containing ChatOpenAICompletions formatted content\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const message = new AIMessage(\"Hello world\");\n * const standardBlocks = convertToV1FromChatCompletions(message);\n * // Returns: [{ type: \"text\", text: \"Hello world\" }]\n * ```\n *\n * @example\n * ```typescript\n * const message = new AIMessage([\n *   { type: \"text\", text: \"Hello\" },\n *   { type: \"image_url\", image_url: { url: \"https://example.com/image.png\" } }\n * ]);\n * message.tool_calls = [\n *   { id: \"call_123\", name: \"calculator\", args: { a: 1, b: 2 } }\n * ];\n *\n * const standardBlocks = convertToV1FromChatCompletions(message);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Hello\" },\n * //   { type: \"image\", url: \"https://example.com/image.png\" },\n * //   { type: \"tool_call\", id: \"call_123\", name: \"calculator\", args: { a: 1, b: 2 } }\n * // ]\n * ```\n */\nexport function convertToV1FromChatCompletions(\n  message: AIMessage\n): Array<ContentBlock.Standard> {\n  const blocks: Array<ContentBlock.Standard> = [];\n  if (typeof message.content === \"string\") {\n    blocks.push({\n      type: \"text\",\n      text: message.content,\n    });\n  } else {\n    blocks.push(...convertToV1FromChatCompletionsInput(message.content));\n  }\n  for (const toolCall of message.tool_calls ?? []) {\n    blocks.push({\n      type: \"tool_call\",\n      id: toolCall.id,\n      name: toolCall.name,\n      args: toolCall.args,\n    });\n  }\n  return blocks;\n}\n\n/**\n * Converts a ChatOpenAICompletions message chunk to an array of v1 standard content blocks.\n *\n * This function processes an AI message chunk from OpenAI's chat completions API and converts\n * it to the standardized v1 content block format. It handles both string and array content,\n * as well as tool calls that may be present in the chunk.\n *\n * @param message - The AI message chunk containing OpenAI-formatted content blocks\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const chunk = new AIMessage(\"Hello\");\n * const standardBlocks = convertToV1FromChatCompletionsChunk(chunk);\n * // Returns: [{ type: \"text\", text: \"Hello\" }]\n * ```\n *\n * @example\n * ```typescript\n * const chunk = new AIMessage([\n *   { type: \"text\", text: \"Processing...\" }\n * ]);\n * chunk.tool_calls = [\n *   { id: \"call_456\", name: \"search\", args: { query: \"test\" } }\n * ];\n *\n * const standardBlocks = convertToV1FromChatCompletionsChunk(chunk);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Processing...\" },\n * //   { type: \"tool_call\", id: \"call_456\", name: \"search\", args: { query: \"test\" } }\n * // ]\n * ```\n */\nexport function convertToV1FromChatCompletionsChunk(\n  message: AIMessage\n): Array<ContentBlock.Standard> {\n  const blocks: Array<ContentBlock.Standard> = [];\n  if (typeof message.content === \"string\") {\n    blocks.push({\n      type: \"text\",\n      text: message.content,\n    });\n  } else {\n    blocks.push(...convertToV1FromChatCompletionsInput(message.content));\n  }\n\n  // TODO: parse chunk position information\n  for (const toolCall of message.tool_calls ?? []) {\n    blocks.push({\n      type: \"tool_call\",\n      id: toolCall.id,\n      name: toolCall.name,\n      args: toolCall.args,\n    });\n  }\n  return blocks;\n}\n\n/**\n * Converts an array of ChatOpenAICompletions content blocks to v1 standard content blocks.\n *\n * This function processes content blocks from OpenAI's Chat Completions API format\n * and converts them to the standardized v1 content block format. It handles both\n * OpenAI-specific data blocks (which require conversion) and standard blocks\n * (which are passed through with type assertion).\n *\n * @param blocks - Array of content blocks in ChatOpenAICompletions format\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const openaiBlocks = [\n *   { type: \"text\", text: \"Hello world\" },\n *   { type: \"image_url\", image_url: { url: \"https://example.com/image.png\" } }\n * ];\n *\n * const standardBlocks = convertToV1FromChatCompletionsInput(openaiBlocks);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Hello world\" },\n * //   { type: \"image\", url: \"https://example.com/image.png\" }\n * // ]\n * ```\n */\nexport function convertToV1FromChatCompletionsInput(\n  blocks: Array<ContentBlock>\n): Array<ContentBlock.Standard> {\n  const convertedBlocks: Array<ContentBlock.Standard> = [];\n  for (const block of blocks) {\n    if (isOpenAIDataBlock(block)) {\n      convertedBlocks.push(convertToV1FromOpenAIDataBlock(block));\n    } else {\n      convertedBlocks.push(block as ContentBlock.Standard);\n    }\n  }\n  return convertedBlocks;\n}\n\nfunction convertResponsesAnnotation(\n  annotation: ContentBlock\n): ContentBlock | ContentBlock.Citation {\n  if (annotation.type === \"url_citation\") {\n    const { url, title, start_index, end_index } = annotation;\n    return {\n      type: \"citation\",\n      url,\n      title,\n      startIndex: start_index,\n      endIndex: end_index,\n    };\n  }\n  if (annotation.type === \"file_citation\") {\n    const { file_id, filename, index } = annotation;\n    return {\n      type: \"citation\",\n      title: filename,\n      startIndex: index,\n      endIndex: index,\n      fileId: file_id,\n    };\n  }\n  return annotation;\n}\n\n/**\n * Converts a ChatOpenAIResponses message to an array of v1 standard content blocks.\n *\n * This function processes an AI message containing OpenAI Responses-specific content blocks\n * and converts them to the standardized v1 content block format. It handles reasoning summaries,\n * text content with annotations, tool calls, and various tool outputs including code interpreter,\n * web search, file search, computer calls, and MCP-related blocks.\n *\n * @param message - The AI message containing OpenAI Responses-formatted content blocks\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const message = new AIMessage({\n *   content: [{ type: \"text\", text: \"Hello world\", annotations: [] }],\n *   tool_calls: [{ id: \"123\", name: \"calculator\", args: { a: 1, b: 2 } }],\n *   additional_kwargs: {\n *     reasoning: { summary: [{ text: \"Let me calculate this...\" }] },\n *     tool_outputs: [\n *       {\n *         type: \"code_interpreter_call\",\n *         code: \"print('hello')\",\n *         outputs: [{ type: \"logs\", logs: \"hello\" }]\n *       }\n *     ]\n *   }\n * });\n *\n * const standardBlocks = convertToV1FromResponses(message);\n * // Returns:\n * // [\n * //   { type: \"reasoning\", reasoning: \"Let me calculate this...\" },\n * //   { type: \"text\", text: \"Hello world\", annotations: [] },\n * //   { type: \"tool_call\", id: \"123\", name: \"calculator\", args: { a: 1, b: 2 } },\n * //   { type: \"code_interpreter_call\", code: \"print('hello')\" },\n * //   { type: \"code_interpreter_result\", output: [{ type: \"code_interpreter_output\", returnCode: 0, stdout: \"hello\" }] }\n * // ]\n * ```\n */\nexport function convertToV1FromResponses(\n  message: AIMessage\n): Array<ContentBlock.Standard> {\n  function* iterateContent(): Iterable<ContentBlock.Standard> {\n    if (\n      _isObject(message.additional_kwargs?.reasoning) &&\n      _isArray(message.additional_kwargs.reasoning.summary)\n    ) {\n      const summary =\n        message.additional_kwargs.reasoning.summary.reduce<string>(\n          (acc, item) => {\n            if (_isObject(item) && _isString(item.text)) {\n              return `${acc}${item.text}`;\n            }\n            return acc;\n          },\n          \"\"\n        );\n      yield {\n        type: \"reasoning\",\n        reasoning: summary,\n      };\n    }\n    const content =\n      typeof message.content === \"string\"\n        ? [{ type: \"text\", text: message.content }]\n        : message.content;\n    for (const block of content) {\n      if (_isContentBlock(block, \"text\")) {\n        const { text, annotations, ...rest } = block;\n        if (Array.isArray(annotations)) {\n          yield {\n            ...rest,\n            type: \"text\",\n            text: String(text),\n            annotations: annotations.map(convertResponsesAnnotation),\n          };\n        } else {\n          yield {\n            ...rest,\n            type: \"text\",\n            text: String(text),\n          };\n        }\n      }\n    }\n    for (const toolCall of message.tool_calls ?? []) {\n      yield {\n        type: \"tool_call\",\n        id: toolCall.id,\n        name: toolCall.name,\n        args: toolCall.args,\n      };\n    }\n    if (\n      _isObject(message.additional_kwargs) &&\n      _isArray(message.additional_kwargs.tool_outputs)\n    ) {\n      for (const toolOutput of message.additional_kwargs.tool_outputs) {\n        if (_isContentBlock(toolOutput, \"web_search_call\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"web_search\",\n            args: { query: toolOutput.query },\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"file_search_call\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"file_search\",\n            args: { query: toolOutput.query },\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"computer_call\")) {\n          yield { type: \"non_standard\", value: toolOutput };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"code_interpreter_call\")) {\n          if (_isString(toolOutput.code)) {\n            yield {\n              id: toolOutput.id,\n              type: \"server_tool_call\",\n              name: \"code_interpreter\",\n              args: { code: toolOutput.code },\n            };\n          }\n          if (_isArray(toolOutput.outputs)) {\n            const returnCode = iife(() => {\n              if (toolOutput.status === \"in_progress\") return undefined;\n              if (toolOutput.status === \"completed\") return 0;\n              if (toolOutput.status === \"incomplete\") return 127;\n              if (toolOutput.status === \"interpreting\") return undefined;\n              if (toolOutput.status === \"failed\") return 1;\n              return undefined;\n            });\n            for (const output of toolOutput.outputs) {\n              if (_isContentBlock(output, \"logs\")) {\n                yield {\n                  type: \"server_tool_call_result\",\n                  toolCallId: toolOutput.id ?? \"\",\n                  status: \"success\",\n                  output: {\n                    type: \"code_interpreter_output\",\n                    returnCode: returnCode ?? 0,\n                    stderr: [0, undefined].includes(returnCode)\n                      ? undefined\n                      : String(output.logs),\n                    stdout: [0, undefined].includes(returnCode)\n                      ? String(output.logs)\n                      : undefined,\n                  },\n                };\n                continue;\n              }\n            }\n          }\n          continue;\n        } else if (_isContentBlock(toolOutput, \"mcp_call\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"mcp_call\",\n            args: toolOutput.input,\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"mcp_list_tools\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"mcp_list_tools\",\n            args: toolOutput.input,\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"mcp_approval_request\")) {\n          yield { type: \"non_standard\", value: toolOutput };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"image_generation_call\")) {\n          // Convert image_generation_call to proper image content block if result is available\n          if (_isString(toolOutput.result)) {\n            yield {\n              type: \"image\",\n              mimeType: \"image/png\",\n              data: toolOutput.result,\n              id: _isString(toolOutput.id) ? toolOutput.id : undefined,\n              metadata: {\n                status: _isString(toolOutput.status)\n                  ? toolOutput.status\n                  : undefined,\n              },\n            };\n          }\n          // Also yield as non_standard for backwards compatibility\n          yield { type: \"non_standard\", value: toolOutput };\n          continue;\n        }\n        if (_isObject(toolOutput)) {\n          yield { type: \"non_standard\", value: toolOutput };\n        }\n      }\n    }\n  }\n  return Array.from(iterateContent());\n}\n\n/**\n * Converts a ChatOpenAIResponses message chunk to an array of v1 standard content blocks.\n *\n * This function processes an AI message chunk containing OpenAI-specific content blocks\n * and converts them to the standardized v1 content block format. It handles both the\n * regular message content and tool call chunks that are specific to streaming responses.\n *\n * @param message - The AI message chunk containing OpenAI-formatted content blocks\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const messageChunk = new AIMessageChunk({\n *   content: [{ type: \"text\", text: \"Hello\" }],\n *   tool_call_chunks: [\n *     { id: \"call_123\", name: \"calculator\", args: '{\"a\": 1' }\n *   ]\n * });\n *\n * const standardBlocks = convertToV1FromResponsesChunk(messageChunk);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Hello\" },\n * //   { type: \"tool_call_chunk\", id: \"call_123\", name: \"calculator\", args: '{\"a\": 1' }\n * // ]\n * ```\n */\nexport function convertToV1FromResponsesChunk(\n  message: AIMessageChunk\n): Array<ContentBlock.Standard> {\n  function* iterateContent(): Iterable<ContentBlock.Standard> {\n    yield* convertToV1FromResponses(message);\n    for (const toolCallChunk of message.tool_call_chunks ?? []) {\n      yield {\n        type: \"tool_call_chunk\",\n        id: toolCallChunk.id,\n        name: toolCallChunk.name,\n        args: toolCallChunk.args,\n      };\n    }\n  }\n  return Array.from(iterateContent());\n}\n\nexport const ChatOpenAITranslator: StandardContentBlockTranslator = {\n  translateContent: (message) => {\n    if (typeof message.content === \"string\") {\n      return convertToV1FromChatCompletions(message);\n    }\n    return convertToV1FromResponses(message);\n  },\n  translateContentChunk: (message) => {\n    if (typeof message.content === \"string\") {\n      return convertToV1FromChatCompletionsChunk(message);\n    }\n    return convertToV1FromResponsesChunk(message);\n  },\n};\n"],"mappings":"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"}
+{"version":3,"file":"openai.js","names":["message: AIMessage","blocks: Array<ContentBlock.Standard>","blocks: Array<ContentBlock>","convertedBlocks: Array<ContentBlock.Standard>","annotation: ContentBlock","message: AIMessageChunk","ChatOpenAITranslator: StandardContentBlockTranslator"],"sources":["../../../src/messages/block_translators/openai.ts"],"sourcesContent":["import type { ContentBlock } from \"../content/index.js\";\nimport type { AIMessageChunk, AIMessage } from \"../ai.js\";\nimport type { StandardContentBlockTranslator } from \"./index.js\";\nimport { convertToV1FromOpenAIDataBlock, isOpenAIDataBlock } from \"./data.js\";\nimport {\n  _isArray,\n  _isContentBlock,\n  _isObject,\n  _isString,\n  iife,\n} from \"./utils.js\";\n\n/**\n * Converts a ChatOpenAICompletions message to an array of v1 standard content blocks.\n *\n * This function processes an AI message from ChatOpenAICompletions API format\n * and converts it to the standardized v1 content block format. It handles both\n * string content and structured content blocks, as well as tool calls.\n *\n * @param message - The AI message containing ChatOpenAICompletions formatted content\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const message = new AIMessage(\"Hello world\");\n * const standardBlocks = convertToV1FromChatCompletions(message);\n * // Returns: [{ type: \"text\", text: \"Hello world\" }]\n * ```\n *\n * @example\n * ```typescript\n * const message = new AIMessage([\n *   { type: \"text\", text: \"Hello\" },\n *   { type: \"image_url\", image_url: { url: \"https://example.com/image.png\" } }\n * ]);\n * message.tool_calls = [\n *   { id: \"call_123\", name: \"calculator\", args: { a: 1, b: 2 } }\n * ];\n *\n * const standardBlocks = convertToV1FromChatCompletions(message);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Hello\" },\n * //   { type: \"image\", url: \"https://example.com/image.png\" },\n * //   { type: \"tool_call\", id: \"call_123\", name: \"calculator\", args: { a: 1, b: 2 } }\n * // ]\n * ```\n */\nexport function convertToV1FromChatCompletions(\n  message: AIMessage\n): Array<ContentBlock.Standard> {\n  const blocks: Array<ContentBlock.Standard> = [];\n  if (typeof message.content === \"string\") {\n    // Only add text block if content is non-empty\n    if (message.content.length > 0) {\n      blocks.push({\n        type: \"text\",\n        text: message.content,\n      });\n    }\n  } else {\n    blocks.push(...convertToV1FromChatCompletionsInput(message.content));\n  }\n  for (const toolCall of message.tool_calls ?? []) {\n    blocks.push({\n      type: \"tool_call\",\n      id: toolCall.id,\n      name: toolCall.name,\n      args: toolCall.args,\n    });\n  }\n  return blocks;\n}\n\n/**\n * Converts a ChatOpenAICompletions message chunk to an array of v1 standard content blocks.\n *\n * This function processes an AI message chunk from OpenAI's chat completions API and converts\n * it to the standardized v1 content block format. It handles both string and array content,\n * as well as tool calls that may be present in the chunk.\n *\n * @param message - The AI message chunk containing OpenAI-formatted content blocks\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const chunk = new AIMessage(\"Hello\");\n * const standardBlocks = convertToV1FromChatCompletionsChunk(chunk);\n * // Returns: [{ type: \"text\", text: \"Hello\" }]\n * ```\n *\n * @example\n * ```typescript\n * const chunk = new AIMessage([\n *   { type: \"text\", text: \"Processing...\" }\n * ]);\n * chunk.tool_calls = [\n *   { id: \"call_456\", name: \"search\", args: { query: \"test\" } }\n * ];\n *\n * const standardBlocks = convertToV1FromChatCompletionsChunk(chunk);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Processing...\" },\n * //   { type: \"tool_call\", id: \"call_456\", name: \"search\", args: { query: \"test\" } }\n * // ]\n * ```\n */\nexport function convertToV1FromChatCompletionsChunk(\n  message: AIMessage\n): Array<ContentBlock.Standard> {\n  const blocks: Array<ContentBlock.Standard> = [];\n  if (typeof message.content === \"string\") {\n    // Only add text block if content is non-empty\n    if (message.content.length > 0) {\n      blocks.push({\n        type: \"text\",\n        text: message.content,\n      });\n    }\n  } else {\n    blocks.push(...convertToV1FromChatCompletionsInput(message.content));\n  }\n\n  // TODO: parse chunk position information\n  for (const toolCall of message.tool_calls ?? []) {\n    blocks.push({\n      type: \"tool_call\",\n      id: toolCall.id,\n      name: toolCall.name,\n      args: toolCall.args,\n    });\n  }\n  return blocks;\n}\n\n/**\n * Converts an array of ChatOpenAICompletions content blocks to v1 standard content blocks.\n *\n * This function processes content blocks from OpenAI's Chat Completions API format\n * and converts them to the standardized v1 content block format. It handles both\n * OpenAI-specific data blocks (which require conversion) and standard blocks\n * (which are passed through with type assertion).\n *\n * @param blocks - Array of content blocks in ChatOpenAICompletions format\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const openaiBlocks = [\n *   { type: \"text\", text: \"Hello world\" },\n *   { type: \"image_url\", image_url: { url: \"https://example.com/image.png\" } }\n * ];\n *\n * const standardBlocks = convertToV1FromChatCompletionsInput(openaiBlocks);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Hello world\" },\n * //   { type: \"image\", url: \"https://example.com/image.png\" }\n * // ]\n * ```\n */\nexport function convertToV1FromChatCompletionsInput(\n  blocks: Array<ContentBlock>\n): Array<ContentBlock.Standard> {\n  const convertedBlocks: Array<ContentBlock.Standard> = [];\n  for (const block of blocks) {\n    if (isOpenAIDataBlock(block)) {\n      convertedBlocks.push(convertToV1FromOpenAIDataBlock(block));\n    } else {\n      convertedBlocks.push(block as ContentBlock.Standard);\n    }\n  }\n  return convertedBlocks;\n}\n\nfunction convertResponsesAnnotation(\n  annotation: ContentBlock\n): ContentBlock | ContentBlock.Citation {\n  if (annotation.type === \"url_citation\") {\n    const { url, title, start_index, end_index } = annotation;\n    return {\n      type: \"citation\",\n      url,\n      title,\n      startIndex: start_index,\n      endIndex: end_index,\n    };\n  }\n  if (annotation.type === \"file_citation\") {\n    const { file_id, filename, index } = annotation;\n    return {\n      type: \"citation\",\n      title: filename,\n      startIndex: index,\n      endIndex: index,\n      fileId: file_id,\n    };\n  }\n  return annotation;\n}\n\n/**\n * Converts a ChatOpenAIResponses message to an array of v1 standard content blocks.\n *\n * This function processes an AI message containing OpenAI Responses-specific content blocks\n * and converts them to the standardized v1 content block format. It handles reasoning summaries,\n * text content with annotations, tool calls, and various tool outputs including code interpreter,\n * web search, file search, computer calls, and MCP-related blocks.\n *\n * @param message - The AI message containing OpenAI Responses-formatted content blocks\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const message = new AIMessage({\n *   content: [{ type: \"text\", text: \"Hello world\", annotations: [] }],\n *   tool_calls: [{ id: \"123\", name: \"calculator\", args: { a: 1, b: 2 } }],\n *   additional_kwargs: {\n *     reasoning: { summary: [{ text: \"Let me calculate this...\" }] },\n *     tool_outputs: [\n *       {\n *         type: \"code_interpreter_call\",\n *         code: \"print('hello')\",\n *         outputs: [{ type: \"logs\", logs: \"hello\" }]\n *       }\n *     ]\n *   }\n * });\n *\n * const standardBlocks = convertToV1FromResponses(message);\n * // Returns:\n * // [\n * //   { type: \"reasoning\", reasoning: \"Let me calculate this...\" },\n * //   { type: \"text\", text: \"Hello world\", annotations: [] },\n * //   { type: \"tool_call\", id: \"123\", name: \"calculator\", args: { a: 1, b: 2 } },\n * //   { type: \"code_interpreter_call\", code: \"print('hello')\" },\n * //   { type: \"code_interpreter_result\", output: [{ type: \"code_interpreter_output\", returnCode: 0, stdout: \"hello\" }] }\n * // ]\n * ```\n */\nexport function convertToV1FromResponses(\n  message: AIMessage\n): Array<ContentBlock.Standard> {\n  function* iterateContent(): Iterable<ContentBlock.Standard> {\n    if (\n      _isObject(message.additional_kwargs?.reasoning) &&\n      _isArray(message.additional_kwargs.reasoning.summary)\n    ) {\n      const summary =\n        message.additional_kwargs.reasoning.summary.reduce<string>(\n          (acc, item) => {\n            if (_isObject(item) && _isString(item.text)) {\n              return `${acc}${item.text}`;\n            }\n            return acc;\n          },\n          \"\"\n        );\n      yield {\n        type: \"reasoning\",\n        reasoning: summary,\n      };\n    }\n    const content =\n      typeof message.content === \"string\"\n        ? [{ type: \"text\", text: message.content }]\n        : message.content;\n    for (const block of content) {\n      if (_isContentBlock(block, \"text\")) {\n        const { text, annotations, ...rest } = block;\n        if (Array.isArray(annotations)) {\n          yield {\n            ...rest,\n            type: \"text\",\n            text: String(text),\n            annotations: annotations.map(convertResponsesAnnotation),\n          };\n        } else {\n          yield {\n            ...rest,\n            type: \"text\",\n            text: String(text),\n          };\n        }\n      }\n    }\n    for (const toolCall of message.tool_calls ?? []) {\n      yield {\n        type: \"tool_call\",\n        id: toolCall.id,\n        name: toolCall.name,\n        args: toolCall.args,\n      };\n    }\n    if (\n      _isObject(message.additional_kwargs) &&\n      _isArray(message.additional_kwargs.tool_outputs)\n    ) {\n      for (const toolOutput of message.additional_kwargs.tool_outputs) {\n        if (_isContentBlock(toolOutput, \"web_search_call\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"web_search\",\n            args: { query: toolOutput.query },\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"file_search_call\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"file_search\",\n            args: { query: toolOutput.query },\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"computer_call\")) {\n          yield { type: \"non_standard\", value: toolOutput };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"code_interpreter_call\")) {\n          if (_isString(toolOutput.code)) {\n            yield {\n              id: toolOutput.id,\n              type: \"server_tool_call\",\n              name: \"code_interpreter\",\n              args: { code: toolOutput.code },\n            };\n          }\n          if (_isArray(toolOutput.outputs)) {\n            const returnCode = iife(() => {\n              if (toolOutput.status === \"in_progress\") return undefined;\n              if (toolOutput.status === \"completed\") return 0;\n              if (toolOutput.status === \"incomplete\") return 127;\n              if (toolOutput.status === \"interpreting\") return undefined;\n              if (toolOutput.status === \"failed\") return 1;\n              return undefined;\n            });\n            for (const output of toolOutput.outputs) {\n              if (_isContentBlock(output, \"logs\")) {\n                yield {\n                  type: \"server_tool_call_result\",\n                  toolCallId: toolOutput.id ?? \"\",\n                  status: \"success\",\n                  output: {\n                    type: \"code_interpreter_output\",\n                    returnCode: returnCode ?? 0,\n                    stderr: [0, undefined].includes(returnCode)\n                      ? undefined\n                      : String(output.logs),\n                    stdout: [0, undefined].includes(returnCode)\n                      ? String(output.logs)\n                      : undefined,\n                  },\n                };\n                continue;\n              }\n            }\n          }\n          continue;\n        } else if (_isContentBlock(toolOutput, \"mcp_call\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"mcp_call\",\n            args: toolOutput.input,\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"mcp_list_tools\")) {\n          yield {\n            id: toolOutput.id,\n            type: \"server_tool_call\",\n            name: \"mcp_list_tools\",\n            args: toolOutput.input,\n          };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"mcp_approval_request\")) {\n          yield { type: \"non_standard\", value: toolOutput };\n          continue;\n        } else if (_isContentBlock(toolOutput, \"image_generation_call\")) {\n          // Convert image_generation_call to proper image content block if result is available\n          if (_isString(toolOutput.result)) {\n            yield {\n              type: \"image\",\n              mimeType: \"image/png\",\n              data: toolOutput.result,\n              id: _isString(toolOutput.id) ? toolOutput.id : undefined,\n              metadata: {\n                status: _isString(toolOutput.status)\n                  ? toolOutput.status\n                  : undefined,\n              },\n            };\n          }\n          // Also yield as non_standard for backwards compatibility\n          yield { type: \"non_standard\", value: toolOutput };\n          continue;\n        }\n        if (_isObject(toolOutput)) {\n          yield { type: \"non_standard\", value: toolOutput };\n        }\n      }\n    }\n  }\n  return Array.from(iterateContent());\n}\n\n/**\n * Converts a ChatOpenAIResponses message chunk to an array of v1 standard content blocks.\n *\n * This function processes an AI message chunk containing OpenAI-specific content blocks\n * and converts them to the standardized v1 content block format. It handles both the\n * regular message content and tool call chunks that are specific to streaming responses.\n *\n * @param message - The AI message chunk containing OpenAI-formatted content blocks\n * @returns Array of content blocks in v1 standard format\n *\n * @example\n * ```typescript\n * const messageChunk = new AIMessageChunk({\n *   content: [{ type: \"text\", text: \"Hello\" }],\n *   tool_call_chunks: [\n *     { id: \"call_123\", name: \"calculator\", args: '{\"a\": 1' }\n *   ]\n * });\n *\n * const standardBlocks = convertToV1FromResponsesChunk(messageChunk);\n * // Returns:\n * // [\n * //   { type: \"text\", text: \"Hello\" },\n * //   { type: \"tool_call_chunk\", id: \"call_123\", name: \"calculator\", args: '{\"a\": 1' }\n * // ]\n * ```\n */\nexport function convertToV1FromResponsesChunk(\n  message: AIMessageChunk\n): Array<ContentBlock.Standard> {\n  function* iterateContent(): Iterable<ContentBlock.Standard> {\n    yield* convertToV1FromResponses(message);\n    for (const toolCallChunk of message.tool_call_chunks ?? []) {\n      yield {\n        type: \"tool_call_chunk\",\n        id: toolCallChunk.id,\n        name: toolCallChunk.name,\n        args: toolCallChunk.args,\n      };\n    }\n  }\n  return Array.from(iterateContent());\n}\n\nexport const ChatOpenAITranslator: StandardContentBlockTranslator = {\n  translateContent: (message) => {\n    if (typeof message.content === \"string\") {\n      return convertToV1FromChatCompletions(message);\n    }\n    return convertToV1FromResponses(message);\n  },\n  translateContentChunk: (message) => {\n    if (typeof message.content === \"string\") {\n      return convertToV1FromChatCompletionsChunk(message);\n    }\n    return convertToV1FromResponsesChunk(message);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,+BACdA,SAC8B;CAC9B,MAAMC,SAAuC,CAAE;AAC/C,KAAI,OAAO,QAAQ,YAAY,UAE7B;MAAI,QAAQ,QAAQ,SAAS,GAC3B,OAAO,KAAK;GACV,MAAM;GACN,MAAM,QAAQ;EACf,EAAC;CACH,OAED,OAAO,KAAK,GAAG,oCAAoC,QAAQ,QAAQ,CAAC;AAEtE,MAAK,MAAM,YAAY,QAAQ,cAAc,CAAE,GAC7C,OAAO,KAAK;EACV,MAAM;EACN,IAAI,SAAS;EACb,MAAM,SAAS;EACf,MAAM,SAAS;CAChB,EAAC;AAEJ,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCD,SAAgB,oCACdD,SAC8B;CAC9B,MAAMC,SAAuC,CAAE;AAC/C,KAAI,OAAO,QAAQ,YAAY,UAE7B;MAAI,QAAQ,QAAQ,SAAS,GAC3B,OAAO,KAAK;GACV,MAAM;GACN,MAAM,QAAQ;EACf,EAAC;CACH,OAED,OAAO,KAAK,GAAG,oCAAoC,QAAQ,QAAQ,CAAC;AAItE,MAAK,MAAM,YAAY,QAAQ,cAAc,CAAE,GAC7C,OAAO,KAAK;EACV,MAAM;EACN,IAAI,SAAS;EACb,MAAM,SAAS;EACf,MAAM,SAAS;CAChB,EAAC;AAEJ,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BD,SAAgB,oCACdC,QAC8B;CAC9B,MAAMC,kBAAgD,CAAE;AACxD,MAAK,MAAM,SAAS,OAClB,KAAI,kBAAkB,MAAM,EAC1B,gBAAgB,KAAK,+BAA+B,MAAM,CAAC;MAE3D,gBAAgB,KAAK,MAA+B;AAGxD,QAAO;AACR;AAED,SAAS,2BACPC,YACsC;AACtC,KAAI,WAAW,SAAS,gBAAgB;EACtC,MAAM,EAAE,KAAK,OAAO,aAAa,WAAW,GAAG;AAC/C,SAAO;GACL,MAAM;GACN;GACA;GACA,YAAY;GACZ,UAAU;EACX;CACF;AACD,KAAI,WAAW,SAAS,iBAAiB;EACvC,MAAM,EAAE,SAAS,UAAU,OAAO,GAAG;AACrC,SAAO;GACL,MAAM;GACN,OAAO;GACP,YAAY;GACZ,UAAU;GACV,QAAQ;EACT;CACF;AACD,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCD,SAAgB,yBACdJ,SAC8B;CAC9B,UAAU,iBAAkD;AAC1D,MACE,UAAU,QAAQ,mBAAmB,UAAU,IAC/C,SAAS,QAAQ,kBAAkB,UAAU,QAAQ,EACrD;GACA,MAAM,UACJ,QAAQ,kBAAkB,UAAU,QAAQ,OAC1C,CAAC,KAAK,SAAS;AACb,QAAI,UAAU,KAAK,IAAI,UAAU,KAAK,KAAK,CACzC,QAAO,GAAG,MAAM,KAAK,MAAM;AAE7B,WAAO;GACR,GACD,GACD;GACH,MAAM;IACJ,MAAM;IACN,WAAW;GACZ;EACF;EACD,MAAM,UACJ,OAAO,QAAQ,YAAY,WACvB,CAAC;GAAE,MAAM;GAAQ,MAAM,QAAQ;EAAS,CAAC,IACzC,QAAQ;AACd,OAAK,MAAM,SAAS,QAClB,KAAI,gBAAgB,OAAO,OAAO,EAAE;GAClC,MAAM,EAAE,MAAM,YAAa,GAAG,MAAM,GAAG;AACvC,OAAI,MAAM,QAAQ,YAAY,EAC5B,MAAM;IACJ,GAAG;IACH,MAAM;IACN,MAAM,OAAO,KAAK;IAClB,aAAa,YAAY,IAAI,2BAA2B;GACzD;QAED,MAAM;IACJ,GAAG;IACH,MAAM;IACN,MAAM,OAAO,KAAK;GACnB;EAEJ;AAEH,OAAK,MAAM,YAAY,QAAQ,cAAc,CAAE,GAC7C,MAAM;GACJ,MAAM;GACN,IAAI,SAAS;GACb,MAAM,SAAS;GACf,MAAM,SAAS;EAChB;AAEH,MACE,UAAU,QAAQ,kBAAkB,IACpC,SAAS,QAAQ,kBAAkB,aAAa,CAEhD,MAAK,MAAM,cAAc,QAAQ,kBAAkB,cAAc;AAC/D,OAAI,gBAAgB,YAAY,kBAAkB,EAAE;IAClD,MAAM;KACJ,IAAI,WAAW;KACf,MAAM;KACN,MAAM;KACN,MAAM,EAAE,OAAO,WAAW,MAAO;IAClC;AACD;GACD,WAAU,gBAAgB,YAAY,mBAAmB,EAAE;IAC1D,MAAM;KACJ,IAAI,WAAW;KACf,MAAM;KACN,MAAM;KACN,MAAM,EAAE,OAAO,WAAW,MAAO;IAClC;AACD;GACD,WAAU,gBAAgB,YAAY,gBAAgB,EAAE;IACvD,MAAM;KAAE,MAAM;KAAgB,OAAO;IAAY;AACjD;GACD,WAAU,gBAAgB,YAAY,wBAAwB,EAAE;AAC/D,QAAI,UAAU,WAAW,KAAK,EAC5B,MAAM;KACJ,IAAI,WAAW;KACf,MAAM;KACN,MAAM;KACN,MAAM,EAAE,MAAM,WAAW,KAAM;IAChC;AAEH,QAAI,SAAS,WAAW,QAAQ,EAAE;KAChC,MAAM,aAAa,KAAK,MAAM;AAC5B,UAAI,WAAW,WAAW,cAAe,QAAO;AAChD,UAAI,WAAW,WAAW,YAAa,QAAO;AAC9C,UAAI,WAAW,WAAW,aAAc,QAAO;AAC/C,UAAI,WAAW,WAAW,eAAgB,QAAO;AACjD,UAAI,WAAW,WAAW,SAAU,QAAO;AAC3C,aAAO;KACR,EAAC;AACF,UAAK,MAAM,UAAU,WAAW,QAC9B,KAAI,gBAAgB,QAAQ,OAAO,EAAE;MACnC,MAAM;OACJ,MAAM;OACN,YAAY,WAAW,MAAM;OAC7B,QAAQ;OACR,QAAQ;QACN,MAAM;QACN,YAAY,cAAc;QAC1B,QAAQ,CAAC,GAAG,MAAU,EAAC,SAAS,WAAW,GACvC,SACA,OAAO,OAAO,KAAK;QACvB,QAAQ,CAAC,GAAG,MAAU,EAAC,SAAS,WAAW,GACvC,OAAO,OAAO,KAAK,GACnB;OACL;MACF;AACD;KACD;IAEJ;AACD;GACD,WAAU,gBAAgB,YAAY,WAAW,EAAE;IAClD,MAAM;KACJ,IAAI,WAAW;KACf,MAAM;KACN,MAAM;KACN,MAAM,WAAW;IAClB;AACD;GACD,WAAU,gBAAgB,YAAY,iBAAiB,EAAE;IACxD,MAAM;KACJ,IAAI,WAAW;KACf,MAAM;KACN,MAAM;KACN,MAAM,WAAW;IAClB;AACD;GACD,WAAU,gBAAgB,YAAY,uBAAuB,EAAE;IAC9D,MAAM;KAAE,MAAM;KAAgB,OAAO;IAAY;AACjD;GACD,WAAU,gBAAgB,YAAY,wBAAwB,EAAE;AAE/D,QAAI,UAAU,WAAW,OAAO,EAC9B,MAAM;KACJ,MAAM;KACN,UAAU;KACV,MAAM,WAAW;KACjB,IAAI,UAAU,WAAW,GAAG,GAAG,WAAW,KAAK;KAC/C,UAAU,EACR,QAAQ,UAAU,WAAW,OAAO,GAChC,WAAW,SACX,OACL;IACF;IAGH,MAAM;KAAE,MAAM;KAAgB,OAAO;IAAY;AACjD;GACD;AACD,OAAI,UAAU,WAAW,EACvB,MAAM;IAAE,MAAM;IAAgB,OAAO;GAAY;EAEpD;CAEJ;AACD,QAAO,MAAM,KAAK,gBAAgB,CAAC;AACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,SAAgB,8BACdK,SAC8B;CAC9B,UAAU,iBAAkD;EAC1D,OAAO,yBAAyB,QAAQ;AACxC,OAAK,MAAM,iBAAiB,QAAQ,oBAAoB,CAAE,GACxD,MAAM;GACJ,MAAM;GACN,IAAI,cAAc;GAClB,MAAM,cAAc;GACpB,MAAM,cAAc;EACrB;CAEJ;AACD,QAAO,MAAM,KAAK,gBAAgB,CAAC;AACpC;AAED,MAAaC,uBAAuD;CAClE,kBAAkB,CAAC,YAAY;AAC7B,MAAI,OAAO,QAAQ,YAAY,SAC7B,QAAO,+BAA+B,QAAQ;AAEhD,SAAO,yBAAyB,QAAQ;CACzC;CACD,uBAAuB,CAAC,YAAY;AAClC,MAAI,OAAO,QAAQ,YAAY,SAC7B,QAAO,oCAAoC,QAAQ;AAErD,SAAO,8BAA8B,QAAQ;CAC9C;AACF"}

package/dist/stores.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stores.d.ts","names":["Serializable","BaseStore","K","V","Promise","AsyncGenerator","InMemoryStore","T","Record"],"sources":["../src/stores.d.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n/**\n * Abstract interface for a key-value store.\n */\nexport declare abstract class BaseStore<K, V> extends Serializable {\n    /**\n     * Abstract method to get multiple values for a set of keys.\n     * @param {K[]} keys - An array of keys.\n     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n     */\n    abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Abstract method to set a value for multiple keys.\n     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Abstract method to delete multiple keys.\n     * @param {K[]} keys - An array of keys to delete.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mdelete(keys: K[]): Promise<void>;\n    /**\n     * Abstract method to yield keys optionally based on a prefix.\n     * @param {string} prefix - Optional prefix to filter keys.\n     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n     */\n    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\nexport declare class InMemoryStore<T = any> extends BaseStore<string, T> {\n    lc_namespace: string[];\n    protected store: Record<string, T>;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<T[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, T][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string>;\n}\n//# sourceMappingURL=stores.d.ts.map"],"mappings":";;;;;;AAIA;AAMwBE,uBANMD,SAMNC,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,SAN8BF,YAAAA,CAM9BE;EAAeC;;;;;EAYZD,SAAAA,IAAAA,CAAAA,IAAAA,EAZHA,CAYGA,EAAAA,CAAAA,EAZGE,OAYHF,CAAAA,CAZYC,CAYZD,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAME;;;;AAlBiC;EA6C7CE,SAAAA,IAAAA,CAAAA,aAAa,EAAA,CAjCAJ,CAiCA,EAjCGC,CAiCH,CAAA,EAAA,CAAA,EAjCUC,OAiCV,CAAA,IAAA,CAAA;EAAoCG;;;;;EAcrCA,SAAAA,OAAAA,CAAAA,IAAAA,EAzCNL,CAyCMK,EAAAA,CAAAA,EAzCAH,OAyCAG,CAAAA,IAAAA,CAAAA;EAAOH;;;;AAdqB;uCArBpBC,eAAeH;;;;;;;;;;;;;;;;;;;;;cAqBnCI,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}
+{"version":3,"file":"stores.d.ts","names":["Serializable","BaseStore","K","V","Promise","AsyncGenerator","InMemoryStore","T","Record"],"sources":["../src/stores.d.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n/**\n * Abstract interface for a key-value store.\n */\nexport declare abstract class BaseStore<K, V> extends Serializable {\n    /**\n     * Abstract method to get multiple values for a set of keys.\n     * @param {K[]} keys - An array of keys.\n     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n     */\n    abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Abstract method to set a value for multiple keys.\n     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Abstract method to delete multiple keys.\n     * @param {K[]} keys - An array of keys to delete.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mdelete(keys: K[]): Promise<void>;\n    /**\n     * Abstract method to yield keys optionally based on a prefix.\n     * @param {string} prefix - Optional prefix to filter keys.\n     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n     */\n    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\nexport declare class InMemoryStore<T = any> extends BaseStore<string, T> {\n    lc_namespace: string[];\n    protected store: Record<string, T>;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<T[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, T][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string>;\n}\n//# sourceMappingURL=stores.d.ts.map"],"mappings":";;;;;;AAIA;AAMwBE,uBANMD,SAMNC,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,SAN8BF,YAAAA,CAM9BE;EAAeC;;;;;EAYZD,SAAAA,IAAAA,CAAAA,IAAAA,EAZHA,CAYGA,EAAAA,CAAAA,EAZGE,OAYHF,CAAAA,CAZYC,CAYZD,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAME;;;;AAlBiC;EA6C7CE,SAAAA,IAAAA,CAAAA,aAAaC,EAAA,CAjCAL,CAiCA,EAjCGC,CAiCH,CAAA,EAAA,CAAA,EAjCUC,OAiCV,CAAA,IAAA,CAAA;EAAoCG;;;;;EAcrCA,SAAAA,OAAAA,CAAAA,IAAAA,EAzCNL,CAyCMK,EAAAA,CAAAA,EAzCAH,OAyCAG,CAAAA,IAAAA,CAAAA;EAAOH;;;;AAdqB;uCArBpBC,eAAeH;;;;;;;;;;;;;;;;;;;;;cAqBnCI,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}

package/dist/utils/ssrf.cjs

@@ -0,0 +1,271 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+
+//#region src/utils/ssrf.ts
+var ssrf_exports = {};
+require_rolldown_runtime.__export(ssrf_exports, {
+	isCloudMetadata: () => isCloudMetadata,
+	isLocalhost: () => isLocalhost,
+	isPrivateIp: () => isPrivateIp,
+	isSafeUrl: () => isSafeUrl,
+	isSameOrigin: () => isSameOrigin,
+	validateSafeUrl: () => validateSafeUrl
+});
+const PRIVATE_IP_RANGES = [
+	"10.0.0.0/8",
+	"172.16.0.0/12",
+	"192.168.0.0/16",
+	"127.0.0.0/8",
+	"169.254.0.0/16",
+	"0.0.0.0/8",
+	"::1/128",
+	"fc00::/7",
+	"fe80::/10",
+	"ff00::/8"
+];
+const CLOUD_METADATA_IPS = [
+	"169.254.169.254",
+	"169.254.170.2",
+	"100.100.100.200"
+];
+const CLOUD_METADATA_HOSTNAMES = [
+	"metadata.google.internal",
+	"metadata",
+	"instance-data"
+];
+const LOCALHOST_NAMES = ["localhost", "localhost.localdomain"];
+/**
+* IPv4 regex: four octets 0-255
+*/
+const IPV4_REGEX = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+/**
+* Check if a string is a valid IPv4 address.
+*/
+function isIPv4(ip) {
+	return IPV4_REGEX.test(ip);
+}
+/**
+* Check if a string is a valid IPv6 address.
+* Uses expandIpv6 for validation.
+*/
+function isIPv6(ip) {
+	return expandIpv6(ip) !== null;
+}
+/**
+* Check if a string is a valid IP address (IPv4 or IPv6).
+*/
+function isIP(ip) {
+	return isIPv4(ip) || isIPv6(ip);
+}
+/**
+* Parse an IP address string to an array of integers (for IPv4) or an array of 16-bit values (for IPv6)
+* Returns null if the IP is invalid.
+*/
+function parseIp(ip) {
+	if (isIPv4(ip)) return ip.split(".").map((octet) => parseInt(octet, 10));
+	else if (isIPv6(ip)) {
+		const expanded = expandIpv6(ip);
+		if (!expanded) return null;
+		const parts = expanded.split(":");
+		const result = [];
+		for (const part of parts) result.push(parseInt(part, 16));
+		return result;
+	}
+	return null;
+}
+/**
+* Expand compressed IPv6 address to full form.
+*/
+function expandIpv6(ip) {
+	if (!ip || typeof ip !== "string") return null;
+	if (!ip.includes(":")) return null;
+	if (!/^[0-9a-fA-F:]+$/.test(ip)) return null;
+	let normalized = ip;
+	if (normalized.includes("::")) {
+		const parts$1 = normalized.split("::");
+		if (parts$1.length > 2) return null;
+		const [left, right] = parts$1;
+		const leftParts = left ? left.split(":") : [];
+		const rightParts = right ? right.split(":") : [];
+		const missing = 8 - (leftParts.length + rightParts.length);
+		if (missing < 0) return null;
+		const zeros = Array(missing).fill("0");
+		normalized = [
+			...leftParts,
+			...zeros,
+			...rightParts
+		].filter((p) => p !== "").join(":");
+	}
+	const parts = normalized.split(":");
+	if (parts.length !== 8) return null;
+	for (const part of parts) {
+		if (part.length === 0 || part.length > 4) return null;
+		if (!/^[0-9a-fA-F]+$/.test(part)) return null;
+	}
+	return parts.map((p) => p.padStart(4, "0").toLowerCase()).join(":");
+}
+/**
+* Parse CIDR notation (e.g., "192.168.0.0/24") into network address and prefix length.
+*/
+function parseCidr(cidr) {
+	const [addrStr, prefixStr] = cidr.split("/");
+	if (!addrStr || !prefixStr) return null;
+	const addr = parseIp(addrStr);
+	if (!addr) return null;
+	const prefixLen = parseInt(prefixStr, 10);
+	if (isNaN(prefixLen)) return null;
+	const isIpv6 = isIPv6(addrStr);
+	if (isIpv6 && prefixLen > 128) return null;
+	if (!isIpv6 && prefixLen > 32) return null;
+	return {
+		addr,
+		prefixLen,
+		isIpv6
+	};
+}
+/**
+* Check if an IP address is in a given CIDR range.
+*/
+function isIpInCidr(ip, cidr) {
+	const ipParsed = parseIp(ip);
+	if (!ipParsed) return false;
+	const cidrParsed = parseCidr(cidr);
+	if (!cidrParsed) return false;
+	const isIpv6 = isIPv6(ip);
+	if (isIpv6 !== cidrParsed.isIpv6) return false;
+	const { addr: cidrAddr, prefixLen } = cidrParsed;
+	if (isIpv6) for (let i = 0; i < Math.ceil(prefixLen / 16); i++) {
+		const bitsToCheck = Math.min(16, prefixLen - i * 16);
+		const mask = 65535 << 16 - bitsToCheck & 65535;
+		if ((ipParsed[i] & mask) !== (cidrAddr[i] & mask)) return false;
+	}
+	else for (let i = 0; i < Math.ceil(prefixLen / 8); i++) {
+		const bitsToCheck = Math.min(8, prefixLen - i * 8);
+		const mask = 255 << 8 - bitsToCheck & 255;
+		if ((ipParsed[i] & mask) !== (cidrAddr[i] & mask)) return false;
+	}
+	return true;
+}
+/**
+* Check if an IP address is private (RFC 1918, loopback, link-local, etc.)
+*/
+function isPrivateIp(ip) {
+	if (!isIP(ip)) return false;
+	for (const range of PRIVATE_IP_RANGES) if (isIpInCidr(ip, range)) return true;
+	return false;
+}
+/**
+* Check if a hostname or IP is a known cloud metadata endpoint.
+*/
+function isCloudMetadata(hostname, ip) {
+	if (CLOUD_METADATA_IPS.includes(ip || "")) return true;
+	const lowerHostname = hostname.toLowerCase();
+	if (CLOUD_METADATA_HOSTNAMES.includes(lowerHostname)) return true;
+	return false;
+}
+/**
+* Check if a hostname or IP is localhost.
+*/
+function isLocalhost(hostname, ip) {
+	if (ip) {
+		if (ip === "127.0.0.1" || ip === "::1" || ip === "0.0.0.0") return true;
+		if (ip.startsWith("127.")) return true;
+	}
+	const lowerHostname = hostname.toLowerCase();
+	if (LOCALHOST_NAMES.includes(lowerHostname)) return true;
+	return false;
+}
+/**
+* Validate that a URL is safe to connect to.
+* Performs static validation checks against hostnames and direct IP addresses.
+* Does not perform DNS resolution.
+*
+* @param url URL to validate
+* @param options.allowPrivate Allow private IPs (default: false)
+* @param options.allowHttp Allow http:// scheme (default: false)
+* @returns The validated URL
+* @throws Error if URL is not safe
+*/
+function validateSafeUrl(url, options) {
+	const allowPrivate = options?.allowPrivate ?? false;
+	const allowHttp = options?.allowHttp ?? false;
+	try {
+		let parsedUrl;
+		try {
+			parsedUrl = new URL(url);
+		} catch {
+			throw new Error(`Invalid URL: ${url}`);
+		}
+		const hostname = parsedUrl.hostname;
+		if (!hostname) throw new Error("URL missing hostname.");
+		if (isCloudMetadata(hostname)) throw new Error(`URL points to cloud metadata endpoint: ${hostname}`);
+		if (isLocalhost(hostname)) {
+			if (!allowPrivate) throw new Error(`URL points to localhost: ${hostname}`);
+			return url;
+		}
+		const scheme = parsedUrl.protocol;
+		if (scheme !== "http:" && scheme !== "https:") throw new Error(`Invalid URL scheme: ${scheme}. Only http and https are allowed.`);
+		if (scheme === "http:" && !allowHttp) throw new Error("HTTP scheme not allowed. Use HTTPS or set allowHttp: true.");
+		if (isIP(hostname)) {
+			const ip = hostname;
+			if (isLocalhost(hostname, ip)) {
+				if (!allowPrivate) throw new Error(`URL points to localhost: ${hostname}`);
+				return url;
+			}
+			if (isCloudMetadata(hostname, ip)) throw new Error(`URL resolves to cloud metadata IP: ${ip} (${hostname})`);
+			if (isPrivateIp(ip)) {
+				if (!allowPrivate) throw new Error(`URL resolves to private IP: ${ip} (${hostname}). Set allowPrivate: true to allow.`);
+			}
+			return url;
+		}
+		return url;
+	} catch (error) {
+		if (error && typeof error === "object" && "message" in error) throw error;
+		throw new Error(`URL validation failed: ${error}`);
+	}
+}
+/**
+* Check if a URL is safe to connect to (non-throwing version).
+*
+* @param url URL to check
+* @param options.allowPrivate Allow private IPs (default: false)
+* @param options.allowHttp Allow http:// scheme (default: false)
+* @returns true if URL is safe, false otherwise
+*/
+function isSafeUrl(url, options) {
+	try {
+		validateSafeUrl(url, options);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check if two URLs have the same origin (scheme, host, port).
+* Uses semantic URL parsing to prevent SSRF bypasses via URL variations.
+*
+* @param url1 First URL
+* @param url2 Second URL
+* @returns true if both URLs have the same origin, false otherwise
+*/
+function isSameOrigin(url1, url2) {
+	try {
+		return new URL(url1).origin === new URL(url2).origin;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+exports.isCloudMetadata = isCloudMetadata;
+exports.isLocalhost = isLocalhost;
+exports.isPrivateIp = isPrivateIp;
+exports.isSafeUrl = isSafeUrl;
+exports.isSameOrigin = isSameOrigin;
+Object.defineProperty(exports, 'ssrf_exports', {
+  enumerable: true,
+  get: function () {
+    return ssrf_exports;
+  }
+});
+exports.validateSafeUrl = validateSafeUrl;
+//# sourceMappingURL=ssrf.cjs.map

package/dist/utils/ssrf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf.cjs","names":["ip: string","result: number[]","parts","cidr: string","hostname: string","ip?: string","url: string","options?: { allowPrivate?: boolean; allowHttp?: boolean }","parsedUrl: URL","url1: string","url2: string"],"sources":["../../src/utils/ssrf.ts"],"sourcesContent":["// Private IP ranges (RFC 1918, loopback, link-local, etc.)\nconst PRIVATE_IP_RANGES = [\n  \"10.0.0.0/8\",\n  \"172.16.0.0/12\",\n  \"192.168.0.0/16\",\n  \"127.0.0.0/8\",\n  \"169.254.0.0/16\",\n  \"0.0.0.0/8\",\n  \"::1/128\",\n  \"fc00::/7\",\n  \"fe80::/10\",\n  \"ff00::/8\",\n];\n\n// Cloud metadata IPs\nconst CLOUD_METADATA_IPS = [\n  \"169.254.169.254\",\n  \"169.254.170.2\",\n  \"100.100.100.200\",\n];\n\n// Cloud metadata hostnames (case-insensitive)\nconst CLOUD_METADATA_HOSTNAMES = [\n  \"metadata.google.internal\",\n  \"metadata\",\n  \"instance-data\",\n];\n\n// Localhost variations\nconst LOCALHOST_NAMES = [\"localhost\", \"localhost.localdomain\"];\n\n/**\n * IPv4 regex: four octets 0-255\n */\nconst IPV4_REGEX =\n  /^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/;\n\n/**\n * Check if a string is a valid IPv4 address.\n */\nfunction isIPv4(ip: string): boolean {\n  return IPV4_REGEX.test(ip);\n}\n\n/**\n * Check if a string is a valid IPv6 address.\n * Uses expandIpv6 for validation.\n */\nfunction isIPv6(ip: string): boolean {\n  return expandIpv6(ip) !== null;\n}\n\n/**\n * Check if a string is a valid IP address (IPv4 or IPv6).\n */\nfunction isIP(ip: string): boolean {\n  return isIPv4(ip) || isIPv6(ip);\n}\n\n/**\n * Parse an IP address string to an array of integers (for IPv4) or an array of 16-bit values (for IPv6)\n * Returns null if the IP is invalid.\n */\nfunction parseIp(ip: string): number[] | null {\n  if (isIPv4(ip)) {\n    return ip.split(\".\").map((octet) => parseInt(octet, 10));\n  } else if (isIPv6(ip)) {\n    // Normalize IPv6\n    const expanded = expandIpv6(ip);\n    if (!expanded) return null;\n    const parts = expanded.split(\":\");\n    const result: number[] = [];\n    for (const part of parts) {\n      result.push(parseInt(part, 16));\n    }\n    return result;\n  }\n  return null;\n}\n\n/**\n * Expand compressed IPv6 address to full form.\n */\nfunction expandIpv6(ip: string): string | null {\n  // Basic structural validation\n  if (!ip || typeof ip !== \"string\") return null;\n\n  // Must contain at least one colon\n  if (!ip.includes(\":\")) return null;\n\n  // Check for invalid characters\n  if (!/^[0-9a-fA-F:]+$/.test(ip)) return null;\n\n  let normalized = ip;\n\n  // Handle :: compression\n  if (normalized.includes(\"::\")) {\n    const parts = normalized.split(\"::\");\n    if (parts.length > 2) return null; // Multiple :: is invalid\n\n    const [left, right] = parts;\n    const leftParts = left ? left.split(\":\") : [];\n    const rightParts = right ? right.split(\":\") : [];\n    const missing = 8 - (leftParts.length + rightParts.length);\n\n    if (missing < 0) return null;\n\n    const zeros = Array(missing).fill(\"0\");\n    normalized = [...leftParts, ...zeros, ...rightParts]\n      .filter((p) => p !== \"\")\n      .join(\":\");\n  }\n\n  const parts = normalized.split(\":\");\n  if (parts.length !== 8) return null;\n\n  // Validate each part is a valid hex group (1-4 chars)\n  for (const part of parts) {\n    if (part.length === 0 || part.length > 4) return null;\n    if (!/^[0-9a-fA-F]+$/.test(part)) return null;\n  }\n\n  return parts.map((p) => p.padStart(4, \"0\").toLowerCase()).join(\":\");\n}\n\n/**\n * Parse CIDR notation (e.g., \"192.168.0.0/24\") into network address and prefix length.\n */\nfunction parseCidr(\n  cidr: string\n): { addr: number[]; prefixLen: number; isIpv6: boolean } | null {\n  const [addrStr, prefixStr] = cidr.split(\"/\");\n  if (!addrStr || !prefixStr) {\n    return null;\n  }\n\n  const addr = parseIp(addrStr);\n  if (!addr) {\n    return null;\n  }\n\n  const prefixLen = parseInt(prefixStr, 10);\n  if (isNaN(prefixLen)) {\n    return null;\n  }\n\n  const isIpv6 = isIPv6(addrStr);\n\n  if (isIpv6 && prefixLen > 128) {\n    return null;\n  }\n  if (!isIpv6 && prefixLen > 32) {\n    return null;\n  }\n\n  return { addr, prefixLen, isIpv6 };\n}\n\n/**\n * Check if an IP address is in a given CIDR range.\n */\nfunction isIpInCidr(ip: string, cidr: string): boolean {\n  const ipParsed = parseIp(ip);\n  if (!ipParsed) {\n    return false;\n  }\n\n  const cidrParsed = parseCidr(cidr);\n  if (!cidrParsed) {\n    return false;\n  }\n\n  // Check IPv4 vs IPv6 mismatch\n  const isIpv6 = isIPv6(ip);\n  if (isIpv6 !== cidrParsed.isIpv6) {\n    return false;\n  }\n\n  const { addr: cidrAddr, prefixLen } = cidrParsed;\n\n  // Convert to bits and compare\n  if (isIpv6) {\n    // IPv6: each element is 16 bits\n    for (let i = 0; i < Math.ceil(prefixLen / 16); i++) {\n      const bitsToCheck = Math.min(16, prefixLen - i * 16);\n      const mask = (0xffff << (16 - bitsToCheck)) & 0xffff;\n      if ((ipParsed[i] & mask) !== (cidrAddr[i] & mask)) {\n        return false;\n      }\n    }\n  } else {\n    // IPv4: each element is 8 bits\n    for (let i = 0; i < Math.ceil(prefixLen / 8); i++) {\n      const bitsToCheck = Math.min(8, prefixLen - i * 8);\n      const mask = (0xff << (8 - bitsToCheck)) & 0xff;\n      if ((ipParsed[i] & mask) !== (cidrAddr[i] & mask)) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n\n/**\n * Check if an IP address is private (RFC 1918, loopback, link-local, etc.)\n */\nexport function isPrivateIp(ip: string): boolean {\n  // Validate it's a proper IP\n  if (!isIP(ip)) {\n    return false;\n  }\n\n  for (const range of PRIVATE_IP_RANGES) {\n    if (isIpInCidr(ip, range)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Check if a hostname or IP is a known cloud metadata endpoint.\n */\nexport function isCloudMetadata(hostname: string, ip?: string): boolean {\n  // Check if it's a known metadata IP\n  if (CLOUD_METADATA_IPS.includes(ip || \"\")) {\n    return true;\n  }\n\n  // Check if hostname matches (case-insensitive)\n  const lowerHostname = hostname.toLowerCase();\n  if (CLOUD_METADATA_HOSTNAMES.includes(lowerHostname)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Check if a hostname or IP is localhost.\n */\nexport function isLocalhost(hostname: string, ip?: string): boolean {\n  // Check if it's a localhost IP\n  if (ip) {\n    // Check for typical localhost IPs (loopback range)\n    if (ip === \"127.0.0.1\" || ip === \"::1\" || ip === \"0.0.0.0\") {\n      return true;\n    }\n    // Check if IP starts with 127. (entire loopback range)\n    if (ip.startsWith(\"127.\")) {\n      return true;\n    }\n  }\n\n  // Check if hostname is localhost\n  const lowerHostname = hostname.toLowerCase();\n  if (LOCALHOST_NAMES.includes(lowerHostname)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Validate that a URL is safe to connect to.\n * Performs static validation checks against hostnames and direct IP addresses.\n * Does not perform DNS resolution.\n *\n * @param url URL to validate\n * @param options.allowPrivate Allow private IPs (default: false)\n * @param options.allowHttp Allow http:// scheme (default: false)\n * @returns The validated URL\n * @throws Error if URL is not safe\n */\nexport function validateSafeUrl(\n  url: string,\n  options?: { allowPrivate?: boolean; allowHttp?: boolean }\n): string {\n  const allowPrivate = options?.allowPrivate ?? false;\n  const allowHttp = options?.allowHttp ?? false;\n\n  try {\n    let parsedUrl: URL;\n    try {\n      parsedUrl = new URL(url);\n    } catch {\n      throw new Error(`Invalid URL: ${url}`);\n    }\n\n    const hostname = parsedUrl.hostname;\n    if (!hostname) {\n      throw new Error(\"URL missing hostname.\");\n    }\n\n    // Check if it's a cloud metadata endpoint (always blocked)\n    if (isCloudMetadata(hostname)) {\n      throw new Error(`URL points to cloud metadata endpoint: ${hostname}`);\n    }\n\n    // Check if it's localhost (blocked unless allowPrivate is true)\n    if (isLocalhost(hostname)) {\n      if (!allowPrivate) {\n        throw new Error(`URL points to localhost: ${hostname}`);\n      }\n      return url;\n    }\n\n    // Check scheme (after localhost checks to give better error messages)\n    const scheme = parsedUrl.protocol;\n    if (scheme !== \"http:\" && scheme !== \"https:\") {\n      throw new Error(\n        `Invalid URL scheme: ${scheme}. Only http and https are allowed.`\n      );\n    }\n\n    if (scheme === \"http:\" && !allowHttp) {\n      throw new Error(\n        \"HTTP scheme not allowed. Use HTTPS or set allowHttp: true.\"\n      );\n    }\n\n    // If hostname is already an IP, validate it directly\n    if (isIP(hostname)) {\n      const ip = hostname;\n\n      // Check if it's localhost first (before private IP check)\n      if (isLocalhost(hostname, ip)) {\n        if (!allowPrivate) {\n          throw new Error(`URL points to localhost: ${hostname}`);\n        }\n        return url;\n      }\n\n      // Cloud metadata is always blocked\n      if (isCloudMetadata(hostname, ip)) {\n        throw new Error(\n          `URL resolves to cloud metadata IP: ${ip} (${hostname})`\n        );\n      }\n\n      // Check private IPs\n      if (isPrivateIp(ip)) {\n        if (!allowPrivate) {\n          throw new Error(\n            `URL resolves to private IP: ${ip} (${hostname}). Set allowPrivate: true to allow.`\n          );\n        }\n      }\n\n      return url;\n    }\n\n    // For regular hostnames, we've already done all hostname-based checks above\n    // (cloud metadata, localhost). If those passed, the URL is safe.\n    // We don't perform DNS resolution in this environment-agnostic function.\n    return url;\n  } catch (error) {\n    if (error && typeof error === \"object\" && \"message\" in error) {\n      throw error;\n    }\n    throw new Error(`URL validation failed: ${error}`);\n  }\n}\n\n/**\n * Check if a URL is safe to connect to (non-throwing version).\n *\n * @param url URL to check\n * @param options.allowPrivate Allow private IPs (default: false)\n * @param options.allowHttp Allow http:// scheme (default: false)\n * @returns true if URL is safe, false otherwise\n */\nexport function isSafeUrl(\n  url: string,\n  options?: { allowPrivate?: boolean; allowHttp?: boolean }\n): boolean {\n  try {\n    validateSafeUrl(url, options);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if two URLs have the same origin (scheme, host, port).\n * Uses semantic URL parsing to prevent SSRF bypasses via URL variations.\n *\n * @param url1 First URL\n * @param url2 Second URL\n * @returns true if both URLs have the same origin, false otherwise\n */\nexport function isSameOrigin(url1: string, url2: string): boolean {\n  try {\n    return new URL(url1).origin === new URL(url2).origin;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":"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"}

package/dist/utils/ssrf.d.cts

@@ -0,0 +1,52 @@
+//#region src/utils/ssrf.d.ts
+/**
+ * Check if an IP address is private (RFC 1918, loopback, link-local, etc.)
+ */
+declare function isPrivateIp(ip: string): boolean;
+/**
+ * Check if a hostname or IP is a known cloud metadata endpoint.
+ */
+declare function isCloudMetadata(hostname: string, ip?: string): boolean;
+/**
+ * Check if a hostname or IP is localhost.
+ */
+declare function isLocalhost(hostname: string, ip?: string): boolean;
+/**
+ * Validate that a URL is safe to connect to.
+ * Performs static validation checks against hostnames and direct IP addresses.
+ * Does not perform DNS resolution.
+ *
+ * @param url URL to validate
+ * @param options.allowPrivate Allow private IPs (default: false)
+ * @param options.allowHttp Allow http:// scheme (default: false)
+ * @returns The validated URL
+ * @throws Error if URL is not safe
+ */
+declare function validateSafeUrl(url: string, options?: {
+  allowPrivate?: boolean;
+  allowHttp?: boolean;
+}): string;
+/**
+ * Check if a URL is safe to connect to (non-throwing version).
+ *
+ * @param url URL to check
+ * @param options.allowPrivate Allow private IPs (default: false)
+ * @param options.allowHttp Allow http:// scheme (default: false)
+ * @returns true if URL is safe, false otherwise
+ */
+declare function isSafeUrl(url: string, options?: {
+  allowPrivate?: boolean;
+  allowHttp?: boolean;
+}): boolean;
+/**
+ * Check if two URLs have the same origin (scheme, host, port).
+ * Uses semantic URL parsing to prevent SSRF bypasses via URL variations.
+ *
+ * @param url1 First URL
+ * @param url2 Second URL
+ * @returns true if both URLs have the same origin, false otherwise
+ */
+declare function isSameOrigin(url1: string, url2: string): boolean;
+//#endregion
+export { isCloudMetadata, isLocalhost, isPrivateIp, isSafeUrl, isSameOrigin, validateSafeUrl };
+//# sourceMappingURL=ssrf.d.cts.map

package/dist/utils/ssrf.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf.d.cts","names":["isPrivateIp","isCloudMetadata","isLocalhost","validateSafeUrl","isSafeUrl","isSameOrigin"],"sources":["../../src/utils/ssrf.d.ts"],"sourcesContent":["/**\n * Check if an IP address is private (RFC 1918, loopback, link-local, etc.)\n */\nexport declare function isPrivateIp(ip: string): boolean;\n/**\n * Check if a hostname or IP is a known cloud metadata endpoint.\n */\nexport declare function isCloudMetadata(hostname: string, ip?: string): boolean;\n/**\n * Check if a hostname or IP is localhost.\n */\nexport declare function isLocalhost(hostname: string, ip?: string): boolean;\n/**\n * Validate that a URL is safe to connect to.\n * Performs static validation checks against hostnames and direct IP addresses.\n * Does not perform DNS resolution.\n *\n * @param url URL to validate\n * @param options.allowPrivate Allow private IPs (default: false)\n * @param options.allowHttp Allow http:// scheme (default: false)\n * @returns The validated URL\n * @throws Error if URL is not safe\n */\nexport declare function validateSafeUrl(url: string, options?: {\n    allowPrivate?: boolean;\n    allowHttp?: boolean;\n}): string;\n/**\n * Check if a URL is safe to connect to (non-throwing version).\n *\n * @param url URL to check\n * @param options.allowPrivate Allow private IPs (default: false)\n * @param options.allowHttp Allow http:// scheme (default: false)\n * @returns true if URL is safe, false otherwise\n */\nexport declare function isSafeUrl(url: string, options?: {\n    allowPrivate?: boolean;\n    allowHttp?: boolean;\n}): boolean;\n/**\n * Check if two URLs have the same origin (scheme, host, port).\n * Uses semantic URL parsing to prevent SSRF bypasses via URL variations.\n *\n * @param url1 First URL\n * @param url2 Second URL\n * @returns true if both URLs have the same origin, false otherwise\n */\nexport declare function isSameOrigin(url1: string, url2: string): boolean;\n//# sourceMappingURL=ssrf.d.ts.map"],"mappings":";;AAGA;AAIA;AAIwBE,iBARAF,WAAAA,CAQW,EAAA,EAAA,MAAA,CAAA,EAAA,OAAA;AAYnC;AAYA;AAYA;iBAxCwBC,eAAAA;;;;iBAIAC,WAAAA;;;;;;;;;;;;iBAYAC,eAAAA;;;;;;;;;;;;iBAYAC,SAAAA;;;;;;;;;;;;iBAYAC,YAAAA"}

package/dist/utils/ssrf.d.ts

@@ -0,0 +1,52 @@
+//#region src/utils/ssrf.d.ts
+/**
+ * Check if an IP address is private (RFC 1918, loopback, link-local, etc.)
+ */
+declare function isPrivateIp(ip: string): boolean;
+/**
+ * Check if a hostname or IP is a known cloud metadata endpoint.
+ */
+declare function isCloudMetadata(hostname: string, ip?: string): boolean;
+/**
+ * Check if a hostname or IP is localhost.
+ */
+declare function isLocalhost(hostname: string, ip?: string): boolean;
+/**
+ * Validate that a URL is safe to connect to.
+ * Performs static validation checks against hostnames and direct IP addresses.
+ * Does not perform DNS resolution.
+ *
+ * @param url URL to validate
+ * @param options.allowPrivate Allow private IPs (default: false)
+ * @param options.allowHttp Allow http:// scheme (default: false)
+ * @returns The validated URL
+ * @throws Error if URL is not safe
+ */
+declare function validateSafeUrl(url: string, options?: {
+  allowPrivate?: boolean;
+  allowHttp?: boolean;
+}): string;
+/**
+ * Check if a URL is safe to connect to (non-throwing version).
+ *
+ * @param url URL to check
+ * @param options.allowPrivate Allow private IPs (default: false)
+ * @param options.allowHttp Allow http:// scheme (default: false)
+ * @returns true if URL is safe, false otherwise
+ */
+declare function isSafeUrl(url: string, options?: {
+  allowPrivate?: boolean;
+  allowHttp?: boolean;
+}): boolean;
+/**
+ * Check if two URLs have the same origin (scheme, host, port).
+ * Uses semantic URL parsing to prevent SSRF bypasses via URL variations.
+ *
+ * @param url1 First URL
+ * @param url2 Second URL
+ * @returns true if both URLs have the same origin, false otherwise
+ */
+declare function isSameOrigin(url1: string, url2: string): boolean;
+//#endregion
+export { isCloudMetadata, isLocalhost, isPrivateIp, isSafeUrl, isSameOrigin, validateSafeUrl };
+//# sourceMappingURL=ssrf.d.ts.map

package/dist/utils/ssrf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf.d.ts","names":["isPrivateIp","isCloudMetadata","isLocalhost","validateSafeUrl","isSafeUrl","isSameOrigin"],"sources":["../../src/utils/ssrf.d.ts"],"sourcesContent":["/**\n * Check if an IP address is private (RFC 1918, loopback, link-local, etc.)\n */\nexport declare function isPrivateIp(ip: string): boolean;\n/**\n * Check if a hostname or IP is a known cloud metadata endpoint.\n */\nexport declare function isCloudMetadata(hostname: string, ip?: string): boolean;\n/**\n * Check if a hostname or IP is localhost.\n */\nexport declare function isLocalhost(hostname: string, ip?: string): boolean;\n/**\n * Validate that a URL is safe to connect to.\n * Performs static validation checks against hostnames and direct IP addresses.\n * Does not perform DNS resolution.\n *\n * @param url URL to validate\n * @param options.allowPrivate Allow private IPs (default: false)\n * @param options.allowHttp Allow http:// scheme (default: false)\n * @returns The validated URL\n * @throws Error if URL is not safe\n */\nexport declare function validateSafeUrl(url: string, options?: {\n    allowPrivate?: boolean;\n    allowHttp?: boolean;\n}): string;\n/**\n * Check if a URL is safe to connect to (non-throwing version).\n *\n * @param url URL to check\n * @param options.allowPrivate Allow private IPs (default: false)\n * @param options.allowHttp Allow http:// scheme (default: false)\n * @returns true if URL is safe, false otherwise\n */\nexport declare function isSafeUrl(url: string, options?: {\n    allowPrivate?: boolean;\n    allowHttp?: boolean;\n}): boolean;\n/**\n * Check if two URLs have the same origin (scheme, host, port).\n * Uses semantic URL parsing to prevent SSRF bypasses via URL variations.\n *\n * @param url1 First URL\n * @param url2 Second URL\n * @returns true if both URLs have the same origin, false otherwise\n */\nexport declare function isSameOrigin(url1: string, url2: string): boolean;\n//# sourceMappingURL=ssrf.d.ts.map"],"mappings":";;AAGA;AAIA;AAIwBE,iBARAF,WAAAA,CAQW,EAAA,EAAA,MAAA,CAAA,EAAA,OAAA;AAYnC;AAYA;AAYA;iBAxCwBC,eAAAA;;;;iBAIAC,WAAAA;;;;;;;;;;;;iBAYAC,eAAAA;;;;;;;;;;;;iBAYAC,SAAAA;;;;;;;;;;;;iBAYAC,YAAAA"}