@nocobase/plugin-ai 1.9.32 → 1.9.34

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

@@ -1,20 +1,21 @@
-import { z } from "zod";
 import { BaseCallbackConfig, CallbackManagerForLLMRun, CallbackManagerForToolRun } from "../../callbacks/manager.js";
 import { BaseChatMessageHistory, BaseListChatMessageHistory } from "../../chat_history.js";
 import { Document } from "../../documents/document.js";
 import { BaseChatModel, BaseChatModelCallOptions, BaseChatModelParams } from "../../language_models/chat_models.js";
 import { BaseLLMParams, LLM } from "../../language_models/llms.js";
-import { BaseMessage, AIMessage } from "../../messages/index.js";
+import { BaseMessage, AIMessage, AIMessageChunk } from "../../messages/index.js";
 import { BaseOutputParser } from "../../output_parsers/base.js";
 import { GenerationChunk, type ChatResult, ChatGenerationChunk } from "../../outputs.js";
 import { BaseRetriever } from "../../retrievers/index.js";
 import { Runnable } from "../../runnables/base.js";
 import { StructuredTool, ToolParams } from "../../tools/index.js";
+import { ToolInputSchemaOutputType } from "../../tools/types.js";
 import { BaseTracer, Run } from "../../tracers/base.js";
 import { Embeddings, EmbeddingsInterface, EmbeddingsParams } from "../../embeddings.js";
 import { StructuredOutputMethodParams, BaseLanguageModelInput, StructuredOutputMethodOptions } from "../../language_models/base.js";
 import { VectorStore } from "../../vectorstores.js";
 import { cosine } from "../ml-distance/similarities.js";
+import { InteropZodObject, InteropZodType } from "../types/zod.js";
 /**
  * Parser for comma-separated values. It splits the input text by commas
  * and trims the resulting values.
@@ -60,18 +61,18 @@ export declare class FakeChatModel extends BaseChatModel {
     _llmType(): string;
     _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
-export declare class FakeStreamingChatModel extends BaseChatModel {
-    sleep?: number;
-    responses?: BaseMessage[];
+export declare class FakeStreamingChatModel extends BaseChatModel<FakeStreamingChatModelCallOptions> {
+    sleep: number;
+    responses: BaseMessage[];
+    chunks: AIMessageChunk[];
+    toolStyle: "openai" | "anthropic" | "bedrock" | "google";
     thrownErrorString?: string;
-    constructor(fields: {
-        sleep?: number;
-        responses?: BaseMessage[];
-        thrownErrorString?: string;
-    } & BaseLLMParams);
+    private tools;
+    constructor({ sleep, responses, chunks, toolStyle, thrownErrorString, ...rest }: FakeStreamingChatModelFields & BaseLLMParams);
     _llmType(): string;
+    bindTools(tools: (StructuredTool | ToolSpec)[]): Runnable<BaseLanguageModelInput, AIMessageChunk, FakeStreamingChatModelCallOptions>;
     _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    _streamResponseChunks(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export declare class FakeRetriever extends BaseRetriever {
     lc_namespace: string[];
@@ -81,6 +82,32 @@ export declare class FakeRetriever extends BaseRetriever {
     });
     _getRelevantDocuments(_query: string): Promise<Document<Record<string, any>>[]>;
 }
+/** Minimal shape actually needed by `bindTools` */
+export interface ToolSpec {
+    name: string;
+    description?: string;
+    schema: InteropZodType | Record<string, unknown>;
+}
+/**
+ * Interface specific to the Fake Streaming Chat model.
+ */
+export interface FakeStreamingChatModelCallOptions extends BaseChatModelCallOptions {
+}
+/**
+ * Interface for the Constructor-field specific to the Fake Streaming Chat model (all optional because we fill in defaults).
+ */
+export interface FakeStreamingChatModelFields extends BaseChatModelParams {
+    /** Milliseconds to pause between fallback char-by-char chunks */
+    sleep?: number;
+    /** Full AI messages to fall back to when no `chunks` supplied */
+    responses?: BaseMessage[];
+    /** Exact chunks to emit (can include tool-call deltas) */
+    chunks?: AIMessageChunk[];
+    /** How tool specs are formatted in `bindTools` */
+    toolStyle?: "openai" | "anthropic" | "bedrock" | "google";
+    /** Throw this error instead of streaming (useful in tests) */
+    thrownErrorString?: string;
+}
 /**
  * Interface for the input parameters specific to the Fake List Chat model.
  */
