@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/agent/prompts/toolsPrompt.ts

@@ -60,7 +60,7 @@ IMPORTANT: Use "**/" prefix for recursive search:
 ### grep
 Search for text within files.
 - query (string, required): Text to search for
-- file_type (string, optional): ts, tsx, js, jsx, py, java, go, etc.
+- file_type (string, optional): language or extension (ts, tsx, js, txt, .env)
 - pattern (string, optional): Glob pattern for files
 - regex (boolean, optional): Treat query as regex
 - context (number, optional): Lines around matches
@@ -84,8 +84,16 @@ Track progress on multi-step tasks.
   - step (string): Action description
   - status: "pending" | "in_progress" | "completed"
 
-Use plan for tasks with 3+ steps. Update as you progress.
-Always update the plan after each step is completed.
+Use plan for any task that is not a single obvious step. Default to planning when unsure.
+Use plan when there are 2+ actions, file changes, or unclear success criteria.
+Plan rules:
+- Keep plans short (3-6 steps) and outcome-focused
+- Exactly one step can be "in_progress" at a time
+- Mark a step "completed" before starting the next
+- Keep unstarted steps "pending"
+Always update the plan after each step.
+Never output a plan as plain text, JSON, or tags. Use the plan tool call only.
+Never mark multiple future steps as completed in a single update. Show progress incrementally as each step is done.
 
 ## Web Access
 
@@ -117,6 +125,11 @@ Ask user with predefined options. ONLY way to ask questions.
 - options (array, required): At least 2 options
   - label (string): Display text
   - value (string|null): Return value
+  - group (string, optional): Group header for consecutive options with the same group
+- timeout (number, optional): Seconds before the question auto-rejects
+- validation (object, optional): Regex validation for custom text input
+  - pattern (string): Regex pattern the custom text must match
+  - message (string, optional): Error message shown on validation failure
 
 CRITICAL: Never ask questions in plain text. Always use this tool.
 
@@ -210,12 +223,64 @@ NEVER ask questions in plain text. The question tool is MANDATORY.
 
 # Workflow Summary
 
-1. COMMUNICATE: Say what you're about to do
-2. READ: Always read files before modifying
-3. ACT: Use the appropriate tool
-4. VERIFY: Run tests/builds to confirm
-5. REPORT: Summarize what was done`;
+1. PLAN: Use plan unless the task is trivial (single obvious action)
+2. COMMUNICATE: Say what you're about to do
+3. READ: Always read files before modifying
+4. ACT: Use the appropriate tool
+5. VERIFY: Run tests/builds to confirm
+6. REPORT: Summarize what was done`;
 
