chore(core/v1): patch changes (#9172)

Author: hntrl

libs/langchain-core/CHANGELOG.md

@@ -0,0 +1,36 @@
+# @langchain/core
+
+## 0.3.78
+
+### Patch Changes
+
+- 1519a97: update chunk concat logic to match on missing ID fields
+- 079e11d: omit tool call chunks without tool call id
+
+## 0.3.76
+
+### Patch Changes
+
+- 41bd944: support base64 embeddings format
+- e90bc0a: fix(core): prevent tool call chunks from merging incorrectly in AIMes…
+- 3a99a40: Fix deserialization of RemoveMessage if represented as a plain object
+- 58e9522: make mustache prompt with nested object working correctly
+- e44dc1b: handle backticks in structured output
+
+## 0.3.75
+
+### Patch Changes
+
+- d6d841f: fix(core): Fix deep nesting of runnables within traceables
+
+## 0.3.74
+
+### Patch Changes
+
+- 4e53005: fix(core): Always inherit parent run id onto callback manager from context
+
+## 0.3.73
+
+### Patch Changes
+
+- a5a2e10: add root export to satisfy bundler requirements

libs/langchain-core/src/messages/tool.ts

@@ -24,6 +24,7 @@ export interface ToolMessageFields<
   artifact?: any;
   tool_call_id: string;
   status?: "success" | "error";
+  metadata?: Record<string, unknown>;
 }
 
 /**
@@ -74,6 +75,8 @@ export class ToolMessage<TStructure extends MessageStructure = MessageStructure>
 
   tool_call_id: string;
 
+  metadata?: Record<string, unknown>;
+
   /**
    * Artifact of the Tool execution which is not meant to be sent to the model.
    *
@@ -107,6 +110,7 @@ export class ToolMessage<TStructure extends MessageStructure = MessageStructure>
     this.tool_call_id = toolMessageFields.tool_call_id;
     this.artifact = toolMessageFields.artifact;
     this.status = toolMessageFields.status;
+    this.metadata = toolMessageFields.metadata;
   }
 
   static isInstance(message: unknown): message is ToolMessage {

libs/langchain-core/src/output_parsers/json.ts

@@ -18,6 +18,14 @@ export class JsonOutputParser<
 
   lc_serializable = true;
 
+  /** @internal */
+  override _concatOutputChunks<T>(first: T, second: T): T {
+    if (this.diff) {
+      return super._concatOutputChunks(first, second);
+    }
+    return second;
+  }
+
   protected _diff(
     prev: unknown | undefined,
     next: unknown

libs/langchain-core/src/output_parsers/tests/json.test.ts

@@ -336,15 +336,51 @@ test("JSONOutputParser parses streamed JSON", async () => {
   );
 });
 
+test("JSONOutputParser traces streamed JSON as just the last chunk", async () => {
+  async function* generator() {
+    for (const token of STREAMED_TOKENS) {
+      yield token;
+    }
+  }
+  const parser = new JsonOutputParser();
+  let tracedOutput;
+  const result = await acc(
+    parser.transform(generator(), {
+      callbacks: [
+        {
+          handleChainEnd(outputs) {
+            tracedOutput = outputs;
+          },
+        },
+      ],
+    })
+  );
+  expect(result.at(-1)).toEqual(tracedOutput);
+});
+
 test("JSONOutputParser parses streamed JSON diff", async () => {
   async function* generator() {
     for (const token of STREAMED_TOKENS) {
       yield token;
     }
   }
   const parser = new JsonOutputParser({ diff: true });
-  const result = await acc(parser.transform(generator(), {}));
+  let tracedOutput;
+  const result = await acc(
+    parser.transform(generator(), {
+      callbacks: [
+        {
+          handleChainEnd(outputs) {
+            tracedOutput = outputs;
+          },
+        },
+      ],
+    })
+  );
   expect(result).toEqual(EXPECTED_STREAMED_JSON_DIFF);
+  expect(tracedOutput).toEqual(
+    EXPECTED_STREAMED_JSON_DIFF.map((patch) => patch[0])
+  );
 });
 
 test("JsonOutputParser supports a type param", async () => {

libs/langchain-core/src/prompts/chat.ts

@@ -641,11 +641,13 @@ class _StringImageMessagePromptTemplate<
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             additionalContentFields = prompt.additionalContentFields as any;
           }
-          content.push({
-            ...additionalContentFields,
-            type: "text",
-            text: formatted,
-          });
+          if (formatted !== "") {
+            content.push({
+              ...additionalContentFields,
+              type: "text",
+              text: formatted,
+            });
+          }
           /** @TODO replace this */
           // eslint-disable-next-line no-instanceof/no-instanceof
         } else if (prompt instanceof ImagePromptTemplate) {

libs/langchain-core/src/runnables/base.ts

@@ -456,6 +456,11 @@ export abstract class Runnable<
     return outputs;
   }
 
