langsmith 0.0.71-rc.5 → 0.1.0

package/README.md

@@ -71,21 +71,261 @@ console.log(response);
 
 ### Logging Traces Outside LangChain
 
-_Note: this API is experimental and may change in the future_
-
 You can still use the LangSmith development platform without depending on any
 LangChain code. You can connect either by setting the appropriate environment variables,
 or by directly specifying the connection information in the RunTree.
 
 1. **Copy the environment variables from the Settings Page and add them to your application.**
 
-```typescript
-process.env["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"; // or your own server
-process.env["LANGCHAIN_API_KEY"] = "<YOUR-LANGSMITH-API-KEY>";
-// process.env["LANGCHAIN_PROJECT"] = "My Project Name"; // Optional: "default" is used if not set
+```shell
+export LANGCHAIN_API_KEY=<YOUR-LANGSMITH-API-KEY>
+# export LANGCHAIN_PROJECT="My Project Name" #  Optional: "default" is used if not set
+# export LANGCHAIN_ENDPOINT=https://api.smith.langchain.com # or your own server
+```
+
+## Integrations
+
+Langsmith's `traceable` wrapper function makes it easy to trace any function or LLM call in your own favorite framework. Below are some examples.
+
+### 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.
+
+In order to use, you first need to set your LangSmith API key:
+
+```shell
+export LANGCHAIN_API_KEY=<your-api-key>
+```
+
+Next, you will need to install the LangSmith SDK and the OpenAI SDK:
+
+```shell
+npm install langsmith openai
+```
+
+After that, initialize your OpenAI client:
+
+```ts
+import { OpenAI } from "openai";
+
+const client = new OpenAI();
+```
+
+Then, you can wrap the client methods you want to use by passing it to the `traceable` function like this:
+
+```ts
+import { traceable } from "langsmith/traceable";
+
+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);
+}
 ```
 
-2. **Log traces using a RunTree.**
+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
+within other functions wrapped with `traceable`.
+
+```ts
+const nestedTrace = traceable(async (text: string) => {
+  const completion = await createCompletion({
+    model: "gpt-3.5-turbo",
+    messages: [{ content: text, role: "user" }],
+  });
+  return completion;
+});
+
+await nestedTrace("Why is the sky blue?");
+```
+
+```
+{
+  "id": "chatcmpl-8sPToJQLLVepJvyeTfzZMOMVIKjMo",
+  "object": "chat.completion",
+  "created": 1707978348,
+  "model": "gpt-3.5-turbo-0613",
+  "choices": [
+    {
+      "index": 0,
+      "message": {
+        "role": "assistant",
+        "content": "The sky appears blue because of a phenomenon known as Rayleigh scattering. The Earth's atmosphere is composed of tiny molecules, such as nitrogen and oxygen, which are much smaller than the wavelength of visible light. When sunlight interacts with these molecules, it gets scattered in all directions. However, shorter wavelengths of light (blue and violet) are scattered more compared to longer wavelengths (red, orange, and yellow). \n\nAs a result, when sunlight passes through the Earth's atmosphere, the blue and violet wavelengths are scattered in all directions, making the sky appear blue. This scattering of shorter wavelengths is also responsible for the vibrant colors observed during sunrise and sunset, when the sunlight has to pass through a thicker portion of the atmosphere, causing the longer wavelengths to dominate the scattered light."
+      },
+      "logprobs": null,
+      "finish_reason": "stop"
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 13,
+    "completion_tokens": 154,
+    "total_tokens": 167
+  },
+  "system_fingerprint": null
+}
+```
+
+:::tip
+[Click here](https://smith.langchain.com/public/4af46ef6-b065-46dc-9cf0-70f1274edb01/r) to see an example LangSmith trace of the above.
+:::
+
+## Next.js
+
+You can use the `traceable` wrapper function in Next.js apps to wrap arbitrary functions much like in the example above.
+
+One neat trick you can use for Next.js and other similar server frameworks is to wrap the entire exported handler for a route
+to group traces for the any sub-runs. Here's an example:
+
+```ts
+import { NextRequest, NextResponse } from "next/server";
+
+import { OpenAI } from "openai";
+import { traceable } from "langsmith/traceable";
+
+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 completion = await createCompletion({
+      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({
+      model: "gpt-3.5-turbo",
+      messages: [
+        { content: "Why is the sky blue?", role: "user" },
+        { content: response1, role: "assistant" },
+        { content: "Cool thank you!", role: "user" },
+      ],
+    });
+
+    const response2 = completion2.choices[0].message.content;
+
+    return {
+      text: response2,
+    };
+  },
+  {
+    name: "Simple Next.js handler",
+  }
+);
+
+export async function POST(req: NextRequest) {
+  const result = await handler();
+  return NextResponse.json(result);
+}
+```
+
+The two OpenAI calls within the handler will be traced with appropriate inputs, outputs,
+and token usage information.
+
+:::tip
+[Click here](https://smith.langchain.com/public/faaf26ad-8c59-4622-bcfe-b7d896733ca6/r) to see an example LangSmith trace of the above.
+:::
+
+## Vercel AI SDK
+
+The [Vercel AI SDK](https://sdk.vercel.ai/docs) contains integrations with a variety of model providers.
+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';
+
+// Note: There are no types for the Mistral API client yet.
+import MistralClient from '@mistralai/mistralai';
+
+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 response = await mistralChatStream({
+    model: 'mistral-tiny',
+    maxTokens: 1000,
+    messages,
+  });
+
+  // Convert the response into a friendly text-stream. The Mistral client responses are
+  // compatible with the Vercel AI SDK OpenAIStream adapter.
+  const stream = OpenAIStream(response as any);
+
+  // Respond with the stream
+  return new StreamingTextResponse(stream);
+}
+```
+
+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:
 
@@ -189,7 +429,9 @@ await parentRun.end({
 await parentRun.patchRun();
 ```
 
-### Create a Dataset from Existing Runs
+## Evaluation
+
+####  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/client.cjs

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = void 0;
+exports.Client = exports.Queue = void 0;
 const uuid = __importStar(require("uuid"));
 const async_caller_js_1 = require("./utils/async_caller.cjs");
 const messages_js_1 = require("./utils/messages.cjs");
@@ -98,6 +98,43 @@ function assertUuid(str) {
         throw new Error(`Invalid UUID: ${str}`);
     }
 }
+class Queue {
+    constructor() {
+        Object.defineProperty(this, "items", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    get size() {
+        return this.items.length;
+    }
+    push(item) {
+        // this.items.push is synchronous with promise creation:
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
+        return new Promise((resolve) => {
+            this.items.push([item, resolve]);
+        });
+    }
+    pop(upToN) {
+        if (upToN < 1) {
+            throw new Error("Number of items to pop off may not be less than 1.");
+        }
+        const popped = [];
+        while (popped.length < upToN && this.items.length) {
+            const item = this.items.shift();
+            if (item) {
+                popped.push(item);
+            }
+            else {
+                break;
+            }
+        }
+        return [popped.map((it) => it[0]), () => popped.forEach((it) => it[1]())];
+    }
+}
+exports.Queue = Queue;
 class Client {
     constructor(config = {}) {
         Object.defineProperty(this, "apiKey", {
@@ -164,7 +201,7 @@ class Client {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: true
         });
         Object.defineProperty(this, "batchEndpointSupported", {
             enumerable: true,
@@ -172,11 +209,11 @@ class Client {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "pendingAutoBatchedRuns", {
+        Object.defineProperty(this, "autoBatchQueue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: new Queue()
         });
         Object.defineProperty(this, "pendingAutoBatchedRunLimit", {
             enumerable: true,
@@ -384,45 +421,46 @@ class Client {
             return sampled;
         }
     }
-    async triggerAutoBatchSend(runs) {
-        let batch = runs;
-        if (batch === undefined) {
-            batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
-            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
+    async drainAutoBatchQueue() {
+        while (this.autoBatchQueue.size >= 0) {
+            const [batch, done] = this.autoBatchQueue.pop(this.pendingAutoBatchedRunLimit);
+            if (!batch.length) {
+                done();
+                return;
+            }
+            try {
+                await this.batchIngestRuns({
+                    runCreates: batch
+                        .filter((item) => item.action === "create")
+                        .map((item) => item.item),
+                    runUpdates: batch
+                        .filter((item) => item.action === "update")
+                        .map((item) => item.item),
+                });
+            }
+            finally {
+                done();
+            }
         }
-        await this.batchIngestRuns({
-            runCreates: batch
-                .filter((item) => item.action === "create")
-                .map((item) => item.item),
-            runUpdates: batch
-                .filter((item) => item.action === "update")
-                .map((item) => item.item),
-        });
     }
-    appendRunCreateToAutoBatchQueue(item) {
+    async processRunOperation(item, immediatelyTriggerBatch) {
         const oldTimeout = this.autoBatchTimeout;
         clearTimeout(this.autoBatchTimeout);
         this.autoBatchTimeout = undefined;
-        this.pendingAutoBatchedRuns.push(item);
-        while (this.pendingAutoBatchedRuns.length >= this.pendingAutoBatchedRunLimit) {
-            const batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
-            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
-            void this.triggerAutoBatchSend(batch);
-        }
-        if (this.pendingAutoBatchedRuns.length > 0) {
-            if (!oldTimeout) {
-                this.autoBatchTimeout = setTimeout(() => {
-                    this.autoBatchTimeout = undefined;
-                    void this.triggerAutoBatchSend();
-                }, this.autoBatchInitialDelayMs);
-            }
-            else {
-                this.autoBatchTimeout = setTimeout(() => {
-                    this.autoBatchTimeout = undefined;
-                    void this.triggerAutoBatchSend();
-                }, this.autoBatchAggregationDelayMs);
-            }
+        const itemPromise = this.autoBatchQueue.push(item);
+        if (immediatelyTriggerBatch ||
+            this.autoBatchQueue.size > this.pendingAutoBatchedRunLimit) {
+            await this.drainAutoBatchQueue();
+        }
+        if (this.autoBatchQueue.size > 0) {
+            this.autoBatchTimeout = setTimeout(() => {
+                this.autoBatchTimeout = undefined;
+                void this.drainAutoBatchQueue();
+            }, oldTimeout
+                ? this.autoBatchAggregationDelayMs
+                : this.autoBatchInitialDelayMs);
         }
+        return itemPromise;
     }
     async batchEndpointIsSupported() {
         const response = await fetch(`${this.apiUrl}/info`, {
@@ -453,7 +491,7 @@ class Client {
         if (this.autoBatchTracing &&
             runCreate.trace_id !== undefined &&
             runCreate.dotted_order !== undefined) {
-            this.appendRunCreateToAutoBatchQueue({
+            void this.processRunOperation({
                 action: "create",
                 item: runCreate,
             });
@@ -555,7 +593,15 @@ class Client {
         if (this.autoBatchTracing &&
             data.trace_id !== undefined &&
             data.dotted_order !== undefined) {
-            this.appendRunCreateToAutoBatchQueue({ action: "update", item: data });
+            if (run.end_time !== undefined && data.parent_run_id === undefined) {
+                // Trigger a batch as soon as a root trace ends and block to ensure trace finishes
+                // in serverless environments.
+                await this.processRunOperation({ action: "update", item: data }, true);
+                return;
+            }
+            else {
+                void this.processRunOperation({ action: "update", item: data });
+            }
             return;
         }
         const headers = { ...this.headers, "Content-Type": "application/json" };

package/dist/client.d.ts

@@ -66,6 +66,12 @@ export type CreateExampleOptions = {
     createdAt?: Date;
     exampleId?: string;
 };
+export declare class Queue<T> {
+    items: [T, () => void][];
+    get size(): number;
+    push(item: T): Promise<void>;
+    pop(upToN: number): [T[], () => void];
+}
 export declare class Client {
     private apiKey?;
     private apiUrl;
@@ -79,7 +85,7 @@ export declare class Client {
     private sampledPostUuids;
     private autoBatchTracing;
     private batchEndpointSupported?;
-    private pendingAutoBatchedRuns;
+    private autoBatchQueue;
     private pendingAutoBatchedRunLimit;
     private autoBatchTimeout;
     private autoBatchInitialDelayMs;
@@ -103,8 +109,8 @@ export declare class Client {
     private _getPaginated;
     private _getCursorPaginatedList;
     private _filterForSampling;
-    private triggerAutoBatchSend;
-    private appendRunCreateToAutoBatchQueue;
+    private drainAutoBatchQueue;
+    private processRunOperation;
     protected batchEndpointIsSupported(): Promise<boolean>;
     createRun(run: CreateRunParams): Promise<void>;
     /**

package/dist/client.js

@@ -72,6 +72,42 @@ function assertUuid(str) {
         throw new Error(`Invalid UUID: ${str}`);
     }
 }
+export class Queue {
+    constructor() {
+        Object.defineProperty(this, "items", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    get size() {
+        return this.items.length;
+    }
+    push(item) {
+        // this.items.push is synchronous with promise creation:
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
+        return new Promise((resolve) => {
+            this.items.push([item, resolve]);
+        });
+    }
+    pop(upToN) {
+        if (upToN < 1) {
+            throw new Error("Number of items to pop off may not be less than 1.");
+        }
+        const popped = [];
+        while (popped.length < upToN && this.items.length) {
+            const item = this.items.shift();
+            if (item) {
+                popped.push(item);
+            }
+            else {
+                break;
+            }
+        }
+        return [popped.map((it) => it[0]), () => popped.forEach((it) => it[1]())];
+    }
+}
 export class Client {
     constructor(config = {}) {
         Object.defineProperty(this, "apiKey", {
@@ -138,7 +174,7 @@ export class Client {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: true
         });
         Object.defineProperty(this, "batchEndpointSupported", {
             enumerable: true,
@@ -146,11 +182,11 @@ export class Client {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "pendingAutoBatchedRuns", {
+        Object.defineProperty(this, "autoBatchQueue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: new Queue()
         });
         Object.defineProperty(this, "pendingAutoBatchedRunLimit", {
             enumerable: true,
@@ -358,45 +394,46 @@ export class Client {
             return sampled;
         }
     }
-    async triggerAutoBatchSend(runs) {
-        let batch = runs;
-        if (batch === undefined) {
-            batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
-            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
+    async drainAutoBatchQueue() {
+        while (this.autoBatchQueue.size >= 0) {
+            const [batch, done] = this.autoBatchQueue.pop(this.pendingAutoBatchedRunLimit);
+            if (!batch.length) {
+                done();
+                return;
+            }
+            try {
+                await this.batchIngestRuns({
+                    runCreates: batch
+                        .filter((item) => item.action === "create")
+                        .map((item) => item.item),
+                    runUpdates: batch
+                        .filter((item) => item.action === "update")
+                        .map((item) => item.item),
+                });
+            }
+            finally {
+                done();
+            }
         }
-        await this.batchIngestRuns({
-            runCreates: batch
-                .filter((item) => item.action === "create")
-                .map((item) => item.item),
-            runUpdates: batch
-                .filter((item) => item.action === "update")
-                .map((item) => item.item),
-        });
     }
-    appendRunCreateToAutoBatchQueue(item) {
+    async processRunOperation(item, immediatelyTriggerBatch) {
         const oldTimeout = this.autoBatchTimeout;
         clearTimeout(this.autoBatchTimeout);
         this.autoBatchTimeout = undefined;
-        this.pendingAutoBatchedRuns.push(item);
-        while (this.pendingAutoBatchedRuns.length >= this.pendingAutoBatchedRunLimit) {
-            const batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
-            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
-            void this.triggerAutoBatchSend(batch);
-        }
-        if (this.pendingAutoBatchedRuns.length > 0) {
-            if (!oldTimeout) {
-                this.autoBatchTimeout = setTimeout(() => {
-                    this.autoBatchTimeout = undefined;
-                    void this.triggerAutoBatchSend();
-                }, this.autoBatchInitialDelayMs);
-            }
-            else {
-                this.autoBatchTimeout = setTimeout(() => {
-                    this.autoBatchTimeout = undefined;
-                    void this.triggerAutoBatchSend();
-                }, this.autoBatchAggregationDelayMs);
-            }
+        const itemPromise = this.autoBatchQueue.push(item);
+        if (immediatelyTriggerBatch ||
+            this.autoBatchQueue.size > this.pendingAutoBatchedRunLimit) {
+            await this.drainAutoBatchQueue();
+        }
+        if (this.autoBatchQueue.size > 0) {
+            this.autoBatchTimeout = setTimeout(() => {
+                this.autoBatchTimeout = undefined;
+                void this.drainAutoBatchQueue();
+            }, oldTimeout
+                ? this.autoBatchAggregationDelayMs
+                : this.autoBatchInitialDelayMs);
         }
+        return itemPromise;
     }
     async batchEndpointIsSupported() {
         const response = await fetch(`${this.apiUrl}/info`, {
@@ -427,7 +464,7 @@ export class Client {
         if (this.autoBatchTracing &&
             runCreate.trace_id !== undefined &&
             runCreate.dotted_order !== undefined) {
-            this.appendRunCreateToAutoBatchQueue({
+            void this.processRunOperation({
                 action: "create",
                 item: runCreate,
             });
@@ -529,7 +566,15 @@ export class Client {
         if (this.autoBatchTracing &&
             data.trace_id !== undefined &&
             data.dotted_order !== undefined) {
-            this.appendRunCreateToAutoBatchQueue({ action: "update", item: data });
+            if (run.end_time !== undefined && data.parent_run_id === undefined) {
+                // Trigger a batch as soon as a root trace ends and block to ensure trace finishes
+                // in serverless environments.
+                await this.processRunOperation({ action: "update", item: data }, true);
+                return;
+            }
+            else {
+                void this.processRunOperation({ action: "update", item: data });
+            }
             return;
         }
         const headers = { ...this.headers, "Content-Type": "application/json" };

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.0.71-rc.5";
+exports.__version__ = "0.1.0";

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.0.71-rc.5";
+export declare const __version__ = "0.1.0";

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.0.71-rc.5";
+export const __version__ = "0.1.0";

package/dist/traceable.d.ts

@@ -1,6 +1,34 @@
 import { RunTree, RunTreeConfig } from "./run_trees.js";
 export type RunTreeLike = RunTree;
-export type TraceableFunction<Inputs extends any[], Output> = (...rawInputs: Inputs | [RunTreeLike, ...Inputs]) => Promise<Output>;
+type WrapArgReturnPair<Pair> = Pair extends [
+    infer Args extends any[],
+    infer Return
+] ? {
+    (...args: Args): Promise<Return>;
+    (...args: [runTree: RunTreeLike, ...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 {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3] | [A4, R4] | [A5, R5]>> : Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3] | [A4, R4]>> : Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3]>> : Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2]>> : Func extends {
+    (...args: infer A1): infer R1;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1]>> : never;
 /**
  * Higher-order function that takes function as input and returns a
  * "TraceableFunction" - a wrapped version of the input that
@@ -15,5 +43,6 @@ export type TraceableFunction<Inputs extends any[], Output> = (...rawInputs: Inp
  * @param config Additional metadata such as name, tags or providing
  *     a custom LangSmith client instance
  */
-export declare function traceable<Inputs extends any[], Output>(wrappedFunc: (...args: Inputs) => Output, config?: RunTreeConfig): TraceableFunction<Inputs, Output>;
-export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any, any>;
+export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<RunTreeConfig>): TraceableFunction<Func>;
+export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.0.71-rc.5",
+  "version": "0.1.0",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [