@illuma-ai/agents 1.0.81

package/dist/cjs/llm/vertexai/index.cjs

@@ -0,0 +1,329 @@
+'use strict';
+
+var googleGauth = require('@langchain/google-gauth');
+var googleCommon = require('@langchain/google-common');
+
+class CustomChatConnection extends googleCommon.ChatConnection {
+    async formatData(input, parameters) {
+        const formattedData = (await super.formatData(input, parameters));
+        if (formattedData.generationConfig?.thinkingConfig?.thinkingBudget === -1) {
+            // -1 means "let the model decide" - delete the property so the API doesn't receive an invalid value
+            if (formattedData.generationConfig.thinkingConfig.includeThoughts === false) {
+                formattedData.generationConfig.thinkingConfig.includeThoughts = true;
+            }
+            delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
+        }
+        return formattedData;
+    }
+}
+/**
+ * Integration with Google Vertex AI chat models.
+ *
+ * Setup:
+ * Install `@langchain/google-vertexai` and set your stringified
+ * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.
+ *
+ * ```bash
+ * npm install @langchain/google-vertexai
+ * export GOOGLE_APPLICATION_CREDENTIALS="path/to/credentials"
+ * ```
+ *
+ * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)
+ *
+ * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)
+ *
+ * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+ * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+ *
+ * ```typescript
+ * // When calling `.withConfig`, call options should be passed via the first argument
+ * const llmWithArgsBound = llm.withConfig({
+ *   stop: ["\n"],
+ *   tools: [...],
+ * });
+ *
+ * // When calling `.bindTools`, call options should be passed via the second argument
+ * const llmWithTools = llm.bindTools(
+ *   [...],
+ *   {
+ *     tool_choice: "auto",
+ *   }
+ * );
+ * ```
+ *
+ * ## Examples
+ *
+ * <details open>
+ * <summary><strong>Instantiate</strong></summary>
+ *
+ * ```typescript
+ * import { ChatVertexAI } from '@langchain/google-vertexai';
+ *
+ * const llm = new ChatVertexAI({
+ *   model: "gemini-1.5-pro",
+ *   temperature: 0,
+ *   // other params...
+ * });
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Invoking</strong></summary>
+ *
+ * ```typescript
+ * const input = `Translate "I love programming" into French.`;
+ *
+ * // Models also accept a list of chat messages or a formatted prompt
+ * const result = await llm.invoke(input);
+ * console.log(result);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n\nHere's why this is the best translation:\n\n* **J'adore** means \"I love\" and conveys a strong passion.\n* **Programmer** is the French verb for \"to program.\"\n\nThis translation is natural and idiomatic in French. \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 63,
+ *     "total_tokens": 72
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Streaming Chunks</strong></summary>
+ *
+ * ```typescript
+ * for await (const chunk of await llm.stream(input)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Aggregate Streamed Chunks</strong></summary>
+ *
+ * ```typescript
+ * import { AIMessageChunk } from '@langchain/core/messages';
+ * import { concat } from '@langchain/core/utils/stream';
+ *
+ * const stream = await llm.stream(input);
+ * let full: AIMessageChunk | undefined;
+ * for await (const chunk of stream) {
+ *   full = !full ? chunk : concat(full, chunk);
+ * }
+ * console.log(full);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Bind tools</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const GetWeather = {
+ *   name: "GetWeather",
+ *   description: "Get the current weather in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const GetPopulation = {
+ *   name: "GetPopulation",
+ *   description: "Get the current population in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
+ * const aiMsg = await llmWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?"
+ * );
+ * console.log(aiMsg.tool_calls);
+ * ```
+ *
+ * ```txt
+ * [
+ *   {
+ *     name: 'GetPopulation',
+ *     args: { location: 'New York City, NY' },
+ *     id: '33c1c1f47e2f492799c77d2800a43912',
+ *     type: 'tool_call'
+ *   }
+ * ]
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Structured Output</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const Joke = z.object({
+ *   setup: z.string().describe("The setup of the joke"),
+ *   punchline: z.string().describe("The punchline to the joke"),
+ *   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+ * }).describe('Joke to tell user.');
+ *
+ * const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
+ * const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+ * console.log(jokeResult);
+ * ```
+ *
+ * ```txt
+ * {
+ *   setup: 'What do you call a cat that loves to bowl?',
+ *   punchline: 'An alley cat!'
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const aiMsgForMetadata = await llm.invoke(input);
+ * console.log(aiMsgForMetadata.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Stream Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const streamForMetadata = await llm.stream(
+ *   input,
+ *   {
+ *     streamUsage: true
+ *   }
+ * );
+ * let fullForMetadata: AIMessageChunk | undefined;
+ * for await (const chunk of streamForMetadata) {
+ *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
+ * }
+ * console.log(fullForMetadata?.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ */
+class ChatVertexAI extends googleGauth.ChatGoogle {
+    lc_namespace = ['langchain', 'chat_models', 'vertexai'];
+    dynamicThinkingBudget = false;
+    static lc_name() {
+        return 'IllumaVertexAI';
+    }
+    constructor(fields) {
+        const dynamicThinkingBudget = fields?.thinkingBudget === -1;
+        super({
+            ...fields,
+            platformType: 'gcp',
+        });
+        this.dynamicThinkingBudget = dynamicThinkingBudget;
+    }
+    invocationParams(options) {
+        const params = super.invocationParams(options);
+        if (this.dynamicThinkingBudget) {
+            params.maxReasoningTokens = -1;
+        }
+        return params;
+    }
+    buildConnection(fields, client) {
+        this.connection = new CustomChatConnection({ ...fields, ...this }, this.caller, client, false);
+        this.streamedConnection = new CustomChatConnection({ ...fields, ...this }, this.caller, client, true);
+    }
+}
+
+exports.ChatVertexAI = ChatVertexAI;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/llm/vertexai/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../src/llm/vertexai/index.ts"],"sourcesContent":["import { ChatGoogle } from '@langchain/google-gauth';\nimport { ChatConnection } from '@langchain/google-common';\nimport type {\n  GeminiRequest,\n  GoogleAIModelRequestParams,\n  GoogleAbstractedClient,\n} from '@langchain/google-common';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport type { VertexAIClientOptions } from '@/types';\n\nclass CustomChatConnection extends ChatConnection<VertexAIClientOptions> {\n  async formatData(\n    input: BaseMessage[],\n    parameters: GoogleAIModelRequestParams\n  ): Promise<unknown> {\n    const formattedData = (await super.formatData(\n      input,\n      parameters\n    )) as GeminiRequest;\n    if (formattedData.generationConfig?.thinkingConfig?.thinkingBudget === -1) {\n      // -1 means \"let the model decide\" - delete the property so the API doesn't receive an invalid value\n      if (\n        formattedData.generationConfig.thinkingConfig.includeThoughts === false\n      ) {\n        formattedData.generationConfig.thinkingConfig.includeThoughts = true;\n      }\n      delete formattedData.generationConfig.thinkingConfig.thinkingBudget;\n    }\n    return formattedData;\n  }\n}\n\n/**\n * Integration with Google Vertex AI chat models.\n *\n * Setup:\n * Install `@langchain/google-vertexai` and set your stringified\n * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.\n *\n * ```bash\n * npm install @langchain/google-vertexai\n * export GOOGLE_APPLICATION_CREDENTIALS=\"path/to/credentials\"\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)\n *\n * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)\n *\n * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.\n * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:\n *\n * ```typescript\n * // When calling `.withConfig`, call options should be passed via the first argument\n * const llmWithArgsBound = llm.withConfig({\n *   stop: [\"\\n\"],\n *   tools: [...],\n * });\n *\n * // When calling `.bindTools`, call options should be passed via the second argument\n * const llmWithTools = llm.bindTools(\n *   [...],\n *   {\n *     tool_choice: \"auto\",\n *   }\n * );\n * ```\n *\n * ## Examples\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { ChatVertexAI } from '@langchain/google-vertexai';\n *\n * const llm = new ChatVertexAI({\n *   model: \"gemini-1.5-pro\",\n *   temperature: 0,\n *   // other params...\n * });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Invoking</strong></summary>\n *\n * ```typescript\n * const input = `Translate \"I love programming\" into French.`;\n *\n * // Models also accept a list of chat messages or a formatted prompt\n * const result = await llm.invoke(input);\n * console.log(result);\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"content\": \"\\\"J'adore programmer\\\" \\n\\nHere's why this is the best translation:\\n\\n* **J'adore** means \\\"I love\\\" and conveys a strong passion.\\n* **Programmer** is the French verb for \\\"to program.\\\"\\n\\nThis translation is natural and idiomatic in French. \\n\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": [],\n *   \"usage_metadata\": {\n *     \"input_tokens\": 9,\n *     \"output_tokens\": 63,\n *     \"total_tokens\": 72\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Streaming Chunks</strong></summary>\n *\n * ```typescript\n * for await (const chunk of await llm.stream(input)) {\n *   console.log(chunk);\n * }\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"content\": \"\\\"\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": []\n * }\n * AIMessageChunk {\n *   \"content\": \"J'adore programmer\\\" \\n\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": []\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {},\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": []\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {\n *     \"finishReason\": \"stop\"\n *   },\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": [],\n *   \"usage_metadata\": {\n *     \"input_tokens\": 9,\n *     \"output_tokens\": 8,\n *     \"total_tokens\": 17\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Aggregate Streamed Chunks</strong></summary>\n *\n * ```typescript\n * import { AIMessageChunk } from '@langchain/core/messages';\n * import { concat } from '@langchain/core/utils/stream';\n *\n * const stream = await llm.stream(input);\n * let full: AIMessageChunk | undefined;\n * for await (const chunk of stream) {\n *   full = !full ? chunk : concat(full, chunk);\n * }\n * console.log(full);\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"content\": \"\\\"J'adore programmer\\\" \\n\",\n *   \"additional_kwargs\": {},\n *   \"response_metadata\": {\n *     \"finishReason\": \"stop\"\n *   },\n *   \"tool_calls\": [],\n *   \"tool_call_chunks\": [],\n *   \"invalid_tool_calls\": [],\n *   \"usage_metadata\": {\n *     \"input_tokens\": 9,\n *     \"output_tokens\": 8,\n *     \"total_tokens\": 17\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Bind tools</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const GetWeather = {\n *   name: \"GetWeather\",\n *   description: \"Get the current weather in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const GetPopulation = {\n *   name: \"GetPopulation\",\n *   description: \"Get the current population in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);\n * const aiMsg = await llmWithTools.invoke(\n *   \"Which city is hotter today and which is bigger: LA or NY?\"\n * );\n * console.log(aiMsg.tool_calls);\n * ```\n *\n * ```txt\n * [\n *   {\n *     name: 'GetPopulation',\n *     args: { location: 'New York City, NY' },\n *     id: '33c1c1f47e2f492799c77d2800a43912',\n *     type: 'tool_call'\n *   }\n * ]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Structured Output</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const Joke = z.object({\n *   setup: z.string().describe(\"The setup of the joke\"),\n *   punchline: z.string().describe(\"The punchline to the joke\"),\n *   rating: z.number().optional().describe(\"How funny the joke is, from 1 to 10\")\n * }).describe('Joke to tell user.');\n *\n * const structuredLlm = llm.withStructuredOutput(Joke, { name: \"Joke\" });\n * const jokeResult = await structuredLlm.invoke(\"Tell me a joke about cats\");\n * console.log(jokeResult);\n * ```\n *\n * ```txt\n * {\n *   setup: 'What do you call a cat that loves to bowl?',\n *   punchline: 'An alley cat!'\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Usage Metadata</strong></summary>\n *\n * ```typescript\n * const aiMsgForMetadata = await llm.invoke(input);\n * console.log(aiMsgForMetadata.usage_metadata);\n * ```\n *\n * ```txt\n * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Stream Usage Metadata</strong></summary>\n *\n * ```typescript\n * const streamForMetadata = await llm.stream(\n *   input,\n *   {\n *     streamUsage: true\n *   }\n * );\n * let fullForMetadata: AIMessageChunk | undefined;\n * for await (const chunk of streamForMetadata) {\n *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);\n * }\n * console.log(fullForMetadata?.usage_metadata);\n * ```\n *\n * ```txt\n * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }\n * ```\n * </details>\n *\n * <br />\n */\nexport class ChatVertexAI extends ChatGoogle {\n  lc_namespace = ['langchain', 'chat_models', 'vertexai'];\n  dynamicThinkingBudget = false;\n\n  static lc_name(): 'IllumaVertexAI' {\n    return 'IllumaVertexAI';\n  }\n\n  constructor(fields?: VertexAIClientOptions) {\n    const dynamicThinkingBudget = fields?.thinkingBudget === -1;\n    super({\n      ...fields,\n      platformType: 'gcp',\n    });\n    this.dynamicThinkingBudget = dynamicThinkingBudget;\n  }\n  invocationParams(\n    options?: this['ParsedCallOptions'] | undefined\n  ): GoogleAIModelRequestParams {\n    const params = super.invocationParams(options);\n    if (this.dynamicThinkingBudget) {\n      params.maxReasoningTokens = -1;\n    }\n    return params;\n  }\n\n  buildConnection(\n    fields: VertexAIClientOptions,\n    client: GoogleAbstractedClient\n  ): void {\n    this.connection = new CustomChatConnection(\n      { ...fields, ...this },\n      this.caller,\n      client,\n      false\n    );\n\n    this.streamedConnection = new CustomChatConnection(\n      { ...fields, ...this },\n      this.caller,\n      client,\n      true\n    );\n  }\n}\n"],"names":["ChatConnection","ChatGoogle"],"mappings":";;;;;AAUA,MAAM,oBAAqB,SAAQA,2BAAqC,CAAA;AACtE,IAAA,MAAM,UAAU,CACd,KAAoB,EACpB,UAAsC,EAAA;AAEtC,QAAA,MAAM,aAAa,IAAI,MAAM,KAAK,CAAC,UAAU,CAC3C,KAAK,EACL,UAAU,CACX,CAAkB;QACnB,IAAI,aAAa,CAAC,gBAAgB,EAAE,cAAc,EAAE,cAAc,KAAK,EAAE,EAAE;;YAEzE,IACE,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,eAAe,KAAK,KAAK,EACvE;gBACA,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,eAAe,GAAG,IAAI;;AAEtE,YAAA,OAAO,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,cAAc;;AAErE,QAAA,OAAO,aAAa;;AAEvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyRG;AACG,MAAO,YAAa,SAAQC,sBAAU,CAAA;IAC1C,YAAY,GAAG,CAAC,WAAW,EAAE,aAAa,EAAE,UAAU,CAAC;IACvD,qBAAqB,GAAG,KAAK;AAE7B,IAAA,OAAO,OAAO,GAAA;AACZ,QAAA,OAAO,gBAAgB;;AAGzB,IAAA,WAAA,CAAY,MAA8B,EAAA;QACxC,MAAM,qBAAqB,GAAG,MAAM,EAAE,cAAc,KAAK,EAAE;AAC3D,QAAA,KAAK,CAAC;AACJ,YAAA,GAAG,MAAM;AACT,YAAA,YAAY,EAAE,KAAK;AACpB,SAAA,CAAC;AACF,QAAA,IAAI,CAAC,qBAAqB,GAAG,qBAAqB;;AAEpD,IAAA,gBAAgB,CACd,OAA+C,EAAA;QAE/C,MAAM,MAAM,GAAG,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC;AAC9C,QAAA,IAAI,IAAI,CAAC,qBAAqB,EAAE;AAC9B,YAAA,MAAM,CAAC,kBAAkB,GAAG,EAAE;;AAEhC,QAAA,OAAO,MAAM;;IAGf,eAAe,CACb,MAA6B,EAC7B,MAA8B,EAAA;QAE9B,IAAI,CAAC,UAAU,GAAG,IAAI,oBAAoB,CACxC,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,EACtB,IAAI,CAAC,MAAM,EACX,MAAM,EACN,KAAK,CACN;QAED,IAAI,CAAC,kBAAkB,GAAG,IAAI,oBAAoB,CAChD,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,EACtB,IAAI,CAAC,MAAM,EACX,MAAM,EACN,IAAI,CACL;;AAEJ;;;;"}

package/dist/cjs/main.cjs

@@ -0,0 +1,240 @@
+'use strict';
+
+var run = require('./run.cjs');
+var stream = require('./stream.cjs');
+var splitStream = require('./splitStream.cjs');
+var events = require('./events.cjs');
+var core = require('./messages/core.cjs');
+var ids = require('./messages/ids.cjs');
+var prune = require('./messages/prune.cjs');
+var format = require('./messages/format.cjs');
+var cache = require('./messages/cache.cjs');
+var content = require('./messages/content.cjs');
+var tools = require('./messages/tools.cjs');
+var Graph = require('./graphs/Graph.cjs');
+var MultiAgentGraph = require('./graphs/MultiAgentGraph.cjs');
+var Calculator = require('./tools/Calculator.cjs');
+var CodeExecutor = require('./tools/CodeExecutor.cjs');
+var BrowserTools = require('./tools/BrowserTools.cjs');
+var ProgrammaticToolCalling = require('./tools/ProgrammaticToolCalling.cjs');
+var ToolSearch = require('./tools/ToolSearch.cjs');
+var ToolNode = require('./tools/ToolNode.cjs');
+var schema = require('./tools/schema.cjs');
+var handlers = require('./tools/handlers.cjs');
+var tool = require('./tools/search/tool.cjs');
+var schema$1 = require('./tools/search/schema.cjs');
+var validate = require('./schemas/validate.cjs');
+var _enum = require('./common/enum.cjs');
+var graph = require('./utils/graph.cjs');
+var llm = require('./utils/llm.cjs');
+var misc = require('./utils/misc.cjs');
+var handlers$1 = require('./utils/handlers.cjs');
+var run$1 = require('./utils/run.cjs');
+var tokens = require('./utils/tokens.cjs');
+var toonFormat = require('./utils/toonFormat.cjs');
+var contextAnalytics = require('./utils/contextAnalytics.cjs');
+var schema$2 = require('./utils/schema.cjs');
+var index = require('./llm/openai/index.cjs');
+var providers = require('./llm/providers.cjs');
+
+
+
+exports.Run = run.Run;
+exports.defaultOmitOptions = run.defaultOmitOptions;
+exports.ChatModelStreamHandler = stream.ChatModelStreamHandler;
+exports.createContentAggregator = stream.createContentAggregator;
+exports.getChunkContent = stream.getChunkContent;
+exports.SEPARATORS = splitStream.SEPARATORS;
+exports.SplitStreamHandler = splitStream.SplitStreamHandler;
+exports.HandlerRegistry = events.HandlerRegistry;
+exports.LLMStreamHandler = events.LLMStreamHandler;
+exports.ModelEndHandler = events.ModelEndHandler;
+exports.TestChatStreamHandler = events.TestChatStreamHandler;
+exports.TestLLMStreamHandler = events.TestLLMStreamHandler;
+exports.ToolEndHandler = events.ToolEndHandler;
+exports.createMetadataAggregator = events.createMetadataAggregator;
+exports.convertMessagesToContent = core.convertMessagesToContent;
+exports.findLastIndex = core.findLastIndex;
+exports.formatAnthropicArtifactContent = core.formatAnthropicArtifactContent;
+exports.formatAnthropicMessage = core.formatAnthropicMessage;
+exports.formatArtifactPayload = core.formatArtifactPayload;
+exports.getConverseOverrideMessage = core.getConverseOverrideMessage;
+exports.modifyDeltaProperties = core.modifyDeltaProperties;
+exports.getMessageId = ids.getMessageId;
+exports.calculateTotalTokens = prune.calculateTotalTokens;
+exports.checkValidNumber = prune.checkValidNumber;
+exports.createPruneMessages = prune.createPruneMessages;
+exports.getMessagesWithinTokenLimit = prune.getMessagesWithinTokenLimit;
+exports.ensureThinkingBlockInMessages = format.ensureThinkingBlockInMessages;
+exports.formatAgentMessages = format.formatAgentMessages;
+exports.formatFromLangChain = format.formatFromLangChain;
+exports.formatLangChainMessages = format.formatLangChainMessages;
+exports.formatMediaMessage = format.formatMediaMessage;
+exports.formatMessage = format.formatMessage;
+exports.labelContentByAgent = format.labelContentByAgent;
+exports.shiftIndexTokenCountMap = format.shiftIndexTokenCountMap;
+exports.addBedrockCacheControl = cache.addBedrockCacheControl;
+exports.addCacheControl = cache.addCacheControl;
+exports.stripAnthropicCacheControl = cache.stripAnthropicCacheControl;
+exports.stripBedrockCacheControl = cache.stripBedrockCacheControl;
+exports.formatContentStrings = content.formatContentStrings;
+exports.extractToolDiscoveries = tools.extractToolDiscoveries;
+exports.hasToolSearchInCurrentTurn = tools.hasToolSearchInCurrentTurn;
+exports.Graph = Graph.Graph;
+exports.StandardGraph = Graph.StandardGraph;
+exports.MultiAgentGraph = MultiAgentGraph.MultiAgentGraph;
+exports.Calculator = Calculator.Calculator;
+exports.CalculatorSchema = Calculator.CalculatorSchema;
+exports.CalculatorToolDefinition = Calculator.CalculatorToolDefinition;
+exports.CalculatorToolDescription = Calculator.CalculatorToolDescription;
+exports.CalculatorToolName = Calculator.CalculatorToolName;
+exports.CodeExecutionToolDefinition = CodeExecutor.CodeExecutionToolDefinition;
+exports.CodeExecutionToolDescription = CodeExecutor.CodeExecutionToolDescription;
+exports.CodeExecutionToolName = CodeExecutor.CodeExecutionToolName;
+exports.CodeExecutionToolSchema = CodeExecutor.CodeExecutionToolSchema;
+exports.createCodeExecutionTool = CodeExecutor.createCodeExecutionTool;
+exports.getCodeBaseURL = CodeExecutor.getCodeBaseURL;
+exports.imageExtRegex = CodeExecutor.imageExtRegex;
+exports.EBrowserTools = BrowserTools.EBrowserTools;
+exports.createBrowserTools = BrowserTools.createBrowserTools;
+exports.hasBrowserCapability = BrowserTools.hasBrowserCapability;
+exports.ProgrammaticToolCallingDefinition = ProgrammaticToolCalling.ProgrammaticToolCallingDefinition;
+exports.ProgrammaticToolCallingDescription = ProgrammaticToolCalling.ProgrammaticToolCallingDescription;
+exports.ProgrammaticToolCallingName = ProgrammaticToolCalling.ProgrammaticToolCallingName;
+exports.ProgrammaticToolCallingSchema = ProgrammaticToolCalling.ProgrammaticToolCallingSchema;
+exports.createProgrammaticToolCallingTool = ProgrammaticToolCalling.createProgrammaticToolCallingTool;
+exports.executeTools = ProgrammaticToolCalling.executeTools;
+exports.extractUsedToolNames = ProgrammaticToolCalling.extractUsedToolNames;
+exports.fetchSessionFiles = ProgrammaticToolCalling.fetchSessionFiles;
+exports.filterToolsByUsage = ProgrammaticToolCalling.filterToolsByUsage;
+exports.formatCompletedResponse = ProgrammaticToolCalling.formatCompletedResponse;
+exports.makeRequest = ProgrammaticToolCalling.makeRequest;
+exports.normalizeToPythonIdentifier = ProgrammaticToolCalling.normalizeToPythonIdentifier;
+exports.unwrapToolResponse = ProgrammaticToolCalling.unwrapToolResponse;
+exports.ToolSearchToolDefinition = ToolSearch.ToolSearchToolDefinition;
+exports.ToolSearchToolDescription = ToolSearch.ToolSearchToolDescription;
+exports.ToolSearchToolName = ToolSearch.ToolSearchToolName;
+exports.ToolSearchToolSchema = ToolSearch.ToolSearchToolSchema;
+exports.countNestedGroups = ToolSearch.countNestedGroups;
+exports.createToolSearch = ToolSearch.createToolSearch;
+exports.escapeRegexSpecialChars = ToolSearch.escapeRegexSpecialChars;
+exports.extractMcpServerName = ToolSearch.extractMcpServerName;
+exports.formatServerListing = ToolSearch.formatServerListing;
+exports.getAvailableMcpServers = ToolSearch.getAvailableMcpServers;
+exports.getBaseToolName = ToolSearch.getBaseToolName;
+exports.getDeferredToolsListing = ToolSearch.getDeferredToolsListing;
+exports.hasNestedQuantifiers = ToolSearch.hasNestedQuantifiers;
+exports.isDangerousPattern = ToolSearch.isDangerousPattern;
+exports.isFromAnyMcpServer = ToolSearch.isFromAnyMcpServer;
+exports.isFromMcpServer = ToolSearch.isFromMcpServer;
+exports.normalizeServerFilter = ToolSearch.normalizeServerFilter;
+exports.performLocalSearch = ToolSearch.performLocalSearch;
+exports.sanitizeRegex = ToolSearch.sanitizeRegex;
+exports.ToolNode = ToolNode.ToolNode;
+exports.toolsCondition = ToolNode.toolsCondition;
+exports.createSchemaOnlyTool = schema.createSchemaOnlyTool;
+exports.createSchemaOnlyTools = schema.createSchemaOnlyTools;
+exports.handleServerToolResult = handlers.handleServerToolResult;
+exports.handleToolCallChunks = handlers.handleToolCallChunks;
+exports.handleToolCalls = handlers.handleToolCalls;
+exports.toolResultTypes = handlers.toolResultTypes;
+exports.createSearchTool = tool.createSearchTool;
+Object.defineProperty(exports, "DATE_RANGE", {
+	enumerable: true,
+	get: function () { return schema$1.DATE_RANGE; }
+});
+exports.DEFAULT_COUNTRY_DESCRIPTION = schema$1.DEFAULT_COUNTRY_DESCRIPTION;
+exports.DEFAULT_QUERY_DESCRIPTION = schema$1.DEFAULT_QUERY_DESCRIPTION;
+exports.WebSearchToolDefinition = schema$1.WebSearchToolDefinition;
+exports.WebSearchToolDescription = schema$1.WebSearchToolDescription;
+exports.WebSearchToolName = schema$1.WebSearchToolName;
+exports.WebSearchToolSchema = schema$1.WebSearchToolSchema;
+exports.countrySchema = schema$1.countrySchema;
+exports.dateSchema = schema$1.dateSchema;
+exports.imagesSchema = schema$1.imagesSchema;
+exports.newsSchema = schema$1.newsSchema;
+exports.querySchema = schema$1.querySchema;
+exports.videosSchema = schema$1.videosSchema;
+exports.createValidationErrorMessage = validate.createValidationErrorMessage;
+exports.isValidJsonSchema = validate.isValidJsonSchema;
+exports.normalizeJsonSchema = validate.normalizeJsonSchema;
+exports.prepareSchemaForProvider = validate.prepareSchemaForProvider;
+exports.validateStructuredOutput = validate.validateStructuredOutput;
+exports.zodToJsonSchema = validate.zodToJsonSchema;
+Object.defineProperty(exports, "Callback", {
+	enumerable: true,
+	get: function () { return _enum.Callback; }
+});
+Object.defineProperty(exports, "CommonEvents", {
+	enumerable: true,
+	get: function () { return _enum.CommonEvents; }
+});
+Object.defineProperty(exports, "Constants", {
+	enumerable: true,
+	get: function () { return _enum.Constants; }
+});
+Object.defineProperty(exports, "ContentTypes", {
+	enumerable: true,
+	get: function () { return _enum.ContentTypes; }
+});
+Object.defineProperty(exports, "EnvVar", {
+	enumerable: true,
+	get: function () { return _enum.EnvVar; }
+});
+Object.defineProperty(exports, "GraphEvents", {
+	enumerable: true,
+	get: function () { return _enum.GraphEvents; }
+});
+Object.defineProperty(exports, "GraphNodeActions", {
+	enumerable: true,
+	get: function () { return _enum.GraphNodeActions; }
+});
+Object.defineProperty(exports, "GraphNodeKeys", {
+	enumerable: true,
+	get: function () { return _enum.GraphNodeKeys; }
+});
+Object.defineProperty(exports, "MessageTypes", {
+	enumerable: true,
+	get: function () { return _enum.MessageTypes; }
+});
+Object.defineProperty(exports, "Providers", {
+	enumerable: true,
+	get: function () { return _enum.Providers; }
+});
+Object.defineProperty(exports, "StepTypes", {
+	enumerable: true,
+	get: function () { return _enum.StepTypes; }
+});
+Object.defineProperty(exports, "TitleMethod", {
+	enumerable: true,
+	get: function () { return _enum.TitleMethod; }
+});
+Object.defineProperty(exports, "ToolCallTypes", {
+	enumerable: true,
+	get: function () { return _enum.ToolCallTypes; }
+});
+exports.joinKeys = graph.joinKeys;
+exports.resetIfNotEmpty = graph.resetIfNotEmpty;
+exports.isGoogleLike = llm.isGoogleLike;
+exports.isOpenAILike = llm.isOpenAILike;
+exports.isPresent = misc.isPresent;
+exports.unescapeObject = misc.unescapeObject;
+exports.createHandlers = handlers$1.createHandlers;
+exports.RunnableCallable = run$1.RunnableCallable;
+exports.sleep = run$1.sleep;
+exports.TokenEncoderManager = tokens.TokenEncoderManager;
+exports.createTokenCounter = tokens.createTokenCounter;
+exports.getTokenCountForMessage = tokens.getTokenCountForMessage;
+exports.ensureToonLoaded = toonFormat.ensureToonLoaded;
+exports.extractFirstJson = toonFormat.extractFirstJson;
+exports.isToonAvailable = toonFormat.isToonAvailable;
+exports.isToonFormat = toonFormat.isToonFormat;
+exports.jsonToToon = toonFormat.jsonToToon;
+exports.processToolOutput = toonFormat.processToolOutput;
+exports.buildContextAnalytics = contextAnalytics.buildContextAnalytics;
+exports.isZodSchema = schema$2.isZodSchema;
+exports.toJsonSchema = schema$2.toJsonSchema;
+exports.CustomOpenAIClient = index.CustomOpenAIClient;
+exports.getChatModelClass = providers.getChatModelClass;
+exports.llmProviders = providers.llmProviders;
+//# sourceMappingURL=main.cjs.map

package/dist/cjs/main.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}