@blaxel/langgraph 0.2.10-dev.86 → 0.2.10-dev1

package/README.md

@@ -1,7 +1,7 @@
 # Blaxel Typescript SDK
 
 <p align="center">
-  <img src="https://blaxel.ai/logo.png" alt="Blaxel"/>
+  <img src="https://blaxel.ai/logo-bg.png" alt="Blaxel"/>
 </p>
 
 **Blaxel is a computing platform for AI agent builders, with all the services and infrastructure to build and deploy agents efficiently.** This repository contains the TypeScript SDK to interact with Blaxel resources using LangChain/LangGraph format.

package/dist/model.js

@@ -23,6 +23,7 @@ const blModel = async (model, options) => {
                 apiKey: core_1.settings.token,
                 model: modelData?.spec?.runtime?.model,
                 baseUrl: url,
+                customHeaders: core_1.settings.headers,
                 ...options,
             });
         }

package/dist/telemetry/intrumentation.d.ts

@@ -0,0 +1,41 @@
+import { InstrumentationConfig } from "@opentelemetry/instrumentation";
+export interface LangChainInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * Whether to log prompts, completions and embeddings on traces.
+     * @default true
+     */
+    traceContent?: boolean;
+    /**
+     * A custom logger to log any exceptions that happen during span creation.
+     */
+    exceptionLogger?: (e: Error) => void;
+}
+import { InstrumentationBase, InstrumentationModuleDefinition } from "@opentelemetry/instrumentation";
+export declare class LangChainInstrumentation extends InstrumentationBase {
+    protected _config: LangChainInstrumentationConfig;
+    constructor(config?: LangChainInstrumentationConfig);
+    manuallyInstrument({ chainsModule, agentsModule, toolsModule, vectorStoreModule, runnablesModule, }: {
+        chainsModule?: any;
+        agentsModule?: any;
+        toolsModule?: any;
+        vectorStoreModule?: any;
+        runnablesModule?: any;
+    }): void;
+    protected init(): InstrumentationModuleDefinition[];
+    private patchChainModule;
+    private patchAgentModule;
+    private patchToolsModule;
+    private patchVectorStoreModule;
+    private patchRunnablesModule;
+    private unpatchChainModule;
+    private unpatchAgentModule;
+    private unpatchToolsModule;
+    private unpatchVectorStoreModule;
+    private unpatchRunnablesModule;
+    private _shouldSendPrompts;
+}
+import { Tracer } from "@opentelemetry/api";
+import { TraceloopSpanKindValues } from "@traceloop/ai-semantic-conventions";
+export declare function genericWrapper(tracer: () => Tracer, shouldSendPrompts: boolean, spanKind: TraceloopSpanKindValues, spanName?: string): (original: Function) => (this: any, ...args: unknown[]) => any;
+export declare function taskWrapper(tracer: () => Tracer, shouldSendPrompts: boolean, spanName?: string): (original: Function) => (this: any, ...args: unknown[]) => any;
+export declare function workflowWrapper(tracer: () => Tracer, shouldSendPrompts: boolean, spanName: string): (original: Function) => (this: any, ...args: unknown[]) => any;

