langchain 0.0.197-rc.0 → 0.0.197-rc.1

package/dist/tools/base.cjs

@@ -1,111 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
-const zod_1 = require("zod");
-const manager_js_1 = require("../callbacks/manager.cjs");
-const index_js_1 = require("../base_language/index.cjs");
-/**
- * Custom error class used to handle exceptions related to tool input parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
- */
-class ToolInputParsingException extends Error {
-    constructor(message, output) {
-        super(message);
-        Object.defineProperty(this, "output", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.output = output;
-    }
-}
-exports.ToolInputParsingException = ToolInputParsingException;
-/**
- * Base class for Tools that accept input of any shape defined by a Zod schema.
- */
-class StructuredTool extends index_js_1.BaseLangChain {
-    get lc_namespace() {
-        return ["langchain", "tools"];
-    }
-    constructor(fields) {
-        super(fields ?? {});
-        Object.defineProperty(this, "returnDirect", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    /**
-     * Invokes the tool with the provided input and configuration.
-     * @param input The input for the tool.
-     * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    async invoke(input, config) {
-        return this.call(input, config);
-    }
-    /**
-     * Calls the tool with the provided argument, configuration, and tags. It
-     * parses the input according to the schema, handles any errors, and
-     * manages callbacks.
-     * @param arg The input argument for the tool.
-     * @param configArg Optional configuration or callbacks for the tool.
-     * @param tags Optional tags for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    async call(arg, configArg, 
-    /** @deprecated */
-    tags) {
-        let parsed;
-        try {
-            parsed = await this.schema.parseAsync(arg);
-        }
-        catch (e) {
-            throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(arg));
-        }
-        const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), undefined, undefined, undefined, undefined, config.runName);
-        let result;
-        try {
-            result = await this._call(parsed, runManager);
-        }
-        catch (e) {
-            await runManager?.handleToolError(e);
-            throw e;
-        }
-        await runManager?.handleToolEnd(result);
-        return result;
-    }
-}
-exports.StructuredTool = StructuredTool;
-/**
- * Base class for Tools that accept input as a string.
- */
-class Tool extends StructuredTool {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: zod_1.z
-                .object({ input: zod_1.z.string().optional() })
-                .transform((obj) => obj.input)
-        });
-    }
-    /**
-     * Calls the tool with the provided argument and callbacks. It handles
-     * string inputs specifically.
-     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.
-     * @param callbacks Optional callbacks for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    call(arg, callbacks) {
-        return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
-    }
-}
-exports.Tool = Tool;
+var tools_1 = require("@langchain/core/tools");
+Object.defineProperty(exports, "ToolInputParsingException", { enumerable: true, get: function () { return tools_1.ToolInputParsingException; } });
+Object.defineProperty(exports, "StructuredTool", { enumerable: true, get: function () { return tools_1.StructuredTool; } });
+Object.defineProperty(exports, "Tool", { enumerable: true, get: function () { return tools_1.Tool; } });

package/dist/tools/base.d.ts

@@ -1,72 +1 @@
-import { z } from "zod";
-import { CallbackManagerForToolRun, Callbacks } from "../callbacks/manager.js";
-import { BaseLangChain, BaseLangChainParams } from "../base_language/index.js";
-import { RunnableConfig } from "../schema/runnable/config.js";
-/**
- * Parameters for the Tool classes.
- */
-export interface ToolParams extends BaseLangChainParams {
-}
-/**
- * Custom error class used to handle exceptions related to tool input parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
- */
-export declare class ToolInputParsingException extends Error {
-    output?: string;
-    constructor(message: string, output?: string);
-}
-/**
- * Base class for Tools that accept input of any shape defined by a Zod schema.
- */
-export declare abstract class StructuredTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T>, string> {
-    abstract schema: T | z.ZodEffects<T>;
-    get lc_namespace(): string[];
-    constructor(fields?: ToolParams);
-    protected abstract _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun): Promise<string>;
-    /**
-     * Invokes the tool with the provided input and configuration.
-     * @param input The input for the tool.
-     * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    invoke(input: (z.output<T> extends string ? string : never) | z.input<T>, config?: RunnableConfig): Promise<string>;
-    /**
-     * Calls the tool with the provided argument, configuration, and tags. It
-     * parses the input according to the schema, handles any errors, and
-     * manages callbacks.
-     * @param arg The input argument for the tool.
-     * @param configArg Optional configuration or callbacks for the tool.
-     * @param tags Optional tags for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    call(arg: (z.output<T> extends string ? string : never) | z.input<T>, configArg?: Callbacks | RunnableConfig, 
-    /** @deprecated */
-    tags?: string[]): Promise<string>;
-    abstract name: string;
-    abstract description: string;
-    returnDirect: boolean;
-}
-/**
- * Base class for Tools that accept input as a string.
- */
-export declare abstract class Tool extends StructuredTool {
-    schema: z.ZodEffects<z.ZodObject<{
-        input: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        input?: string | undefined;
-    }, {
-        input?: string | undefined;
-    }>, string | undefined, {
-        input?: string | undefined;
-    }>;
-    constructor(fields?: ToolParams);
-    /**
-     * Calls the tool with the provided argument and callbacks. It handles
-     * string inputs specifically.
-     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.
-     * @param callbacks Optional callbacks for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    call(arg: string | undefined | z.input<this["schema"]>, callbacks?: Callbacks): Promise<string>;
-}
+export { type ToolParams, ToolInputParsingException, StructuredTool, Tool, } from "@langchain/core/tools";

package/dist/tools/base.js

@@ -1,105 +1 @@
-import { z } from "zod";
-import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
-import { BaseLangChain } from "../base_language/index.js";
-/**
- * Custom error class used to handle exceptions related to tool input parsing.
- * It extends the built-in `Error` class and adds an optional `output`
- * property that can hold the output that caused the exception.
- */
-export class ToolInputParsingException extends Error {
-    constructor(message, output) {
-        super(message);
-        Object.defineProperty(this, "output", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.output = output;
-    }
-}
-/**
- * Base class for Tools that accept input of any shape defined by a Zod schema.
- */
-export class StructuredTool extends BaseLangChain {
-    get lc_namespace() {
-        return ["langchain", "tools"];
-    }
-    constructor(fields) {
-        super(fields ?? {});
-        Object.defineProperty(this, "returnDirect", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    /**
-     * Invokes the tool with the provided input and configuration.
-     * @param input The input for the tool.
-     * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    async invoke(input, config) {
-        return this.call(input, config);
-    }
-    /**
-     * Calls the tool with the provided argument, configuration, and tags. It
-     * parses the input according to the schema, handles any errors, and
-     * manages callbacks.
-     * @param arg The input argument for the tool.
-     * @param configArg Optional configuration or callbacks for the tool.
-     * @param tags Optional tags for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    async call(arg, configArg, 
-    /** @deprecated */
-    tags) {
-        let parsed;
-        try {
-            parsed = await this.schema.parseAsync(arg);
-        }
-        catch (e) {
-            throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(arg));
-        }
-        const config = parseCallbackConfigArg(configArg);
-        const callbackManager_ = await CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), undefined, undefined, undefined, undefined, config.runName);
-        let result;
-        try {
-            result = await this._call(parsed, runManager);
-        }
-        catch (e) {
-            await runManager?.handleToolError(e);
-            throw e;
-        }
-        await runManager?.handleToolEnd(result);
-        return result;
-    }
-}
-/**
- * Base class for Tools that accept input as a string.
- */
-export class Tool extends StructuredTool {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: z
-                .object({ input: z.string().optional() })
-                .transform((obj) => obj.input)
-        });
-    }
-    /**
-     * Calls the tool with the provided argument and callbacks. It handles
-     * string inputs specifically.
-     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.
-     * @param callbacks Optional callbacks for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    call(arg, callbacks) {
-        return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
-    }
-}
+export { ToolInputParsingException, StructuredTool, Tool, } from "@langchain/core/tools";

package/dist/tools/bingserpapi.d.ts

@@ -11,7 +11,7 @@ declare class BingSerpAPI extends Tool {
     /**
      * Not implemented. Will throw an error if called.
      */
