@kirosnn/mosaic 0.0.7

package/src/agent/provider/openai.ts

@@ -0,0 +1,220 @@
+import { streamText, CoreMessage } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+
+export class OpenAIProvider implements Provider {
+  async *sendMessage(
+    messages: CoreMessage[],
+    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 openai = createOpenAI({
+      apiKey: cleanApiKey,
+    });
+
+    type OpenAIEndpoint = 'responses' | 'chat' | 'completion';
+
+    const pickModel = (endpoint: OpenAIEndpoint) => {
+      switch (endpoint) {
+        case 'responses':
+          return openai.responses(cleanModel);
+        case 'chat':
+          return openai.chat(cleanModel);
+        case 'completion':
+          return openai.completion(cleanModel);
+      }
+    };
+
+    const run = async function* (
+      endpoint: OpenAIEndpoint,
+      strictJsonSchema: boolean
+    ): AsyncGenerator<AgentEvent> {
+      const result = streamText({
+        model: pickModel(endpoint),
+        messages: messages,
+        system: config.systemPrompt,
+        tools: config.tools,
+        maxSteps: config.maxSteps ?? 10,
+        abortSignal: options?.abortSignal,
+        providerOptions: {
+          openai: {
+            strictJsonSchema,
+            reasoningEffort: 'medium',
+          },
+        },
+      });
+
+      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;
+        }
+      }
+
+      return;
+    };
+
+    const classifyEndpointError = (msg: string): OpenAIEndpoint | null => {
+      const m = msg || '';
+      if (m.includes('v1/chat/completions')) {
+        if (m.toLowerCase().includes('not a chat model')) return 'responses';
+      }
+      if (m.includes('v1/responses')) {
+        if (m.toLowerCase().includes('not supported') || m.toLowerCase().includes('unknown')) return 'chat';
+      }
+      if (m.includes('v1/completions')) {
+        return 'completion';
+      }
+      if (m.toLowerCase().includes('did you mean to use v1/completions')) {
+        return 'completion';
+      }
+      return null;
+    };
+
+    try {
+      yield* run('responses', true);
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      const msg = error instanceof Error ? error.message : String(error);
+      const looksLikeStrictSchemaError =
+        msg.includes('Invalid schema for function') &&
+        msg.includes('required') &&
+        msg.includes('properties');
+
+      if (looksLikeStrictSchemaError) {
+        try {
+          yield* run('responses', false);
+          return;
+        } catch (retryError) {
+          if (options?.abortSignal?.aborted) return;
+          yield {
+            type: 'error',
+            error: retryError instanceof Error ? retryError.message : 'Unknown error occurred',
+          };
+          return;
+        }
+      }
+
+      const fallbackEndpoint = classifyEndpointError(msg);
+      if (fallbackEndpoint && fallbackEndpoint !== 'responses') {
+        try {
+          yield* run(fallbackEndpoint, true);
+          return;
+        } catch (endpointError) {
+          if (options?.abortSignal?.aborted) return;
+          const endpointMsg = endpointError instanceof Error ? endpointError.message : String(endpointError);
+          const strictSchemaFromFallback =
+            endpointMsg.includes('Invalid schema for function') &&
+            endpointMsg.includes('required') &&
+            endpointMsg.includes('properties');
+
+          if (strictSchemaFromFallback) {
+            try {
+              yield* run(fallbackEndpoint, false);
+              return;
+            } catch (endpointRetryError) {
+              if (options?.abortSignal?.aborted) return;
+              yield {
+                type: 'error',
+                error:
+                  endpointRetryError instanceof Error
+                    ? endpointRetryError.message
+                    : 'Unknown error occurred',
+              };
+              return;
+            }
+          }
+
+          yield {
+            type: 'error',
+            error: endpointMsg || 'Unknown error occurred',
+          };
+          return;
+        }
+      }
+
+      yield {
+        type: 'error',
+        error: msg || 'Unknown error occurred',
+      };
+    }
+  }
+}

