@aigne/core 1.1.0-beta.5 → 1.3.0

package/lib/esm/models/{chat-openai.js → openai-chat-model.js}

@@ -1,9 +1,9 @@
 import { nanoid } from "nanoid";
 import OpenAI from "openai";
-import { isNonNullable } from "../utils/type-utils";
-import { ChatModel, } from "./chat";
+import { isNonNullable } from "../utils/type-utils.js";
+import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
-export class ChatModelOpenAI extends ChatModel {
+export class OpenAIChatModel extends ChatModel {
     config;
     constructor(config) {
         super();
@@ -12,7 +12,7 @@ export class ChatModelOpenAI extends ChatModel {
     _client;
     get client() {
         if (!this.config?.apiKey)
-            throw new Error("Api Key is required for ChatModelOpenAI");
+            throw new Error("Api Key is required for OpenAIChatModel");
         this._client ??= new OpenAI({ apiKey: this.config.apiKey });
         return this._client;
     }
@@ -62,7 +62,7 @@ export class ChatModelOpenAI extends ChatModel {
                 text += choice.delta.content;
         }
         const result = {};
-        if (input.responseFormat?.type === "json_schema") {
+        if (input.responseFormat?.type === "json_schema" && text) {
             result.json = JSON.parse(text);
         }
         else {

package/lib/esm/prompt/prompt-builder.d.ts

@@ -1,22 +1,24 @@
-import type { GetPromptResult } from "@modelcontextprotocol/sdk/types";
-import { Agent, type AgentInput } from "../agents/agent";
-import type { AIAgent } from "../agents/ai-agent";
-import type { Context } from "../execution-engine/context";
-import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
-import { ChatMessagesTemplate } from "./template";
-export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
-export declare function userInput(message: string | object): AgentInput;
-export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
+import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
+import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import type { AIAgent } from "../agents/ai-agent.js";
+import type { AgentMemory } from "../agents/memory.js";
+import type { Context } from "../execution-engine/context.js";
+import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
+import { ChatMessagesTemplate } from "./template.js";
+export declare const MESSAGE_KEY = "$message";
+export declare const DEFAULT_MAX_HISTORY_MESSAGES = 10;
+export declare function createMessage(message: string | object): Message;
+export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuilderBuildOptions {
-    enableHistory?: boolean;
-    maxHistoryMessages?: number;
+    memory?: AgentMemory;
     context?: Context;
     agent?: AIAgent;
-    input?: AgentInput;
+    input?: Message;
     model?: ChatModel;
+    outputSchema?: AgentOptions["outputSchema"];
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;
@@ -31,8 +33,6 @@ export declare class PromptBuilder {
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
-    histories: ChatModelInputMessage[];
-    addHistory(...messages: ChatModelInputMessage[]): void;
     build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;

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

@@ -1,31 +1,21 @@
 import { readFile } from "node:fs/promises";
-import { isNil } from "lodash";
+import { isNil } from "lodash-es";
 import { ZodObject } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-import { Agent } from "../agents/agent";
-import { AgentMessageTemplate, ChatMessagesTemplate, SystemMessageTemplate, UserMessageTemplate, parseChatMessages, } from "./template";
-export const USER_INPUT_MESSAGE_KEY = "$user_input_message";
-export function userInput(message) {
-    return { [USER_INPUT_MESSAGE_KEY]: message };
+import { Agent } from "../agents/agent.js";
+import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
+import { AgentMessageTemplate, ChatMessagesTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
+export const MESSAGE_KEY = "$message";
+export const DEFAULT_MAX_HISTORY_MESSAGES = 10;
+export function createMessage(message) {
+    return { [MESSAGE_KEY]: message };
 }
-export function addMessagesToInput(input, messages) {
-    const originalUserInputMessages = input[USER_INPUT_MESSAGE_KEY];
-    const newMessages = [];
-    if (typeof originalUserInputMessages === "string") {
-        newMessages.push({ role: "user", content: originalUserInputMessages });
-    }
-    else {
-        const messages = parseChatMessages(originalUserInputMessages);
-        if (messages)
-            newMessages.push(...messages);
-        else
-            newMessages.push({
-                role: "user",
-                content: JSON.stringify(originalUserInputMessages),
-            });
-    }
-    newMessages.push(...messages);
-    return { ...input, [USER_INPUT_MESSAGE_KEY]: newMessages };
+export function getMessage(input) {
+    const userInputMessage = input[MESSAGE_KEY];
+    if (typeof userInputMessage === "string")
+        return userInputMessage;
+    if (!isNil(userInputMessage))
+        return JSON.stringify(userInputMessage);
+    return undefined;
 }
 export class PromptBuilder {
     static from(instructions) {
@@ -44,12 +34,27 @@ export class PromptBuilder {
     static fromMCPPromptResult(result) {
         return new PromptBuilder({
             instructions: ChatMessagesTemplate.from(result.messages.map((i) => {
-                if (i.content.type !== "text")
+                let content;
+                if (i.content.type === "text")
+                    content = i.content.text;
+                else if (i.content.type === "resource") {
+                    const { resource } = i.content;
+                    if (typeof resource.text === "string") {
+                        content = resource.text;
+                    }
+                    else if (typeof resource.blob === "string") {
+                        content = [{ type: "image_url", url: resource.blob }];
+                    }
+                }
+                else if (i.content.type === "image") {
+                    content = [{ type: "image_url", url: i.content.data }];
+                }
+                if (!content)
                     throw new Error(`Unsupported content type ${i.content.type}`);
                 if (i.role === "user")
-                    return UserMessageTemplate.from(i.content.text);
+                    return UserMessageTemplate.from(content);
                 if (i.role === "assistant")
-                    return AgentMessageTemplate.from(i.content.text);
+                    return AgentMessageTemplate.from(content);
                 throw new Error(`Unsupported role ${i.role}`);
             })),
         });
@@ -58,10 +63,6 @@ export class PromptBuilder {
         this.instructions = options?.instructions;
     }
     instructions;
-    histories = [];
-    addHistory(...messages) {
-        this.histories.push(...messages);
-    }
     async build(options) {
         return {
             messages: this.buildMessages(options),
@@ -74,35 +75,26 @@ export class PromptBuilder {
         const messages = (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input) ?? [];
-        if (options.enableHistory) {
-            messages.push(...(options.maxHistoryMessages
-                ? this.histories.slice(-options.maxHistoryMessages)
-                : this.histories));
-        }
-        const userMessages = [];
-        const userInputMessage = input?.[USER_INPUT_MESSAGE_KEY];
-        // Parse messages from the user input with the key $user_input_message
-        if (!isNil(userInputMessage)) {
-            if (typeof userInputMessage === "string") {
-                userMessages.push(UserMessageTemplate.from(userInputMessage).format());
-            }
-            else {
-                const messages = parseChatMessages(userInputMessage);
-                if (messages)
-                    userMessages.push(...messages.map((i) => i.format()));
-                else
-                    userMessages.push(UserMessageTemplate.from(JSON.stringify(userInputMessage)).format());
-            }
+        const memory = options.memory ?? options.agent?.memory;
+        if (memory?.enabled) {
+            const k = memory.maxMemoriesInChat ?? DEFAULT_MAX_HISTORY_MESSAGES;
+            const histories = memory.memories.slice(-k);
+            if (histories?.length)
+                messages.push(...histories.map((i) => ({
+                    role: i.role,
+                    content: convertMessageToContent(i.content),
+                    name: i.source,
+                })));
         }
-        if (userMessages.length) {
-            if (options.enableHistory)
-                this.addHistory(...userMessages);
-            messages.push(...userMessages);
+        const content = input && getMessage(input);
+        // add user input if it's not the same as the last message
+        if (content && messages.at(-1)?.content !== content) {
+            messages.push({ role: "user", content });
         }
         return messages;
     }
     buildResponseFormat(options) {
-        const outputSchema = options.agent?.outputSchema;
+        const outputSchema = options.outputSchema || options.agent?.outputSchema;
         if (!outputSchema)
             return undefined;
         const isJsonOutput = !isEmptyObjectType(outputSchema);
@@ -111,7 +103,7 @@ export class PromptBuilder {
                 type: "json_schema",
                 jsonSchema: {
                     name: "output",
-                    schema: zodToJsonSchema(outputSchema),
+                    schema: outputSchemaToResponseFormatSchema(outputSchema),
                     strict: true,
                 },
             }
@@ -127,7 +119,9 @@ export class PromptBuilder {
             function: {
                 name: i.name,
                 description: i.description,
-                parameters: !isEmptyObjectType(i.inputSchema) ? zodToJsonSchema(i.inputSchema) : {},
+                parameters: !isEmptyObjectType(i.inputSchema)
+                    ? outputSchemaToResponseFormatSchema(i.inputSchema)
+                    : {},
             },
         }));
         let toolChoice;
@@ -170,3 +164,7 @@ function isFromPath(value) {
 function isEmptyObjectType(schema) {
     return schema instanceof ZodObject && Object.keys(schema.shape).length === 0;
 }
+function convertMessageToContent(i) {
+    const str = i[MESSAGE_KEY];
+    return !isNil(str) ? (typeof str === "string" ? str : JSON.stringify(str)) : JSON.stringify(i);
+}

package/lib/esm/prompt/template.d.ts

@@ -1,4 +1,4 @@
-import type { ChatModelInputMessage, ChatModelOutputToolCall } from "../models/chat";
+import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../models/chat-model.js";
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
@@ -16,22 +16,16 @@ export declare class SystemMessageTemplate extends ChatMessageTemplate {
     static from(content: string, name?: string): SystemMessageTemplate;
 }
 export declare class UserMessageTemplate extends ChatMessageTemplate {
-    static from(template: NonNullable<ChatModelInputMessage["content"]>, name?: string): UserMessageTemplate;
+    static from(template: ChatModelInputMessageContent, name?: string): UserMessageTemplate;
 }
 export declare class AgentMessageTemplate extends ChatMessageTemplate {
     toolCalls?: ChatModelOutputToolCall[] | undefined;
-    static from(template: string | ChatModelOutputToolCall[], name?: string): AgentMessageTemplate;
-    constructor(content?: string, toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
+    static from(template?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[], name?: string): AgentMessageTemplate;
+    constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCalls: ChatModelOutputToolCall[] | undefined;
-        role: import("../models/chat").Role;
-        content?: string | ({
-            type: "text";
-            text: string;
-        } | {
-            type: "image_url";
-            url: string;
-        })[];
+        role: import("../models/chat-model.js").Role;
+        content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
     };
@@ -42,20 +36,14 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content: object | string, toolCallId: string, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCallId: string;
-        role: import("../models/chat").Role;
-        content?: string | ({
-            type: "text";
-            text: string;
-        } | {
-            type: "image_url";
-            url: string;
-        })[];
+        role: import("../models/chat-model.js").Role;
+        content?: ChatModelInputMessageContent;
         toolCalls?: {
             id: string;
             type: "function";
             function: {
                 name: string;
-                arguments: import("..").AgentInput;
+                arguments: import("../index.js").Message;
             };
         }[];
         name?: string;

package/lib/esm/prompt/template.js

@@ -56,10 +56,8 @@ export class UserMessageTemplate extends ChatMessageTemplate {
 }
 export class AgentMessageTemplate extends ChatMessageTemplate {
     toolCalls;
-    static from(template, name) {
-        return typeof template === "string"
-            ? new AgentMessageTemplate(template, undefined, name)
-            : new AgentMessageTemplate(undefined, template, name);
+    static from(template, toolCalls, name) {
+        return new AgentMessageTemplate(template, toolCalls, name);
     }
     constructor(content, toolCalls, name) {
         super("agent", content, name);
@@ -150,7 +148,7 @@ export function parseChatMessages(messages) {
             case "user":
                 return UserMessageTemplate.from(message.content, message.name);
             case "agent":
-                return new AgentMessageTemplate(message.content, message.toolCalls, message.name);
+                return AgentMessageTemplate.from(message.content, message.toolCalls, message.name);
             case "tool":
                 return ToolMessageTemplate.from(message.content, message.toolCallId, message.name);
         }

package/lib/esm/utils/json-schema.d.ts

@@ -0,0 +1,3 @@
+import type { ZodType } from "zod";
+import type { Message } from "../agents/agent.js";
+export declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;

package/lib/esm/utils/json-schema.js

@@ -0,0 +1,20 @@
+import { isObject } from "lodash-es";
+import { zodToJsonSchema } from "zod-to-json-schema";
+export function outputSchemaToResponseFormatSchema(agentOutput) {
+    return setAdditionPropertiesDeep(zodToJsonSchema(agentOutput), false);
+}
+function setAdditionPropertiesDeep(schema, additionalProperties) {
+    if (Array.isArray(schema)) {
+        return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
+    }
+    if (isObject(schema)) {
+        return Object.entries(schema).reduce((acc, [key, value]) => {
+            acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
+            if (acc.type === "object") {
+                acc.additionalProperties = additionalProperties;
+            }
+            return acc;
+        }, {});
+    }
+    return schema;
+}

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

@@ -1,5 +1,6 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { ListPromptsResult, ListToolsResult } from "@modelcontextprotocol/sdk/types";
-import { MCPPrompt, MCPTool } from "../agents/mcp-agent";
+import { type ListPromptsResult, type ListResourceTemplatesResult, type ListResourcesResult, type ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
+import { MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
 export declare function toolFromMCPTool(client: Client, tool: ListToolsResult["tools"][number]): MCPTool;
 export declare function promptFromMCPPrompt(client: Client, prompt: ListPromptsResult["prompts"][number]): MCPPrompt;
+export declare function resourceFromMCPResource(client: Client, resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number]): MCPResource;

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

@@ -1,19 +1,15 @@
-import { jsonSchemaToZod } from "@n8n/json-schema-to-zod";
+import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
+import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
+import { CallToolResultSchema, GetPromptResultSchema, ReadResourceResultSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import { MCPPrompt, MCPTool } from "../agents/mcp-agent";
+import { MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
 export function toolFromMCPTool(client, tool) {
     return new MCPTool({
         client,
         name: tool.name,
         description: tool.description,
         inputSchema: jsonSchemaToZod(tool.inputSchema),
-        outputSchema: z
-            .object({
-            _meta: z.record(z.unknown()).optional(),
-            content: z.array(z.record(z.unknown())),
-            isError: z.boolean().optional(),
-        })
-            .passthrough(),
+        outputSchema: CallToolResultSchema,
     });
 }
 export function promptFromMCPPrompt(client, prompt) {
@@ -27,11 +23,26 @@ export function promptFromMCPPrompt(client, prompt) {
                 Object.fromEntries(prompt.arguments.map((i) => [i.name, { type: "string", description: i.description }])),
             required: prompt.arguments?.filter((i) => i.required).map((i) => i.name),
         }),
-        outputSchema: z
-            .object({
-            description: z.string().optional(),
-            messages: z.array(z.record(z.unknown())),
-        })
-            .passthrough(),
+        outputSchema: GetPromptResultSchema,
     });
 }
+export function resourceFromMCPResource(client, resource) {
+    const [uri, variables] = isResourceTemplate(resource)
+        ? [
+            resource.uriTemplate,
+            // TODO: use template.variableNames when it's available https://github.com/modelcontextprotocol/typescript-sdk/pull/188
+            new UriTemplate(resource.uriTemplate).parts.flatMap((i) => (typeof i === "object" ? i.names : [])),
+        ]
+        : [resource.uri, []];
+    return new MCPResource({
+        client,
+        name: resource.name,
+        uri,
+        description: resource.description,
+        inputSchema: z.object(Object.fromEntries(variables.map((i) => [i, z.string()]))),
+        outputSchema: ReadResourceResultSchema,
+    });
+}
+function isResourceTemplate(resource) {
+    return typeof resource.uriTemplate === "string";
+}

package/lib/esm/utils/run-chat-loop.d.ts

@@ -1,10 +1,11 @@
-import type { AgentInput, AgentOutput } from "../agents/agent";
-import type { UserAgent } from "../execution-engine";
+import type { Message } from "../agents/agent.js";
+import type { UserAgent } from "../agents/user-agent.js";
 export interface ChatLoopOptions {
     log?: typeof console.log;
-    initialCall?: AgentInput | string;
+    initialCall?: Message | string;
     welcome?: string;
     defaultQuestion?: string;
-    onResponse?: (response: AgentOutput) => void;
+    onResponse?: (response: Message) => void;
+    inputKey?: string;
 }
 export declare function runChatLoopInTerminal(userAgent: UserAgent, { log, ...options }?: ChatLoopOptions): Promise<void>;

package/lib/esm/utils/run-chat-loop.js

@@ -1,13 +1,26 @@
 import inquirer from "inquirer";
-import { logger } from "./logger";
+import { logger } from "./logger.js";
 export async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console), ...options } = {}) {
+    let isLoopExited = false;
+    let prompt;
     if (options?.welcome)
         log(options.welcome);
     if (options?.initialCall) {
         await callAgent(userAgent, options.initialCall, { ...options, log });
     }
+    (async () => {
+        for await (const output of userAgent.stream) {
+            if (isLoopExited)
+                return;
+            if (options?.onResponse)
+                options.onResponse(output);
+            else
+                log(output);
+            prompt?.ui.close();
+        }
+    })();
     for (let i = 0;; i++) {
-        const { question } = await inquirer.prompt([
+        prompt = inquirer.prompt([
             {
                 type: "input",
                 name: "question",
@@ -15,7 +28,14 @@ export async function runChatLoopInTerminal(userAgent, { log = console.log.bind(
                 default: i === 0 ? options?.defaultQuestion : undefined,
             },
         ]);
-        if (!question.trim())
+        let question;
+        try {
+            question = (await prompt).question;
+        }
+        catch {
+            // ignore abort error from inquirer
+        }
+        if (!question?.trim())
             continue;
         const cmd = COMMANDS[question.trim()];
         if (cmd) {
@@ -28,9 +48,10 @@ export async function runChatLoopInTerminal(userAgent, { log = console.log.bind(
         }
         await callAgent(userAgent, question, { ...options, log });
     }
+    isLoopExited = true;
 }
 async function callAgent(agent, input, options) {
-    const response = await logger.spinner(agent.call(input), "🤖");
+    const response = await logger.spinner(agent.call(options.inputKey && typeof input === "string" ? { [options.inputKey]: input } : input), "🤖");
     if (options?.onResponse)
         options.onResponse(response);
     else

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

@@ -1,4 +1,7 @@
+export type PromiseOrValue<T> = T | Promise<T>;
+export type Nullish<T> = T | null | undefined;
 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 orArrayToArray<T>(value?: T | T[]): T[];
 export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
 export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;

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

@@ -1,8 +1,10 @@
-import { get as _get } from "lodash";
-import isNil from "lodash/isNil";
+import { get as _get, isNil } from "lodash-es";
 export function isNonNullable(value) {
     return !isNil(value);
 }
+export function isNotEmpty(arr) {
+    return arr.length > 0;
+}
 export function orArrayToArray(value) {
     if (isNil(value))
         return [];

package/package.json

@@ -1,13 +1,25 @@
 {
   "name": "@aigne/core",
-  "version": "1.1.0-beta.5",
-  "description": "AIGNE core library",
+  "version": "1.3.0",
+  "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
   },
   "author": "Arcblock <blocklet@arcblock.io> https://github.com/blocklet",
-  "homepage": "https://github.com/blocklet/ai-studio#readme",
+  "homepage": "https://github.com/AIGNE-io/aigne-framework",
   "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AIGNE-io/aigne-framework"
+  },
+  "files": [
+    "lib/cjs",
+    "lib/dts",
+    "lib/esm",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "type": "module",
   "main": "./lib/cjs/index.js",
   "module": "./lib/esm/index.js",
@@ -19,51 +31,40 @@
       "types": "./lib/dts/index.d.ts"
     }
   },
-  "files": [
-    "lib/cjs",
-    "lib/dts",
-    "lib/esm",
-    "LICENSE",
-    "README.md",
-    "CHANGELOG.md"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/blocklet/ai-studio.git"
-  },
   "dependencies": {
-    "@google/generative-ai": "^0.24.0",
-    "@modelcontextprotocol/sdk": "^1.6.1",
-    "@n8n/json-schema-to-zod": "^1.1.0",
+    "@aigne/json-schema-to-zod": "^1.3.2",
+    "@modelcontextprotocol/sdk": "^1.7.0",
     "@types/debug": "^4.1.12",
     "@types/mustache": "^4.2.5",
     "debug": "^4.4.0",
-    "inquirer": "^12.4.3",
-    "lodash": "^4.17.21",
+    "inquirer": "^12.5.0",
+    "lodash-es": "^4.17.21",
     "mustache": "^4.2.0",
-    "nanoid": "^5.1.3",
-    "openai": "^4.86.2",
+    "nanoid": "^5.1.5",
     "ora": "^8.2.0",
     "zod": "^3.24.2",
-    "zod-to-json-schema": "^3.24.3"
+    "zod-to-json-schema": "^3.24.5"
   },
   "peerDependencies": {
-    "@google/generative-ai": "^0.21.0",
-    "openai": "^4.79.1"
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@google/generative-ai": "^0.24.0",
+    "openai": "^4.87.3"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.4",
-    "@types/lodash": "^4.17.16",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@google/generative-ai": "^0.24.0",
+    "@types/bun": "^1.2.5",
+    "@types/lodash-es": "^4.17.12",
     "npm-run-all": "^4.1.5",
+    "openai": "^4.89.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.2"
   },
   "scripts": {
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
+    "lint": "tsc --noEmit",
     "build": "tsc --build scripts/tsconfig.build.json",
     "clean": "rimraf lib coverage",
     "test": "bun test",
-    "test:coverage": "bun test --coverage --coverage-reporter lcov"
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text"
   }
 }