@blaxel/langgraph 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/{model → cjs/model}/google-genai/chat_models.js

@@ -389,6 +389,7 @@ const zod_to_genai_parameters_js_1 = require("./utils/zod_to_genai_parameters.js
  *
  * <br />
  */
+// @ts-ignore - Type instantiation depth issue with complex generics
 class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
     static lc_name() {
         return "ChatGoogleGenerativeAI";
@@ -678,8 +679,11 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
         }
         let functionName = name ?? "extract";
         let outputParser;
+        // @ts-ignore - Type instantiation depth issue with Zod schemas
         let tools;
+        // @ts-ignore - Type instantiation depth issue with Zod schemas
         if ((0, types_1.isZodSchema)(schema)) {
+            // @ts-ignore - Type instantiation depth issue with Zod schemas
             const jsonSchema = (0, zod_to_genai_parameters_js_1.zodToGenerativeAIParameters)(schema);
             tools = [
                 {
@@ -695,22 +699,23 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             outputParser = new output_parsers_js_1.GoogleGenerativeAIToolsOutputParser({
                 returnSingle: true,
                 keyName: functionName,
-                zodSchema: schema,
+                zodSchema: schema, // Type assertion to avoid deep instantiation issues
             });
         }
         else {
             let geminiFunctionDefinition;
-            if (typeof schema.name === "string" &&
-                typeof schema.parameters === "object" &&
-                schema.parameters != null) {
-                geminiFunctionDefinition = schema;
-                functionName = schema.name;
+            const schemaAsAny = schema; // Type assertion to handle union type
+            if (typeof schemaAsAny.name === "string" &&
+                typeof schemaAsAny.parameters === "object" &&
+                schemaAsAny.parameters != null) {
+                geminiFunctionDefinition = schemaAsAny;
+                functionName = schemaAsAny.name;
             }
             else {
                 geminiFunctionDefinition = {
                     name: functionName,
-                    description: schema.description ?? "",
-                    parameters: schema,
+                    description: schemaAsAny.description ?? "",
+                    parameters: schemaAsAny,
                 };
             }
             tools = [

package/dist/{model → cjs/model}/google-genai/output_parsers.js

@@ -17,6 +17,7 @@ class GoogleGenerativeAIToolsOutputParser extends output_parsers_1.BaseLLMOutput
         super(params);
         this.keyName = params.keyName;
         this.returnSingle = params.returnSingle ?? this.returnSingle;
+        // @ts-ignore - Type instantiation depth issue with Zod schemas
         this.zodSchema = params.zodSchema;
     }
     async _validateResult(result) {

package/dist/{model → cjs/model}/google-genai/utils/common.js

@@ -365,6 +365,7 @@ function convertToGenerativeAITools(tools) {
         {
             functionDeclarations: tools.map((tool) => {
                 if ((0, function_calling_1.isLangChainTool)(tool) && isZodType(tool.schema)) {
+                    // @ts-ignore - Type instantiation depth issue with Zod schemas
                     const jsonSchema = (0, zod_to_genai_parameters_js_1.zodToGenerativeAIParameters)(tool.schema);
                     return {
                         name: tool.name,

package/dist/cjs/telemetry.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const RunnableModule = __importStar(require("@langchain/core/runnables"));
+const ToolsModule = __importStar(require("@langchain/core/tools"));
+const VectorStoresModule = __importStar(require("@langchain/core/vectorstores"));
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const instrumentation_langchain_1 = require("@traceloop/instrumentation-langchain");
+const AgentsModule = __importStar(require("langchain/agents"));
+const ChainsModule = __importStar(require("langchain/chains"));
+const langchain = new instrumentation_langchain_1.LangChainInstrumentation();
+langchain.manuallyInstrument({
+    runnablesModule: RunnableModule,
+    toolsModule: ToolsModule,
+    chainsModule: ChainsModule,
+    agentsModule: AgentsModule,
+    vectorStoreModule: VectorStoresModule,
+});
+langchain.enable();
+(0, instrumentation_1.registerInstrumentations)({
+    instrumentations: [langchain],
+});

package/dist/{tools.js → cjs/tools.js}

@@ -7,7 +7,9 @@ const tools_1 = require("@langchain/core/tools");
 async function blTool(name, options) {
     try {
         const blaxelTool = await (0, core_1.getTool)(name, options);
-        return blaxelTool.map((t) => (0, tools_1.tool)(t.call.bind(t), {
+        return blaxelTool.map((t) => 
+        // @ts-ignore - Type instantiation depth issue with tool schemas
+        (0, tools_1.tool)(t.call.bind(t), {
             name: t.name,
             description: t.description,
             schema: t.inputSchema,

package/dist/{model → cjs/types/model}/xai.d.ts

@@ -37,5 +37,5 @@ export declare class ChatXAI extends ChatOpenAI {
      * @param options - Additional options for parameter retrieval.
      * @returns An object containing LangChain parameters.
      */
-    getLsParams(options: unknown): import("@langchain/core/language_models/chat_models", { with: { "resolution-mode": "import" } }).LangSmithParams;
+    getLsParams(options: unknown): import("@langchain/core/language_models/chat_models").LangSmithParams;
 }

package/dist/{tools.d.ts → cjs/types/tools.d.ts}

@@ -1,15 +1,11 @@
-import { ToolOptions } from "@blaxel/core/tools/mcpTool";
+import type { ToolOptions } from "@blaxel/core";
 export declare function blTool(name: string, options?: ToolOptions | number): Promise<import("@langchain/core/tools").DynamicStructuredTool<import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
     [x: string]: any;
 }, {
     [x: string]: any;
-}>, unknown, {
-    [x: string]: any;
-}, unknown>[]>;
+}>, any, any, unknown>[]>;
 export declare function blTools(names: string[], ms?: number): Promise<import("@langchain/core/tools").DynamicStructuredTool<import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
     [x: string]: any;
 }, {
     [x: string]: any;
-}>, unknown, {
-    [x: string]: any;
-}, unknown>[]>;
+}>, any, any, unknown>[]>;