package/dist/telemetry/intrumentation.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainInstrumentation = void 0;
+exports.genericWrapper = genericWrapper;
+exports.taskWrapper = taskWrapper;
+exports.workflowWrapper = workflowWrapper;
+const api_1 = require("@opentelemetry/api");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const ai_semantic_conventions_1 = require("@traceloop/ai-semantic-conventions");
+class LangChainInstrumentation extends instrumentation_1.InstrumentationBase {
+    constructor(config = {}) {
+        super("@traceloop/instrumentation-langchain", '0.0.0', config);
+    }
+    manuallyInstrument({ chainsModule, agentsModule, toolsModule, vectorStoreModule, runnablesModule, }) {
+        console.log("Manually instrumenting langchain");
+        if (chainsModule) {
+            this._diag.debug("Manually instrumenting langchain chains");
+            this.patchChainModule(chainsModule);
+        }
+        if (agentsModule) {
+            this._diag.debug("Manually instrumenting langchain agents");
+            this.patchAgentModule(agentsModule);
+        }
+        if (toolsModule) {
+            this._diag.debug("Manually instrumenting langchain tools");
+            this.patchToolsModule(toolsModule);
+        }
+        if (vectorStoreModule) {
+            this._diag.debug("Manually instrumenting langchain vector stores");
+            this.patchVectorStoreModule(vectorStoreModule);
+        }
+        if (runnablesModule) {
+            this._diag.debug("Manually instrumenting @langchain/core/runnables");
+            this.patchRunnablesModule(runnablesModule);
+        }
+    }
+    init() {
+        console.log("Initializing langchain instrumentation");
+        const chainModule = new instrumentation_1.InstrumentationNodeModuleDefinition("langchain/chains.cjs", [">=0.3.0"], this.patchChainModule.bind(this), this.unpatchChainModule.bind(this));
+        const agentModule = new instrumentation_1.InstrumentationNodeModuleDefinition("langchain/agents.cjs", [">=0.3.0"], this.patchAgentModule.bind(this), this.unpatchAgentModule.bind(this));
+        const toolsModule = new instrumentation_1.InstrumentationNodeModuleDefinition("langchain/tools.cjs", [">=0.3.0"], this.patchToolsModule.bind(this), this.unpatchToolsModule.bind(this));
+        const vectorStoreModule = new instrumentation_1.InstrumentationNodeModuleDefinition("langchain/core/vectorstores.cjs", [">=0.3.0"], this.patchVectorStoreModule.bind(this), this.unpatchVectorStoreModule.bind(this));
+        const runnablesModule = new instrumentation_1.InstrumentationNodeModuleDefinition("@langchain/core/runnables.cjs", [">=0.3.0"], this.patchRunnablesModule.bind(this), this.unpatchRunnablesModule.bind(this));
+        return [
+            chainModule,
+            agentModule,
+            toolsModule,
+            vectorStoreModule,
+            runnablesModule,
+        ];
+    }
+    patchChainModule(moduleExports, moduleVersion) {
+        console.log("Patching langchain/chains.cjs");
+        this._diag.debug(`Patching langchain/chains.cjs@${moduleVersion}`);
+        this._wrap(moduleExports.RetrievalQAChain.prototype, "_call", workflowWrapper(() => this.tracer, this._shouldSendPrompts(), "retrieval_qa.workflow"));
+        this._wrap(moduleExports.BaseChain.prototype, "call", taskWrapper(() => this.tracer, this._shouldSendPrompts()));
+        return moduleExports;
+    }
+    patchAgentModule(moduleExports, moduleVersion) {
+        console.log("Patching langchain/agents.cjs");
+        this._diag.debug(`Patching langchain/agents.cjs@${moduleVersion}`);
+        this._wrap(moduleExports.AgentExecutor.prototype, "_call", workflowWrapper(() => this.tracer, this._shouldSendPrompts(), "langchain.agent"));
+        return moduleExports;
+    }
+    patchToolsModule(moduleExports, moduleVersion) {
+        console.log("Patching langchain/tools.cjs");
+        this._diag.debug(`Patching langchain/tools.cjs@${moduleVersion}`);
+        this._wrap(moduleExports.Tool.prototype, "call", taskWrapper(() => this.tracer, this._shouldSendPrompts()));
+        return moduleExports;
+    }
+    patchVectorStoreModule(moduleExports, moduleVersion) {
+        console.log("Patching langchain/vectorstores.cjs");
+        this._diag.debug(`Patching langchain/vectorstores.cjs@${moduleVersion}`);
+        this._wrap(moduleExports.VectorStoreRetriever.prototype, "_getRelevantDocuments", taskWrapper(() => this.tracer, this._shouldSendPrompts()));
+        return moduleExports;
+    }
+    patchRunnablesModule(moduleExports, moduleVersion) {
+        console.log("Patching @langchain/core/runnables.cjs");
+        this._diag.debug(`Patching @langchain/core/runnables@${moduleVersion}`);
+        this._wrap(moduleExports.RunnableSequence.prototype, "invoke", taskWrapper(() => this.tracer, this._shouldSendPrompts()));
+        return moduleExports;
+    }
+    unpatchChainModule(moduleExports, moduleVersion) {
+        console.log("Unpatching langchain/chains.cjs");
+        this._diag.debug(`Unpatching langchain/chains.cjs@${moduleVersion}`);
+        this._unwrap(moduleExports.RetrievalQAChain.prototype, "_call");
+        this._unwrap(moduleExports.BaseChain.prototype, "call");
+        return moduleExports;
+    }
+    unpatchAgentModule(moduleExports, moduleVersion) {
+        console.log("Unpatching langchain/agents.cjs");
+        this._diag.debug(`Unpatching langchain/agents.cjs@${moduleVersion}`);
+        this._unwrap(moduleExports.AgentExecutor.prototype, "_call");
+        return moduleExports;
+    }
+    unpatchToolsModule(moduleExports) {
+        console.log("Unpatching langchain/tools.cjs");
+        this._diag.debug(`Unpatching langchain/tools.cjs`);
+        this._unwrap(moduleExports.Tool.prototype, "call");
+        return moduleExports;
+    }
+    unpatchVectorStoreModule(moduleExports) {
+        console.log("Unpatching langchain/vectorstores.cjs");
+        this._diag.debug(`Unpatching langchain/vectorstores.cjs`);
+        this._unwrap(moduleExports.VectorStoreRetriever.prototype, "_getRelevantDocuments");
+        return moduleExports;
+    }
+    unpatchRunnablesModule(moduleExports) {
+        console.log("Unpatching @langchain/core/runnables.cjs");
+        this._diag.debug(`Unpatching @langchain/core/runnables.cjs`);
+        this._unwrap(moduleExports.Runnable.prototype, "invoke");
+        return moduleExports;
+    }
+    _shouldSendPrompts() {
+        console.log("Should send prompts");
+        const contextShouldSendPrompts = api_1.context
+            .active()
+            .getValue(ai_semantic_conventions_1.CONTEXT_KEY_ALLOW_TRACE_CONTENT);
+        if (contextShouldSendPrompts !== undefined) {
+            return !!contextShouldSendPrompts;
+        }
+        return this._config.traceContent !== undefined
+            ? this._config.traceContent
+            : true;
+    }
+}
+exports.LangChainInstrumentation = LangChainInstrumentation;
+const api_2 = require("@opentelemetry/api");
+const instrumentation_2 = require("@opentelemetry/instrumentation");
+const ai_semantic_conventions_2 = require("@traceloop/ai-semantic-conventions");
+function genericWrapper(tracer, shouldSendPrompts, spanKind, spanName) {
+    console.log("Generic wrapper");
+    // eslint-disable-next-line
+    return (original) => {
+        return function method(...args) {
+            const span = tracer().startSpan(spanName || `${this.constructor.name}.${spanKind}`);
+            span.setAttribute(ai_semantic_conventions_2.SpanAttributes.TRACELOOP_SPAN_KIND, spanKind);
+            if (shouldSendPrompts) {
+                try {
+                    if (args.length === 1 &&
+                        typeof args[0] === "object" &&
+                        !(args[0] instanceof Map)) {
+                        span.setAttribute(ai_semantic_conventions_2.SpanAttributes.TRACELOOP_ENTITY_INPUT, JSON.stringify({ args: [], kwargs: args[0] }));
+                    }
+                    else {
+                        span.setAttribute(ai_semantic_conventions_2.SpanAttributes.TRACELOOP_ENTITY_INPUT, JSON.stringify({
+                            args: args.map((arg) => arg instanceof Map ? Array.from(arg.entries()) : arg),
+                            kwargs: {},
+                        }));
+                    }
+                }
+                catch (e) {
+                    this._diag.debug(e);
+                    this._config.exceptionLogger?.(e);
+                }
+            }
+            const execContext = api_2.trace.setSpan(api_1.context.active(), span);
+            const execPromise = (0, instrumentation_2.safeExecuteInTheMiddle)(() => {
+                return api_1.context.with(execContext, () => {
+                    return original.apply(this, args);
+                });
+            }, 
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            () => { });
+            const wrappedPromise = execPromise
+                .then((result) => {
+                return new Promise((resolve) => {
+                    span.setStatus({ code: api_2.SpanStatusCode.OK });
+                    try {
+                        if (shouldSendPrompts) {
+                            if (result instanceof Map) {
+                                span.setAttribute(ai_semantic_conventions_2.SpanAttributes.TRACELOOP_ENTITY_OUTPUT, JSON.stringify(Array.from(result.entries())));
+                            }
+                            else {
+                                span.setAttribute(ai_semantic_conventions_2.SpanAttributes.TRACELOOP_ENTITY_OUTPUT, JSON.stringify(result));
+                            }
+                        }
+                    }
+                    catch (e) {
+                        this._diag.debug(e);
+                        this._config.exceptionLogger?.(e);
+                    }
+                    finally {
+                        span.end();
+                        resolve(result);
+                    }
+                });
+            })
+                .catch((error) => {
+                return new Promise((_, reject) => {
+                    span.setStatus({
+                        code: api_2.SpanStatusCode.ERROR,
+                        message: error.message,
+                    });
+                    span.end();
+                    reject(error);
+                });
+            });
+            return api_1.context.bind(execContext, wrappedPromise);
+        };
+    };
+}
+function taskWrapper(tracer, shouldSendPrompts, spanName) {
+    return genericWrapper(tracer, shouldSendPrompts, ai_semantic_conventions_2.TraceloopSpanKindValues.TASK, spanName);
+}
+function workflowWrapper(tracer, shouldSendPrompts, spanName) {
+    return genericWrapper(tracer, shouldSendPrompts, ai_semantic_conventions_2.TraceloopSpanKindValues.WORKFLOW, spanName);
+}