+  /** @internal */
+  _concatOutputChunks<O>(first: O, second: O): O {
+    return concat(first, second);
+  }
+
   /**
    * Helper method to transform an Iterator of Input values into an Iterator of
    * Output values, with callbacks.
@@ -480,15 +485,19 @@ export abstract class Runnable<
 
     const config = ensureConfig(options);
     const callbackManager_ = await getCallbackManagerForConfig(config);
+    const outerThis = this;
     async function* wrapInputForTracing() {
       for await (const chunk of inputGenerator) {
         if (finalInputSupported) {
           if (finalInput === undefined) {
             finalInput = chunk;
           } else {
             try {
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              finalInput = concat(finalInput, chunk as any);
+              finalInput = outerThis._concatOutputChunks(
+                finalInput,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                chunk as any
+              );
             } catch {
               finalInput = undefined;
               finalInputSupported = false;
@@ -546,8 +555,11 @@ export abstract class Runnable<
             finalOutput = chunk;
           } else {
             try {
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              finalOutput = concat(finalOutput, chunk as any);
+              finalOutput = this._concatOutputChunks(
+                finalOutput,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                chunk as any
+              );
             } catch {
               finalOutput = undefined;
               finalOutputSupported = false;
@@ -650,7 +662,7 @@ export abstract class Runnable<
         // Make a best effort to gather, for any type that supports concat.
         // This method should throw an error if gathering fails.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        finalChunk = concat(finalChunk, chunk as any);
+        finalChunk = this._concatOutputChunks(finalChunk, chunk as any);
       }
     }
     yield* this._streamIterator(finalChunk, ensureConfig(options));
@@ -1365,6 +1377,11 @@ export class RunnableBinding<
     return this.bound.batch(inputs, mergedOptions, batchOptions);
   }
 
+  /** @internal */
+  override _concatOutputChunks<O>(first: O, second: O): O {
+    return this.bound._concatOutputChunks(first, second);
+  }
+
   async *_streamIterator(
     input: RunInput,
     options?: Partial<CallOptions> | undefined
@@ -1979,6 +1996,11 @@ export class RunnableSequence<
     return nextStepInputs;
   }
 
+  /** @internal */
+  override _concatOutputChunks<O>(first: O, second: O): O {
+    return this.last._concatOutputChunks(first, second);
+  }
+
   async *_streamIterator(
     input: RunInput,
     options?: RunnableConfig
@@ -2029,7 +2051,7 @@ export class RunnableSequence<
           } else {
             try {
               // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              finalOutput = concat(finalOutput, chunk as any);
+              finalOutput = this._concatOutputChunks(finalOutput, chunk as any);
             } catch {
               finalOutput = undefined;
               concatSupported = false;
@@ -2563,8 +2585,11 @@ export class RunnableLambda<
                 } else {
                   // Make a best effort to gather, for any type that supports concat.
                   try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    finalOutput = concat(finalOutput, chunk as any);
+                    finalOutput = this._concatOutputChunks(
+                      finalOutput,
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      chunk as any
+                    );
                   } catch {
                     finalOutput = chunk as RunOutput;
                   }
@@ -2583,8 +2608,11 @@ export class RunnableLambda<
                 } else {
                   // Make a best effort to gather, for any type that supports concat.
                   try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    finalOutput = concat(finalOutput, chunk as any);
+                    finalOutput = this._concatOutputChunks(
+                      finalOutput,
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      chunk as any
+                    );
                   } catch {
                     finalOutput = chunk as RunOutput;
                   }
