@arki-moe/agent-ts 2.2.1 → 2.2.3

package/README.md

@@ -53,7 +53,7 @@ When `apiKey` is not provided in config, adapters read from the corresponding en
 - `Agent(adapterName, config)` - Create Agent
 - `agent.context` - Public property, complete conversation history
 - `agent.registerTool(tool)` - Register tool
-- `agent.run(message)` - Execute tool chain automatically, returns all new `Message[]`
+- `agent.run(message, options?)` - Execute tool chain automatically, returns all new `Message[]`
 - `agent.fork()` - Create a new agent with a copied context
 
 ### Config
@@ -68,7 +68,7 @@ When `apiKey` is not provided in config, adapters read from the corresponding en
 | `onToolCall` | `(message, args) => boolean \| void \| Promise<boolean \| void>` | Called before each tool execution; return `false` to skip tool execution and `onToolResult` |
 | `onToolResult` | `(message) => void \| Promise<void>` | Called after each tool execution (`message.role === Role.ToolResult`) |
 
-`agent.run` always appends new messages to `agent.context`. Multiple tool calls in a single model response are executed in parallel.
+`agent.run` always appends new messages to `agent.context`. Set `options.once = true` to avoid persisting the user message (useful for one-shot hints). Multiple tool calls in a single model response are executed in parallel.
 
 `onToolCall` receives parsed JSON args and can mutate them before execution. Returning `false` skips the tool call and does not emit a `ToolResult` message.
 

package/dist/adapter/openai.js

