@nocobase/plugin-ai 1.9.33 → 1.9.35

package/dist/node_modules/@langchain/core/dist/utils/json_schema.js

@@ -1 +1,91 @@
+import { toJSONSchema } from "zod/v4/core";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { dereference } from "@cfworker/json-schema";
+import { isZodSchemaV3, isZodSchemaV4, interopZodObjectStrict, isZodObjectV4, interopZodTransformInputSchema, } from "./types/zod.js";
 export { deepCompareStrict, Validator } from "@cfworker/json-schema";
+/**
+ * Converts a Zod schema or JSON schema to a JSON schema.
+ * @param schema - The schema to convert.
+ * @returns The converted schema.
+ */
+export function toJsonSchema(schema) {
+    if (isZodSchemaV4(schema)) {
+        const inputSchema = interopZodTransformInputSchema(schema, true);
+        if (isZodObjectV4(inputSchema)) {
+            const strictSchema = interopZodObjectStrict(inputSchema, true);
+            return toJSONSchema(strictSchema);
+        }
+        else {
+            return toJSONSchema(schema);
+        }
+    }
+    if (isZodSchemaV3(schema)) {
+        return zodToJsonSchema(schema);
+    }
+    return schema;
+}
+/**
+ * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
+ * (like recursive or unresolvable refs).
+ *
+ * @param schema - The schema to validate.
+ * @returns `true` if the schema validates only strings, `false` otherwise.
+ */
+export function validatesOnlyStrings(schema) {
+    // Null, undefined, or empty schema
+    if (!schema ||
+        typeof schema !== "object" ||
+        Object.keys(schema).length === 0 ||
+        Array.isArray(schema)) {
+        return false; // Validates anything, not just strings
+    }
+    // Explicit type constraint
+    if ("type" in schema) {
+        if (typeof schema.type === "string") {
+            return schema.type === "string";
+        }
+        if (Array.isArray(schema.type)) {
+            // not sure why someone would do `"type": ["string"]` or especially `"type": ["string",
+            // "string", "string", ...]` but we're not here to judge
+            return schema.type.every((t) => t === "string");
+        }
+        return false; // Invalid or non-string type
+    }
+    // Enum with only string values
+    if ("enum" in schema) {
+        return (Array.isArray(schema.enum) &&
+            schema.enum.length > 0 &&
+            schema.enum.every((val) => typeof val === "string"));
+    }
+    // String constant
+    if ("const" in schema) {
+        return typeof schema.const === "string";
+    }
+    // Schema combinations
+    if ("allOf" in schema && Array.isArray(schema.allOf)) {
+        // If any subschema validates only strings, then the overall schema validates only strings
+        return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
+    }
+    if (("anyOf" in schema && Array.isArray(schema.anyOf)) ||
+        ("oneOf" in schema && Array.isArray(schema.oneOf))) {
+        const subschemas = ("anyOf" in schema ? schema.anyOf : schema.oneOf);
+        // All subschemas must validate only strings
+        return (subschemas.length > 0 &&
+            subschemas.every((subschema) => validatesOnlyStrings(subschema)));
+    }
+    // We're not going to try on this one, it's too complex - we just assume if it has a "not" key and hasn't matched one of the above checks, it's not a string schema.
+    if ("not" in schema) {
+        return false; // The not case can validate non-strings
+    }
+    if ("$ref" in schema && typeof schema.$ref === "string") {
+        const ref = schema.$ref;
+        const resolved = dereference(schema);
+        if (resolved[ref]) {
+            return validatesOnlyStrings(resolved[ref]);
+        }
+        return false;
+    }
+    // ignore recursive refs and other cases where type is omitted for now
+    // ignore other cases for now where type is omitted
+    return false;
+}

package/dist/node_modules/@langchain/core/dist/utils/math.cjs

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maximalMarginalRelevance = exports.euclideanDistance = exports.innerProduct = exports.cosineSimilarity = exports.normalize = exports.matrixFunc = void 0;
+exports.matrixFunc = matrixFunc;
+exports.normalize = normalize;
+exports.cosineSimilarity = cosineSimilarity;
+exports.innerProduct = innerProduct;
+exports.euclideanDistance = euclideanDistance;
+exports.maximalMarginalRelevance = maximalMarginalRelevance;
 const similarities_js_1 = require("./ml-distance/similarities.cjs");
 const distances_js_1 = require("./ml-distance/distances.cjs");
 const euclidean_js_1 = require("./ml-distance-euclidean/euclidean.cjs");
@@ -30,12 +35,10 @@ function matrixFunc(X, Y, func) {
     }
     return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
 }