@@ -2621,7 +2649,7 @@ export class RunnableLambda<
         // Make a best effort to gather, for any type that supports concat.
         try {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          finalChunk = concat(finalChunk, chunk as any);
+          finalChunk = this._concatOutputChunks(finalChunk, chunk as any);
         } catch {
           finalChunk = chunk;
         }
@@ -2928,7 +2956,10 @@ export class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable<
       for await (const chunk of stream) {
         yield chunk;
         try {
-          output = output === undefined ? output : concat(output, chunk);
+          output =
+            output === undefined
+              ? output
+              : this._concatOutputChunks(output, chunk);
         } catch {
           output = undefined;
         }

libs/langchain-core/src/tools/index.ts

@@ -139,6 +139,7 @@ export abstract class StructuredTool<
       fields?.verboseParsingErrors ?? this.verboseParsingErrors;
     this.responseFormat = fields?.responseFormat ?? this.responseFormat;
     this.defaultConfig = fields?.defaultConfig ?? this.defaultConfig;
+    this.metadata = fields?.metadata ?? this.metadata;
   }
 
   protected abstract _call(
@@ -313,6 +314,7 @@ export abstract class StructuredTool<
       artifact,
       toolCallId,
       name: this.name,
+      metadata: this.metadata,
     });
     await runManager?.handleToolEnd(formattedOutput);
     return formattedOutput as ToolReturnType<TArg, TConfig, ToolOutputT>;
@@ -732,26 +734,31 @@ function _formatToolOutput<TOutput extends ToolOutputType>(params: {
   name: string;
   artifact?: unknown;
   toolCallId?: string;
+  metadata?: Record<string, unknown>;
 }): ToolMessage | TOutput {
-  const { content, artifact, toolCallId } = params;
+  const { content, artifact, toolCallId, metadata } = params;
   if (toolCallId && !isDirectToolOutput(content)) {
     if (
       typeof content === "string" ||
       (Array.isArray(content) &&
         content.every((item) => typeof item === "object"))
     ) {
       return new ToolMessage({
+        status: "success",
         content,
         artifact,
         tool_call_id: toolCallId,
         name: params.name,
+        metadata,
       });
     } else {
       return new ToolMessage({
+        status: "success",
         content: _stringify(content),
         artifact,
         tool_call_id: toolCallId,
         name: params.name,
+        metadata,
       });
     }
   } else {

libs/langchain-core/src/tools/tests/tools.test.ts

@@ -4,12 +4,13 @@ import { z as z4 } from "zod/v4";
 
 import {
   DynamicStructuredTool,
+  DynamicTool,
   StructuredToolParams,
   ToolInputParsingException,
   isStructuredToolParams,
   tool,
 } from "../index.js";
-import { ToolMessage } from "../../messages/tool.js";
+import { ToolCall, ToolMessage } from "../../messages/tool.js";
 import { RunnableConfig } from "../../runnables/types.js";
 
 test("Tool should error if responseFormat is content_and_artifact but the function doesn't return a tuple", async () => {
@@ -447,3 +448,30 @@ describe("isStructuredToolParams", () => {
     expect(isStructuredToolParams(nonStructuredToolParams)).toBe(false);
   });
 });
+
+describe("DynamicTool", () => {
+  test("will thread metadata through to a resulting ToolMessage", async () => {
+    const tool = new DynamicTool({
+      name: "test",
+      description: "test",
+      metadata: {
+        foo: "bar",
+      },
+      func: async () => "test",
+    });
+
+    const input: ToolCall = {
+      id: "test_id",
+      name: "test",
+      args: { input: "test" },
+      type: "tool_call",
+    };
+
+    const result = await tool.invoke(input);
+
+    expect(result).toBeInstanceOf(ToolMessage);
+    expect(result.metadata).toEqual({
+      foo: "bar",
+    });
+  });
+});

libs/langchain-core/src/tools/types.ts

@@ -81,6 +81,10 @@ export interface ToolParams extends BaseLangChainParams {
    * @default false
    */
   verboseParsingErrors?: boolean;
+  /**
+   * Metadata for the tool.
+   */
+  metadata?: Record<string, unknown>;
 }
 
 export type ToolRunnableConfig<