package/dist/tools.d.ts

@@ -1,14 +1,14 @@
-export declare function blTool(name: string): Promise<import("@langchain/core/tools").DynamicStructuredTool<import("zod", { with: { "resolution-mode": "import" } }).ZodObject<any, import("zod", { with: { "resolution-mode": "import" } }).UnknownKeysParam, import("zod", { with: { "resolution-mode": "import" } }).ZodTypeAny, {
+export declare function blTool(name: 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>[]>;
-export declare function blTools(names: string[]): Promise<import("@langchain/core/tools").DynamicStructuredTool<import("zod", { with: { "resolution-mode": "import" } }).ZodObject<any, import("zod", { with: { "resolution-mode": "import" } }).UnknownKeysParam, import("zod", { with: { "resolution-mode": "import" } }).ZodTypeAny, {
+}>[]>;
+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>[]>;
+}>[]>;

package/dist/tools.js

@@ -4,9 +4,9 @@ exports.blTool = blTool;
 exports.blTools = blTools;
 const core_1 = require("@blaxel/core");
 const tools_1 = require("@langchain/core/tools");
-async function blTool(name) {
+async function blTool(name, ms) {
     try {
-        const blaxelTool = await (0, core_1.getTool)(name);
+        const blaxelTool = await (0, core_1.getTool)(name, ms);
         return blaxelTool.map((t) => (0, tools_1.tool)(t.call.bind(t), {
             name: t.name,
             description: t.description,
@@ -18,7 +18,7 @@ async function blTool(name) {
         throw err;
     }
 }
-async function blTools(names) {
-    const toolArrays = await Promise.all(names.map(blTool));
+async function blTools(names, ms) {
+    const toolArrays = await Promise.all(names.map((n) => blTool(n, ms)));
     return toolArrays.flat();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/langgraph",
-  "version": "0.2.10-dev.86",
+  "version": "0.2.10-dev1",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -65,7 +65,7 @@
     "langchain": "^0.3.24",
     "zod": "^3.24.3",
     "zod-to-json-schema": "^3.24.5",
-    "@blaxel/core": "0.2.10-dev.86"
+    "@blaxel/core": "0.2.10-dev1"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",