@aigne/core 1.63.0-beta → 1.63.0-beta.10

package/lib/esm/agents/ai-agent.js

@@ -1,3 +1,4 @@
+import fastq from "fastq";
 import { z } from "zod";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "../prompt/prompts/structured-stream-instructions.js";
@@ -5,6 +6,7 @@ import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js
 import { ExtractMetadataTransform } from "../utils/structured-stream-extractor.js";
 import { checkArguments, isEmpty } from "../utils/type-utils.js";
 import { Agent, agentOptionsSchema, isAgentResponseDelta, } from "./agent.js";
+import { fileUnionContentsSchema } from "./model.js";
 import { isTransferAgentOutput } from "./types.js";
 export const DEFAULT_OUTPUT_KEY = "message";
 export const DEFAULT_OUTPUT_FILE_KEY = "files";
@@ -55,6 +57,7 @@ export const aiAgentOptionsSchema = agentOptionsSchema.extend({
     inputKey: z.string().optional(),
     outputKey: z.string().optional(),
     toolChoice: aiAgentToolChoiceSchema.optional(),
+    toolCallsConcurrency: z.number().int().min(0).optional(),
     keepTextInToolUses: z.boolean().optional(),
     memoryAgentsAsTools: z.boolean().optional(),
     memoryPromptTemplate: z.string().optional(),
@@ -108,12 +111,15 @@ export class AIAgent extends Agent {
             typeof options.instructions === "string"
                 ? PromptBuilder.from(options.instructions)
                 : (options.instructions ?? new PromptBuilder());
+        this.autoReorderSystemMessages = options.autoReorderSystemMessages ?? false;
+        this.autoMergeSystemMessages = options.autoMergeSystemMessages ?? false;
         this.inputKey = options.inputKey;
         this.inputFileKey = options.inputFileKey;
         this.outputKey = options.outputKey || DEFAULT_OUTPUT_KEY;
         this.outputFileKey = options.outputFileKey || DEFAULT_OUTPUT_FILE_KEY;
         this.outputFileType = options.outputFileType;
         this.toolChoice = options.toolChoice;
+        this.toolCallsConcurrency = options.toolCallsConcurrency || 1;
         this.keepTextInToolUses = options.keepTextInToolUses;
         this.memoryAgentsAsTools = options.memoryAgentsAsTools;
         this.memoryPromptTemplate = options.memoryPromptTemplate;
@@ -143,6 +149,8 @@ export class AIAgent extends Agent {
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-prompt-builder}
      */
     instructions;
+    autoReorderSystemMessages;
+    autoMergeSystemMessages;
     /**
      * Pick a message from input to use as the user's message
      */
@@ -170,6 +178,12 @@ export class AIAgent extends Agent {
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-router}
      */
     toolChoice;
+    /**
+     * Maximum number of tool calls to execute concurrently
+     *
+     * @default 1
+     */
+    toolCallsConcurrency;
     /**
      * Whether to preserve text generated during tool usage in the final output
      */
@@ -227,6 +241,20 @@ export class AIAgent extends Agent {
      * which outputs structured data in YAML format within <metadata> tags.
      */
     customStructuredStreamInstructions;
+    get inputSchema() {
+        let schema = super.inputSchema;
+        if (this.inputKey) {
+            schema = schema.extend({
+                [this.inputKey]: z.string().nullish(),
+            });
+        }
+        if (this.inputFileKey) {
+            schema = schema.extend({
+                [this.inputFileKey]: fileUnionContentsSchema.nullish(),
+            });
+        }
+        return schema;
+    }
     /**
      * Process an input message and generate a response
      *
@@ -284,31 +312,43 @@ export class AIAgent extends Agent {
                     yield { delta: { text: { [outputKey]: "\n" } } };
                 }
                 const executedToolCalls = [];
+                let error;
+                const queue = fastq.promise(async ({ tool, call }) => {
+                    try {
+                        // NOTE: should pass both arguments (model generated) and input (user provided) to the tool
+                        const output = await this.invokeSkill(tool, { ...input, ...call.function.arguments }, options).catch((error) => {
+                            if (!this.catchToolsError) {
+                                return Promise.reject(error);
+                            }
+                            return {
+                                isError: true,
+                                error: {
+                                    message: error.message,
+                                },
+                            };
+                        });
+                        executedToolCalls.push({ call, output });
+                    }
+                    catch (e) {
+                        error = e;
+                        queue.killAndDrain();
+                    }
+                }, this.toolCallsConcurrency || 1);
                 // Execute tools
                 for (const call of toolCalls) {
                     const tool = toolsMap.get(call.function.name);
                     if (!tool)
                         throw new Error(`Tool not found: ${call.function.name}`);
-                    // NOTE: should pass both arguments (model generated) and input (user provided) to the tool
-                    const output = await this.invokeSkill(tool, { ...input, ...call.function.arguments }, options).catch((error) => {
-                        if (!this.catchToolsError) {
-                            return Promise.reject(error);
-                        }
-                        return {
-                            isError: true,
-                            error: {
-                                message: error.message,
-                            },
-                        };
-                    });
-                    // NOTE: Return transfer output immediately
-                    if (isTransferAgentOutput(output)) {
-                        return output;
-                    }
-                    executedToolCalls.push({ call, output });
+                    queue.push({ tool, call });
                 }
+                await queue.drained();
+                if (error)
+                    throw error;
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
+                    const transferOutput = executedToolCalls.find((i) => isTransferAgentOutput(i.output))?.output;
+                    if (transferOutput)
+                        return transferOutput;
                     toolCallMessages.push(await AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...(await Promise.all(executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()))));
                     continue;
                 }

package/lib/esm/agents/chat-model.js

@@ -6,7 +6,7 @@ import { checkArguments, isNil, omitByDeep } from "../utils/type-utils.js";
 import { agentOptionsSchema, } from "./agent.js";
 import { fileContentSchema, fileUnionContentSchema, localContentSchema, Model, urlContentSchema, } from "./model.js";
 const CHAT_MODEL_DEFAULT_RETRY_OPTIONS = {
-    retries: 3,
+    retries: 10,
     shouldRetry: async (error) => error instanceof StructuredOutputError || (await import("is-network-error")).default(error),
 };
 export class StructuredOutputError extends Error {

package/lib/esm/loader/agent-yaml.d.ts

@@ -1,5 +1,6 @@
+import type { AFSOptions } from "@aigne/afs";
 import { type ZodType, z } from "zod";
-import type { AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
+import type { AFSConfig, AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { type Role } from "../agents/chat-model.js";
 import { ProcessMode, type ReflectionMode } from "../agents/team-agent.js";
@@ -19,6 +20,10 @@ export type NestAgentSchema = string | {
     defaultInput?: Record<string, any>;
     hooks?: HooksSchema | HooksSchema[];
 } | AgentSchema;
+export type AFSModuleSchema = string | {
+    module: string;
+    options?: Record<string, any>;
+};
 export interface BaseAgentSchema {
     name?: string;
     description?: string;
@@ -36,6 +41,10 @@ export interface BaseAgentSchema {
         provider: string;
         subscribeTopic?: string[];
     };
+    afs?: boolean | (Omit<AFSOptions, "modules"> & {
+        modules?: AFSModuleSchema[];
+    });
+    afsConfig?: AFSConfig;
 }
 export type Instructions = {
     role: Exclude<Role, "tool">;
@@ -45,9 +54,13 @@ export type Instructions = {
 export interface AIAgentSchema extends BaseAgentSchema {
     type: "ai";
     instructions?: Instructions;
+    autoReorderSystemMessages?: boolean;
+    autoMergeSystemMessages?: boolean;
     inputKey?: string;
+    inputFileKey?: string;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    toolCallsConcurrency?: number;
     keepTextInToolUses?: boolean;
 }
 export interface ImageAgentSchema extends BaseAgentSchema {

package/lib/esm/loader/agent-yaml.js

@@ -49,6 +49,25 @@ export async function parseAgentFile(path, data) {
                     subscribeTopic: optionalize(z.array(z.string())),
                 })),
             ])),
+            afs: optionalize(z.union([
+                z.boolean(),
+                camelizeSchema(z.object({
+                    storage: optionalize(z.object({
+                        url: optionalize(z.string()),
+                    })),
+                    modules: optionalize(z.array(z.union([
+                        z.string(),
+                        z.object({
+                            module: z.string(),
+                            options: optionalize(z.record(z.any())),
+                        }),
+                    ]))),
+                })),
+            ])),
+            afsConfig: optionalize(camelizeSchema(z.object({
+                injectHistory: optionalize(z.boolean()),
+                historyWindowSize: optionalize(z.number().int().min(1)),
+            }))),
         });
         const instructionItemSchema = z.union([
             z.object({
@@ -89,9 +108,14 @@ export async function parseAgentFile(path, data) {
                 .object({
                 type: z.literal("ai"),
                 instructions: optionalize(instructionsSchema),
+                autoReorderSystemMessages: optionalize(z.boolean()),
+                autoMergeSystemMessages: optionalize(z.boolean()),
                 inputKey: optionalize(z.string()),
                 outputKey: optionalize(z.string()),
+                inputFileKey: optionalize(z.string()),
+                outputFileKey: optionalize(z.string()),
                 toolChoice: optionalize(z.nativeEnum(AIAgentToolChoice)),
+                toolCallsConcurrency: optionalize(z.number().int().min(0)),
                 keepTextInToolUses: optionalize(z.boolean()),
                 structuredStreamMode: optionalize(z.boolean()),
             })

package/lib/esm/loader/index.d.ts

@@ -1,3 +1,4 @@
+import { type AFSModule } from "@aigne/afs";
 import { type ZodType, z } from "zod";
 import { Agent, type AgentOptions } from "../agents/agent.js";
 import type { ChatModel } from "../agents/chat-model.js";
@@ -11,6 +12,12 @@ export interface LoadOptions {
     }[];
     model?: ChatModel | ((model?: z.infer<typeof aigneFileSchema>["model"]) => PromiseOrValue<ChatModel | undefined>);
     imageModel?: ImageModel | ((model?: z.infer<typeof aigneFileSchema>["imageModel"]) => PromiseOrValue<ImageModel | undefined>);
+    afs?: {
+        availableModules?: {
+            module: string;
+            create: (options?: Record<string, any>) => PromiseOrValue<AFSModule>;
+        }[];
+    };
 }
 export declare function load(path: string, options?: LoadOptions): Promise<AIGNEOptions>;
 export declare function loadAgent(path: string, options?: LoadOptions, agentOptions?: AgentOptions): Promise<Agent>;

package/lib/esm/loader/index.js

@@ -1,3 +1,4 @@
+import { AFS } from "@aigne/afs";
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { parse } from "yaml";
 import { z } from "zod";
@@ -107,6 +108,26 @@ async function parseAgent(path, agent, options, agentOptions) {
     const memory = "memory" in agent && options?.memories?.length
         ? await loadMemory(options.memories, typeof agent.memory === "object" ? agent.memory.provider : undefined, typeof agent.memory === "object" ? agent.memory : {})
         : undefined;
+    let afs;
+    if (typeof agent.afs === "boolean") {
+        if (agent.afs) {
+            afs = new AFS();
+        }
+    }
+    else if (agent.afs) {
+        afs = new AFS({
+            ...agent.afs,
+            modules: agent.afs.modules &&
+                (await Promise.all(agent.afs.modules.map((m) => {
+                    const mod = typeof m === "string"
+                        ? options?.afs?.availableModules?.find((mod) => mod.module === m)
+                        : options?.afs?.availableModules?.find((mod) => mod.module === m.module);
+                    if (!mod)
+                        throw new Error(`AFS module not found: ${typeof m === "string" ? m : m.module}`);
+                    return mod.create(typeof m === "string" ? {} : m.options);
+                }))),
+        });
+    }
     const model = agent.model && typeof options?.model === "function"
         ? await options.model(agent.model)
         : undefined;
@@ -124,6 +145,7 @@ async function parseAgent(path, agent, options, agentOptions) {
             ...((await parseHooks(path, agent.hooks, options)) ?? []),
             ...[agentOptions?.hooks].flat().filter(isNonNullable),
         ],
+        afs,
     };
     let instructions;
     if ("instructions" in agent && agent.instructions) {

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

@@ -31,6 +31,7 @@ export declare class PromptBuilder {
         prompt: string;
     }>;
     private buildMessages;
+    private refineMessages;
     private convertMemoriesToMessages;
     private buildResponseFormat;
     private buildTools;

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

@@ -8,9 +8,11 @@ import { DEFAULT_OUTPUT_FILE_KEY, DEFAULT_OUTPUT_KEY } from "../agents/ai-agent.
 import { fileUnionContentsSchema } from "../agents/model.js";
 import { optionalize } from "../loader/schema.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { checkArguments, flat, isNonNullable, isRecord, unique } from "../utils/type-utils.js";
+import { checkArguments, flat, isNonNullable, isRecord, partition, unique, } from "../utils/type-utils.js";
+import { getAFSSystemPrompt } from "./prompts/afs-builtin-prompt.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "./prompts/structured-stream-instructions.js";
+import { getAFSSkills } from "./skills/afs.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export class PromptBuilder {
     static from(instructions, { workingDir } = {}) {
@@ -67,7 +69,7 @@ export class PromptBuilder {
                 ? undefined
                 : this.buildResponseFormat(options),
             outputFileType: options.agent?.outputFileType,
-            ...this.buildTools(options),
+            ...(await this.buildTools(options)),
         };
     }
     async buildImagePrompt(options) {
@@ -82,9 +84,9 @@ export class PromptBuilder {
         const { input } = options;
         const inputKey = options.agent?.inputKey;
         const message = inputKey && typeof input?.[inputKey] === "string" ? input[inputKey] : undefined;
-        const messages = (await (typeof this.instructions === "string"
+        const [messages, otherCustomMessages] = partition((await (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
-            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [];
+            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [], (i) => i.role === "system");
         const inputFileKey = options.agent?.inputFileKey;
         const files = flat(inputFileKey
             ? checkArguments("Check input files", optionalize(fileUnionContentsSchema), input?.[inputFileKey])
@@ -97,16 +99,19 @@ export class PromptBuilder {
             memories.push(...options.context.memories);
         }
         if (options.agent?.afs) {
-            const history = await options.agent.afs.list(AFSHistory.Path, {
-                limit: options.agent.maxRetrieveMemoryCount || 1,
-                orderBy: [["createdAt", "desc"]],
-            });
-            if (message) {
-                const result = await options.agent.afs.search("/", message);
-                const ms = result.list.map((entry) => ({ content: stringify(entry.content) }));
-                memories.push(...ms);
+            messages.push(await SystemMessageTemplate.from(await getAFSSystemPrompt(options.agent.afs)).format({}));
+            if (options.agent.afsConfig?.injectHistory) {
+                const history = await options.agent.afs.list(AFSHistory.Path, {
+                    limit: options.agent.afsConfig.historyWindowSize || 10,
+                    orderBy: [["createdAt", "desc"]],
+                });
+                if (message) {
+                    const result = await options.agent.afs.search("/", message);
+                    const ms = result.list.map((entry) => ({ content: stringify(entry.content) }));
+                    memories.push(...ms);
+                }
+                memories.push(...history.list.filter((i) => isNonNullable(i.content)));
             }
-            memories.push(...history.list.filter((i) => isNonNullable(i.content)));
         }
         if (memories.length)
             messages.push(...(await this.convertMemoriesToMessages(memories, options)));
@@ -124,13 +129,46 @@ export class PromptBuilder {
         }
         if (message || files.length) {
             const content = [];
-            if (message)
+            if (message &&
+                // avoid duplicate user messages: developer may have already included the message in the custom user messages
+                !otherCustomMessages.some((i) => i.role === "user" &&
+                    (typeof i.content === "string"
+                        ? i.content.includes(message)
+                        : i.content?.some((c) => c.type === "text" && c.text.includes(message))))) {
                 content.push({ type: "text", text: message });
+            }
             if (files.length)
                 content.push(...files);
-            messages.push({ role: "user", content });
+            if (content.length) {
+                messages.push({ role: "user", content });
+            }
         }
-        return messages;
+        messages.push(...otherCustomMessages);
+        return this.refineMessages(options, messages);
+    }
+    refineMessages(options, messages) {
+        const { autoReorderSystemMessages, autoMergeSystemMessages } = options.agent ?? {};
+        if (!autoReorderSystemMessages && !autoMergeSystemMessages)
+            return messages;
+        const [systemMessages, otherMessages] = partition(messages, (m) => m.role === "system");
+        if (!autoMergeSystemMessages) {
+            return systemMessages.concat(otherMessages);
+        }
+        const result = [];
+        if (systemMessages.length) {
+            result.push({
+                role: "system",
+                content: systemMessages
+                    .map((i) => typeof i.content === "string"
+                    ? i.content
+                    : i.content
+                        ?.map((c) => (c.type === "text" ? c.text : null))
+                        .filter(isNonNullable)
+                        .join("\n"))
+                    .join("\n"),
+            });
+        }
+        return result.concat(otherMessages);
     }
     async convertMemoriesToMessages(memories, options) {
         const messages = [];
@@ -213,11 +251,14 @@ export class PromptBuilder {
             }
             : undefined;
     }
-    buildTools(options) {
+    async buildTools(options) {
         const toolAgents = unique((options.context?.skills ?? [])
             .concat(options.agent?.skills ?? [])
             .concat(options.agent?.memoryAgentsAsTools ? options.agent.memories : [])
             .flatMap((i) => (i.isInvokable ? i : i.skills)), (i) => i.name);
+        if (options.agent?.afs) {
+            toolAgents.push(...(await getAFSSkills(options.agent.afs)));
+        }
         const tools = toolAgents.map((i) => ({
             type: "function",
             function: {

package/lib/esm/prompt/prompts/afs-builtin-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { AFS } from "@aigne/afs";
+export declare function getAFSSystemPrompt(afs: AFS): Promise<string>;

package/lib/esm/prompt/prompts/afs-builtin-prompt.js

@@ -0,0 +1,20 @@
+import { stringify } from "yaml";
+export async function getAFSSystemPrompt(afs) {
+    return `\
+
+<afs_usage>
+AFS (AIGNE File System) provides tools to interact with a virtual file system, allowing you to list, search, read, and write files. Use these tools to manage and retrieve files as needed.
+
+Modules:
+${stringify(await afs.listModules())}
+
+Available Tools:
+1. afs_list: Browse directory contents like filesystem ls/tree command - shows files and folders in a given path
+2. afs_search: Find files by content keywords - use specific keywords related to what you're looking for
+3. afs_read: Read file contents - path must be an exact file path from list or search results
+4. afs_write: Write content to a file in the AFS
+
+Workflow: Use afs_list to browse directories, afs_search to find specific content, then afs_read to access file contents.
+</afs_usage>
+`;
+}

package/lib/esm/prompt/skills/afs.d.ts

@@ -0,0 +1,3 @@
+import type { AFS } from "@aigne/afs";
+import { type Agent } from "../../agents/agent.js";
+export declare function getAFSSkills(afs: AFS): Promise<Agent[]>;

package/lib/esm/prompt/skills/afs.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { FunctionAgent } from "../../agents/agent.js";
+export async function getAFSSkills(afs) {
+    return [
+        FunctionAgent.from({
+            name: "afs_list",
+            description: "Browse directory contents in the AFS like filesystem ls/tree command - shows files and folders in the specified path",
+            inputSchema: z.object({
+                path: z.string().describe("The directory path to browse (e.g., '/', '/docs', '/src')"),
+                options: z
+                    .object({
+                    recursive: z.boolean().optional().describe("Whether to list files recursively"),
+                    maxDepth: z.number().optional().describe("Maximum depth to list files"),
+                    limit: z.number().optional().describe("Maximum number of entries to return"),
+                })
+                    .optional(),
+            }),
+            process: async (input) => {
+                return afs.list(input.path, input.options);
+            },
+        }),
+        FunctionAgent.from({
+            name: "afs_search",
+            description: "Find files by searching content using keywords - returns matching files with their paths",
+            inputSchema: z.object({
+                path: z.string().describe("The directory path to search in (e.g., '/', '/docs')"),
+                query: z
+                    .string()
+                    .describe("Keywords to search for in file contents (e.g., 'function authentication', 'database config')"),
+                options: z
+                    .object({
+                    limit: z.number().optional().describe("Maximum number of entries to return"),
+                })
+                    .optional(),
+            }),
+            process: async (input) => {
+                return afs.search(input.path, input.query, input.options);
+            },
+        }),
+        FunctionAgent.from({
+            name: "afs_read",
+            description: "Read file contents from the AFS - path must be an exact file path from list or search results",
+            inputSchema: z.object({
+                path: z
+                    .string()
+                    .describe("Exact file path from list or search results (e.g., '/docs/api.md', '/src/utils/helper.js')"),
+            }),
+            process: async (input) => {
+                const file = await afs.read(input.path);
+                return {
+                    file,
+                };
+            },
+        }),
+        FunctionAgent.from({
+            name: "afs_write",
+            description: "Create or update a file in the AFS with new content - overwrites existing files",
+            inputSchema: z.object({
+                path: z
+                    .string()
+                    .describe("Full file path where to write content (e.g., '/docs/new-file.md', '/src/component.js')"),
+                content: z.string().describe("The text content to write to the file"),
+            }),
+            process: async (input) => {
+                const file = await afs.write(input.path, {
+                    content: input.content,
+                });
+                return { file };
+            },
+        }),
+    ];
+}

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

@@ -27,3 +27,4 @@ export declare function createAccessorArray<T>(array: T[], accessor: (array: T[]
 export declare function checkArguments<T extends ZodType>(prefix: string, schema: T, args: unknown): z.infer<T>;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;
+export declare function partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];

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

@@ -177,3 +177,16 @@ export function tryOrThrow(fn, error) {
             throw error;
     }
 }
+export function partition(array, predicate) {
+    const pass = [];
+    const fail = [];
+    for (const item of array) {
+        if (predicate(item)) {
+            pass.push(item);
+        }
+        else {
+            fail.push(item);
+        }
+    }
+    return [pass, fail];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.63.0-beta",
+  "version": "1.63.0-beta.10",
   "description": "The functional core of agentic AI",
   "publishConfig": {
     "access": "public"
@@ -92,9 +92,9 @@
     "zod": "^3.25.67",
     "zod-from-json-schema": "^0.0.5",
     "zod-to-json-schema": "^3.24.6",
-    "@aigne/observability-api": "^0.11.2-beta",
+    "@aigne/observability-api": "^0.11.2-beta.5",
     "@aigne/platform-helpers": "^0.6.3",
-    "@aigne/afs": "^1.0.0"
+    "@aigne/afs": "^1.1.0-beta"
   },
   "devDependencies": {
     "@types/bun": "^1.2.22",