-export function getToolsPrompt(): string {
-  return TOOLS_PROMPT;
+export function getToolsPrompt(mcpToolInfos?: Array<{ serverId: string; name: string; description: string; inputSchema: Record<string, unknown>; canonicalId: string; safeId: string }>): string {
+  if (!mcpToolInfos || mcpToolInfos.length === 0) {
+    return TOOLS_PROMPT;
+  }
+
+  const mcpSection = buildMcpToolsSection(mcpToolInfos);
+  return TOOLS_PROMPT + '\n\n' + mcpSection;
+}
+
+function buildMcpToolsSection(tools: Array<{ serverId: string; name: string; description: string; inputSchema: Record<string, unknown>; canonicalId: string; safeId: string }>): string {
+  const lines: string[] = [];
+  lines.push('## External Tools (MCP)');
+  lines.push('');
+  lines.push('These tools are provided by external MCP servers. Call them by their tool name.');
+  lines.push('They may require approval before execution.');
+  lines.push('');
+
+  const byServer = new Map<string, typeof tools>();
+  for (const t of tools) {
+    const list = byServer.get(t.serverId) || [];
+    list.push(t);
+    byServer.set(t.serverId, list);
+  }
+
+  for (const [serverId, serverTools] of byServer) {
+    lines.push(`### Server: ${serverId}`);
+    lines.push('');
+    for (const t of serverTools) {
+      lines.push(`#### ${t.safeId}`);
+      if (t.description) {
+        lines.push(t.description);
+      }
+      const schema = t.inputSchema;
+      if (schema && typeof schema === 'object' && schema.properties) {
+        const props = schema.properties as Record<string, Record<string, unknown>>;
+        const required = (schema.required || []) as string[];
+        const paramLines: string[] = [];
+        for (const [key, propSchema] of Object.entries(props)) {
+          const type = propSchema.type || 'unknown';
+          const desc = propSchema.description || '';
+          const req = required.includes(key) ? 'required' : 'optional';
+          paramLines.push(`- ${key} (${type}, ${req})${desc ? ': ' + desc : ''}`);
+        }
+        if (paramLines.length > 0) {
+          lines.push('Parameters:');
+          lines.push(...paramLines);
+        }
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
 }

package/src/agent/provider/anthropic.ts

@@ -2,6 +2,7 @@ import { streamText, CoreMessage } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
 import { shouldEnableReasoning } from './reasoning';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 export class AnthropicProvider implements Provider {
   async *sendMessage(
@@ -17,107 +18,106 @@ export class AnthropicProvider implements Provider {
       apiKey: cleanApiKey,
     });
 
-    const result = streamText({
-      model: anthropic(cleanModel),
-      messages: messages,
-      system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal,
-      experimental_providerMetadata: reasoningEnabled
-        ? {
-          anthropic: {
-            thinkingBudgetTokens: 10000,
-          },
+    try {
+      let stepCounter = 0;
+
+      yield* runWithRetry(async function* () {
+        const result = streamText({
+          model: anthropic(cleanModel),
+          messages: messages,
+          system: config.systemPrompt,
+          tools: config.tools,
+          maxSteps: config.maxSteps || 100,
+          abortSignal: options?.abortSignal,
+          experimental_providerMetadata: reasoningEnabled
+            ? {
+              anthropic: {
+                thinkingBudgetTokens: 10000,
+              },
+            }
+            : undefined,
+        });
+
+        for await (const chunk of result.fullStream as any) {
+          const c: any = chunk;
+          switch (c.type) {
+            case 'reasoning':
+              if (c.textDelta) {
+                yield {
+                  type: 'reasoning-delta',
+                  content: c.textDelta,
+                };
+              }
+              break;
+
+            case 'text-delta':
+              yield {
+                type: 'text-delta',
+                content: c.textDelta,
+              };
+              break;
+
+            case 'step-start':
+              yield {
+                type: 'step-start',
+                stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
+              };
+              stepCounter++;
+              break;
+
+            case 'step-finish':
+              yield {
+                type: 'step-finish',
+                stepNumber:
+                  typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
+                finishReason: String(c.finishReason ?? 'stop'),
+              };
+              break;
+
+            case 'tool-call':
+              yield {
+                type: 'tool-call-end',
+                toolCallId: String(c.toolCallId ?? ''),
+                toolName: String(c.toolName ?? ''),
+                args: (c.args ?? {}) as Record<string, unknown>,
+              };
+              break;
+
+            case 'tool-result':
+              yield {
+                type: 'tool-result',
+                toolCallId: String(c.toolCallId ?? ''),
+                toolName: String(c.toolName ?? ''),
+                result: c.result,
+              };
+              break;
+
+            case 'finish':
+              yield {
+                type: 'finish',
+                finishReason: String(c.finishReason ?? 'stop'),
+                usage: c.usage,
+              };
+              break;
+
+            case 'error': {
+              const err = normalizeError(c.error);
+              const decision = getRetryDecision(err);
+              if (decision.shouldRetry) {
+                throw err;
+              }
+              yield {
+                type: 'error',
+                error: err.message,
+              };
+              break;
+            }
+          }
         }
-        : undefined,
-    });
-
-    try {
-      let stepCounter = 0;
-
-      for await (const chunk of result.fullStream as any) {
-        const c: any = chunk;
-        switch (c.type) {
-          case 'reasoning':
-            if (c.textDelta) {
-              yield {
-                type: 'reasoning-delta',
-                content: c.textDelta,
-              };
-            }
-            break;
-
-          case 'text-delta':
-            yield {
-              type: 'text-delta',
-              content: c.textDelta,
-            };
-            break;
-
-          case 'step-start':
-            yield {
-              type: 'step-start',
-              stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
-            };
-            stepCounter++;
-            break;
-
-          case 'step-finish':
-            yield {
-              type: 'step-finish',
-              stepNumber:
-                typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
-              finishReason: String(c.finishReason ?? 'stop'),
-            };
-            break;
-
-          case 'tool-call':
-            yield {
-              type: 'tool-call-end',
-              toolCallId: String(c.toolCallId ?? ''),
-              toolName: String(c.toolName ?? ''),
-              args: (c.args ?? {}) as Record<string, unknown>,
-            };
-            break;
-
-          case 'tool-result':
-            yield {
-              type: 'tool-result',
-              toolCallId: String(c.toolCallId ?? ''),
-              toolName: String(c.toolName ?? ''),
-              result: c.result,
-            };
-            break;
-
-          case 'finish':
-            yield {
-              type: 'finish',
-              finishReason: String(c.finishReason ?? 'stop'),
-              usage: c.usage,
-            };
-            break;
-
-          case 'error':
-            {
-              const err = c.error;
-              const msg =
-                err instanceof Error
-                  ? err.message
-                  : typeof err === 'string'
-                    ? err
-                    : 'Unknown error';
-            yield {
-              type: 'error',
-              error: msg,
-            };
-            }
-            break;
-        }
-      }
-    } catch (error) {
-      if (options?.abortSignal?.aborted) return;
-      yield {
+      }, { abortSignal: options?.abortSignal });
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      yield {
         type: 'error',
         error: error instanceof Error ? error.message : 'Unknown error occurred',
       };

package/src/agent/provider/google.ts

@@ -2,6 +2,7 @@ import { streamText, CoreMessage } from 'ai';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
 import { shouldEnableReasoning } from './reasoning';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 export class GoogleProvider implements Provider {
   async *sendMessage(
@@ -17,109 +18,108 @@ export class GoogleProvider implements Provider {
       apiKey: cleanApiKey,
     });
 
-    const result = streamText({
-      model: google(cleanModel),
-      messages: messages,
-      system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal,
-      providerOptions: reasoningEnabled
-        ? {
-          google: {
-            thinkingConfig: {
-              style: 'THINKING_STYLE_DETAILED',
-            },
-          },
+    try {
+      let stepCounter = 0;
+
+      yield* runWithRetry(async function* () {
+        const result = streamText({
+          model: google(cleanModel),
+          messages: messages,
+          system: config.systemPrompt,
+          tools: config.tools,
+          maxSteps: config.maxSteps || 100,
+          abortSignal: options?.abortSignal,
+          providerOptions: reasoningEnabled
+            ? {
+              google: {
+                thinkingConfig: {
+                  style: 'THINKING_STYLE_DETAILED',
+                },
+              },
+            }
+            : undefined,
+        });
+
+        for await (const chunk of result.fullStream as any) {
+          const c: any = chunk;
+          switch (c.type) {
+            case 'reasoning':
+              if (c.textDelta) {
+                yield {
+                  type: 'reasoning-delta',
+                  content: c.textDelta,
+                };
+              }
+              break;
+
+            case 'text-delta':
+              yield {
+                type: 'text-delta',
+                content: c.textDelta,
+              };
+              break;
+
+            case 'step-start':
+              yield {
+                type: 'step-start',
+                stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
+              };
+              stepCounter++;
+              break;
+
+            case 'step-finish':
+              yield {
+                type: 'step-finish',
+                stepNumber:
+                  typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
+                finishReason: String(c.finishReason ?? 'stop'),
+              };
+              break;
+
+            case 'tool-call':
+              yield {
+                type: 'tool-call-end',
+                toolCallId: String(c.toolCallId ?? ''),
+                toolName: String(c.toolName ?? ''),
+                args: (c.args ?? {}) as Record<string, unknown>,
+              };
+              break;
+
+            case 'tool-result':
+              yield {
+                type: 'tool-result',
+                toolCallId: String(c.toolCallId ?? ''),
+                toolName: String(c.toolName ?? ''),
+                result: c.result,
+              };
+              break;
+
+            case 'finish':
+              yield {
+                type: 'finish',
+                finishReason: String(c.finishReason ?? 'stop'),
+                usage: c.usage,
+              };
+              break;
+
+            case 'error': {
+              const err = normalizeError(c.error);
+              const decision = getRetryDecision(err);
+              if (decision.shouldRetry) {
+                throw err;
+              }
+              yield {
+                type: 'error',
+                error: err.message,
+              };
+              break;
+            }
+          }
         }
-        : undefined,
-    });
-
-    try {
-      let stepCounter = 0;
-
-      for await (const chunk of result.fullStream as any) {
-        const c: any = chunk;
-        switch (c.type) {
-          case 'reasoning':
-            if (c.textDelta) {
-              yield {
-                type: 'reasoning-delta',
-                content: c.textDelta,
-              };
-            }
-            break;
-
-          case 'text-delta':
-            yield {
-              type: 'text-delta',
-              content: c.textDelta,
-            };
-            break;
-
-          case 'step-start':
-            yield {
-              type: 'step-start',
-              stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
-            };
-            stepCounter++;
-            break;
-
-          case 'step-finish':
-            yield {
-              type: 'step-finish',
-              stepNumber:
-                typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
-              finishReason: String(c.finishReason ?? 'stop'),
-            };
-            break;
-
-          case 'tool-call':
-            yield {
-              type: 'tool-call-end',
-              toolCallId: String(c.toolCallId ?? ''),
-              toolName: String(c.toolName ?? ''),
-              args: (c.args ?? {}) as Record<string, unknown>,
-            };
-            break;
-
-          case 'tool-result':
-            yield {
-              type: 'tool-result',
-              toolCallId: String(c.toolCallId ?? ''),
-              toolName: String(c.toolName ?? ''),
-              result: c.result,
-            };
-            break;
-
-          case 'finish':
-            yield {
-              type: 'finish',
-              finishReason: String(c.finishReason ?? 'stop'),
-              usage: c.usage,
-            };
-            break;
-
-          case 'error':
-            {
-              const err = c.error;
-              const msg =
-                err instanceof Error
-                  ? err.message
-                  : typeof err === 'string'
-                    ? err
-                    : 'Unknown error';
-            yield {
-              type: 'error',
-              error: msg,
-            };
-            }
-            break;
-        }
-      }
-    } catch (error) {
-      if (options?.abortSignal?.aborted) return;
-      yield {
+      }, { abortSignal: options?.abortSignal });
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      yield {
         type: 'error',
         error: error instanceof Error ? error.message : 'Unknown error occurred',
       };