@langchain/anthropic 0.3.21 → 0.3.22

package/dist/chat_models.cjs

@@ -7,7 +7,7 @@ const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
 const base_1 = require("@langchain/core/language_models/base");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const json_schema_1 = require("@langchain/core/utils/json_schema");
 const runnables_1 = require("@langchain/core/runnables");
 const types_1 = require("@langchain/core/utils/types");
 const function_calling_1 = require("@langchain/core/utils/function_calling");
@@ -641,8 +641,8 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
                 return {
                     name: tool.name,
                     description: tool.description,
-                    input_schema: ((0, types_1.isZodSchema)(tool.schema)
-                        ? (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema)
+                    input_schema: ((0, types_1.isInteropZodSchema)(tool.schema)
+                        ? (0, json_schema_1.toJsonSchema)(tool.schema)
                         : tool.schema),
                 };
             }
@@ -879,8 +879,8 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         let functionName = name ?? "extract";
         let outputParser;
         let tools;
-        if ((0, types_1.isZodSchema)(schema)) {
-            const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+        if ((0, types_1.isInteropZodSchema)(schema)) {
+            const jsonSchema = (0, json_schema_1.toJsonSchema)(schema);
             tools = [
                 {
                     name: functionName,

package/dist/chat_models.d.ts

@@ -6,7 +6,7 @@ import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { BaseChatModel, BaseChatModelCallOptions, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { type StructuredOutputMethodOptions, type BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
-import { z } from "zod";
+import { InteropZodType } from "@langchain/core/utils/types";
 import { AnthropicMessageCreateParams, AnthropicMessageStreamEvent, AnthropicRequestOptions, AnthropicStreamingMessageCreateParams, AnthropicThinkingConfigParam, AnthropicToolChoice, ChatAnthropicToolType } from "./types.js";
 export interface ChatAnthropicCallOptions extends BaseChatModelCallOptions, Pick<AnthropicInput, "streamUsage"> {
     tools?: ChatAnthropicToolType[];
@@ -575,8 +575,8 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
     /** @ignore */
     protected completionWithRetry(request: AnthropicMessageCreateParams & Kwargs, options: AnthropicRequestOptions): Promise<Anthropic.Message>;
     _llmType(): string;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/chat_models.js

@@ -4,9 +4,9 @@ import { ChatGenerationChunk } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
 import { isOpenAITool, } from "@langchain/core/language_models/base";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
-import { isZodSchema } from "@langchain/core/utils/types";
+import { isInteropZodSchema, } from "@langchain/core/utils/types";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { AnthropicToolsOutputParser } from "./output_parsers.js";
 import { handleToolChoice } from "./utils/tools.js";
@@ -638,8 +638,8 @@ export class ChatAnthropicMessages extends BaseChatModel {
                 return {
                     name: tool.name,
                     description: tool.description,
-                    input_schema: (isZodSchema(tool.schema)
-                        ? zodToJsonSchema(tool.schema)
+                    input_schema: (isInteropZodSchema(tool.schema)
+                        ? toJsonSchema(tool.schema)
                         : tool.schema),
                 };
             }
@@ -876,8 +876,8 @@ export class ChatAnthropicMessages extends BaseChatModel {
         let functionName = name ?? "extract";
         let outputParser;
         let tools;
-        if (isZodSchema(schema)) {
-            const jsonSchema = zodToJsonSchema(schema);
+        if (isInteropZodSchema(schema)) {
+            const jsonSchema = toJsonSchema(schema);
             tools = [
                 {
                     name: functionName,

package/dist/experimental/tool_calling.cjs

@@ -6,7 +6,8 @@ const messages_1 = require("@langchain/core/messages");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
 const runnables_1 = require("@langchain/core/runnables");
 const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const json_schema_1 = require("@langchain/core/utils/json_schema");
+const types_1 = require("@langchain/core/utils/types");
 const chat_models_js_1 = require("../chat_models.cjs");
 const tool_calling_js_1 = require("./utils/tool_calling.cjs");
 /**
@@ -226,8 +227,8 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
         let functionName = name ?? "extract";
         let outputParser;
         let tools;
-        if (isZodSchema(schema)) {
-            const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+        if ((0, types_1.isInteropZodSchema)(schema)) {
+            const jsonSchema = (0, json_schema_1.toJsonSchema)(schema);
             tools = [
                 {
                     type: "function",
@@ -307,12 +308,6 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
     }
 }
 exports.ChatAnthropicTools = ChatAnthropicTools;
-function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
-}
 function isStructuredOutputMethodParams(x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {

package/dist/experimental/tool_calling.d.ts

@@ -5,7 +5,7 @@ import { CallbackManagerForLLMRun, Callbacks } from "@langchain/core/callbacks/m
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import type { BaseLanguageModelCallOptions, BaseLanguageModelInput, StructuredOutputMethodParams, StructuredOutputMethodOptions, ToolDefinition } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
-import { z } from "zod";
+import { InteropZodType } from "@langchain/core/utils/types";
 import { type AnthropicInput } from "../chat_models.js";
 export interface ChatAnthropicToolsCallOptions extends BaseLanguageModelCallOptions {
     tools?: ToolDefinition[];
@@ -45,10 +45,10 @@ export declare class ChatAnthropicTools extends BaseChatModel<ChatAnthropicTools
     generate(messages: BaseMessageLike[][], parsedOptions?: ChatAnthropicToolsCallOptions, callbacks?: Callbacks): Promise<LLMResult>;
     _generate(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
     _llmType(): string;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false> & {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, false> | InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false> & {
         force?: boolean;
     }): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, true> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true> & {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, true> | InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true> & {
         force?: boolean;
     }): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;

package/dist/experimental/tool_calling.js

@@ -3,7 +3,8 @@ import { AIMessage, SystemMessage, coerceMessageLikeToMessage, } from "@langchai
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { toJsonSchema, } from "@langchain/core/utils/json_schema";
+import { isInteropZodSchema, } from "@langchain/core/utils/types";
 import { ChatAnthropic } from "../chat_models.js";
 import { DEFAULT_TOOL_SYSTEM_PROMPT, formatAsXMLRepresentation, fixArrayXMLParameters, } from "./utils/tool_calling.js";
 /**
@@ -223,8 +224,8 @@ export class ChatAnthropicTools extends BaseChatModel {
         let functionName = name ?? "extract";
         let outputParser;
         let tools;
-        if (isZodSchema(schema)) {
-            const jsonSchema = zodToJsonSchema(schema);
+        if (isInteropZodSchema(schema)) {
+            const jsonSchema = toJsonSchema(schema);
             tools = [
                 {
                     type: "function",
@@ -303,12 +304,6 @@ export class ChatAnthropicTools extends BaseChatModel {
         });
     }
 }
-function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
-}
 function isStructuredOutputMethodParams(x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {

package/dist/experimental/utils/tool_calling.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchema7ObjectType } from "zod-to-json-schema";
+import { type JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
 import { PromptTemplate } from "@langchain/core/prompts";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 export declare const DEFAULT_TOOL_SYSTEM_PROMPT: PromptTemplate<import("@langchain/core/prompts").ParamsFromFString<"In this environment you have access to a set of tools you can use to answer the user's question.\n\nYou may call them like this:\n<function_calls>\n<invoke>\n<tool_name>$TOOL_NAME</tool_name>\n<parameters>\n<$PARAMETER_NAME>$PARAMETER_VALUE</$PARAMETER_NAME>\n...\n</parameters>\n</invoke>\n</function_calls>\n\nHere are the tools available:\n{tools}\n\nIf the schema above contains a property typed as an enum, you must only return values matching an allowed value for that enum.">, any>;

package/dist/output_parsers.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractToolCalls = exports.AnthropicToolsOutputParser = void 0;
 const output_parsers_1 = require("@langchain/core/output_parsers");
+const types_1 = require("@langchain/core/utils/types");
 class AnthropicToolsOutputParser extends output_parsers_1.BaseLLMOutputParser {
     static lc_name() {
         return "AnthropicToolsOutputParser";
@@ -61,12 +62,12 @@ class AnthropicToolsOutputParser extends output_parsers_1.BaseLLMOutputParser {
         if (this.zodSchema === undefined) {
             return parsedResult;
         }
-        const zodParsedResult = await this.zodSchema.safeParseAsync(parsedResult);
+        const zodParsedResult = await (0, types_1.interopSafeParseAsync)(this.zodSchema, parsedResult);
         if (zodParsedResult.success) {
             return zodParsedResult.data;
         }
         else {
-            throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(parsedResult, null, 2));
+            throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.issues)}`, JSON.stringify(parsedResult, null, 2));
         }
     }
     async parseResult(generations) {

package/dist/output_parsers.d.ts

@@ -1,9 +1,9 @@
-import { z } from "zod";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
-import { JsonOutputKeyToolsParserParams } from "@langchain/core/output_parsers/openai_tools";
+import { JsonOutputKeyToolsParserParamsInterop } from "@langchain/core/output_parsers/openai_tools";
 import { ChatGeneration } from "@langchain/core/outputs";
 import { ToolCall } from "@langchain/core/messages/tool";
-interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+import { InteropZodType } from "@langchain/core/utils/types";
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParamsInterop<T> {
 }
 export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
     static lc_name(): string;
@@ -13,7 +13,7 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     keyName: string;
     /** Whether to return only the first tool call. */
     returnSingle: boolean;
-    zodSchema?: z.ZodType<T>;
+    zodSchema?: InteropZodType<T>;
     constructor(params: AnthropicToolsOutputParserParams<T>);
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;

package/dist/output_parsers.js

@@ -1,4 +1,5 @@
 import { BaseLLMOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
+import { interopSafeParseAsync, } from "@langchain/core/utils/types";
 export class AnthropicToolsOutputParser extends BaseLLMOutputParser {
     static lc_name() {
         return "AnthropicToolsOutputParser";
@@ -58,12 +59,12 @@ export class AnthropicToolsOutputParser extends BaseLLMOutputParser {
         if (this.zodSchema === undefined) {
             return parsedResult;
         }
-        const zodParsedResult = await this.zodSchema.safeParseAsync(parsedResult);
+        const zodParsedResult = await interopSafeParseAsync(this.zodSchema, parsedResult);
         if (zodParsedResult.success) {
             return zodParsedResult.data;
         }
         else {
-            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(parsedResult, null, 2));
+            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.issues)}`, JSON.stringify(parsedResult, null, 2));
         }
     }
     async parseResult(generations) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -36,12 +36,10 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "fast-xml-parser": "^4.4.1",
-    "zod": "^3.22.4",
-    "zod-to-json-schema": "^3.22.4"
+    "fast-xml-parser": "^4.4.1"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.3.48 <0.4.0"
+    "@langchain/core": ">=0.3.58 <0.4.0"
   },
   "devDependencies": {
     "@anthropic-ai/vertex-sdk": "^0.4.1",
@@ -65,7 +63,8 @@
     "release-it": "^18.1.2",
     "rimraf": "^5.0.1",
     "ts-jest": "^29.1.0",
-    "typescript": "~5.1.6"
+    "typescript": "~5.1.6",
+    "zod": "^3.25.32"
   },
   "publishConfig": {
     "access": "public"