-exports.matrixFunc = matrixFunc;
 function normalize(M, similarity = false) {
     const max = matrixMaxVal(M);
     return M.map((row) => row.map((val) => (similarity ? 1 - val / max : val / max)));
 }
-exports.normalize = normalize;
 /**
  * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
  *
@@ -49,15 +52,12 @@ exports.normalize = normalize;
 function cosineSimilarity(X, Y) {
     return matrixFunc(X, Y, similarities_js_1.cosine);
 }
-exports.cosineSimilarity = cosineSimilarity;
 function innerProduct(X, Y) {
     return matrixFunc(X, Y, distances_js_1.innerProduct);
 }
-exports.innerProduct = innerProduct;
 function euclideanDistance(X, Y) {
     return matrixFunc(X, Y, euclidean_js_1.euclidean);
 }
-exports.euclideanDistance = euclideanDistance;
 /**
  * This function implements the Maximal Marginal Relevance algorithm
  * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
@@ -98,7 +98,6 @@ function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = 0.5, k
     }
     return selectedEmbeddingsIndexes;
 }
-exports.maximalMarginalRelevance = maximalMarginalRelevance;
 /**
  * Finds the index of the maximum value in the given array.
  * @param {number[]} array - The input array.

package/dist/node_modules/@langchain/core/dist/utils/ml-distance/distances.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.innerProduct = void 0;
+exports.innerProduct = innerProduct;
 /**
  *Returns the Inner Product similarity between vectors a and b
  * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
@@ -15,4 +15,3 @@ function innerProduct(a, b) {
     }
     return ans;
 }
-exports.innerProduct = innerProduct;

package/dist/node_modules/@langchain/core/dist/utils/ml-distance/similarities.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cosine = void 0;
+exports.cosine = cosine;
 /**
  * Returns the average of cosine distances between vectors a and b
  * @param a - first vector
@@ -18,4 +18,3 @@ function cosine(a, b) {
     }
     return p / (Math.sqrt(p2) * Math.sqrt(q2));
 }
-exports.cosine = cosine;

package/dist/node_modules/@langchain/core/dist/utils/ml-distance-euclidean/euclidean.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.euclidean = exports.squaredEuclidean = void 0;
+exports.squaredEuclidean = squaredEuclidean;
+exports.euclidean = euclidean;
 function squaredEuclidean(p, q) {
     let d = 0;
     for (let i = 0; i < p.length; i++) {
@@ -8,8 +9,6 @@ function squaredEuclidean(p, q) {
     }
     return d;
 }
-exports.squaredEuclidean = squaredEuclidean;
 function euclidean(p, q) {
     return Math.sqrt(squaredEuclidean(p, q));
 }
-exports.euclidean = euclidean;

package/dist/node_modules/@langchain/core/dist/utils/sax-js/sax.cjs

@@ -282,41 +282,41 @@ const initializeSax = function () {
     }
     var S = 0;
     sax.STATE = {
-        BEGIN: S++,
-        BEGIN_WHITESPACE: S++,
-        TEXT: S++,
-        TEXT_ENTITY: S++,
-        OPEN_WAKA: S++,
-        SGML_DECL: S++,
-        SGML_DECL_QUOTED: S++,
-        DOCTYPE: S++,
-        DOCTYPE_QUOTED: S++,
-        DOCTYPE_DTD: S++,
-        DOCTYPE_DTD_QUOTED: S++,
-        COMMENT_STARTING: S++,
-        COMMENT: S++,
-        COMMENT_ENDING: S++,
-        COMMENT_ENDED: S++,
-        CDATA: S++,
-        CDATA_ENDING: S++,
-        CDATA_ENDING_2: S++,
-        PROC_INST: S++,
-        PROC_INST_BODY: S++,
-        PROC_INST_ENDING: S++,
-        OPEN_TAG: S++,
-        OPEN_TAG_SLASH: S++,
-        ATTRIB: S++,
-        ATTRIB_NAME: S++,
-        ATTRIB_NAME_SAW_WHITE: S++,
-        ATTRIB_VALUE: S++,
-        ATTRIB_VALUE_QUOTED: S++,
-        ATTRIB_VALUE_CLOSED: S++,
-        ATTRIB_VALUE_UNQUOTED: S++,
-        ATTRIB_VALUE_ENTITY_Q: S++,
-        ATTRIB_VALUE_ENTITY_U: S++,
-        CLOSE_TAG: S++,
-        CLOSE_TAG_SAW_WHITE: S++,
-        SCRIPT: S++,
+        BEGIN: S++, // leading byte order mark or whitespace
+        BEGIN_WHITESPACE: S++, // leading whitespace
+        TEXT: S++, // general stuff
+        TEXT_ENTITY: S++, // &amp and such.
+        OPEN_WAKA: S++, // <
+        SGML_DECL: S++, // <!BLARG
+        SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
+        DOCTYPE: S++, // <!DOCTYPE
+        DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
+        DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
+        DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
+        COMMENT_STARTING: S++, // <!-
+        COMMENT: S++, // <!--
+        COMMENT_ENDING: S++, // <!-- blah -
+        COMMENT_ENDED: S++, // <!-- blah --
+        CDATA: S++, // <![CDATA[ something
+        CDATA_ENDING: S++, // ]
+        CDATA_ENDING_2: S++, // ]]
+        PROC_INST: S++, // <?hi
+        PROC_INST_BODY: S++, // <?hi there
+        PROC_INST_ENDING: S++, // <?hi "there" ?
+        OPEN_TAG: S++, // <strong
+        OPEN_TAG_SLASH: S++, // <strong /
+        ATTRIB: S++, // <a
+        ATTRIB_NAME: S++, // <a foo
+        ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
+        ATTRIB_VALUE: S++, // <a foo=
+        ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
+        ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
+        ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
+        ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
+        ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
+        CLOSE_TAG: S++, // </a
+        CLOSE_TAG_SAW_WHITE: S++, // </a   >
+        SCRIPT: S++, // <script> ...
         SCRIPT_ENDING: S++, // <script> ... <
     };
     sax.XML_ENTITIES = {

package/dist/node_modules/@langchain/core/dist/utils/sax-js/sax.js

@@ -279,41 +279,41 @@ const initializeSax = function () {
     }
     var S = 0;
     sax.STATE = {
-        BEGIN: S++,
-        BEGIN_WHITESPACE: S++,
-        TEXT: S++,
-        TEXT_ENTITY: S++,
-        OPEN_WAKA: S++,
-        SGML_DECL: S++,
-        SGML_DECL_QUOTED: S++,
-        DOCTYPE: S++,
-        DOCTYPE_QUOTED: S++,
-        DOCTYPE_DTD: S++,
-        DOCTYPE_DTD_QUOTED: S++,
-        COMMENT_STARTING: S++,
-        COMMENT: S++,
-        COMMENT_ENDING: S++,
-        COMMENT_ENDED: S++,
-        CDATA: S++,
-        CDATA_ENDING: S++,
-        CDATA_ENDING_2: S++,
-        PROC_INST: S++,
-        PROC_INST_BODY: S++,
-        PROC_INST_ENDING: S++,
-        OPEN_TAG: S++,
-        OPEN_TAG_SLASH: S++,
-        ATTRIB: S++,
-        ATTRIB_NAME: S++,
-        ATTRIB_NAME_SAW_WHITE: S++,
-        ATTRIB_VALUE: S++,
-        ATTRIB_VALUE_QUOTED: S++,
-        ATTRIB_VALUE_CLOSED: S++,
-        ATTRIB_VALUE_UNQUOTED: S++,
-        ATTRIB_VALUE_ENTITY_Q: S++,
-        ATTRIB_VALUE_ENTITY_U: S++,
-        CLOSE_TAG: S++,
-        CLOSE_TAG_SAW_WHITE: S++,
-        SCRIPT: S++,
+        BEGIN: S++, // leading byte order mark or whitespace
+        BEGIN_WHITESPACE: S++, // leading whitespace
+        TEXT: S++, // general stuff
+        TEXT_ENTITY: S++, // &amp and such.
+        OPEN_WAKA: S++, // <
+        SGML_DECL: S++, // <!BLARG
+        SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
+        DOCTYPE: S++, // <!DOCTYPE
+        DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
+        DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
+        DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
+        COMMENT_STARTING: S++, // <!-
+        COMMENT: S++, // <!--
+        COMMENT_ENDING: S++, // <!-- blah -
+        COMMENT_ENDED: S++, // <!-- blah --
+        CDATA: S++, // <![CDATA[ something
+        CDATA_ENDING: S++, // ]
+        CDATA_ENDING_2: S++, // ]]
+        PROC_INST: S++, // <?hi
+        PROC_INST_BODY: S++, // <?hi there
+        PROC_INST_ENDING: S++, // <?hi "there" ?
+        OPEN_TAG: S++, // <strong
+        OPEN_TAG_SLASH: S++, // <strong /
+        ATTRIB: S++, // <a
+        ATTRIB_NAME: S++, // <a foo
+        ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
+        ATTRIB_VALUE: S++, // <a foo=
+        ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
+        ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
+        ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
+        ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
+        ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
+        CLOSE_TAG: S++, // </a
+        CLOSE_TAG_SAW_WHITE: S++, // </a   >
+        SCRIPT: S++, // <script> ...
         SCRIPT_ENDING: S++, // <script> ... <
     };
     sax.XML_ENTITIES = {

package/dist/node_modules/@langchain/core/dist/utils/signal.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.raceWithSignal = void 0;
+exports.raceWithSignal = raceWithSignal;
 async function raceWithSignal(promise, signal) {
     if (signal === undefined) {
         return promise;
@@ -27,4 +27,3 @@ async function raceWithSignal(promise, signal) {
         }),
     ]).finally(() => signal.removeEventListener("abort", listener));
 }
-exports.raceWithSignal = raceWithSignal;

package/dist/node_modules/@langchain/core/dist/utils/stream.cjs

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pipeGeneratorWithSetup = exports.AsyncGeneratorWithSetup = exports.concat = exports.atee = exports.IterableReadableStream = void 0;
+exports.AsyncGeneratorWithSetup = exports.IterableReadableStream = void 0;
+exports.atee = atee;
+exports.concat = concat;
+exports.pipeGeneratorWithSetup = pipeGeneratorWithSetup;
 const config_js_1 = require("../runnables/config.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 const signal_js_1 = require("./signal.cjs");
@@ -136,7 +139,6 @@ function atee(iter, length = 2) {
         }
     });
 }
-exports.atee = atee;
 function concat(first, second) {
     if (Array.isArray(first) && Array.isArray(second)) {
         return first.concat(second);
@@ -173,7 +175,6 @@ function concat(first, second) {
         throw new Error(`Cannot concat ${typeof first} and ${typeof second}`);
     }
 }
-exports.concat = concat;
 class AsyncGeneratorWithSetup {
     constructor(params) {
         Object.defineProperty(this, "generator", {
@@ -271,4 +272,3 @@ async function pipeGeneratorWithSetup(to, generator, startSetup, signal, ...args
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };
 }
-exports.pipeGeneratorWithSetup = pipeGeneratorWithSetup;

package/dist/node_modules/@langchain/core/dist/utils/testing/helpers.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.charChunks = void 0;
+const index_js_1 = require("../../messages/index.cjs");
+/** Tiny helper to convert string into char chunk. For eg: Turn `"Hi!"` into `[AIMessageChunk("H"), AIMessageChunk("i"), AIMessageChunk("!")] */
+const charChunks = (text) => [...text].map((c) => new index_js_1.AIMessageChunk({ content: c }));
+exports.charChunks = charChunks;

