@arki-moe/agent-ts 5.1.0 → 5.2.0

package/README.md

@@ -47,6 +47,7 @@ console.log(agent.context);
 |---------|----------|----------|
 | `openai` | `apiKey` (or `OPENAI_API_KEY` env), `model` | `system`, `baseUrl` |
 | `openrouter` | `apiKey` (or `OPENROUTER_API_KEY` env), `model` | `system`, `baseUrl`, `httpReferer`, `title` |
+| `selfhost_chat_completions` | `apiKey` (or `SELFHOST_API_KEY` env), `model` | `system`, `baseUrl` |
 
 When `apiKey` is not provided in config, adapters read from the corresponding environment variable. An error is thrown only when both are missing.
 
@@ -67,6 +68,7 @@ When `apiKey` is not provided in config, adapters read from the corresponding en
 | `endCondition` | `(context, last) => boolean` | Stop condition for `run`. Defaults to `last.role === Role.Ai` |
 | `onStream` | `(textDelta: string) => void \| Promise<void>` | Stream hook for AI text only. When provided, adapters use SSE streaming and still return the final `Message[]`. |
 | `isAbort` | `() => boolean \| Promise<boolean>` | Abort hook polled during `run`; return `true` to stop early and return partial results. |
+| `toolChoice` | `"auto" \| "required" \| "none" \| object` | Tool choice passed to adapters. Defaults to `auto` when tools are provided. |
 | `onToolCall` | `(message, args, agent) => boolean \| void \| Promise<boolean \| void>` | Called before each tool execution; return `false` to skip tool execution and `onToolResult` |
 | `onToolResult` | `(message, agent) => void \| Promise<void>` | Called after each tool execution (`message.role === Role.ToolResult`) |
 

package/dist/adapter/openai.js

@@ -31,6 +31,7 @@ async function openaiAdapter(config, context, tools) {
     const baseUrl = config.baseUrl ?? "https://api.openai.com";
     const apiKey = config.apiKey || process.env.OPENAI_API_KEY || "";
     const model = config.model ?? "gpt-5-nano";
+    const toolChoice = config.toolChoice;
     const onStream = config.onStream;
     const { check, isAborted } = (0, abort_1.createAbortChecker)(config.isAbort);
     if (!apiKey)
@@ -44,7 +45,7 @@ async function openaiAdapter(config, context, tools) {
         model,
         messages,
         tools: tools.length ? tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters ?? {} } })) : undefined,
-        tool_choice: tools.length ? "auto" : undefined,
+        tool_choice: tools.length ? (toolChoice ?? "auto") : undefined,
         stream: onStream ? true : undefined,
     };
     if (await check())

package/dist/adapter/openrouter.js

@@ -31,6 +31,7 @@ async function openrouterAdapter(config, context, tools) {
     const baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
     const apiKey = config.apiKey || process.env.OPENROUTER_API_KEY || "";
     const model = config.model ?? "gpt-5-nano";
+    const toolChoice = config.toolChoice;
     const httpReferer = config.httpReferer;
     const title = config.title;
     const onStream = config.onStream;
@@ -46,7 +47,7 @@ async function openrouterAdapter(config, context, tools) {
         model,
         messages,
         tools: tools.length ? tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters ?? {} } })) : undefined,
