@sisu-ai/mw-tool-calling 1.0.0

package/README.md

@@ -0,0 +1,18 @@
+# @sisu-ai/mw-tool-calling
+
+Native tools API loop for providers that support tool calls.
+
+## Behavior
+- First turn: calls `ctx.model.generate(messages, { tools, toolChoice:'auto' })`.
+- If assistant returns `tool_calls`, appends the assistant message and executes each tool.
+  - Executes each unique `(name, args)` once and responds to every `tool_call_id`.
+  - Handles provider quirks (e.g., missing args on duplicates) by reusing last args.
+- Second turn: asks for a pure completion (`toolChoice:'none'`).
+
+## Usage
+```ts
+import { toolCalling } from '@sisu-ai/mw-tool-calling';
+
+const app = new Agent()
+  .use(toolCalling);
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '@sisu-ai/core';
+export declare const toolCalling: Middleware;

package/dist/index.js

@@ -0,0 +1,78 @@
+export const toolCalling = async (ctx, next) => {
+    await next();
+    for (let i = 0; i < 6; i++) {
+        ctx.log.debug?.('[tool-calling] iteration start', { i, messages: ctx.messages.length });
+        const toolList = ctx.tools.list();
+        const allowTools = i === 0 ? 'auto' : 'none';
+        const genOpts = { toolChoice: allowTools, signal: ctx.signal };
+        if (allowTools !== 'none') {
+            genOpts.tools = toolList;
+            genOpts.parallelToolCalls = false;
+        }
+        const out = await ctx.model.generate(ctx.messages, genOpts);
+        const msg = out.message;
+        const toolCalls = msg.tool_calls;
+        if (toolCalls && toolCalls.length > 0) {
+            // Important: include the assistant message that requested tools so tool_call_id has a valid anchor.
+            ctx.messages.push(msg);
+            ctx.log.info?.('[tool-calling] model requested tools', toolCalls.map(tc => ({ id: tc.id, name: tc.name, hasArgs: typeof tc.arguments !== 'undefined' })));
+            // Execute each unique (name,args) once, but reply to every tool_call_id.
+            const cache = new Map();
+            const keyOf = (tc) => `${tc.name}:${safeStableStringify(tc.arguments)}`;
+            const lastArgsByName = new Map();
+            // Pre-pass: fill missing arguments from last seen arguments of same tool name (provider quirk)
+            const resolvedCalls = toolCalls.map((tc) => {
+                if (typeof tc.arguments === 'undefined' && lastArgsByName.has(tc.name)) {
+                    return { ...tc, arguments: lastArgsByName.get(tc.name) };
+                }
+                return tc;
+            });
+            for (const call of resolvedCalls) {
+                const tool = ctx.tools.get(call.name);
+                if (!tool)
+                    throw new Error('Unknown tool: ' + call.name);
+                const key = keyOf(call);
+                let result = cache.get(key);
+                if (result === undefined) {
+                    const args = tool.schema?.parse ? tool.schema.parse(call.arguments) : call.arguments;
+                    ctx.log.debug?.('[tool-calling] invoking tool', { name: call.name, id: call.id, args });
+                    result = await tool.handler(args, ctx);
+                    cache.set(key, result);
+                    lastArgsByName.set(call.name, args);
+                }
+                else {
+                    ctx.log.debug?.('[tool-calling] reusing cached tool result for duplicate call', { name: call.name, id: call.id });
+                }
+                // Prefer tool_call_id when available (tools API)
+                const toolMsg = { role: 'tool', content: JSON.stringify(result) };
+                if (call.id)
+                    toolMsg.tool_call_id = call.id;
+                else
+                    toolMsg.name = call.name;
+                ctx.messages.push(toolMsg);
+                ctx.log.debug?.('[tool-calling] tool result appended', { name: call.name, id: call.id, contentBytes: toolMsg.content.length });
+            }
+            continue;
+        }
+        else {
+            ctx.log.info?.('[tool-calling] no tool calls; appending assistant message');
+            ctx.messages.push(msg);
+            break;
+        }
+    }
+};
+function safeStableStringify(v) {
+    try {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            const keys = Object.keys(v).sort();
+            const obj = {};
+            for (const k of keys)
+                obj[k] = v[k];
+            return JSON.stringify(obj);
+        }
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@sisu-ai/mw-tool-calling",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "peerDependencies": {
+    "@sisu-ai/core": "0.2.0"
+  }
+}