package/dist/node_modules/@langchain/core/dist/utils/testing/helpers.d.ts

@@ -0,0 +1,3 @@
+import { AIMessageChunk } from "../../messages/index.js";
+/** Tiny helper to convert string into char chunk. For eg: Turn `"Hi!"` into `[AIMessageChunk("H"), AIMessageChunk("i"), AIMessageChunk("!")] */
+export declare const charChunks: (text: string) => AIMessageChunk[];

package/dist/node_modules/@langchain/core/dist/utils/testing/helpers.js

@@ -0,0 +1,3 @@
+import { AIMessageChunk } from "../../messages/index.js";
+/** Tiny helper to convert string into char chunk. For eg: Turn `"Hi!"` into `[AIMessageChunk("H"), AIMessageChunk("i"), AIMessageChunk("!")] */
+export const charChunks = (text) => [...text].map((c) => new AIMessageChunk({ content: c }));

package/dist/node_modules/@langchain/core/dist/utils/testing/index.cjs

@@ -16,6 +16,7 @@ const base_js_2 = require("../../runnables/base.cjs");
 const index_js_3 = require("../../tools/index.cjs");
 const base_js_3 = require("../../tracers/base.cjs");
 const embeddings_js_1 = require("../../embeddings.cjs");
+const json_schema_js_1 = require("../json_schema.cjs");
 const vectorstores_js_1 = require("../../vectorstores.cjs");
 const similarities_js_1 = require("../ml-distance/similarities.cjs");
 /**
@@ -186,8 +187,8 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
 }
 exports.FakeChatModel = FakeChatModel;
 class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
-    constructor(fields) {
-        super(fields);
+    constructor({ sleep = 50, responses = [], chunks = [], toolStyle = "openai", thrownErrorString, ...rest }) {
+        super(rest);
         Object.defineProperty(this, "sleep", {
             enumerable: true,
             configurable: true,
@@ -198,7 +199,19 @@ class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
+        });
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "toolStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
         });
         Object.defineProperty(this, "thrownErrorString", {
             enumerable: true,
@@ -206,54 +219,120 @@ class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
             writable: true,
             value: void 0
         });
-        this.sleep = fields.sleep ?? this.sleep;
-        this.responses = fields.responses;
-        this.thrownErrorString = fields.thrownErrorString;
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.sleep = sleep;
+        this.responses = responses;
+        this.chunks = chunks;
+        this.toolStyle = toolStyle;
+        this.thrownErrorString = thrownErrorString;
     }
     _llmType() {
         return "fake";
     }
+    bindTools(tools) {
+        const merged = [...this.tools, ...tools];
+        const toolDicts = merged.map((t) => {
+            switch (this.toolStyle) {
+                case "openai":
+                    return {
+                        type: "function",
+                        function: {
+                            name: t.name,
+                            description: t.description,
+                            parameters: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                        },
+                    };
+                case "anthropic":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        input_schema: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                    };
+                case "bedrock":
+                    return {
+                        toolSpec: {
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                        },
+                    };
+                case "google":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        parameters: (0, json_schema_js_1.toJsonSchema)(t.schema),
+                    };
+                default:
+                    throw new Error(`Unsupported tool style: ${this.toolStyle}`);
+            }
+        });
+        const wrapped = this.toolStyle === "google"
+            ? [{ functionDeclarations: toolDicts }]
+            : toolDicts;
+        /* creating a *new* instance – mirrors LangChain .bind semantics for type-safety and avoiding noise */
+        const next = new FakeStreamingChatModel({
+            sleep: this.sleep,
+            responses: this.responses,
+            chunks: this.chunks,
+            toolStyle: this.toolStyle,
+            thrownErrorString: this.thrownErrorString,
+        });
+        next.tools = merged;
+        return next.withConfig({ tools: wrapped });
+    }
     async _generate(messages, _options, _runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        const content = this.responses?.[0].content ?? messages[0].content;
+        const content = this.responses?.[0]?.content ?? messages[0].content ?? "";
         const generation = {
             generations: [
                 {
                     text: "",
                     message: new index_js_1.AIMessage({
                         content,
+                        tool_calls: this.chunks?.[0]?.tool_calls,
                     }),
                 },
             ],
         };
         return generation;
     }