-    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
+    toJSON(): import("@langchain/core/load/serializable").SerializedNotImplemented;
     name: string;
     description: string;
     key: string;

package/dist/tools/convert_to_openai.cjs

@@ -1,41 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatToOpenAIAssistantTool = exports.formatToOpenAITool = exports.formatToOpenAIFunction = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-/**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
- */
-function formatToOpenAIFunction(tool) {
-    return {
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
-    };
-}
-exports.formatToOpenAIFunction = formatToOpenAIFunction;
-function formatToOpenAITool(tool) {
-    const schema = (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema);
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: schema,
-        },
-    };
-}
-exports.formatToOpenAITool = formatToOpenAITool;
-function formatToOpenAIAssistantTool(tool) {
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
-        },
-    };
-}
-exports.formatToOpenAIAssistantTool = formatToOpenAIAssistantTool;
+var openai_1 = require("@langchain/openai");
+Object.defineProperty(exports, "formatToOpenAIFunction", { enumerable: true, get: function () { return openai_1.formatToOpenAIFunction; } });
+Object.defineProperty(exports, "formatToOpenAITool", { enumerable: true, get: function () { return openai_1.formatToOpenAITool; } });
+Object.defineProperty(exports, "formatToOpenAIAssistantTool", { enumerable: true, get: function () { return openai_1.formatToOpenAIAssistantTool; } });

