langsmith 0.1.2 → 0.1.5

package/README.md

@@ -90,8 +90,9 @@ Langsmith's `traceable` wrapper function makes it easy to trace any function or
 ### OpenAI SDK
 
 <!-- markdown-link-check-disable -->
-The easiest ways to trace calls from the [OpenAI SDK](https://platform.openai.com/docs/api-reference) with LangSmith
-is using the `traceable` wrapper function available in LangSmith 0.1.0 and up.
+
+The easiest way to trace calls from the [OpenAI SDK](https://platform.openai.com/docs/api-reference) with LangSmith
+is using the `wrapOpenAI` wrapper function available in LangSmith 0.1.3 and up.
 
 In order to use, you first need to set your LangSmith API key:
 
@@ -105,72 +106,41 @@ Next, you will need to install the LangSmith SDK and the OpenAI SDK:
 npm install langsmith openai
 ```
 
-After that, initialize your OpenAI client:
+After that, initialize your OpenAI client and wrap the client with `wrapOpenAI` method to enable tracing for the completions and chat completions methods:
 
 ```ts
 import { OpenAI } from "openai";
+import { wrapOpenAI } from "langsmith/wrappers";
+
+const openai = wrapOpenAI(new OpenAI());
 
-const client = new OpenAI();
+await openai.chat.completions.create({
+  model: "gpt-3.5-turbo",
+  messages: [{ content: "Hi there!", role: "user" }],
+});
 ```
 
-Then, you can wrap the client methods you want to use by passing it to the `traceable` function like this:
+Alternatively, you can use the `traceable` function to wrap the client methods you want to use:
 
 ```ts
 import { traceable } from "langsmith/traceable";
 
+const openai = new OpenAI();
+
 const createCompletion = traceable(
   openai.chat.completions.create.bind(openai.chat.completions),
   { name: "OpenAI Chat Completion", run_type: "llm" }
 );
-```
-
-Note the use of `.bind` to preserve the function's context. The `run_type` field in the extra config object
-marks the function as an LLM call, and enables token usage tracking for OpenAI.
-
-This new method takes the same exact arguments and has the same return type as the original method,
-but will log everything to LangSmith!
 
-```ts
 await createCompletion({
   model: "gpt-3.5-turbo",
   messages: [{ content: "Hi there!", role: "user" }],
 });
 ```
 
-```
-{
-  id: 'chatcmpl-8sOWEOYVyehDlyPcBiaDtTxWvr9v6',
-  object: 'chat.completion',
-  created: 1707974654,
-  model: 'gpt-3.5-turbo-0613',
-  choices: [
-    {
-      index: 0,
-      message: { role: 'assistant', content: 'Hello! How can I help you today?' },
-      logprobs: null,
-      finish_reason: 'stop'
-    }
-  ],
-  usage: { prompt_tokens: 10, completion_tokens: 9, total_tokens: 19 },
-  system_fingerprint: null
-}
-```
-
-This also works for streaming:
-
-```ts
-const stream = await createCompletion({
-  model: "gpt-3.5-turbo",
-  stream: true,
-  messages: [{ content: "Hi there!", role: "user" }],
-});
-```
-
-```ts
-for await (const chunk of stream) {
-  console.log(chunk);
-}
-```
+Note the use of `.bind` to preserve the function's context. The `run_type` field in the
+extra config object marks the function as an LLM call, and enables token usage tracking
+for OpenAI.
 
 Oftentimes, you use the OpenAI client inside of other functions or as part of a longer
 sequence. You can automatically get nested traces by using this wrapped method
@@ -178,7 +148,7 @@ within other functions wrapped with `traceable`.
 
 ```ts
 const nestedTrace = traceable(async (text: string) => {
-  const completion = await createCompletion({
+  const completion = await openai.chat.completions.create({
     model: "gpt-3.5-turbo",
     messages: [{ content: text, role: "user" }],
   });
@@ -230,25 +200,22 @@ import { NextRequest, NextResponse } from "next/server";
 
 import { OpenAI } from "openai";
 import { traceable } from "langsmith/traceable";
+import { wrapOpenAI } from "langsmith/wrappers";
 
 export const runtime = "edge";
 
 const handler = traceable(
   async function () {
-    const openai = new OpenAI();
-    const createCompletion = traceable(
-      openai.chat.completions.create.bind(openai.chat.completions),
-      { name: "OpenAI Chat Completion", run_type: "llm" }
-    );
+    const openai = wrapOpenAI(new OpenAI());
 
-    const completion = await createCompletion({
+    const completion = await openai.chat.completions.create({
       model: "gpt-3.5-turbo",
       messages: [{ content: "Why is the sky blue?", role: "user" }],
     });
 
     const response1 = completion.choices[0].message.content;
 
-    const completion2 = await createCompletion({
+    const completion2 = await openai.chat.completions.create({
       model: "gpt-3.5-turbo",
       messages: [
         { content: "Why is the sky blue?", role: "user" },
@@ -287,28 +254,25 @@ The [Vercel AI SDK](https://sdk.vercel.ai/docs) contains integrations with a var
 Here's an example of how you can trace outputs in a Next.js handler:
 
 ```ts
-import { traceable } from 'langsmith/traceable';
-import { OpenAIStream, StreamingTextResponse } from 'ai';
+import { traceable } from "langsmith/traceable";
+import { OpenAIStream, StreamingTextResponse } from "ai";
 
 // Note: There are no types for the Mistral API client yet.
-import MistralClient from '@mistralai/mistralai';
+import MistralClient from "@mistralai/mistralai";
 
-const client = new MistralClient(process.env.MISTRAL_API_KEY || '');
+const client = new MistralClient(process.env.MISTRAL_API_KEY || "");
 
 export async function POST(req: Request) {
   // Extract the `messages` from the body of the request
   const { messages } = await req.json();
 
-  const mistralChatStream = traceable(
-    client.chatStream.bind(client),
-    {
-      name: "Mistral Stream",
-      run_type: "llm",
-    }
-  );
+  const mistralChatStream = traceable(client.chatStream.bind(client), {
+    name: "Mistral Stream",
+    run_type: "llm",
+  });
 
   const response = await mistralChatStream({
-    model: 'mistral-tiny',
+    model: "mistral-tiny",
     maxTokens: 1000,
     messages,
   });
@@ -324,7 +288,6 @@ export async function POST(req: Request) {
 
 See the [AI SDK docs](https://sdk.vercel.ai/docs) for more examples.
 
-
 #### Alternatives: **Log traces using a RunTree.**
 
 A RunTree tracks your application. Each RunTree object is required to have a name and run_type. These and other important attributes are as follows:
@@ -413,7 +376,7 @@ try {
   await childChainRun.end({
     error: `I errored again ${e.message}`,
   });
-  await childChainRun.patchRun(); 
+  await childChainRun.patchRun();
   throw e;
 }
 
@@ -431,7 +394,7 @@ await parentRun.patchRun();
 
 ## Evaluation
 
-####  Create a Dataset from Existing Runs
+#### Create a Dataset from Existing Runs
 
 Once your runs are stored in LangSmith, you can convert them into a dataset.
 For this example, we will do so using the Client, but you can also do this using

package/dist/cli/docker-compose.yaml

@@ -29,6 +29,8 @@ services:
         condition: service_healthy
       clickhouse-setup:
         condition: service_completed_successfully
+      postgres-setup:
+        condition: service_completed_successfully
     restart: always
   langchain-queue:
     image: langchain/${_LANGSMITH_IMAGE_PREFIX-}langchainplus-backend:${_LANGSMITH_IMAGE_VERSION:-latest}
@@ -44,6 +46,8 @@ services:
         condition: service_healthy
       clickhouse-setup:
         condition: service_completed_successfully
+      postgres-setup:
+        condition: service_completed_successfully
     restart: always
   langchain-hub:
     image: langchain/${_LANGSMITH_IMAGE_PREFIX-}langchainhub-backend:${_LANGSMITH_IMAGE_VERSION:-latest}
@@ -55,7 +59,15 @@ services:
     ports:
       - 1985:1985
     depends_on:
-      - langchain-db
+      langchain-db:
+        condition: service_healthy
+      langchain-redis:
+        condition: service_healthy
+      clickhouse-setup:
+        condition: service_completed_successfully
+      postgres-setup:
+        condition: service_completed_successfully
+    restart: always
   langchain-db:
     image: postgres:14.7
     command:
@@ -114,13 +126,29 @@ services:
     depends_on:
       langchain-clickhouse:
         condition: service_healthy
-    restart: "no"
+    restart: "on-failure:10"
     entrypoint:
       [
         "bash",
         "-c",
         "migrate -source file://clickhouse/migrations -database 'clickhouse://langchain-clickhouse:9000?username=default&password=password&database=default&x-multi-statement=true&x-migrations-table-engine=MergeTree' up",
       ]
+  postgres-setup:
+    image: langchain/${_LANGSMITH_IMAGE_PREFIX-}langchainplus-backend:${_LANGSMITH_IMAGE_VERSION:-latest}
+    depends_on:
+      langchain-db:
+        condition: service_healthy
+    environment:
+      - LANGCHAIN_ENV=local_docker
+      - LOG_LEVEL=warning
+      - LANGSMITH_LICENSE_KEY=${LANGSMITH_LICENSE_KEY}
+    restart: "on-failure:10"
+    entrypoint:
+      [
+        "bash",
+        "-c",
+        "alembic upgrade head",
+      ]
 volumes:
   langchain-db-data:
   langchain-redis-data:

package/dist/client.cjs

@@ -244,7 +244,6 @@ class Client {
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
         this.apiKey = trimQuotes(config.apiKey ?? defaultConfig.apiKey);
         this.webUrl = trimQuotes(config.webUrl ?? defaultConfig.webUrl);
-        this.validateApiKeyIfHosted();
         this.timeout_ms = config.timeout_ms ?? 12000;
         this.caller = new async_caller_js_1.AsyncCaller(config.callerOptions ?? {});
         this.hideInputs = config.hideInputs ?? defaultConfig.hideInputs;
@@ -267,12 +266,6 @@ class Client {
             hideOutputs: hideOutputs,
         };
     }
-    validateApiKeyIfHosted() {
-        const isLocal = isLocalhost(this.apiUrl);
-        if (!isLocal && !this.apiKey) {
-            throw new Error("API key must be provided when using hosted LangSmith API");
-        }
-    }
     getHostUrl() {
         if (this.webUrl) {
             return this.webUrl;
@@ -569,13 +562,18 @@ class Client {
             "Content-Type": "application/json",
             Accept: "application/json",
         };
-        const response = await this.caller.call(fetch, `${this.apiUrl}/runs/batch`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-        });
-        await raiseForStatus(response, "batch create run");
+        try {
+            const response = await this.caller.call(fetch, `${this.apiUrl}/runs/batch`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(this.timeout_ms),
+            });
+            await raiseForStatus(response, "batch create run");
+        }
+        catch (e) {
+            console.error(`Failed to batch create runs: ${e}`);
+        }
     }
     async updateRun(runId, run) {
         assertUuid(runId);

package/dist/client.d.ts

@@ -98,7 +98,6 @@ export declare class Client {
         hideInputs?: boolean;
         hideOutputs?: boolean;
     };
-    private validateApiKeyIfHosted;
     private getHostUrl;
     private get headers();
     private processInputs;

package/dist/client.js

@@ -217,7 +217,6 @@ export class Client {
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
         this.apiKey = trimQuotes(config.apiKey ?? defaultConfig.apiKey);
         this.webUrl = trimQuotes(config.webUrl ?? defaultConfig.webUrl);
-        this.validateApiKeyIfHosted();
         this.timeout_ms = config.timeout_ms ?? 12000;
         this.caller = new AsyncCaller(config.callerOptions ?? {});
         this.hideInputs = config.hideInputs ?? defaultConfig.hideInputs;
@@ -240,12 +239,6 @@ export class Client {
             hideOutputs: hideOutputs,
         };
     }
-    validateApiKeyIfHosted() {
-        const isLocal = isLocalhost(this.apiUrl);
-        if (!isLocal && !this.apiKey) {
-            throw new Error("API key must be provided when using hosted LangSmith API");
-        }
-    }
     getHostUrl() {
         if (this.webUrl) {
             return this.webUrl;
@@ -542,13 +535,18 @@ export class Client {
             "Content-Type": "application/json",
             Accept: "application/json",
         };
-        const response = await this.caller.call(fetch, `${this.apiUrl}/runs/batch`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-        });
-        await raiseForStatus(response, "batch create run");
+        try {
+            const response = await this.caller.call(fetch, `${this.apiUrl}/runs/batch`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(this.timeout_ms),
+            });
+            await raiseForStatus(response, "batch create run");
+        }
+        catch (e) {
+            console.error(`Failed to batch create runs: ${e}`);
+        }
     }
     async updateRun(runId, run) {
         assertUuid(runId);

package/dist/index.cjs

@@ -6,4 +6,4 @@ Object.defineProperty(exports, "Client", { enumerable: true, get: function () {
 var run_trees_js_1 = require("./run_trees.cjs");
 Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () { return run_trees_js_1.RunTree; } });
 // Update using yarn bump-version
-exports.__version__ = "0.1.2";
+exports.__version__ = "0.1.5";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export type { Dataset, Example, TracerSession, Run, Feedback, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
-export declare const __version__ = "0.1.2";
+export declare const __version__ = "0.1.5";

package/dist/index.js

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export { RunTree } from "./run_trees.js";
 // Update using yarn bump-version
-export const __version__ = "0.1.2";
+export const __version__ = "0.1.5";

package/dist/run_trees.cjs

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRunTree = exports.RunTree = exports.convertToDottedOrderFormat = void 0;
+exports.isRunnableConfigLike = exports.isRunTree = exports.RunTree = exports.convertToDottedOrderFormat = void 0;
 const uuid = __importStar(require("uuid"));
 const env_js_1 = require("./utils/env.cjs");
 const client_js_1 = require("./client.cjs");
@@ -98,6 +98,12 @@ class RunTree {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "error", {
             enumerable: true,
             configurable: true,
@@ -153,10 +159,11 @@ class RunTree {
             value: void 0
         });
         const defaultConfig = RunTree.getDefaultConfig();
-        Object.assign(this, { ...defaultConfig, ...config });
+        const client = config.client ?? new client_js_1.Client();
+        Object.assign(this, { ...defaultConfig, ...config, client });
         if (!this.trace_id) {
             if (this.parent_run) {
-                this.trace_id = this.parent_run.trace_id;
+                this.trace_id = this.parent_run.trace_id ?? this.id;
             }
             else {
                 this.trace_id = this.id;
@@ -173,6 +180,35 @@ class RunTree {
             }
         }
     }
+    static fromRunnableConfig(config, props) {
+        // We only handle the callback manager case for now
+        const callbackManager = config?.callbacks;
+        let parentRun;
+        let projectName;
+        if (callbackManager) {
+            const parentRunId = callbackManager?.getParentRunId?.() ?? "";
+            const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
+            parentRun = langChainTracer?.getRun?.(parentRunId);
+            projectName = langChainTracer?.projectName;
+        }
+        const deduppedTags = [
+            ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
+        ];
+        const dedupedMetadata = {
+            ...parentRun?.extra?.metadata,
+            ...config?.metadata,
+        };
+        const rt = new RunTree({
+            name: props?.name ?? "<lambda>",
+            parent_run: parentRun,
+            tags: deduppedTags,
+            extra: {
+                metadata: dedupedMetadata,
+            },
+            project_name: projectName,
+        });
+        return rt;
+    }
     static getDefaultConfig() {
         return {
             id: uuid.v4(),
@@ -188,7 +224,6 @@ class RunTree {
             serialized: {},
             inputs: {},
             extra: {},
-            client: new client_js_1.Client({}),
         };
     }
     async createChild(config) {
@@ -244,6 +279,7 @@ class RunTree {
             parent_run_id: parent_run_id,
             trace_id: run.trace_id,
             dotted_order: run.dotted_order,
+            tags: run.tags,
         };
         return persistedRun;
     }
@@ -268,6 +304,7 @@ class RunTree {
             events: this.events,
             dotted_order: this.dotted_order,
             trace_id: this.trace_id,
+            tags: this.tags,
         };
         await this.client.updateRun(this.id, runUpdate);
     }
@@ -279,3 +316,22 @@ function isRunTree(x) {
         typeof x.postRun === "function");
 }
 exports.isRunTree = isRunTree;
+function containsLangChainTracerLike(x) {
+    return (Array.isArray(x) &&
+        x.some((callback) => {
+            return (typeof callback.name === "string" &&
+                callback.name === "langchain_tracer");
+        }));
+}
+function isRunnableConfigLike(x) {
+    // Check that it's an object with a callbacks arg
+    // that has either a CallbackManagerLike object with a langchain tracer within it
+    // or an array with a LangChainTracerLike object within it
+    return (x !== undefined &&
+        typeof x.callbacks === "object" &&
+        // Callback manager with a langchain tracer
+        (containsLangChainTracerLike(x.callbacks?.handlers) ||
+            // Or it's an array with a LangChainTracerLike object within it
+            containsLangChainTracerLike(x.callbacks)));
+}
+exports.isRunnableConfigLike = isRunnableConfigLike;

package/dist/run_trees.d.ts

@@ -7,10 +7,12 @@ export interface RunTreeConfig {
     id?: string;
     project_name?: string;
     parent_run?: RunTree;
+    parent_run_id?: string;
     child_runs?: RunTree[];
     start_time?: number;
     end_time?: number;
     extra?: KVMap;
+    tags?: string[];
     error?: string;
     serialized?: object;
     inputs?: KVMap;
@@ -18,16 +20,34 @@ export interface RunTreeConfig {
     reference_example_id?: string;
     client?: Client;
 }
+export interface RunnableConfigLike {
+    /**
+     * Tags for this call and any sub-calls (eg. a Chain calling an LLM).
+     * You can use these to filter calls.
+     */
+    tags?: string[];
+    /**
+     * Metadata for this call and any sub-calls (eg. a Chain calling an LLM).
+     * Keys should be strings, values should be JSON-serializable.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Callbacks for this call and any sub-calls (eg. a Chain calling an LLM).
+     * Tags are passed to all callbacks, metadata is passed to handle*Start callbacks.
+     */
+    callbacks?: any;
+}
 export declare class RunTree implements BaseRun {
     id: string;
     name: RunTreeConfig["name"];
     run_type: string;
     project_name: string;
-    parent_run?: RunTree;
+    parent_run?: BaseRun;
     child_runs: RunTree[];
     start_time: number;
     end_time?: number;
     extra: KVMap;
+    tags?: string[];
     error?: string;
     serialized: object;
     inputs: KVMap;
@@ -38,6 +58,11 @@ export declare class RunTree implements BaseRun {
     trace_id: string;
     dotted_order: string;
     constructor(config: RunTreeConfig);
+    static fromRunnableConfig(config: RunnableConfigLike, props: {
+        name: string;
+        tags?: string[];
+        metadata?: KVMap;
+    }): RunTree;
     private static getDefaultConfig;
     createChild(config: RunTreeConfig): Promise<RunTree>;
     end(outputs?: KVMap, error?: string, endTime?: number): Promise<void>;
@@ -46,3 +71,4 @@ export declare class RunTree implements BaseRun {
     patchRun(): Promise<void>;
 }
 export declare function isRunTree(x?: unknown): x is RunTree;
+export declare function isRunnableConfigLike(x?: unknown): x is RunnableConfigLike;

package/dist/run_trees.js

@@ -71,6 +71,12 @@ export class RunTree {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "error", {
             enumerable: true,
             configurable: true,
@@ -126,10 +132,11 @@ export class RunTree {
             value: void 0
         });
         const defaultConfig = RunTree.getDefaultConfig();
-        Object.assign(this, { ...defaultConfig, ...config });
+        const client = config.client ?? new Client();
+        Object.assign(this, { ...defaultConfig, ...config, client });
         if (!this.trace_id) {
             if (this.parent_run) {
-                this.trace_id = this.parent_run.trace_id;
+                this.trace_id = this.parent_run.trace_id ?? this.id;
             }
             else {
                 this.trace_id = this.id;
@@ -146,6 +153,35 @@ export class RunTree {
             }
         }
     }
+    static fromRunnableConfig(config, props) {
+        // We only handle the callback manager case for now
+        const callbackManager = config?.callbacks;
+        let parentRun;
+        let projectName;
+        if (callbackManager) {
+            const parentRunId = callbackManager?.getParentRunId?.() ?? "";
+            const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
+            parentRun = langChainTracer?.getRun?.(parentRunId);
+            projectName = langChainTracer?.projectName;
+        }
+        const deduppedTags = [
+            ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
+        ];
+        const dedupedMetadata = {
+            ...parentRun?.extra?.metadata,
+            ...config?.metadata,
+        };
+        const rt = new RunTree({
+            name: props?.name ?? "<lambda>",
+            parent_run: parentRun,
+            tags: deduppedTags,
+            extra: {
+                metadata: dedupedMetadata,
+            },
+            project_name: projectName,
+        });
+        return rt;
+    }
     static getDefaultConfig() {
         return {
             id: uuid.v4(),
@@ -161,7 +197,6 @@ export class RunTree {
             serialized: {},
             inputs: {},
             extra: {},
-            client: new Client({}),
         };
     }
     async createChild(config) {
@@ -217,6 +252,7 @@ export class RunTree {
             parent_run_id: parent_run_id,
             trace_id: run.trace_id,
             dotted_order: run.dotted_order,
+            tags: run.tags,
         };
         return persistedRun;
     }
@@ -241,6 +277,7 @@ export class RunTree {
             events: this.events,
             dotted_order: this.dotted_order,
             trace_id: this.trace_id,
+            tags: this.tags,
         };
         await this.client.updateRun(this.id, runUpdate);
     }
@@ -250,3 +287,21 @@ export function isRunTree(x) {
         typeof x.createChild === "function" &&
         typeof x.postRun === "function");
 }
+function containsLangChainTracerLike(x) {
+    return (Array.isArray(x) &&
+        x.some((callback) => {
+            return (typeof callback.name === "string" &&
+                callback.name === "langchain_tracer");
+        }));
+}
+export function isRunnableConfigLike(x) {
+    // Check that it's an object with a callbacks arg
+    // that has either a CallbackManagerLike object with a langchain tracer within it
+    // or an array with a LangChainTracerLike object within it
+    return (x !== undefined &&
+        typeof x.callbacks === "object" &&
+        // Callback manager with a langchain tracer
+        (containsLangChainTracerLike(x.callbacks?.handlers) ||
+            // Or it's an array with a LangChainTracerLike object within it
+            containsLangChainTracerLike(x.callbacks)));
+}

package/dist/schemas.d.ts

@@ -118,6 +118,7 @@ export interface RunUpdate {
     id?: string;
     end_time?: number;
     extra?: KVMap;
+    tags?: string[];
     error?: string;
     inputs?: KVMap;
     outputs?: KVMap;

package/dist/traceable.cjs

@@ -36,6 +36,10 @@ function traceable(wrappedFunc, config) {
             currentRunTree = args[0];
             rawInputs = args.slice(1);
         }
+        else if ((0, run_trees_js_1.isRunnableConfigLike)(args[0])) {
+            currentRunTree = run_trees_js_1.RunTree.fromRunnableConfig(args[0], ensuredConfig);
+            rawInputs = args.slice(1);
+        }
         else if (previousRunTree !== undefined) {
             currentRunTree = await previousRunTree.createChild(ensuredConfig);
             rawInputs = args;

package/dist/traceable.d.ts

@@ -1,4 +1,4 @@
-import { RunTree, RunTreeConfig } from "./run_trees.js";
+import { RunTree, RunTreeConfig, RunnableConfigLike } from "./run_trees.js";
 export type RunTreeLike = RunTree;
 type WrapArgReturnPair<Pair> = Pair extends [
     infer Args extends any[],
@@ -6,6 +6,7 @@ type WrapArgReturnPair<Pair> = Pair extends [
 ] ? {
     (...args: Args): Promise<Return>;
     (...args: [runTree: RunTreeLike, ...rest: Args]): Promise<Return>;
+    (...args: [config: RunnableConfigLike, ...rest: Args]): Promise<Return>;
 } : never;
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 export type TraceableFunction<Func extends (...args: any[]) => any> = Func extends {

package/dist/traceable.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "async_hooks";
-import { RunTree, isRunTree } from "./run_trees.js";
+import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
 const asyncLocalStorage = new AsyncLocalStorage();
 const isAsyncIterable = (x) => x != null &&
     typeof x === "object" &&
@@ -33,6 +33,10 @@ export function traceable(wrappedFunc, config) {
             currentRunTree = args[0];
             rawInputs = args.slice(1);
         }
+        else if (isRunnableConfigLike(args[0])) {
+            currentRunTree = RunTree.fromRunnableConfig(args[0], ensuredConfig);
+            rawInputs = args.slice(1);
+        }
         else if (previousRunTree !== undefined) {
             currentRunTree = await previousRunTree.createChild(ensuredConfig);
             rawInputs = args;

package/dist/wrappers.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapOpenAI = void 0;
+const traceable_js_1 = require("./traceable.cjs");
+const wrapOpenAI = (openai, options) => {
+    // @ts-expect-error Promise<APIPromise<...>> != APIPromise<...>
+    openai.chat.completions.create = (0, traceable_js_1.traceable)(openai.chat.completions.create.bind(openai.chat.completions), Object.assign({ name: "ChatOpenAI", run_type: "llm" }, options?.client));
+    // @ts-expect-error Promise<APIPromise<...>> != APIPromise<...>
+    openai.completions.create = (0, traceable_js_1.traceable)(openai.completions.create.bind(openai.completions), Object.assign({ name: "OpenAI", run_type: "llm" }, options?.client));
+    return openai;
+};
+exports.wrapOpenAI = wrapOpenAI;

package/dist/wrappers.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAI } from "openai";
+import type { Client } from "./index.js";
+export declare const wrapOpenAI: (openai: OpenAI, options?: {
+    client?: Client;
+}) => OpenAI;

package/dist/wrappers.js

@@ -0,0 +1,8 @@
+import { traceable } from "./traceable.js";
+export const wrapOpenAI = (openai, options) => {
+    // @ts-expect-error Promise<APIPromise<...>> != APIPromise<...>
+    openai.chat.completions.create = traceable(openai.chat.completions.create.bind(openai.chat.completions), Object.assign({ name: "ChatOpenAI", run_type: "llm" }, options?.client));
+    // @ts-expect-error Promise<APIPromise<...>> != APIPromise<...>
+    openai.completions.create = traceable(openai.completions.create.bind(openai.completions), Object.assign({ name: "OpenAI", run_type: "llm" }, options?.client));
+    return openai;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -20,6 +20,9 @@
     "schemas.cjs",
     "schemas.js",
     "schemas.d.ts",
+    "wrappers.cjs",
+    "wrappers.js",
+    "wrappers.d.ts",
     "index.cjs",
     "index.js",
     "index.d.ts"
@@ -66,7 +69,8 @@
   "devDependencies": {
     "@babel/preset-env": "^7.22.4",
     "@jest/globals": "^29.5.0",
-    "@langchain/core": "^0.1.28",
+    "@langchain/core": "^0.1.32",
+    "@langchain/langgraph": "^0.0.8",
     "@tsconfig/recommended": "^1.0.2",
     "@types/jest": "^29.5.1",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
@@ -80,6 +84,7 @@
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
+    "openai": "^4.28.0",
     "prettier": "^2.8.8",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
@@ -129,6 +134,11 @@
       "import": "./schemas.js",
       "require": "./schemas.cjs"
     },
+    "./wrappers": {
+      "types": "./wrappers.d.ts",
+      "import": "./wrappers.js",
+      "require": "./wrappers.cjs"
+    },
     "./package.json": "./package.json"
   }
 }

package/wrappers.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/wrappers.cjs');

package/wrappers.d.ts

@@ -0,0 +1 @@
+export * from './dist/wrappers.js'

package/wrappers.js

@@ -0,0 +1 @@
+export * from './dist/wrappers.js'