@aigne/core 1.12.0 → 1.13.0

package/lib/esm/models/openai-chat-model.js

@@ -45,6 +45,7 @@ export class OpenAIChatModel extends ChatModel {
     supportsToolsUseWithJsonSchema = true;
     supportsParallelToolCalls = true;
     supportsToolsEmptyParameters = true;
+    supportsToolStreaming = true;
     supportsTemperature = true;
     get client() {
         const apiKey = this.options?.apiKey || process.env[this.apiKeyEnvName] || this.apiKeyDefault;
@@ -86,9 +87,9 @@ export class OpenAIChatModel extends ChatModel {
             response_format: responseFormat,
         });
         if (options?.streaming && input.responseFormat?.type !== "json_schema") {
-            return await extractResultFromStream(stream, false, true);
+            return await this.extractResultFromStream(stream, false, true);
         }
-        const result = await extractResultFromStream(stream, jsonMode);
+        const result = await this.extractResultFromStream(stream, jsonMode);
         if (!this.supportsToolsUseWithJsonSchema &&
             !result.toolCalls?.length &&
             input.responseFormat?.type === "json_schema" &&
@@ -154,7 +155,103 @@ export class OpenAIChatModel extends ChatModel {
             ...body,
             response_format: resolvedResponseFormat,
         });
-        return extractResultFromStream(res, jsonMode);
+        return this.extractResultFromStream(res, jsonMode);
+    }
+    async extractResultFromStream(stream, jsonMode, streaming) {
+        const result = new ReadableStream({
+            start: async (controller) => {
+                try {
+                    let text = "";
+                    let refusal = "";
+                    const toolCalls = [];
+                    let model;
+                    for await (const chunk of stream) {
+                        const choice = chunk.choices?.[0];
+                        if (!model) {
+                            model = chunk.model;
+                            controller.enqueue({
+                                delta: {
+                                    json: {
+                                        model,
+                                    },
+                                },
+                            });
+                        }
+                        if (choice?.delta.tool_calls?.length) {
+                            for (const call of choice.delta.tool_calls) {
+                                if (this.supportsToolStreaming && call.index !== undefined) {
+                                    handleToolCallDelta(toolCalls, call);
+                                }
+                                else {
+                                    handleCompleteToolCall(toolCalls, call);
+                                }
+                            }
+                        }
+                        if (choice?.delta.content) {
+                            text += choice.delta.content;
+                            if (!jsonMode) {
+                                controller.enqueue({
+                                    delta: {
+                                        text: {
+                                            text: choice.delta.content,
+                                        },
+                                    },
+                                });
+                            }
+                        }
+                        if (choice?.delta.refusal) {
+                            refusal += choice.delta.refusal;
+                            if (!jsonMode) {
+                                controller.enqueue({
+                                    delta: {
+                                        text: { text: choice.delta.refusal },
+                                    },
+                                });
+                            }
+                        }
+                        if (chunk.usage) {
+                            controller.enqueue({
+                                delta: {
+                                    json: {
+                                        usage: {
+                                            inputTokens: chunk.usage.prompt_tokens,
+                                            outputTokens: chunk.usage.completion_tokens,
+                                        },
+                                    },
+                                },
+                            });
+                        }
+                    }
+                    text = text || refusal;
+                    if (jsonMode && text) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    json: parseJSON(text),
+                                },
+                            },
+                        });
+                    }
+                    if (toolCalls.length) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    toolCalls: toolCalls.map(({ args, ...c }) => ({
+                                        ...c,
+                                        function: { ...c.function, arguments: parseJSON(args) },
+                                    })),
+                                },
+                            },
+                        });
+                    }
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        return streaming ? result : await agentResponseStreamToObject(result);
     }
 }
 export const ROLE_MAP = {
@@ -235,103 +332,6 @@ export function jsonSchemaToOpenAIJsonSchema(schema) {
     }
     return schema;
 }