package/src/agent/provider/xai.ts

@@ -0,0 +1,122 @@
+import { streamText, CoreMessage } from 'ai';
+import { createXai } from '@ai-sdk/xai';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+
+export class XaiProvider implements Provider {
+  async *sendMessage(
+    messages: CoreMessage[],
+    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 xai = createXai({
+      apiKey: cleanApiKey,
+    });
+
+    const result = streamText({
+      model: xai(cleanModel),
+      messages: messages,
+      system: config.systemPrompt,
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal,
+      providerOptions: {
+        xai: {
+          reasoningEffort: 'high',
+        },
+      },
+    });
+
+    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 {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+}

package/src/agent/tools/bash.ts

@@ -0,0 +1,20 @@
+import { tool, type CoreTool } from 'ai';
+import { z } from 'zod';
+import { executeTool } from './executor';
+
+export const bash: CoreTool = tool({
+  description: 'Execute a shell command in the workspace. Add --timeout <ms> at the END of your command for long-running processes (max 90000ms). IMPORTANT: This operation requires user approval - the user will see the command that will be executed and must approve before it runs. If rejected, ask the user for clarification using the question tool.',
+  parameters: z.object({
+    command: z.string().describe('The shell command to execute. Add --timeout <ms> at the end (max 90000ms) for: dev servers (--timeout 5000), builds (--timeout 90000), tests (--timeout 60000), installs (--timeout 90000), interactive CLIs with menus/options (--timeout 5000). You will receive the command output and must analyze it to determine if it succeeded or failed.'),
+  }),
+  execute: async (args) => {
+    const result = await executeTool('bash', args);
+    if (!result.success) {
+      const errorMessage = result.error || 'Unknown error occurred';
+      return result.userMessage
+        ? { error: errorMessage, userMessage: result.userMessage }
+        : { error: errorMessage };
+    }
+    return result.result;
+  },
+});

package/src/agent/tools/definitions.ts

@@ -0,0 +1,27 @@
+import type { CoreTool } from 'ai';
+
+import { bash } from './bash.ts';
+import { list } from './list.ts';
+import { read } from './read.ts';
+import { write } from './write.ts';
+import { glob } from './glob.ts';
+import { grep } from './grep.ts';
+import { edit } from './edit.ts';
+import { question } from './question.ts';
+import { explore } from './explore.ts';
+
+export const tools: Record<string, CoreTool> = {
+  read,
+  write,
+  list,
+  bash,
+  glob,
+  grep,
+  edit,
+  question,
+  explore,
+};
+
+export function getTools(): Record<string, CoreTool> {
+  return tools;
+}

package/src/agent/tools/edit.ts

@@ -0,0 +1,23 @@
+import { tool, type CoreTool } from 'ai';
+import { z } from 'zod';
+import { executeTool } from './executor';
+
+export const edit: CoreTool = tool({
+  description: 'Edit a specific part of a file by replacing old content with new content. More precise than rewriting the entire file. IMPORTANT: This operation requires user approval - the user will see a preview showing the old and new content and must approve before changes are made. If rejected, ask the user for clarification using the question tool.',
+  parameters: z.object({
+    path: z.string().describe('The path to the file relative to the workspace root'),
+    old_content: z.string().describe('The exact text content to find and replace'),
+    new_content: z.string().describe('The new text content to replace with'),
+    occurrence: z.number().nullable().optional().describe('Which occurrence to replace (1 for first, 2 for second, etc. Use null for 1)'),
+  }),
+  execute: async (args) => {
+    const result = await executeTool('edit', args);
+    if (!result.success) {
+      const errorMessage = result.error || 'Unknown error occurred';
+      return result.userMessage
+        ? { error: errorMessage, userMessage: result.userMessage }
+        : { error: errorMessage };
+    }
+    return result;
+  },
+});