@@ -66,6 +66,24 @@ async function openaiAdapter(config, context, tools) {
     }
     if (onStream) {
         let content = "";
+        const toolCalls = new Map();
+        const upsertToolCall = (tc) => {
+            const index = typeof tc?.index === "number" ? tc.index : toolCalls.size;
+            let entry = toolCalls.get(index);
+            if (!entry) {
+                entry = { args: "" };
+                toolCalls.set(index, entry);
+            }
+            if (typeof tc?.id === "string")
+                entry.id = tc.id;
+            const fn = tc?.function;
+            if (fn) {
+                if (typeof fn.name === "string")
+                    entry.name = fn.name;
+                if (typeof fn.arguments === "string")
+                    entry.args += fn.arguments;
+            }
+        };
         await (0, sse_1.readSse)(res, async (dataLine) => {
             if (dataLine === "[DONE]")
                 return;
@@ -79,11 +97,30 @@ async function openaiAdapter(config, context, tools) {
             const delta = parsed?.choices?.[0]?.delta;
             if (!delta)
                 return;
+            if (Array.isArray(delta.tool_calls)) {
+                for (const tc of delta.tool_calls) {
+                    upsertToolCall(tc);
+                }
+            }
             if (typeof delta.content === "string") {
                 content += delta.content;
                 await Promise.resolve(onStream(delta.content));
             }
         });
+        if (toolCalls.size > 0) {
+            return [...toolCalls.entries()]
+                .sort((a, b) => a[0] - b[0])
+                .map(([index, tc]) => {
+                if (!tc.name)
+                    throw new Error(`OpenAI streaming tool call missing function name at index ${index}`);
+                return {
+                    role: types_1.Role.ToolCall,
+                    toolName: tc.name,
+                    callId: tc.id ?? `call_${index}`,
+                    argsText: tc.args.length ? tc.args : "{}",
+                };
+            });
+        }
         return [{ role: types_1.Role.Ai, content }];
     }
     const text = await res.text();

package/dist/adapter/openrouter.js

@@ -76,6 +76,24 @@ async function openrouterAdapter(config, context, tools) {
     }
     if (onStream) {
         let content = "";
+        const toolCalls = new Map();
+        const upsertToolCall = (tc) => {
+            const index = typeof tc?.index === "number" ? tc.index : toolCalls.size;
+            let entry = toolCalls.get(index);
+            if (!entry) {
+                entry = { args: "" };
+                toolCalls.set(index, entry);
+            }
+            if (typeof tc?.id === "string")
+                entry.id = tc.id;
+            const fn = tc?.function;
+            if (fn) {
+                if (typeof fn.name === "string")
+                    entry.name = fn.name;
+                if (typeof fn.arguments === "string")
+                    entry.args += fn.arguments;
+            }
+        };
         await (0, sse_1.readSse)(res, async (dataLine) => {
             if (dataLine === "[DONE]")
                 return;
@@ -89,11 +107,30 @@ async function openrouterAdapter(config, context, tools) {
             const delta = parsed?.choices?.[0]?.delta;
             if (!delta)
                 return;
+            if (Array.isArray(delta.tool_calls)) {
+                for (const tc of delta.tool_calls) {
+                    upsertToolCall(tc);
+                }
+            }
             if (typeof delta.content === "string") {
                 content += delta.content;
                 await Promise.resolve(onStream(delta.content));
             }
         });
+        if (toolCalls.size > 0) {
+            return [...toolCalls.entries()]
+                .sort((a, b) => a[0] - b[0])
+                .map(([index, tc]) => {
+                if (!tc.name)
+                    throw new Error(`OpenRouter streaming tool call missing function name at index ${index}`);
+                return {
+                    role: types_1.Role.ToolCall,
+                    toolName: tc.name,
+                    callId: tc.id ?? `call_${index}`,
+                    argsText: tc.args.length ? tc.args : "{}",
+                };
+            });
+        }
         return [{ role: types_1.Role.Ai, content }];
     }
     const text = await res.text();

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import type { AgentConfig, Context, Message, Tool } from "./types";
+import type { AgentConfig, Context, Message, RunOptions, Tool } from "./types";
 export { openaiAdapter } from "./adapter/openai";
 export { openrouterAdapter } from "./adapter/openrouter";
-export type { Adapter, AgentConfig, Context, Message, Tool } from "./types";
+export type { Adapter, AgentConfig, Context, Message, RunOptions, Tool } from "./types";
 export { Role } from "./types";
 export declare class Agent {
     context: Context;
@@ -14,6 +14,6 @@ export declare class Agent {
     private onToolResult?;
     constructor(adapterName: string, config: AgentConfig);
     registerTool(tool: Tool): void;
-    run(message: string): Promise<Message[]>;
+    run(message: string, options?: RunOptions): Promise<Message[]>;
     fork(): Agent;
 }

package/dist/index.js

@@ -28,15 +28,31 @@ class Agent {
     registerTool(tool) {
         this.tools.push(tool);
     }
-    async run(message) {
-        this.context.push({ role: types_1.Role.User, content: message });
+    async run(message, options = {}) {
+        const once = options.once ?? false;
         const all = [];
-        let msgs = await this.adapter(this.config, this.context, this.tools);
-        this.context.push(...msgs);
-        all.push(...msgs);
+        const sessionContext = [...this.context];
+        const persistToContext = (msgs) => {
+            this.context.push(...msgs);
+        };
+        const pushToSession = (msgs) => {
+            sessionContext.push(...msgs);
+        };
+        const userMessage = { role: types_1.Role.User, content: message };
+        pushToSession([userMessage]);
+        if (!once)
+            persistToContext([userMessage]);
+        const runAdapter = async () => {
+            const msgs = await this.adapter(this.config, sessionContext, this.tools);
+            pushToSession(msgs);
+            persistToContext(msgs);
+            all.push(...msgs);
+            return msgs;
+        };
+        let msgs = await runAdapter();
         for (;;) {
             const last = msgs[msgs.length - 1];
-            if (this.endCondition(this.context, last))
+            if (this.endCondition(sessionContext, last))
                 return all;
             const toolCalls = msgs.filter((m) => m.role === types_1.Role.ToolCall);
             if (toolCalls.length === 0)
@@ -81,11 +97,10 @@ class Agent {
                 return result;
             }));
             const filteredResults = results.filter((result) => result !== null);
-            this.context.push(...filteredResults);
+            pushToSession(filteredResults);
+            persistToContext(filteredResults);
             all.push(...filteredResults);
-            msgs = await this.adapter(this.config, this.context, this.tools);
-            this.context.push(...msgs);
-            all.push(...msgs);
+            msgs = await runAdapter();
         }
     }
     fork() {

package/dist/types.d.ts

@@ -43,4 +43,7 @@ export type AgentConfig = {
     }>) => void | Promise<void>;
     [key: string]: unknown;
 };
+export type RunOptions = {
+    once?: boolean;
+};
 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": "2.2.1",
+  "version": "2.2.3",
   "description": "Minimal Agent library, zero dependencies",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",