package/dist/tools/convert_to_openai.d.ts

@@ -1,11 +1 @@
-import type { OpenAI as OpenAIClient } from "openai";
-import { StructuredTool } from "./base.js";
-/**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
- */
-export declare function formatToOpenAIFunction(tool: StructuredTool): OpenAIClient.Chat.ChatCompletionCreateParams.Function;
-export declare function formatToOpenAITool(tool: StructuredTool): OpenAIClient.Chat.ChatCompletionTool;
-export declare function formatToOpenAIAssistantTool(tool: StructuredTool): OpenAIClient.Beta.AssistantCreateParams.AssistantToolsFunction;
+export { formatToOpenAIFunction, formatToOpenAITool, formatToOpenAIAssistantTool, } from "@langchain/openai";

package/dist/tools/convert_to_openai.js

@@ -1,35 +1 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-/**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
- */
-export function formatToOpenAIFunction(tool) {
-    return {
-        name: tool.name,
-        description: tool.description,
-        parameters: zodToJsonSchema(tool.schema),
-    };
-}
-export function formatToOpenAITool(tool) {
-    const schema = zodToJsonSchema(tool.schema);
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: schema,
-        },
-    };
-}
-export function formatToOpenAIAssistantTool(tool) {
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: zodToJsonSchema(tool.schema),
-        },
-    };
-}
+export { formatToOpenAIFunction, formatToOpenAITool, formatToOpenAIAssistantTool, } from "@langchain/openai";

package/dist/tools/searchapi.d.ts