-async function extractResultFromStream(stream, jsonMode, streaming) {
-    const result = new ReadableStream({
-        async start(controller) {
-            try {
-                let text = "";
-                let refusal = "";
-                const toolCalls = [];
-                let model;
-                for await (const chunk of stream) {
-                    const choice = chunk.choices?.[0];
-                    if (!model) {
-                        model = chunk.model;
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    model,
-                                },
-                            },
-                        });
-                    }
-                    if (choice?.delta.tool_calls?.length) {
-                        for (const call of choice.delta.tool_calls) {
-                            // Gemini not support tool call delta
-                            if (call.index !== undefined) {
-                                handleToolCallDelta(toolCalls, call);
-                            }
-                            else {
-                                handleCompleteToolCall(toolCalls, call);
-                            }
-                        }
-                    }
-                    if (choice?.delta.content) {
-                        text += choice.delta.content;
-                        if (!jsonMode) {
-                            controller.enqueue({
-                                delta: {
-                                    text: {
-                                        text: choice.delta.content,
-                                    },
-                                },
-                            });
-                        }
-                    }
-                    if (choice?.delta.refusal) {
-                        refusal += choice.delta.refusal;
-                        if (!jsonMode) {
-                            controller.enqueue({
-                                delta: {
-                                    text: { text: choice.delta.refusal },
-                                },
-                            });
-                        }
-                    }
-                    if (chunk.usage) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    usage: {
-                                        inputTokens: chunk.usage.prompt_tokens,
-                                        outputTokens: chunk.usage.completion_tokens,
-                                    },
-                                },
-                            },
-                        });
-                    }
-                }
-                text = text || refusal;
-                if (jsonMode && text) {
-                    controller.enqueue({
-                        delta: {
-                            json: {
-                                json: parseJSON(text),
-                            },
-                        },
-                    });
-                }
-                if (toolCalls.length) {
-                    controller.enqueue({
-                        delta: {
-                            json: {
-                                toolCalls: toolCalls.map(({ args, ...c }) => ({
-                                    ...c,
-                                    function: { ...c.function, arguments: parseJSON(args) },
-                                })),
-                            },
-                        },
-                    });
-                }
-                controller.close();
-            }
-            catch (error) {
-                controller.error(error);
-            }
-        },
-    });
-    return streaming ? result : await agentResponseStreamToObject(result);
-}
 function handleToolCallDelta(toolCalls, call) {
     toolCalls[call.index] ??= {
         id: call.id || nanoid(),

package/lib/esm/prompt/prompt-builder.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { ZodObject } from "zod";
 import { Agent } from "../agents/agent.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { isNil } from "../utils/type-utils.js";
+import { isNil, unique } from "../utils/type-utils.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export const MESSAGE_KEY = "$message";
 export const DEFAULT_MAX_HISTORY_MESSAGES = 10;
@@ -112,10 +112,10 @@ export class PromptBuilder {
             : undefined;
     }
     buildTools(options) {
-        const toolAgents = (options.context?.skills ?? [])
+        const toolAgents = unique((options.context?.skills ?? [])
             .concat(options.agent?.skills ?? [])
             // TODO: support nested tools?
-            .flatMap((i) => (i.isInvokable ? i.skills.concat(i) : i.skills));
+            .flatMap((i) => (i.isInvokable ? i.skills.concat(i) : i.skills)), (i) => i.name);
         const tools = toolAgents.map((i) => ({
             type: "function",
             function: {

package/lib/esm/utils/prompts.js

@@ -1,5 +1,5 @@
 export function getJsonOutputPrompt(schema) {
-    let prompt = "Provide your output as a JSON containing the following fields:";
+    let prompt = "Output must be a JSON object containing the following fields only.";
     if (typeof schema === "string") {
         prompt += `\n<json_fields>\n${schema}\n</json_fields>`;
     }

package/lib/esm/utils/type-utils.d.ts

@@ -8,6 +8,7 @@ export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
+export declare function unique<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {

package/lib/esm/utils/type-utils.js

@@ -34,6 +34,17 @@ export function duplicates(arr, key = (item) => item) {
     }
     return Array.from(duplicates);
 }
+export function unique(arr, key = (item) => item) {
+    const seen = new Set();
+    return arr.filter((item) => {
+        const k = key(item);
+        if (seen.has(k)) {
+            return false;
+        }
+        seen.add(k);
+        return true;
+    });
+}
 export function omitBy(obj, predicate) {
     return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
         const k = key;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -58,6 +58,12 @@
       ],
       "utils/*": [
         "./lib/dts/utils/*"
+      ],
+      "client/*": [
+        "./lib/dts/client/*"
+      ],
+      "server/*": [
+        "./lib/dts/server/*"
       ]
     }
   },
@@ -84,6 +90,7 @@
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.796.0",
     "@google/generative-ai": "^0.24.0",
     "openai": "^4.87.3"
   },