-    async *_streamResponseChunks(messages, _options, _runManager) {
+    async *_streamResponseChunks(_messages, _options, runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        const content = this.responses?.[0].content ?? messages[0].content;
-        if (typeof content !== "string") {
-            for (const _ of this.responses ?? messages) {
-                yield new outputs_js_1.ChatGenerationChunk({
-                    text: "",
+        if (this.chunks?.length) {
+            for (const msgChunk of this.chunks) {
+                const cg = new outputs_js_1.ChatGenerationChunk({
                     message: new index_js_1.AIMessageChunk({
-                        content,
+                        content: msgChunk.content,
+                        tool_calls: msgChunk.tool_calls,
+                        additional_kwargs: msgChunk.additional_kwargs ?? {},
                     }),
+                    text: msgChunk.content?.toString() ?? "",
                 });
+                yield cg;
+                await runManager?.handleLLMNewToken(msgChunk.content, undefined, undefined, undefined, undefined, { chunk: cg });
             }
+            return;
         }
-        else {
-            for (const _ of this.responses ?? messages) {
-                yield new outputs_js_1.ChatGenerationChunk({
-                    text: content,
-                    message: new index_js_1.AIMessageChunk({
-                        content,
-                    }),
-                });
-            }
+        const fallback = this.responses?.[0] ??
+            new index_js_1.AIMessage(typeof _messages[0].content === "string" ? _messages[0].content : "");
+        const text = typeof fallback.content === "string" ? fallback.content : "";
+        for (const ch of text) {
+            await new Promise((r) => setTimeout(r, this.sleep));
+            const cg = new outputs_js_1.ChatGenerationChunk({
+                message: new index_js_1.AIMessageChunk({ content: ch }),
+                text: ch,
+            });
+            yield cg;
+            await runManager?.handleLLMNewToken(ch, undefined, undefined, undefined, undefined, { chunk: cg });
         }
     }
 }
@@ -430,7 +509,13 @@ class FakeListChatModel extends chat_models_js_1.BaseChatModel {
     withStructuredOutput(_params, _config) {
         return base_js_2.RunnableLambda.from(async (input) => {
             const message = await this.invoke(input);
-            return JSON.parse(message.content);
+            if (message.tool_calls?.[0]?.args) {
+                return message.tool_calls[0].args;
+            }
+            if (typeof message.content === "string") {
+                return JSON.parse(message.content);
+            }
+            throw new Error("No structured output found");
         });
     }
 }