@kirosnn/mosaic 0.0.9 → 0.71.0

package/src/agent/prompts/toolsPrompt.ts

@@ -1,139 +1,221 @@
 export const TOOLS_PROMPT = `
-AVAILABLE TOOLS:
-
-You have access to the following tools to interact with the workspace:
-
-FILE READING:
-1. read: Read the complete contents of a file
-   - Use this to examine existing code, configuration, or documentation
-   - Parameters: path (string)
-
-FILE WRITING & EDITING:
-2. write: Write or overwrite a file (with advanced features)
-   - Creates parent directories automatically if they don't exist
-   - Can append to existing files instead of overwriting
-   - Parameters: path (string), content (string, optional), append (boolean, optional)
-   - Note: content can be omitted or empty to create an empty file
-
-3. edit: Edit a specific part of a file without rewriting everything
-   - More efficient for targeted changes - replace specific text content
-   - Parameters: path (string), old_content (string), new_content (string), occurrence (number, optional)
-
-FILE & DIRECTORY OPERATIONS:
-4. list: List files and directories with filtering
-   - Supports recursive listing through subdirectories
-   - Can filter by glob patterns (e.g., "*.ts")
-   - Can include or exclude hidden files
-   - Parameters: path (string), recursive (boolean, optional), filter (string, optional), include_hidden (boolean, optional)
-
-SEARCH & DISCOVERY:
-5. glob: Fast file pattern matching
-   - Find files matching a glob pattern
-   - REQUIRED: pattern (string) - Glob pattern to match files (e.g., "*.ts", "**/*.tsx", "src/**/*.js")
-   - OPTIONAL: path (string) - Directory to search in (default: workspace root)
-
-   Examples:
-   - Find all TypeScript files: glob(pattern="**/*.ts")
-   - Find React components: glob(pattern="**/*.tsx")
-   - Search in specific directory: glob(pattern="*.js", path="src")
-
-6. grep: Search for text content within files
-   - Search for text within files matching a glob pattern
-   - REQUIRED: pattern (string) - Glob pattern to match files (e.g., "*.ts", "**/*.tsx")
-   - REQUIRED: query (string) - Text content to search for
-   - OPTIONAL: path (string) - Directory to search in (default: workspace root)
-   - OPTIONAL: case_sensitive (boolean) - Case-sensitive search (default: false)
-   - OPTIONAL: max_results (number) - Maximum results (default: 100)
-
-   Examples:
-   - Find interface in TypeScript files: grep(pattern="**/*.ts", query="interface User")
-   - Search in specific directory: grep(pattern="*.js", query="console.log", path="src")
-   - Case-sensitive search: grep(pattern="**/*.ts", query="UserModel", case_sensitive=true)
-
-AUTONOMOUS EXPLORATION:
-7. explore: Launch an autonomous exploration agent
-   - Explores the codebase iteratively to gather information
-   - The agent uses read, glob, grep, and list tools autonomously
-   - Continues until it has enough information or reaches its limit
-   - Use for open-ended exploration tasks
-   - Parameters: purpose (string) - The goal of the exploration
-
-   Examples:
-   - Understand project structure:
-     explore(purpose="Understand the project structure and main entry points")
-   - Find implementations:
-     explore(purpose="Find all React components that handle user authentication")
-   - Investigate code patterns:
-     explore(purpose="Find how errors are handled throughout the codebase")
-
-COMMAND EXECUTION:
-8. bash: Execute a shell command
-   - Use this to run build tools, tests, git commands, or other CLI tools
-   - Parameters: command (string)
-   - CRITICAL: You MUST add --timeout <ms> at the END of commands that might hang:
-     * Dev servers: ALWAYS add --timeout 5000
-       Example: bash(command="npm run dev --timeout 5000")
-     * Build commands: ALWAYS add --timeout 120000
-       Example: bash(command="npm run build --timeout 120000")
-     * Test runners: ALWAYS add --timeout 60000
-       Example: bash(command="pytest tests/ --timeout 60000")
-     * Package installs: ALWAYS add --timeout 120000
-       Example: bash(command="npm install --timeout 120000")
-     * Interactive CLIs: ALWAYS add --timeout 5000 or avoid entirely
-       Example: bash(command="npx create-react-app myapp --timeout 5000")
-   - Quick commands (ls, cat, git status, echo): No --timeout needed (default: 30s)
-
-USER INTERACTION:
-9. question: Ask the user a question with predefined options
-   - CRITICAL: This is the ONLY way to ask the user questions. NEVER ask questions in plain text.
-   - MANDATORY usage scenarios:
-     * When you need user to pick between choices
-     * When you need user's confirmation or approval
-     * When you need clarification on ambiguous requests
-     * When you're unsure how to proceed
-     * When a tool operation is rejected and you need to know why
-     * When multiple approaches are possible and user input is needed
-   - The UI will show the prompt and options and return the selected option
-   - Parameters:
-     - prompt (string) - The question to ask in the user's language
-     - options (array of objects) - At least 2 options required:
-       - label (string) - The option text shown to user
-       - value (string | null) - Optional value returned (use null if not needed)
-   - Returns: { id, index, label, value }
-   - Example: question(prompt="Which approach do you prefer?", options=[{label:"Approach A", value:"a"}, {label:"Approach B", value:"b"}])
-
-TOOL USAGE GUIDELINES:
-
-- Use explore for open-ended exploration tasks (autonomous agent)
-- Use glob to find files by pattern (fast file discovery)
-- Use grep to search for text content within files
-- Use edit for small changes to avoid rewriting entire files
-- Always use read before modifying files to understand the current state
-- When writing files, preserve existing code structure and style
-- Use list with recursive:true to explore deep directory structures
-- All file paths are relative to the workspace root: {{WORKSPACE}}
-
-ERRORS:
-- Some tools return an object like {"error": "..."} when something went wrong. Treat this as a TOOL ERROR (not an API error).
-- When a tool returns an error, continue the task using that information (e.g., adjust path, create missing parent directory, retry with correct tool).
-
-WORKFLOW BEST PRACTICES:
-
-1. Discover: Use explore for open-ended exploration, or glob/grep for targeted searches
-2. Understand: Use read to examine files
-3. Plan: Think through modifications before acting
-4. Execute: Use edit for small changes, write for new/complete rewrites
-5. Verify: Use bash to run tests and verify changes
-6. Communicate: Explain your actions to the user in their language
-
-CRITICAL REMINDERS:
-- NEVER ask questions in plain text - ALWAYS use the question tool
-- When write/edit/bash operations are rejected by the user, IMMEDIATELY use the question tool to understand why and what to do instead
-- The question tool is NOT optional - it's MANDATORY for any user interaction requiring a response
-- If you catch yourself about to ask something in text, STOP and use the question tool instead
-
-Remember: The user can see your tool usage, so be transparent about what you're doing and why.`;
+# Available Tools
+
+## File Operations
+
+### read
+Read file contents. ALWAYS read before modifying.
+- path (string, required): File path relative to workspace
+- start_line (number, optional): Start reading from this line (1-based)
+- end_line (number, optional): End reading at this line (1-based)
+
+### write
+Create or overwrite a file. Creates parent directories automatically.
+- path (string, required): File path
+- content (string, optional): File content (empty to create empty file)
+- append (boolean, optional): Append instead of overwrite
+
+### edit
+Replace specific text in a file. Preferred for targeted changes.
+- path (string, required): File path
+- old_content (string, required): Exact text to replace
+- new_content (string, required): Replacement text
+- occurrence (number, optional): Which occurrence (default: 1)
+
+### list
+List directory contents.
+- path (string, required): Directory path
+- recursive (boolean, optional): Include subdirectories
+- filter (string, optional): Glob pattern filter
+- include_hidden (boolean, optional): Include hidden files
+
+## Search & Discovery
+
+### explore (RECOMMENDED for understanding context)
+Autonomous exploration agent that intelligently searches the codebase.
+- purpose (string, required): What to find/understand
+
+USE EXPLORE WHEN:
+- Starting work on an unfamiliar codebase
+- Understanding how something works
+- Finding related code, patterns, or architecture
+- You're unsure where to make changes
+
+Examples:
+- explore(purpose="Find API endpoints and understand routing")
+- explore(purpose="Understand the authentication flow")
+- explore(purpose="Find UserService and all its usages")
+
+The explore tool is INTELLIGENT - it autonomously reads files, follows imports, and builds understanding. This is MORE EFFICIENT than manual glob/grep/read cycles.
+
+### glob
+Find files by name pattern. Fast file discovery.
+- pattern (string, required): Glob pattern with **/ for recursive search
+- path (string, optional): Directory to search
+
+IMPORTANT: Use "**/" prefix for recursive search:
+- "**/*.ts" - All TypeScript files (recursive)
+- "*.ts" - Only in current directory (NOT recursive)
+
+### 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.
+- pattern (string, optional): Glob pattern for files
+- regex (boolean, optional): Treat query as regex
+- context (number, optional): Lines around matches
+- output_mode (string, optional): "matches", "files", or "count"
+
+RECOMMENDED: Use file_type for best results:
+- grep(query="handleClick", file_type="tsx")
+- grep(query="interface User", file_type="ts")
+
+TOOL SELECTION:
+| Need to understand how X works | explore |
+| Find specific file by name | glob |
+| Find specific text in code | grep |
+
+## Planning
+
+### plan
+Track progress on multi-step tasks.
+- explanation (string, optional): Context about the plan
+- plan (array, required): Steps with statuses
+  - 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.
+
+## Web Access
+
+### fetch
+Retrieve web content as markdown.
+- url (string, required): URL to fetch
+- max_length (number, optional): Max chars (default: 10000)
+- start_index (number, optional): For pagination
+- raw (boolean, optional): Return raw HTML
+- timeout (number, optional): Timeout in ms (default: 30000)
+
+## Command Execution
+
+### bash
+Execute shell commands. Adapt to OS ({{OS}}).
+- command (string, required): Command to execute
+
+Timeouts (add --timeout <ms> to long commands):
+- Dev servers: 5000
+- Builds: 120000
+- Tests: 60000
+- Package installs: 120000
+
+## User Interaction
+
+### question
+Ask user with predefined options. ONLY way to ask questions.
+- prompt (string, required): Question in user's language
+- options (array, required): At least 2 options
+  - label (string): Display text
+  - value (string|null): Return value
+
+CRITICAL: Never ask questions in plain text. Always use this tool.
+
+# Tool Selection Guide
+
+| Task | Tool | Example |
+|------|------|---------|
+| Understand codebase/architecture | explore | explore(purpose="How does auth work?") |
+| Find files by name | glob | glob(pattern="**/*.config.ts") |
+| Find specific text | grep | grep(query="handleSubmit", file_type="tsx") |
+| Read file contents | read | read(path="src/auth.ts") |
+| Small targeted edit | edit | edit(path="...", old_content="...", new_content="...") |
+| New file or full rewrite | write | write(path="...", content="...") |
+| Run commands/tests | bash | bash(command="npm test") |
+| Track multi-step work | plan | plan(plan=[...]) |
+| Need user input | question | question(prompt="...", options=[...]) |
+
+PREFER EXPLORE for understanding context before making changes.
+PREFER grep with file_type for targeted text searches.
+
+# Continuation - CRITICAL
+
+NEVER stop after using a tool. ALWAYS continue to the next step in the SAME response.
+
+Pattern: text → tool → text → tool → text → tool → ... → completion
+
+CORRECT:
+"Searching for config files." → [glob] → "Found 3 files. Reading the main one." → [read] → "I see the issue. Fixing now." → [edit] → "Done."
+
+WRONG:
+"Searching for config files." → [glob] → "Found 3 files. I'll read them next." → [STOP]
+
+After EVERY tool result, you must either:
+1. Continue with the next action (use another tool), OR
+2. Complete the task with a summary, OR
+3. Ask the user via question tool if genuinely blocked
+
+FORBIDDEN:
+- Stopping mid-task after announcing what you'll do next
+- Ending with "I'll do X next" without actually doing X
+- Waiting for implicit user approval to continue
+
+# Communication with Tools
+
+BEFORE using tools:
+- Brief explanation of what you're doing
+- Then IMMEDIATELY use the tool in the same response
+
+AFTER tool results:
+- Brief comment on result if needed
+- Then IMMEDIATELY continue to next action
+
+AFTER tool errors:
+- Explain what went wrong
+- Then IMMEDIATELY retry with different approach
+
+# File Modification - MANDATORY RULE
+
+You MUST read a file BEFORE modifying it. This is NOT optional.
+
+Correct workflow:
+1. "Let me examine the current implementation." → read(path="src/auth.ts")
+2. "I see the issue. I'll fix the validation logic." → edit(path="src/auth.ts", ...)
+
+WRONG (will fail):
+- Using edit or write on a file you haven't read in this conversation
+- Assuming you know what's in a file without reading it
+
+# Error Recovery
+
+When a tool returns {"error": "..."}:
+1. Tell the user what went wrong
+2. Explain your retry strategy
+3. Try with adjusted parameters
+4. After 2-3 failures, explain the blocker and ask for help
+
+# Question Tool - When to Use
+
+USE question tool:
+- Multiple valid approaches need user preference
+- Destructive action needs confirmation
+- Requirements are genuinely ambiguous
+- A tool was rejected and you need to understand why
+
+DO NOT use question tool:
+- You can figure out the answer by exploring
+- The path forward is reasonably clear
+- It's a standard implementation decision
+
+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`;
 
 export function getToolsPrompt(): string {
   return TOOLS_PROMPT;
-}
+}

package/src/agent/provider/anthropic.ts

@@ -1,6 +1,7 @@
-import { streamText, CoreMessage } from 'ai';
-import { createAnthropic } from '@ai-sdk/anthropic';
-import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { streamText, CoreMessage } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { shouldEnableReasoning } from './reasoning';
 
 export class AnthropicProvider implements Provider {
   async *sendMessage(
@@ -8,8 +9,9 @@ export class AnthropicProvider implements Provider {
     config: ProviderConfig,
     options?: ProviderSendOptions
   ): AsyncGenerator<AgentEvent> {
-    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
-    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
+    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+    const reasoningEnabled = await shouldEnableReasoning(config.provider, cleanModel);
 
     const anthropic = createAnthropic({
       apiKey: cleanApiKey,
@@ -19,15 +21,17 @@ export class AnthropicProvider implements Provider {
       model: anthropic(cleanModel),
       messages: messages,
       system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal,
-      experimental_providerMetadata: {
-        anthropic: {
-          thinkingBudgetTokens: 10000,
-        },
-      },
-    });
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal,
+      experimental_providerMetadata: reasoningEnabled
+        ? {
+          anthropic: {
+            thinkingBudgetTokens: 10000,
+          },
+        }
+        : undefined,
+    });
 
     try {
       let stepCounter = 0;
@@ -119,4 +123,4 @@ export class AnthropicProvider implements Provider {
       };
     }
   }
-}
+}

package/src/agent/provider/google.ts

@@ -1,6 +1,7 @@
-import { streamText, CoreMessage } from 'ai';
-import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { streamText, CoreMessage } from 'ai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { shouldEnableReasoning } from './reasoning';
 
 export class GoogleProvider implements Provider {
   async *sendMessage(
@@ -8,8 +9,9 @@ export class GoogleProvider implements Provider {
     config: ProviderConfig,
     options?: ProviderSendOptions
   ): AsyncGenerator<AgentEvent> {
-    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
-    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
+    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+    const reasoningEnabled = await shouldEnableReasoning(config.provider, cleanModel);
 
     const google = createGoogleGenerativeAI({
       apiKey: cleanApiKey,
@@ -19,17 +21,19 @@ export class GoogleProvider implements Provider {
       model: google(cleanModel),
       messages: messages,
       system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal,
-      providerOptions: {
-        google: {
-          thinkingConfig: {
-            style: 'THINKING_STYLE_DETAILED',
-          },
-        },
-      },
-    });
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal,
+      providerOptions: reasoningEnabled
+        ? {
+          google: {
+            thinkingConfig: {
+              style: 'THINKING_STYLE_DETAILED',
+            },
+          },
+        }
+        : undefined,
+    });
 
     try {
       let stepCounter = 0;
@@ -121,4 +125,4 @@ export class GoogleProvider implements Provider {
       };
     }
   }
-}
+}

package/src/agent/provider/ollama.ts

@@ -1,7 +1,10 @@
 import { Ollama } from 'ollama';
 import { spawn } from 'child_process';
-import { CoreMessage, CoreTool } from 'ai';
-import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { CoreMessage, CoreTool } from 'ai';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { z } from 'zod';
+import { shouldEnableReasoning } from './reasoning';
 
 let serveStartPromise: Promise<void> | null = null;
 const pullPromises = new Map<string, Promise<void>>();
@@ -194,9 +197,9 @@ async function ensureOllamaModelAvailable(ollamaClient: Ollama, model: string):
   return p;
 }
 
-function contentToString(content: CoreMessage['content']): string {
-  if (typeof content === 'string') return content;
-  if (!content) return '';
+function contentToString(content: CoreMessage['content']): string {
+  if (typeof content === 'string') return content;
+  if (!content) return '';
 
   if (Array.isArray(content)) {
     const text = content
@@ -215,30 +218,50 @@ function contentToString(content: CoreMessage['content']): string {
     return JSON.stringify(content);
   } catch {
     return String(content);
-  }
-}
+  }
+}
+
+function imagePartToBase64(image: any): string | undefined {
+  if (!image) return undefined;
+  if (typeof image === 'string') return image;
+  if (Buffer.isBuffer(image)) return image.toString('base64');
+  if (image instanceof Uint8Array) return Buffer.from(image).toString('base64');
+  if (image instanceof ArrayBuffer) return Buffer.from(new Uint8Array(image)).toString('base64');
+  return undefined;
+}
 
 function toOllamaTools(tools?: Record<string, CoreTool>): any[] | undefined {
   if (!tools) return undefined;
 
-  return Object.entries(tools).map(([name, tool]) => ({
-    type: 'function',
-    function: {
-      name,
-      description: String((tool as any)?.description ?? name),
-      parameters: (() => {
-        const params = (tool as any)?.parameters;
-        if (params && typeof params === 'object' && 'type' in params) return params;
-        return { type: 'object', properties: {} };
-      })(),
-    },
-  }));
+  return Object.entries(tools).map(([name, tool]) => {
+    const params = (tool as any)?.parameters;
+    let jsonSchema: any = { type: 'object', properties: {} };
+
+    if (params) {
+      if (params instanceof z.ZodType) {
+        const converted = zodToJsonSchema(params, { target: 'openApi3' });
+        jsonSchema = converted;
+        if ('$schema' in jsonSchema) delete jsonSchema.$schema;
+      } else if (typeof params === 'object' && 'type' in params) {
+        jsonSchema = params;
+      }
+    }
+
+    return {
+      type: 'function',
+      function: {
+        name,
+        description: String((tool as any)?.description ?? name),
+        parameters: jsonSchema,
+      },
+    };
+  });
 }
 
-function coreMessagesToOllamaMessages(messages: CoreMessage[]): any[] {
-  return messages
-    .map((message) => {
-      if (message.role === 'tool') {
+function coreMessagesToOllamaMessages(messages: CoreMessage[]): any[] {
+  return messages
+    .map((message) => {
+      if (message.role === 'tool') {
         const content: any = message.content;
         const part = Array.isArray(content) ? content?.[0] : undefined;
         const toolName = part?.toolName ?? part?.tool_name;
@@ -269,13 +292,28 @@ function coreMessagesToOllamaMessages(messages: CoreMessage[]): any[] {
         };
       }
 
-      return {
-        role: message.role,
-        content: contentToString(message.content),
-      };
-    })
-    .filter(Boolean);
-}
+      if (message.role === 'user' && Array.isArray(message.content)) {
+        const textParts = message.content
+          .map((part: any) => (part && typeof part.text === 'string' ? part.text : ''))
+          .filter(Boolean)
+          .join('');
+        const images = message.content
+          .map((part: any) => (part && part.type === 'image' ? imagePartToBase64(part.image) : undefined))
+          .filter(Boolean);
+        const msg: any = { role: 'user', content: textParts };
+        if (images.length > 0) {
+          msg.images = images;
+        }
+        return msg;
+      }
+
+      return {
+        role: message.role,
+        content: contentToString(message.content),
+      };
+    })
+    .filter(Boolean);
+}
 
 export async function checkAndStartOllama(): Promise<{ running: boolean; started: boolean; error?: string }> {
   const ollamaClient = new Ollama();
@@ -306,8 +344,9 @@ export class OllamaProvider implements Provider {
     config: ProviderConfig,
     options?: ProviderSendOptions
   ): AsyncGenerator<AgentEvent> {
-    const apiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
-    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+    const apiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
+    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+    const reasoningEnabled = await shouldEnableReasoning(config.provider, cleanModel);
 
     if (options?.abortSignal?.aborted) {
       return;
@@ -396,14 +435,14 @@ export class OllamaProvider implements Provider {
 
         const stream = await retry(
           () =>
-            ollamaClient.chat({
-              model: requestModel,
-              messages: ollamaMessages,
-              tools: toolsSchema,
-              stream: true,
-              think: true,
-              signal: options?.abortSignal,
-            } as any) as any,
+            ollamaClient.chat({
+              model: requestModel,
+              messages: ollamaMessages,
+              tools: toolsSchema,
+              stream: true,
+              think: reasoningEnabled,
+              signal: options?.abortSignal,
+            } as any) as any,
           2,
           500
         );
@@ -528,4 +567,4 @@ export class OllamaProvider implements Provider {
       };
     }
   }
-}
+}