-        tool_choice: tools.length ? "auto" : undefined,
+        tool_choice: tools.length ? (toolChoice ?? "auto") : undefined,
         stream: onStream ? true : undefined,
     };
     const headers = {

package/dist/adapter/selfhost_chat_completions.d.ts

@@ -0,0 +1,2 @@
+import { type Message, type Tool } from "../types";
+export declare function selfhostChatCompletionsAdapter(config: Record<string, unknown>, context: Message[], tools: Tool[]): Promise<Message[]>;

package/dist/adapter/selfhost_chat_completions.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selfhostChatCompletionsAdapter = selfhostChatCompletionsAdapter;
+const abort_1 = require("../abort");
+const types_1 = require("../types");
+const sse_1 = require("./sse");
+const ROLE_TO_OPENAI = {
+    [types_1.Role.System]: "system",
+    [types_1.Role.User]: "user",
+    [types_1.Role.Ai]: "assistant",
+};
+function toOpenAIMessages(context) {
+    return context.reduce((out, m) => {
+        if (m.role === types_1.Role.System || m.role === types_1.Role.User || m.role === types_1.Role.Ai)
+            return [...out, { role: ROLE_TO_OPENAI[m.role], content: m.content }];
+        if (m.role === types_1.Role.ToolResult)
+            return [...out, { role: "tool", content: m.content, tool_call_id: m.callId }];
+        if (m.role === types_1.Role.ToolCall) {
+            const tc = { id: m.callId, type: "function", function: { name: m.toolName, arguments: m.argsText ?? "{}" } };
+            const last = out[out.length - 1];
+            if (last?.tool_calls) {
+                last.tool_calls.push(tc);
+                return out;
+            }
+            return [...out, { role: "assistant", tool_calls: [tc] }];
+        }
+        return out;
+    }, []);
+}
+async function selfhostChatCompletionsAdapter(config, context, tools) {
+    const baseUrl = config.baseUrl ?? "http://localhost:1234";
+    const apiKey = config.apiKey || process.env.SELFHOST_API_KEY || "";
+    const model = config.model ?? "gpt-5-nano";
+    const toolChoice = config.toolChoice;
+    const onStream = config.onStream;
+    const { check, isAborted } = (0, abort_1.createAbortChecker)(config.isAbort);
+    if (!apiKey)
+        throw new Error("Self-host chat completions adapter requires apiKey in config or SELFHOST_API_KEY env");
+    const contextMessages = toOpenAIMessages(context);
+    const systemContent = config.system;
+    const messages = systemContent
+        ? [{ role: "system", content: systemContent }, ...contextMessages]
+        : contextMessages;
+    const body = {
+        model,
+        messages,
+        tools: tools.length ? tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters ?? {} } })) : undefined,
+        tool_choice: tools.length ? (toolChoice ?? "auto") : undefined,
+        stream: onStream ? true : undefined,
+    };
+    if (await check())
+        return [];
+    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/v1/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        let errMsg = `Self-host chat completions API HTTP ${res.status}`;
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed?.error?.message)
+                errMsg = parsed.error.message;
+        }
+        catch {
+            if (text)
+                errMsg += `: ${text.slice(0, 200)}`;
+        }
+        throw new Error(errMsg);
+    }
+    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;
+            let parsed;
+            try {
+                parsed = JSON.parse(dataLine);
+            }
+            catch {
+                throw new Error(`Self-host chat completions API returned invalid JSON: ${dataLine.slice(0, 200)}`);
+            }
+            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));
+            }
+            await check();
+        }, check);
+        if (toolCalls.size > 0) {
+            return [...toolCalls.entries()]
+                .sort((a, b) => a[0] - b[0])
+                .map(([index, tc]) => {
+                if (!tc.name)
+                    throw new Error(`Self-host 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 : "{}",
+                };
+            });
+        }
+        if (!content)
+            return [];
+        return [{ role: types_1.Role.Ai, content, isPartial: isAborted() ? true : undefined }];
+    }
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Self-host chat completions API returned invalid JSON: ${text.slice(0, 200)}`);
+    }
+    if (data.error)
+        throw new Error(`Self-host chat completions API error: ${data.error.message}`);
+    const msg = data.choices?.[0]?.message;
+    if (!msg)
+        throw new Error("Self-host chat completions API returned empty response");
+    if (msg.tool_calls?.length) {
+        return msg.tool_calls.map((tc) => ({
+            role: types_1.Role.ToolCall,
+            toolName: tc.function.name,
+            callId: tc.id,
+            argsText: tc.function.arguments ?? "{}",
+        }));
+    }
+    return [{ role: types_1.Role.Ai, content: msg.content ?? "" }];
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { AgentConfig, AgentLike, Context, Message, Tool } from "./types";
 export { openaiAdapter } from "./adapter/openai";
 export { openrouterAdapter } from "./adapter/openrouter";
+export { selfhostChatCompletionsAdapter } from "./adapter/selfhost_chat_completions";
 export type { Adapter, AgentConfig, AgentLike, Context, Message, Tool } from "./types";
 export { Role } from "./types";
 export declare class Agent implements AgentLike {

package/dist/index.js

@@ -1,19 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = exports.Role = exports.openrouterAdapter = exports.openaiAdapter = void 0;
+exports.Agent = exports.Role = exports.selfhostChatCompletionsAdapter = exports.openrouterAdapter = exports.openaiAdapter = void 0;
 const openai_1 = require("./adapter/openai");
 const openrouter_1 = require("./adapter/openrouter");
+const selfhost_chat_completions_1 = require("./adapter/selfhost_chat_completions");
 const abort_1 = require("./abort");
 const types_1 = require("./types");
 var openai_2 = require("./adapter/openai");
 Object.defineProperty(exports, "openaiAdapter", { enumerable: true, get: function () { return openai_2.openaiAdapter; } });
 var openrouter_2 = require("./adapter/openrouter");
 Object.defineProperty(exports, "openrouterAdapter", { enumerable: true, get: function () { return openrouter_2.openrouterAdapter; } });
+var selfhost_chat_completions_2 = require("./adapter/selfhost_chat_completions");
+Object.defineProperty(exports, "selfhostChatCompletionsAdapter", { enumerable: true, get: function () { return selfhost_chat_completions_2.selfhostChatCompletionsAdapter; } });
 var types_2 = require("./types");
 Object.defineProperty(exports, "Role", { enumerable: true, get: function () { return types_2.Role; } });
 const adapters = {
     openai: openai_1.openaiAdapter,
     openrouter: openrouter_1.openrouterAdapter,
+    selfhost_chat_completions: selfhost_chat_completions_1.selfhostChatCompletionsAdapter,
 };
 class Agent {
     constructor(adapterName, config) {

package/dist/types.d.ts

@@ -43,6 +43,7 @@ export type AgentConfig = {
     endCondition?: (context: Message[], last: Message) => boolean;
     onStream?: (textDelta: string) => void | Promise<void>;
     isAbort?: () => boolean | Promise<boolean>;
+    toolChoice?: "auto" | "required" | "none" | Record<string, unknown>;
     onToolCall?: (message: Extract<Message, {
         role: Role.ToolCall;
     }>, args: unknown, agent: AgentLike) => boolean | void | Promise<boolean | void>;

package/package.json

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