@arki-moe/agent-ts 1.0.2 → 2.0.0

package/README.md

@@ -19,18 +19,16 @@ const getTimeTool: Tool = {
 const agent = new Agent("openai", {
   apiKey: "sk-...",
   model: "gpt-5-nano",
-  system: "You are a helpful assistant. Reply concisely.", // optional: system role
+  system: "You are a helpful assistant. Reply concisely.",
+  onToolCall: (msg) => console.log("tool call:", msg),
+  onToolResult: (msg) => console.log("tool result:", msg),
 });
 agent.registerTool(getTimeTool);
 
 // run: Executes tool chain automatically, returns new messages, context is maintained automatically
-const msgs = await agent.run({ role: Role.User, content: "What time is it?" });
+const msgs = await agent.run("What time is it?");
 console.log(msgs);
 
-// step: Single-step inference, returns new messages from the model
-const msgs2 = await agent.step({ role: Role.User, content: "Hello" });
-console.log(msgs2);
-
 // context is a public property that can be read directly
 console.log(agent.context);
 ```
@@ -46,15 +44,24 @@ When `apiKey` is not provided in config, adapters read from the corresponding en
 
 ## API
 
-- `Agent(adapterName, config)` - Create Agent, config contains `apiKey`, `model`, `system` (optional), etc.
+- `Agent(adapterName, config)` - Create Agent
 - `agent.context` - Public property, complete conversation history
 - `agent.registerTool(tool)` - Register tool
-- `agent.step(message?)` - Call model once, returns new `Message[]`
-- `agent.run(message, endCondition?)` - Execute tool chain automatically, returns all new `Message[]`
+- `agent.run(message)` - Execute tool chain automatically, returns all new `Message[]`
 - `agent.fork()` - Create a new agent with a copied context
 
-`agent.step` and `agent.run` always append new messages to `agent.context`.
-`endCondition` receives `(context, last)` and stops the run when it returns `true`. Defaults to `last.role === Role.Ai`.
+### Config
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `apiKey` | `string` | API key (or use env var) |
+| `model` | `string` | Model name |
+| `system` | `string` | Optional system prompt |
+| `endCondition` | `(context, last) => boolean` | Stop condition for `run`. Defaults to `last.role === Role.Ai` |
+| `onToolCall` | `(message) => void \| Promise<void>` | Called before each tool execution |
+| `onToolResult` | `(message) => void \| Promise<void>` | Called after each tool execution |
+
+`agent.run` always appends new messages to `agent.context`. Multiple tool calls in a single model response are executed in parallel.
 
 `agent.fork()` shallow-copies the context array, but message objects are shared. This means:
 - Shallow copy: `forked.context !== agent.context`, so pushing new messages does not affect the other agent.

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import type { Context, Message, Tool } from "./types";
+import type { AgentConfig, Context, Message, Tool } from "./types";
 export { openaiAdapter } from "./adapter/openai";
 export { openrouterAdapter } from "./adapter/openrouter";
-export type { Adapter, Context, Message, Tool } from "./types";
+export type { Adapter, AgentConfig, Context, Message, Tool } from "./types";
 export { Role } from "./types";
 export declare class Agent {
     context: Context;
@@ -9,9 +9,11 @@ export declare class Agent {
     private adapterName;
     private config;
     private tools;
-    constructor(adapterName: string, config: Record<string, unknown>);
+    private endCondition;
+    private onToolCall?;
+    private onToolResult?;
+    constructor(adapterName: string, config: AgentConfig);
     registerTool(tool: Tool): void;
-    step(message?: Message): Promise<Message[]>;
-    run(message: Message, endCondition?: (context: Message[], last: Message) => boolean): Promise<Message[]>;
+    run(message: string): Promise<Message[]>;
     fork(): Agent;
 }

package/dist/index.js

@@ -21,32 +21,32 @@ class Agent {
         this.adapterName = adapterName;
         this.adapter = adapters[adapterName] ?? (() => { throw new Error(`Adapter "${adapterName}" not found`); })();
         this.config = config;
+        this.endCondition = config.endCondition ?? ((_ctx, last) => last.role === types_1.Role.Ai);
+        this.onToolCall = config.onToolCall;
+        this.onToolResult = config.onToolResult;
     }
     registerTool(tool) {
         this.tools.push(tool);
     }
-    async step(message) {
-        if (message) {
-            this.context.push(message);
-        }
-        const msgs = await this.adapter(this.config, this.context, this.tools);
-        this.context.push(...msgs);
-        return msgs;
-    }
-    async run(message, endCondition = (_context, last) => last.role === types_1.Role.Ai) {
+    async run(message) {
+        this.context.push({ role: types_1.Role.User, content: message });
         const all = [];
-        let msgs = await this.step(message);
+        let msgs = await this.adapter(this.config, this.context, this.tools);
+        this.context.push(...msgs);
         all.push(...msgs);
         for (;;) {
             const last = msgs[msgs.length - 1];
-            if (endCondition(this.context, last))
+            if (this.endCondition(this.context, last))
+                return all;
+            const toolCalls = msgs.filter((m) => m.role === types_1.Role.ToolCall);
+            if (toolCalls.length === 0)
                 return all;
-            for (const m of msgs) {
-                if (m.role !== types_1.Role.ToolCall)
-                    continue;
+            const results = await Promise.all(toolCalls.map(async (m) => {
                 const tool = this.tools.find((t) => t.name === m.toolName);
                 if (!tool)
                     throw new Error(`Tool "${m.toolName}" is not registered`);
+                if (this.onToolCall)
+                    await Promise.resolve(this.onToolCall(m));
                 let content;
                 let isError = false;
                 try {
@@ -59,10 +59,14 @@ class Agent {
                     content = err instanceof Error ? err.message : String(err);
                 }
                 const result = { role: types_1.Role.ToolResult, callId: m.callId, content, isError };
-                this.context.push(result);
-                all.push(result);
-            }
-            msgs = await this.step();
+                if (this.onToolResult)
+                    await Promise.resolve(this.onToolResult(result));
+                return result;
+            }));
+            this.context.push(...results);
+            all.push(...results);
+            msgs = await this.adapter(this.config, this.context, this.tools);
+            this.context.push(...msgs);
             all.push(...msgs);
         }
     }

package/dist/types.d.ts

@@ -32,4 +32,10 @@ export type Tool = {
     parameters: unknown;
     execute: (args: unknown) => Promise<unknown> | unknown;
 };
+export type AgentConfig = {
+    endCondition?: (context: Message[], last: Message) => boolean;
+    onToolCall?: (message: Message) => void | Promise<void>;
+    onToolResult?: (message: Message) => void | Promise<void>;
+    [key: string]: unknown;
+};
 export type Adapter = (config: Record<string, unknown>, context: Message[], tools: Tool[]) => Promise<Message[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arki-moe/agent-ts",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Minimal Agent library, zero dependencies",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",