@@ -62,7 +62,7 @@ export declare class SearchApi extends Tool {
      * and will throw an error if called.
      * @returns Throws an error.
      */
-    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
+    toJSON(): import("@langchain/core/load/serializable").SerializedNotImplemented;
     protected apiKey: string;
     protected params: Partial<SearchApiParameters>;
     constructor(apiKey?: string | undefined, params?: Partial<SearchApiParameters>);

package/dist/tools/serpapi.d.ts

@@ -281,7 +281,7 @@ type UrlParameters = Record<string, string | number | boolean | undefined | null
  */
 export declare class SerpAPI extends Tool {
     static lc_name(): string;
-    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
+    toJSON(): import("@langchain/core/load/serializable").SerializedNotImplemented;
     protected key: string;
     protected params: Partial<SerpAPIParameters>;
     protected baseUrl: string;

package/dist/tools/serper.d.ts

@@ -21,7 +21,7 @@ export declare class Serper extends Tool {
      * and will throw an error if called.
      * @returns Throws an error.
      */
-    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
+    toJSON(): import("@langchain/core/load/serializable").SerializedNotImplemented;
     protected key: string;
     protected params: Partial<SerperParameters>;
     constructor(apiKey?: string | undefined, params?: Partial<SerperParameters>);

package/dist/types/openai-types.d.ts

@@ -1,135 +1,3 @@
-import type { OpenAI as OpenAIClient } from "openai";
 import { TiktokenModel } from "js-tiktoken/lite";
-import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 export type { TiktokenModel };
-export declare interface OpenAIBaseInput {
-    /** Sampling temperature to use */
-    temperature: number;
-    /**
-     * Maximum number of tokens to generate in the completion. -1 returns as many
-     * tokens as possible given the prompt and the model's maximum context size.
-     */
-    maxTokens?: number;
-    /** Total probability mass of tokens to consider at each step */
-    topP: number;
-    /** Penalizes repeated tokens according to frequency */
-    frequencyPenalty: number;
-    /** Penalizes repeated tokens */
-    presencePenalty: number;
-    /** Number of completions to generate for each prompt */
-    n: number;
-    /** Dictionary used to adjust the probability of specific tokens being generated */
-    logitBias?: Record<string, number>;
-    /** Unique string identifier representing your end-user, which can help OpenAI to monitor and detect abuse. */
-    user?: string;
-    /** Whether to stream the results or not. Enabling disables tokenUsage reporting */
-    streaming: boolean;
-    /** Model name to use */
-    modelName: string;
-    /** Holds any additional parameters that are valid to pass to {@link
-     * https://platform.openai.com/docs/api-reference/completions/create |
-     * `openai.createCompletion`} that are not explicitly specified on this class.
-     */
-    modelKwargs?: Record<string, any>;
-    /** List of stop words to use when generating */
-    stop?: string[];
-    /**
-     * Timeout to use when making requests to OpenAI.
-     */
-    timeout?: number;
-    /**
-     * API key to use when making requests to OpenAI. Defaults to the value of
-     * `OPENAI_API_KEY` environment variable.
-     */
-    openAIApiKey?: string;
-}
-export type OpenAICoreRequestOptions<Req extends object = Record<string, unknown>> = {
-    path?: string;
-    query?: Req | undefined;
-    body?: Req | undefined;
-    headers?: Record<string, string | null | undefined> | undefined;
-    maxRetries?: number;
-    stream?: boolean | undefined;
-    timeout?: number;
-    httpAgent?: any;
-    signal?: AbortSignal | undefined | null;
-    idempotencyKey?: string;
-};
-export interface OpenAICallOptions extends BaseLanguageModelCallOptions {
-    /**
-     * Additional options to pass to the underlying axios request.
-     */
-    options?: OpenAICoreRequestOptions;
-}
-/**
- * Input to OpenAI class.
- */
-export declare interface OpenAIInput extends OpenAIBaseInput {
-    /** Generates `bestOf` completions server side and returns the "best" */
-    bestOf?: number;
-    /** Batch size to use when passing multiple documents to generate */
-    batchSize: number;
-}
-/**
- * @deprecated Use "baseURL", "defaultHeaders", and "defaultParams" instead.
- */
-export interface LegacyOpenAIInput {
-    /** @deprecated Use baseURL instead */
-    basePath?: string;
-    /** @deprecated Use defaultHeaders and defaultQuery instead */
-    baseOptions?: {
-        headers?: Record<string, string>;
-        params?: Record<string, string>;
-    };
-}
-export interface OpenAIChatInput extends OpenAIBaseInput {
-    /** ChatGPT messages to pass as a prefix to the prompt */
-    prefixMessages?: OpenAIClient.Chat.CreateChatCompletionRequestMessage[];
-}
-export declare interface AzureOpenAIInput {
-    /**
-     * API version to use when making requests to Azure OpenAI.
-     */
-    azureOpenAIApiVersion?: string;
-    /**
-     * API key to use when making requests to Azure OpenAI.
-     */
-    azureOpenAIApiKey?: string;
-    /**
-     * Azure OpenAI API instance name to use when making requests to Azure OpenAI.
-     * this is the name of the instance you created in the Azure portal.
-     * e.g. "my-openai-instance"
-     * this will be used in the endpoint URL: https://my-openai-instance.openai.azure.com/openai/deployments/{DeploymentName}/
-     */
-    azureOpenAIApiInstanceName?: string;
-    /**
-     * Azure OpenAI API deployment name to use for completions when making requests to Azure OpenAI.
-     * This is the name of the deployment you created in the Azure portal.
-     * e.g. "my-openai-deployment"
-     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/
-     */
-    azureOpenAIApiDeploymentName?: string;
-    /**
-     * Azure OpenAI API deployment name to use for embedding when making requests to Azure OpenAI.
-     * This is the name of the deployment you created in the Azure portal.
-     * This will fallback to azureOpenAIApiDeploymentName if not provided.
-     * e.g. "my-openai-deployment"
-     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/
-     */
-    azureOpenAIApiEmbeddingsDeploymentName?: string;
-    /**
-     * Azure OpenAI API deployment name to use for completions when making requests to Azure OpenAI.
-     * Completions are only available for gpt-3.5-turbo and text-davinci-003 deployments.
-     * This is the name of the deployment you created in the Azure portal.
-     * This will fallback to azureOpenAIApiDeploymentName if not provided.
-     * e.g. "my-openai-deployment"
-     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/
-     */
-    azureOpenAIApiCompletionsDeploymentName?: string;
-    /**
-     * Custom endpoint for Azure OpenAI API. This is useful in case you have a deployment in another region.
-     * e.g. setting this value to "https://westeurope.api.cognitive.microsoft.com/openai/deployments"
-     * will be result in the endpoint URL: https://westeurope.api.cognitive.microsoft.com/openai/deployments/{DeploymentName}/
-     */
-    azureOpenAIBasePath?: string;
-}
+export type { OpenAIBaseInput, OpenAICoreRequestOptions, OpenAICallOptions, OpenAIInput, LegacyOpenAIInput, OpenAIChatInput, AzureOpenAIInput, } from "@langchain/openai";

package/dist/util/async_caller.cjs

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("langchain-core/utils/async_caller"), exports);
+__exportStar(require("@langchain/core/utils/async_caller"), exports);

package/dist/util/async_caller.d.ts

@@ -1 +1 @@
-export * from "langchain-core/utils/async_caller";
+export * from "@langchain/core/utils/async_caller";

package/dist/util/async_caller.js

@@ -1 +1 @@
-export * from "langchain-core/utils/async_caller";
+export * from "@langchain/core/utils/async_caller";

package/dist/util/openai.cjs

@@ -1,21 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapOpenAIClientError = void 0;
-const openai_1 = require("openai");
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function wrapOpenAIClientError(e) {
-    let error;
-    if (e.constructor.name === openai_1.APIConnectionTimeoutError.name) {
-        error = new Error(e.message);
-        error.name = "TimeoutError";
-    }
-    else if (e.constructor.name === openai_1.APIUserAbortError.name) {
-        error = new Error(e.message);
-        error.name = "AbortError";
-    }
-    else {
-        error = e;
-    }
-    return error;
-}
-exports.wrapOpenAIClientError = wrapOpenAIClientError;
+var openai_1 = require("@langchain/openai");
+Object.defineProperty(exports, "wrapOpenAIClientError", { enumerable: true, get: function () { return openai_1.wrapOpenAIClientError; } });

package/dist/util/openai.d.ts

@@ -1 +1 @@
-export declare function wrapOpenAIClientError(e: any): any;
+export { wrapOpenAIClientError } from "@langchain/openai";

package/dist/util/openai.js

@@ -1,17 +1 @@
-import { APIConnectionTimeoutError, APIUserAbortError } from "openai";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function wrapOpenAIClientError(e) {
-    let error;
-    if (e.constructor.name === APIConnectionTimeoutError.name) {
-        error = new Error(e.message);
-        error.name = "TimeoutError";
-    }
-    else if (e.constructor.name === APIUserAbortError.name) {
-        error = new Error(e.message);
-        error.name = "AbortError";
-    }
-    else {
-        error = e;
-    }
-    return error;
-}
+export { wrapOpenAIClientError } from "@langchain/openai";

package/dist/util/openapi.d.ts

@@ -7,7 +7,7 @@ export declare class OpenAPISpec {
     getParametersStrict(): Record<string, OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject>;
     getSchemasStrict(): Record<string, OpenAPIV3_1.SchemaObject>;
     getRequestBodiesStrict(): Record<string, OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject>;
-    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "parameters" | "servers"> & {
+    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "servers" | "parameters"> & {
         servers?: OpenAPIV3_1.ServerObject[] | undefined;
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
     } & {
@@ -59,7 +59,7 @@ export declare class OpenAPISpec {
         deprecated?: boolean | undefined;
         security?: OpenAPIV3.SecurityRequirementObject[] | undefined;
         servers?: OpenAPIV3.ServerObject[] | undefined;
-    }, "callbacks" | "parameters" | "servers" | "responses" | "requestBody"> & {
+    }, "callbacks" | "servers" | "parameters" | "responses" | "requestBody"> & {
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
         requestBody?: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject | undefined;
         responses?: OpenAPIV3_1.ResponsesObject | undefined;

package/dist/util/prompt-layer.d.ts

@@ -1,3 +1,3 @@
-import type { OpenAI as OpenAIClient } from "openai";
+import type { OpenAIClient } from "@langchain/openai";
 import { AsyncCaller } from "../util/async_caller.js";
 export declare const promptLayerTrackRequest: (callerFunc: AsyncCaller, functionName: string, kwargs: OpenAIClient.CompletionCreateParams | OpenAIClient.Chat.CompletionCreateParams, plTags: string[] | undefined, requestResponse: any, startTime: number, endTime: number, apiKey: string | undefined) => Promise<any>;