@clinebot/agents 0.0.0 → 0.0.2

package/dist/teams/multi-agent.d.ts

@@ -75,6 +75,7 @@ export type TeamEvent = {
     agentId: string;
     result?: AgentResult;
     error?: Error;
+    messages?: AgentResult["messages"];
 } | {
     type: TeamMessageType.AgentEvent;
     agentId: string;
@@ -414,6 +415,9 @@ export interface TeamRunRecord {
     endedAt?: Date;
     leaseOwner?: string;
     heartbeatAt?: Date;
+    lastProgressAt?: Date;
+    lastProgressMessage?: string;
+    currentActivity?: string;
     result?: AgentResult;
     error?: string;
 }
@@ -561,6 +565,8 @@ export declare class AgentTeamsRuntime {
     private requireTask;
     private assertDependenciesResolved;
     private trackMeaningfulEvent;
+    private recordRunActivityFromAgentEvent;
+    private recordRunProgress;
     private recordProgressStep;
     private emitEvent;
 }

package/dist/teams/spawn-agent-tool.d.ts

@@ -2,13 +2,15 @@
  * Reusable spawn_agent tool for delegating tasks to sub-agents.
  */
 import type { providers as LlmsProviders } from "@clinebot/llms";
-import type { Tool, ToolApprovalRequest, ToolApprovalResult, ToolContext, ToolPolicy } from "@clinebot/shared";
+import { type Tool, type ToolApprovalRequest, type ToolApprovalResult, type ToolContext, type ToolPolicy } from "@clinebot/shared";
+import { z } from "zod";
 import type { AgentEvent, AgentExtension, AgentFinishReason, AgentHooks, BasicLogger, HookErrorMode } from "../types.js";
-export interface SpawnAgentInput {
-    systemPrompt: string;
-    task: string;
-    maxIterations?: number;
-}
+export declare const SpawnAgentInputSchema: z.ZodObject<{
+    systemPrompt: z.ZodString;
+    task: z.ZodString;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SpawnAgentInput = z.infer<typeof SpawnAgentInputSchema>;
 export interface SpawnAgentOutput {
     text: string;
     iterations: number;
@@ -35,11 +37,13 @@ export interface SubAgentEndContext {
 export interface SpawnAgentToolConfig {
     providerId: string;
     modelId: string;
+    cwd?: string;
     apiKey?: string;
     baseUrl?: string;
     providerConfig?: LlmsProviders.ProviderConfig;
     knownModels?: Record<string, LlmsProviders.ModelInfo>;
     thinking?: boolean;
+    clineWorkspaceMetadata?: string;
     defaultMaxIterations?: number;
     subAgentTools?: Tool[];
     createSubAgentTools?: (input: SpawnAgentInput, context: ToolContext) => Tool[] | Promise<Tool[]>;

package/dist/types.d.ts

@@ -89,6 +89,8 @@ export interface AgentDoneEvent {
     text: string;
     /** Total number of iterations */
     iterations: number;
+    /** Aggregated usage information */
+    usage?: AgentUsage;
 }
 export interface AgentErrorEvent {
     type: "error";
@@ -99,6 +101,26 @@ export interface AgentErrorEvent {
     /** Current iteration when error occurred */
     iteration: number;
 }
+export interface ConsecutiveMistakeLimitContext {
+    iteration: number;
+    consecutiveMistakes: number;
+    maxConsecutiveMistakes: number;
+    reason: "api_error" | "invalid_tool_call" | "tool_execution_failed";
+    details?: string;
+}
+export type ConsecutiveMistakeLimitDecision = {
+    action: "continue";
+    /**
+     * Optional guidance appended as a user message before continuing.
+     */
+    guidance?: string;
+} | {
+    action: "stop";
+    /**
+     * Optional reason surfaced when stopping due to the limit.
+     */
+    reason?: string;
+};
 /**
  * Hook error handling behavior.
  * - "ignore": swallow hook errors and continue agent execution
@@ -539,11 +561,12 @@ export declare const AgentResultSchema: z.ZodObject<{
 /**
  * Reasoning effort level for capable models
  */
-export type ReasoningEffort = "low" | "medium" | "high";
+export type ReasoningEffort = "low" | "medium" | "high" | "xhigh";
 export declare const ReasoningEffortSchema: z.ZodEnum<{
     low: "low";
     high: "high";
     medium: "medium";
+    xhigh: "xhigh";
 }>;
 /**
  * Configuration for creating an Agent
@@ -603,6 +626,13 @@ export interface AgentConfig {
      * @default 120000 (2 minutes)
      */
     apiTimeoutMs?: number;
+    /**
+     * Maximum consecutive internal mistakes before escalation.
+     * Mistakes include API turn failures, invalid/missing tool-call arguments,
+     * and iterations where every executed tool call fails.
+     * @default 3
+     */
+    maxConsecutiveMistakes?: number;
     /**
      * Optional runtime file-content loader used when user files are attached.
      * When omitted, attached files will be represented as loader errors.
@@ -659,6 +689,10 @@ export interface AgentConfig {
      * Optional callback to request client approval when a tool policy disables auto-approval.
      */
     requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    /**
+     * Optional callback invoked when consecutive mistakes reach maxConsecutiveMistakes.
+     */
+    onConsecutiveMistakeLimitReached?: (context: ConsecutiveMistakeLimitContext) => Promise<ConsecutiveMistakeLimitDecision> | ConsecutiveMistakeLimitDecision;
     /**
      * Optional logger for tracing agent loop lifecycle and recoverable failures.
      */
@@ -743,6 +777,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
     maxParallelToolCalls: z.ZodDefault<z.ZodNumber>;
     maxTokensPerTurn: z.ZodOptional<z.ZodNumber>;
     apiTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxConsecutiveMistakes: z.ZodDefault<z.ZodNumber>;
     userFileContentLoader: z.ZodOptional<z.ZodFunction<z.core.$ZodTuple<readonly [z.ZodString], z.core.$ZodFunctionOut>, z.ZodPromise<z.ZodString>>>;
     reminderAfterIterations: z.ZodDefault<z.ZodNumber>;
     reminderText: z.ZodOptional<z.ZodString>;
@@ -750,6 +785,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
         low: "low";
         high: "high";
         medium: "medium";
+        xhigh: "xhigh";
     }>>;
     thinkingBudgetTokens: z.ZodOptional<z.ZodNumber>;
     thinking: z.ZodOptional<z.ZodBoolean>;
@@ -784,6 +820,29 @@ export declare const AgentConfigSchema: z.ZodObject<{
         approved: z.ZodBoolean;
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>]>>>;
+    onConsecutiveMistakeLimitReached: z.ZodOptional<z.ZodFunction<z.core.$ZodTuple<readonly [z.ZodObject<{
+        iteration: z.ZodNumber;
+        consecutiveMistakes: z.ZodNumber;
+        maxConsecutiveMistakes: z.ZodNumber;
+        reason: z.ZodEnum<{
+            api_error: "api_error";
+            invalid_tool_call: "invalid_tool_call";
+            tool_execution_failed: "tool_execution_failed";
+        }>;
+        details: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], z.core.$ZodFunctionOut>, z.ZodUnion<readonly [z.ZodObject<{
+        action: z.ZodLiteral<"continue">;
+        guidance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"stop">;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodPromise<z.ZodUnion<readonly [z.ZodObject<{
+        action: z.ZodLiteral<"continue">;
+        guidance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"stop">;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>>;
     logger: z.ZodOptional<z.ZodCustom<BasicLogger, BasicLogger>>;
     abortSignal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
 }, z.core.$strip>;
@@ -807,6 +866,12 @@ export interface ProcessedTurn {
     reasoning?: string;
     /** Tool calls requested by the model */
     toolCalls: PendingToolCall[];
+    /** Model-emitted tool calls that were invalid or missing required fields */
+    invalidToolCalls: Array<{
+        id: string;
+        name?: string;
+        reason: "missing_name" | "missing_arguments" | "invalid_arguments";
+    }>;
     /** Token usage for this turn */
     usage: {
         inputTokens: number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@clinebot/agents",
-	"version": "0.0.0",
+	"version": "0.0.2",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/cline/cline.git",
@@ -8,23 +8,23 @@
 	},
 	"main": "dist/index.js",
 	"dependencies": {
-		"@clinebot/llms": "workspace:*",
-		"@clinebot/shared": "workspace:*",
+		"@clinebot/llms": "0.0.2",
 		"zod": "^4.3.6"
 	},
 	"exports": {
 		".": {
-			"development": "./src/index.ts",
+			"browser": "./dist/index.browser.js",
+			"development": "./dist/index.js",
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
 		},
 		"./node": {
-			"development": "./src/index.node.ts",
-			"types": "./src/index.node.ts",
+			"development": "./dist/index.node.js",
+			"types": "./dist/index.node.d.ts",
 			"import": "./dist/index.node.js"
 		},
 		"./browser": {
-			"development": "./src/index.browser.ts",
+			"development": "./dist/index.browser.js",
 			"types": "./dist/index.browser.d.ts",
 			"import": "./dist/index.browser.js"
 		}

package/src/agent.test.ts

@@ -197,6 +197,120 @@ describe("Agent", () => {
 		expect(logger.error).not.toHaveBeenCalled();
 	});
 
+	it("fails after reaching max consecutive mistakes by default", async () => {
+		const { Agent } = await import("./agent.js");
+		const handler = makeHandler([
+			[
+				{
+					type: "done",
+					id: "r1",
+					success: false,
+					error: "upstream api timeout",
+				},
+			],
+			[
+				{
+					type: "done",
+					id: "r2",
+					success: false,
+					error: "upstream api timeout",
+				},
+			],
+		]);
+		createHandlerMock.mockReturnValue(handler);
+
+		const agent = new Agent({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			systemPrompt: "Handle retries",
+			tools: [],
+			maxConsecutiveMistakes: 2,
+		});
+
+		await expect(agent.run("retry")).rejects.toThrow("upstream api timeout");
+		expect(handler.createMessage).toHaveBeenCalledTimes(2);
+	});
+
+	it("fails immediately on non-recoverable API errors", async () => {
+		const { Agent } = await import("./agent.js");
+		const handler = makeHandler([
+			[
+				{
+					type: "done",
+					id: "r1",
+					success: false,
+					error:
+						'{"error":{"code":404,"message":"models/gemini-flash-latest-1 is not found"}}',
+				},
+			],
+		]);
+		createHandlerMock.mockReturnValue(handler);
+
+		const agent = new Agent({
+			providerId: "gemini",
+			modelId: "gemini-flash-latest-1",
+			systemPrompt: "Handle retries",
+			tools: [],
+			maxConsecutiveMistakes: 3,
+		});
+
+		await expect(agent.run("retry")).rejects.toThrow("404");
+		expect(handler.createMessage).toHaveBeenCalledTimes(1);
+		expect(
+			agent
+				.getMessages()
+				.some((message) =>
+					JSON.stringify(message).includes("previous turn failed"),
+				),
+		).toBe(false);
+	});
+
+	it("continues after mistake limit when callback returns continue", async () => {
+		const { Agent } = await import("./agent.js");
+		const handler = makeHandler([
+			[
+				{
+					type: "done",
+					id: "r1",
+					success: false,
+					error: "temporary api failure",
+				},
+			],
+			[
+				{
+					type: "done",
+					id: "r2",
+					success: false,
+					error: "temporary api failure",
+				},
+			],
+			[
+				{ type: "text", id: "r3", text: "Recovered" },
+				{ type: "usage", id: "r3", inputTokens: 3, outputTokens: 2 },
+				{ type: "done", id: "r3", success: true },
+			],
+		]);
+		createHandlerMock.mockReturnValue(handler);
+
+		const onConsecutiveMistakeLimitReached = vi.fn().mockResolvedValue({
+			action: "continue",
+			guidance: "mistake_limit_reached: continue and recover",
+		});
+		const agent = new Agent({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			systemPrompt: "Handle retries",
+			tools: [],
+			maxConsecutiveMistakes: 2,
+			onConsecutiveMistakeLimitReached,
+		});
+
+		const result = await agent.run("retry");
+		expect(onConsecutiveMistakeLimitReached).toHaveBeenCalledTimes(1);
+		expect(result.finishReason).toBe("completed");
+		expect(result.text).toBe("Recovered");
+	});
+
 	it("executes tool calls and applies tool policy approval", async () => {
 		const { Agent } = await import("./agent.js");
 		const mathTool: Tool<{ a: number; b: number }, { total: number }> =
@@ -451,6 +565,78 @@ describe("Agent", () => {
 		});
 	});
 
+	it("deduplicates streamed tool calls when function.id and call_id both appear", async () => {
+		const { Agent } = await import("./agent.js");
+		const executeRunCommands = vi.fn(
+			async ({ commands }: { commands: string[] }) => commands,
+		);
+		const runCommandsTool = createTool({
+			name: "run_commands",
+			description: "Run commands",
+			inputSchema: {
+				type: "object",
+				properties: {
+					commands: {
+						type: "array",
+						items: { type: "string" },
+					},
+				},
+				required: ["commands"],
+			},
+			execute: executeRunCommands,
+		}) as Tool;
+
+		const handler = makeHandler([
+			[
+				{
+					type: "tool_calls",
+					id: "r1",
+					tool_call: {
+						function: {
+							id: "fc_1",
+							name: "run_commands",
+							arguments: '{"commands":["pwd"]}',
+						},
+					},
+				},
+				{
+					type: "tool_calls",
+					id: "r1",
+					tool_call: {
+						call_id: "call_1",
+						function: {
+							id: "fc_1",
+							name: "run_commands",
+							arguments: '{"commands":["pwd"]}',
+						},
+					},
+				},
+				{ type: "usage", id: "r1", inputTokens: 4, outputTokens: 2 },
+				{ type: "done", id: "r1", success: true },
+			],
+			[
+				{ type: "text", id: "r2", text: "Done" },
+				{ type: "usage", id: "r2", inputTokens: 2, outputTokens: 1 },
+				{ type: "done", id: "r2", success: true },
+			],
+		]);
+		createHandlerMock.mockReturnValue(handler);
+
+		const agent = new Agent({
+			providerId: "anthropic",
+			modelId: "mock-model",
+			systemPrompt: "Use tools",
+			tools: [runCommandsTool],
+		});
+
+		const result = await agent.run("run a command");
+		expect(result.finishReason).toBe("completed");
+		expect(result.toolCalls).toHaveLength(1);
+		expect(result.toolCalls[0]?.error).toBeUndefined();
+		expect(result.toolCalls[0]?.output).toEqual(["pwd"]);
+		expect(executeRunCommands).toHaveBeenCalledTimes(1);
+	});
+
 	it("passes through array-shaped read_files tool args", async () => {
 		const { Agent } = await import("./agent.js");
 		const readFilesTool = createTool({