@@ -135,8 +162,8 @@ export declare class FakeListChatModel extends BaseChatModel<FakeListChatModelCa
     _createResponseChunk(text: string): ChatGenerationChunk;
     _currentResponse(): string;
     _incrementResponse(): void;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, true> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, false> | InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, true> | InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;
@@ -164,17 +191,17 @@ export declare class FakeTracer extends BaseTracer {
     constructor();
     protected persistRun(run: Run): Promise<void>;
 }
-export interface FakeToolParams<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends ToolParams {
+export interface FakeToolParams<T extends InteropZodObject = InteropZodObject> extends ToolParams {
     name: string;
     description: string;
     schema: T;
 }
-export declare class FakeTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends StructuredTool<T> {
+export declare class FakeTool<T extends InteropZodObject = InteropZodObject> extends StructuredTool<T> {
     name: string;
     description: string;
     schema: T;
     constructor(fields: FakeToolParams<T>);
-    protected _call(arg: z.output<T>, _runManager?: CallbackManagerForToolRun): Promise<string>;
+    protected _call(arg: ToolInputSchemaOutputType<T>, _runManager?: CallbackManagerForToolRun): Promise<string>;
 }
 /**
  * A class that provides fake embeddings by overriding the embedDocuments

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

@@ -13,6 +13,7 @@ import { Runnable, RunnableLambda } from "../../runnables/base.js";
 import { StructuredTool } from "../../tools/index.js";
 import { BaseTracer } from "../../tracers/base.js";
 import { Embeddings, } from "../../embeddings.js";
+import { toJsonSchema } from "../json_schema.js";
 import { VectorStore } from "../../vectorstores.js";
 import { cosine } from "../ml-distance/similarities.js";
 /**
@@ -178,8 +179,8 @@ export class FakeChatModel extends BaseChatModel {
     }
 }
 export class FakeStreamingChatModel extends BaseChatModel {
-    constructor(fields) {
-        super(fields);
+    constructor({ sleep = 50, responses = [], chunks = [], toolStyle = "openai", thrownErrorString, ...rest }) {
+        super(rest);
         Object.defineProperty(this, "sleep", {
             enumerable: true,
             configurable: true,
@@ -190,7 +191,19 @@ export class FakeStreamingChatModel extends 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,
@@ -198,54 +211,120 @@ export class FakeStreamingChatModel extends 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: toJsonSchema(t.schema),
+                        },
+                    };
+                case "anthropic":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        input_schema: toJsonSchema(t.schema),
+                    };
+                case "bedrock":
+                    return {
+                        toolSpec: {
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: toJsonSchema(t.schema),
+                        },
+                    };
+                case "google":
+                    return {
+                        name: t.name,
+                        description: t.description,
+                        parameters: 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 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 ChatGenerationChunk({
-                    text: "",
+        if (this.chunks?.length) {
+            for (const msgChunk of this.chunks) {
+                const cg = new ChatGenerationChunk({
                     message: new 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 ChatGenerationChunk({
-                    text: content,
-                    message: new AIMessageChunk({
-                        content,
-                    }),
-                });
-            }
+        const fallback = this.responses?.[0] ??
+            new 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 ChatGenerationChunk({
+                message: new AIMessageChunk({ content: ch }),
+                text: ch,
+            });
+            yield cg;
+            await runManager?.handleLLMNewToken(ch, undefined, undefined, undefined, undefined, { chunk: cg });
         }
     }
 }
@@ -420,7 +499,13 @@ export class FakeListChatModel extends BaseChatModel {
     withStructuredOutput(_params, _config) {
         return 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");
         });
     }
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodingForModel = exports.getEncoding = void 0;
+exports.getEncoding = getEncoding;
+exports.encodingForModel = encodingForModel;
 const lite_1 = require("js-tiktoken/lite");
 const async_caller_js_1 = require("./async_caller.cjs");
 const cache = {};
@@ -18,8 +19,6 @@ async function getEncoding(encoding) {
     }
     return await cache[encoding];
 }
-exports.getEncoding = getEncoding;
 async function encodingForModel(model) {
     return getEncoding((0, lite_1.getEncodingNameForModel)(model));
 }
-exports.encodingForModel = encodingForModel;

package/dist/node_modules/@langchain/core/dist/utils/types/index.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("./is_zod_schema.cjs"), exports);
+__exportStar(require("./zod.cjs"), exports);

package/dist/node_modules/@langchain/core/dist/utils/types/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./is_zod_schema.js";
+export * from "./zod.js";
 /**
  * Represents a string value with autocompleted, but not required, suggestions.
  */

package/dist/node_modules/@langchain/core/dist/utils/types/index.js

@@ -1 +1 @@
-export * from "./is_zod_schema.js";
+export * from "./zod.js";