@polka-codes/core 0.9.22 → 0.9.24

package/dist/_tsup-dts-rollup.d.ts

@@ -9,6 +9,7 @@ import type { ModelMessage as ModelMessage_2 } from 'ai';
 import type { TextPart } from 'ai';
 import type { ToolModelMessage } from '@ai-sdk/provider-utils';
 import type { UserContent } from '@ai-sdk/provider-utils';
+import type { UserContent as UserContent_2 } from 'ai';
 import type { UserModelMessage } from '@ai-sdk/provider-utils';
 import { z } from 'zod';
 
@@ -1122,8 +1123,9 @@ declare class MultiAgent {
         agentName: string;
         task: string;
         context: string;
+        files?: (ImagePart | FilePart)[];
     }): Promise<ExitReason>;
-    continueTask(userMessage: string): Promise<ExitReason>;
+    continueTask(userMessage: UserContent_2): Promise<ExitReason>;
     get hasActiveAgent(): boolean;
     abort(): void;
 }
@@ -1329,7 +1331,7 @@ export { systemInformation as systemInformation_alias_2 }
 /**
  * Union type of all possible task events
  */
-declare type TaskEvent = TaskEventStartTask | TaskEventStartRequest | TaskEventEndRequest | TaskEventUsage | TaskEventText | TaskEventTool | TaskEventToolPause | TaskEventToolHandOverDelegate | TaskEventUsageExceeded | TaskEventEndTask;
+declare type TaskEvent = TaskEventStartTask | TaskEventStartRequest | TaskEventEndRequest | TaskEventUsage | TaskEventText | TaskEventToolUse | TaskEventToolResult | TaskEventToolError | TaskEventToolPause | TaskEventToolHandOverDelegate | TaskEventUsageExceeded | TaskEventEndTask;
 export { TaskEvent }
 export { TaskEvent as TaskEvent_alias_1 }
 export { TaskEvent as TaskEvent_alias_2 }
@@ -1430,17 +1432,14 @@ export { TaskEventText }
 export { TaskEventText as TaskEventText_alias_1 }
 export { TaskEventText as TaskEventText_alias_2 }
 
-/**
- * Event for tool-related updates
- */
-declare interface TaskEventTool extends TaskEventBase {
-    kind: TaskEventKind.ToolUse | TaskEventKind.ToolReply | TaskEventKind.ToolInvalid | TaskEventKind.ToolError | TaskEventKind.ToolInterrupted;
+declare interface TaskEventToolError extends TaskEventBase {
+    kind: TaskEventKind.ToolError;
     tool: string;
-    content: any;
+    error: ToolResponseError | ToolResponseResult;
 }
-export { TaskEventTool }
-export { TaskEventTool as TaskEventTool_alias_1 }
-export { TaskEventTool as TaskEventTool_alias_2 }
+export { TaskEventToolError }
+export { TaskEventToolError as TaskEventToolError_alias_1 }
+export { TaskEventToolError as TaskEventToolError_alias_2 }
 
 /**
  * Event for tool handover
@@ -1466,6 +1465,27 @@ export { TaskEventToolPause }
 export { TaskEventToolPause as TaskEventToolPause_alias_1 }
 export { TaskEventToolPause as TaskEventToolPause_alias_2 }
 
+declare interface TaskEventToolResult extends TaskEventBase {
+    kind: TaskEventKind.ToolReply | TaskEventKind.ToolInvalid | TaskEventKind.ToolInterrupted;
+    tool: string;
+    content: ToolResponseResult;
+}
+export { TaskEventToolResult }
+export { TaskEventToolResult as TaskEventToolResult_alias_1 }
+export { TaskEventToolResult as TaskEventToolResult_alias_2 }
+
+/**
+ * Event for tool-related updates
+ */
+declare interface TaskEventToolUse extends TaskEventBase {
+    kind: TaskEventKind.ToolUse;
+    tool: string;
+    params: Record<string, any>;
+}
+export { TaskEventToolUse }
+export { TaskEventToolUse as TaskEventToolUse_alias_1 }
+export { TaskEventToolUse as TaskEventToolUse_alias_2 }
+
 /**
  * Event for API usage updates
  */

package/dist/index.d.ts

@@ -9,7 +9,9 @@ export { TaskEventStartRequest } from './_tsup-dts-rollup.js';
 export { TaskEventEndRequest } from './_tsup-dts-rollup.js';
 export { TaskEventUsage } from './_tsup-dts-rollup.js';
 export { TaskEventText } from './_tsup-dts-rollup.js';
-export { TaskEventTool } from './_tsup-dts-rollup.js';
+export { TaskEventToolUse } from './_tsup-dts-rollup.js';
+export { TaskEventToolResult } from './_tsup-dts-rollup.js';
+export { TaskEventToolError } from './_tsup-dts-rollup.js';
 export { TaskEventToolPause } from './_tsup-dts-rollup.js';
 export { TaskEventToolHandOverDelegate } from './_tsup-dts-rollup.js';
 export { TaskEventUsageExceeded } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -2236,12 +2236,13 @@ Retrying request ${i + 2} of ${retryCount}`);
       return resp;
     };
     let hasPause = false;
+    const toolUseContents = response.filter((c) => c.type === "tool_use");
     outer: for (const content of response) {
       switch (content.type) {
         case "text":
           break;
         case "tool_use": {
-          await this.#callback({ kind: "ToolUse" /* ToolUse */, agent: this, tool: content.name, content: content.params });
+          await this.#callback({ kind: "ToolUse" /* ToolUse */, agent: this, tool: content.name, params: content.params });
           const toolResp = await this.#invokeTool(content.name, content.params);
           switch (toolResp.type) {
             case "Reply" /* Reply */: {
@@ -2250,52 +2251,73 @@ Retrying request ${i + 2} of ${retryCount}`);
               break;
             }
             case "Exit" /* Exit */:
+            case "HandOver" /* HandOver */:
+            case "Delegate" /* Delegate */: {
+              if (this.config.toolFormat === "native" && toolUseContents.length > 1) {
+                const message = {
+                  type: "Error" /* Error */,
+                  message: {
+                    type: "error-text",
+                    value: `Error: The tool '${content.name}' must be called alone, but it was called with other tools.`
+                  },
+                  canRetry: false
+                };
+                await this.#callback({ kind: "ToolError" /* ToolError */, agent: this, tool: content.name, error: message });
+                toolResponses.push({
+                  type: "response",
+                  tool: content.name,
+                  response: processResponse(message.message),
+                  id: content.id
+                });
+                break;
+              }
               if (toolResponses.length > 0) {
                 break outer;
               }
-              return { type: "exit", reason: toolResp };
+              if (toolResp.type === "Exit" /* Exit */) {
+                return { type: "exit", reason: toolResp };
+              }
+              if (toolResp.type === "HandOver" /* HandOver */) {
+                await this.#callback({
+                  kind: "ToolHandOver" /* ToolHandOver */,
+                  agent: this,
+                  tool: content.name,
+                  agentName: toolResp.agentName,
+                  task: toolResp.task,
+                  context: toolResp.context,
+                  files: toolResp.files
+                });
+                return { type: "exit", reason: toolResp };
+              }
+              if (toolResp.type === "Delegate" /* Delegate */) {
+                await this.#callback({
+                  kind: "ToolDelegate" /* ToolDelegate */,
+                  agent: this,
+                  tool: content.name,
+                  agentName: toolResp.agentName,
+                  task: toolResp.task,
+                  context: toolResp.context,
+                  files: toolResp.files
+                });
+                return { type: "exit", reason: toolResp };
+              }
+              break;
+            }
             case "Invalid" /* Invalid */: {
               await this.#callback({ kind: "ToolInvalid" /* ToolInvalid */, agent: this, tool: content.name, content: toolResp.message });
               toolResponses.push({ type: "response", tool: content.name, response: processResponse(toolResp.message), id: content.id });
-              break outer;
-            }
-            case "Error" /* Error */: {
-              await this.#callback({ kind: "ToolError" /* ToolError */, agent: this, tool: content.name, content: toolResp.message });
-              toolResponses.push({ type: "response", tool: content.name, response: processResponse(toolResp.message), id: content.id });
-              break outer;
-            }
-            case "Interrupted" /* Interrupted */:
-              await this.#callback({ kind: "ToolInterrupted" /* ToolInterrupted */, agent: this, tool: content.name, content: toolResp.message });
-              return { type: "exit", reason: toolResp };
-            case "HandOver" /* HandOver */: {
-              if (toolResponses.length > 0) {
+              if (this.config.toolFormat !== "native") {
                 break outer;
               }
-              await this.#callback({
-                kind: "ToolHandOver" /* ToolHandOver */,
-                agent: this,
-                tool: content.name,
-                agentName: toolResp.agentName,
-                task: toolResp.task,
-                context: toolResp.context,
-                files: toolResp.files
-              });
-              return { type: "exit", reason: toolResp };
+              break;
             }
-            case "Delegate" /* Delegate */: {
-              if (toolResponses.length > 0) {
+            case "Error" /* Error */: {
+              await this.#callback({ kind: "ToolError" /* ToolError */, agent: this, tool: content.name, error: toolResp.message });
+              toolResponses.push({ type: "response", tool: content.name, response: processResponse(toolResp.message), id: content.id });
+              if (this.config.toolFormat !== "native") {
                 break outer;
               }
-              await this.#callback({
-                kind: "ToolDelegate" /* ToolDelegate */,
-                agent: this,
-                tool: content.name,
-                agentName: toolResp.agentName,
-                task: toolResp.task,
-                context: toolResp.context,
-                files: toolResp.files
-              });
-              return { type: "exit", reason: toolResp };
+              break;
             }
             case "Pause" /* Pause */: {
               await this.#callback({ kind: "ToolPause" /* ToolPause */, agent: this, tool: content.name, object: toolResp.object });
@@ -3049,8 +3071,13 @@ var MultiAgent = class {
       throw new Error("An active agent already exists");
     }
     this.#originalTask = options.task;
-    return this.#startTask(options.agentName, `<task>${options.task}</task>
-<context>${options.context}</context>`);
+    const userContent = options.files ?? [];
+    userContent.push({
+      type: "text",
+      text: `<task>${options.task}</task>
+<context>${options.context}</context>`
+    });
+    return this.#startTask(options.agentName, userContent);
   }
   async continueTask(userMessage) {
     if (!this.#agents.length) {
@@ -3738,7 +3765,7 @@ var handler15 = async (provider, args) => {
     commandParts.push(commitRange);
   }
   if (file) {
-    commandParts.push("--", file);
+    commandParts.push("--", `'${file}'`);
   }
   const command = commandParts.join(" ");
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/core",
-  "version": "0.9.22",
+  "version": "0.9.24",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",