nemoris 0.1.0 → 0.1.2

package/src/runtime/tool-loop.js

@@ -1,200 +1,200 @@
-import { ExecApprovalGate } from "./exec-approvals.js";
-
-export function parseToolUseBlocks(response) {
-  if (!response?.content || !Array.isArray(response.content)) return [];
-  return response.content
-    .filter((block) => block.type === "tool_use")
-    .map((block) => ({ id: block.id, name: block.name, input: block.input || {} }));
-}
-
-export function formatToolResults(results) {
-  return [{
-    role: "user",
-    content: results.map((result) => ({
-      type: "tool_result",
-      tool_use_id: result.toolUseId,
-      content: result.output,
-      ...(result.isError ? { is_error: true } : {}),
-    })),
-  }];
-}
-
-export function buildPendingApprovalOutput(results) {
-  if (results.length === 1) {
-    return results[0].output;
-  }
-  return [
-    "Multiple tool calls are waiting for approval before I can continue:",
-    ...results.map((result) => `- ${result.output}`),
-  ].join("\n");
-}
-
-export async function executeToolCalls(toolCalls, registry, policy, agentConfig = null, options = {}) {
-  const allowed = new Set(policy.allowed || []);
-  const blocked = new Set(policy.blocked || []);
-  const approvalGate = options.approvalGate || new ExecApprovalGate({ sendFn: async () => {} });
-
-  const promises = toolCalls.map(async (call) => {
-    if (policy.default === "deny" && !allowed.has(call.name)) {
-      return {
-        toolUseId: call.id,
-        name: call.name,
-        args: call.input,
-        output: `Tool '${call.name}' is not allowed by agent policy.`,
-        isError: true,
-      };
-    }
-    if (blocked.has(call.name)) {
-      return {
-        toolUseId: call.id,
-        name: call.name,
-        args: call.input,
-        output: `Tool '${call.name}' is blocked by agent policy.`,
-        isError: true,
-      };
-    }
-
-    if (approvalGate.requiresApproval(call.name, call.input, agentConfig)) {
-      const approvalRequest = approvalGate.requestApproval({
-        toolName: call.name,
-        toolInput: call.input,
-        jobId: options.jobId || "unknown",
-        agentId: options.agentId || agentConfig?.id || "unknown",
-        skipNotify: options.skipApprovalNotification === true,
-      });
-      const approvalId = approvalRequest?.approvalId || null;
-      void approvalRequest.catch(() => {});
-      return {
-        toolUseId: call.id,
-        name: call.name,
-        args: call.input,
-        output: approvalId
-          ? `Approval required for ${call.name}. Awaiting /exec_approve ${approvalId} or /exec_deny ${approvalId}.`
-          : `Approval required for ${call.name}. Use /exec_approve or /exec_deny.`,
-        isError: false,
-        pendingApproval: true,
-        approvalId,
-      };
-    }
-
-    const result = await registry.executeTool(call.name, call.input);
-    if (result.error) {
-      return {
-        toolUseId: call.id,
-        name: call.name,
-        args: call.input,
-        output: result.error,
-        isError: true,
-      };
-    }
-    return {
-      toolUseId: call.id,
-      name: call.name,
-      args: call.input,
-      output: result.output,
-      isError: false,
-    };
-  });
-
-  return Promise.allSettled(promises).then((settled) =>
-    settled.map((entry) => entry.status === "fulfilled"
-      ? entry.value
-      : {
-          toolUseId: "unknown",
-          name: "unknown",
-          args: {},
-          output: `Internal error: ${entry.reason}`,
-          isError: true,
-        })
-  );
-}
-
-export async function runToolLoop({
-  initialResponse,
-  adapter,
-  invocation,
-  registry,
-  policy,
-  agentConfig = null,
-  approvalGate = null,
-  options = {}
-}) {
-  if (!options.enabled) {
-    return {
-      finalResponse: initialResponse,
-      toolResults: [],
-      iterationCount: 0
-    };
-  }
-
-  let currentResponse = initialResponse;
-  let toolMessages = [];
-  let toolResults = [];
-  let toolCallCount = 0;
-  let iterationCount = 0;
-  const maxToolCalls = options.maxToolCalls || 20;
-  const maxIterations = options.maxIterations || Number.POSITIVE_INFINITY;
-
-  while (true) {
-    const toolCalls = parseToolUseBlocks(currentResponse);
-    if (toolCalls.length === 0) break;
-    if (iterationCount >= maxIterations) break;
-
-    toolCallCount += toolCalls.length;
-    if (toolCallCount > maxToolCalls) break;
-    iterationCount += 1;
-
-    const results = await executeToolCalls(toolCalls, registry, policy, agentConfig, {
-      approvalGate,
-      jobId: options.jobId,
-      agentId: options.agentId,
-      skipApprovalNotification: options.skipApprovalNotification === true,
-    });
-    toolResults = [...toolResults, ...results];
-
-    const pendingApprovals = results.filter((entry) => entry.pendingApproval);
-    if (pendingApprovals.length > 0) {
-      return {
-        finalResponse: currentResponse,
-        toolResults,
-        iterationCount,
-        pendingApprovalResult: {
-          summary: "Tool execution paused pending approval.",
-          output: buildPendingApprovalOutput(pendingApprovals),
-          nextActions: [
-            "Approve or deny the pending exec action from Telegram, then retry the request if needed."
-          ],
-          toolCalls: toolCalls.map((call, index) => ({
-            ...call,
-            output: results[index]?.output,
-            pendingApproval: results[index]?.pendingApproval || false,
-            approvalId: results[index]?.approvalId || null,
-          })),
-          pendingApproval: true,
-          raw: currentResponse,
-        }
-      };
-    }
-
-    const formattedResults = formatToolResults(results);
-    const continuationMessages = [
-      ...invocation.messages,
-      ...toolMessages,
-      { role: "assistant", content: currentResponse.content },
-      ...formattedResults,
-    ];
-    toolMessages = [
-      ...toolMessages,
-      { role: "assistant", content: currentResponse.content },
-      ...formattedResults,
-    ];
-
-    currentResponse = await adapter.invoke({ ...invocation, messages: continuationMessages });
-  }
-
-  return {
-    finalResponse: currentResponse,
-    toolResults,
-    iterationCount
-  };
-}
+import { ExecApprovalGate } from "./exec-approvals.js";
+
+export function parseToolUseBlocks(response) {
+  if (!response?.content || !Array.isArray(response.content)) return [];
+  return response.content
+    .filter((block) => block.type === "tool_use")
+    .map((block) => ({ id: block.id, name: block.name, input: block.input || {} }));
+}
+
+export function formatToolResults(results) {
+  return [{
+    role: "user",
+    content: results.map((result) => ({
+      type: "tool_result",
+      tool_use_id: result.toolUseId,
+      content: result.output,
+      ...(result.isError ? { is_error: true } : {}),
+    })),
+  }];
+}
+
+export function buildPendingApprovalOutput(results) {
+  if (results.length === 1) {
+    return results[0].output;
+  }
+  return [
+    "Multiple tool calls are waiting for approval before I can continue:",
+    ...results.map((result) => `- ${result.output}`),
+  ].join("\n");
+}
+
+export async function executeToolCalls(toolCalls, registry, policy, agentConfig = null, options = {}) {
+  const allowed = new Set(policy.allowed || []);
+  const blocked = new Set(policy.blocked || []);
+  const approvalGate = options.approvalGate || new ExecApprovalGate({ sendFn: async () => {} });
+
+  const promises = toolCalls.map(async (call) => {
+    if (policy.default === "deny" && !allowed.has(call.name)) {
+      return {
+        toolUseId: call.id,
+        name: call.name,
+        args: call.input,
+        output: `Tool '${call.name}' is not allowed by agent policy.`,
+        isError: true,
+      };
+    }
+    if (blocked.has(call.name)) {
+      return {
+        toolUseId: call.id,
+        name: call.name,
+        args: call.input,
+        output: `Tool '${call.name}' is blocked by agent policy.`,
+        isError: true,
+      };
+    }
+
+    if (approvalGate.requiresApproval(call.name, call.input, agentConfig)) {
+      const approvalRequest = approvalGate.requestApproval({
+        toolName: call.name,
+        toolInput: call.input,
+        jobId: options.jobId || "unknown",
+        agentId: options.agentId || agentConfig?.id || "unknown",
+        skipNotify: options.skipApprovalNotification === true,
+      });
+      const approvalId = approvalRequest?.approvalId || null;
+      void approvalRequest.catch(() => {});
+      return {
+        toolUseId: call.id,
+        name: call.name,
+        args: call.input,
+        output: approvalId
+          ? `Approval required for ${call.name}. Awaiting /exec_approve ${approvalId} or /exec_deny ${approvalId}.`
+          : `Approval required for ${call.name}. Use /exec_approve or /exec_deny.`,
+        isError: false,
+        pendingApproval: true,
+        approvalId,
+      };
+    }
+
+    const result = await registry.executeTool(call.name, call.input);
+    if (result.error) {
+      return {
+        toolUseId: call.id,
+        name: call.name,
+        args: call.input,
+        output: result.error,
+        isError: true,
+      };
+    }
+    return {
+      toolUseId: call.id,
+      name: call.name,
+      args: call.input,
+      output: result.output,
+      isError: false,
+    };
+  });
+
+  return Promise.allSettled(promises).then((settled) =>
+    settled.map((entry) => entry.status === "fulfilled"
+      ? entry.value
+      : {
+          toolUseId: "unknown",
+          name: "unknown",
+          args: {},
+          output: `Internal error: ${entry.reason}`,
+          isError: true,
+        })
+  );
+}
+
+export async function runToolLoop({
+  initialResponse,
+  adapter,
+  invocation,
+  registry,
+  policy,
+  agentConfig = null,
+  approvalGate = null,
+  options = {}
+}) {
+  if (!options.enabled) {
+    return {
+      finalResponse: initialResponse,
+      toolResults: [],
+      iterationCount: 0
+    };
+  }
+
+  let currentResponse = initialResponse;
+  let toolMessages = [];
+  let toolResults = [];
+  let toolCallCount = 0;
+  let iterationCount = 0;
+  const maxToolCalls = options.maxToolCalls || 20;
+  const maxIterations = options.maxIterations || Number.POSITIVE_INFINITY;
+
+  while (true) {
+    const toolCalls = parseToolUseBlocks(currentResponse);
+    if (toolCalls.length === 0) break;
+    if (iterationCount >= maxIterations) break;
+
+    toolCallCount += toolCalls.length;
+    if (toolCallCount > maxToolCalls) break;
+    iterationCount += 1;
+
+    const results = await executeToolCalls(toolCalls, registry, policy, agentConfig, {
+      approvalGate,
+      jobId: options.jobId,
+      agentId: options.agentId,
+      skipApprovalNotification: options.skipApprovalNotification === true,
+    });
+    toolResults = [...toolResults, ...results];
+
+    const pendingApprovals = results.filter((entry) => entry.pendingApproval);
+    if (pendingApprovals.length > 0) {
+      return {
+        finalResponse: currentResponse,
+        toolResults,
+        iterationCount,
+        pendingApprovalResult: {
+          summary: "Tool execution paused pending approval.",
+          output: buildPendingApprovalOutput(pendingApprovals),
+          nextActions: [
+            "Approve or deny the pending exec action from Telegram, then retry the request if needed."
+          ],
+          toolCalls: toolCalls.map((call, index) => ({
+            ...call,
+            output: results[index]?.output,
+            pendingApproval: results[index]?.pendingApproval || false,
+            approvalId: results[index]?.approvalId || null,
+          })),
+          pendingApproval: true,
+          raw: currentResponse,
+        }
+      };
+    }
+
+    const formattedResults = formatToolResults(results);
+    const continuationMessages = [
+      ...invocation.messages,
+      ...toolMessages,
+      { role: "assistant", content: currentResponse.content },
+      ...formattedResults,
+    ];
+    toolMessages = [
+      ...toolMessages,
+      { role: "assistant", content: currentResponse.content },
+      ...formattedResults,
+    ];
+
+    currentResponse = await adapter.invoke({ ...invocation, messages: continuationMessages });
+  }
+
+  return {
+    finalResponse: currentResponse,
+    toolResults,
+    iterationCount
+  };
+}