@kirosnn/mosaic 0.0.91 → 0.73.0

package/src/agent/provider/rateLimit.ts

@@ -0,0 +1,178 @@
+export type RetryDecision = {
+  shouldRetry: boolean;
+  retryAfterMs?: number;
+};
+
+export type RetryOptions = {
+  maxRetries: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+  jitterMs: number;
+  abortSignal?: AbortSignal;
+};
+
+const DEFAULT_OPTIONS: RetryOptions = {
+  maxRetries: 4,
+  baseDelayMs: 800,
+  maxDelayMs: 12000,
+  jitterMs: 250,
+};
+
+function toErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === 'string') return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return 'Unknown error';
+  }
+}
+
+export function normalizeError(error: unknown): Error {
+  if (error instanceof Error) return error;
+  return new Error(toErrorMessage(error));
+}
+
+function getStatus(error: unknown): number | undefined {
+  const e: any = error as any;
+  const direct = e?.status ?? e?.statusCode ?? e?.code;
+  if (typeof direct === 'number') return direct;
+  const nested = e?.response?.status ?? e?.response?.statusCode;
+  if (typeof nested === 'number') return nested;
+  const inner = e?.error?.status ?? e?.error?.statusCode;
+  if (typeof inner === 'number') return inner;
+  return undefined;
+}
+
+export function getErrorSignature(error: unknown): string {
+  const status = getStatus(error);
+  const code = (error as any)?.code;
+  const message = toErrorMessage(error);
+  return `${status ?? ''}|${code ?? ''}|${message}`;
+}
+
+function getHeader(error: unknown, name: string): string | undefined {
+  const e: any = error as any;
+  const headers = e?.response?.headers ?? e?.headers ?? e?.responseHeaders;
+  if (!headers) return undefined;
+  const lower = name.toLowerCase();
+  if (typeof headers.get === 'function') {
+    const value = headers.get(name) ?? headers.get(lower);
+    return value ? String(value) : undefined;
+  }
+  if (typeof headers === 'object') {
+    const value = headers[name] ?? headers[lower];
+    return value ? String(value) : undefined;
+  }
+  return undefined;
+}
+
+function parseRetryAfter(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  const seconds = Number(trimmed);
+  if (!Number.isNaN(seconds)) {
+    return Math.max(0, Math.round(seconds * 1000));
+  }
+  const dateMs = Date.parse(trimmed);
+  if (!Number.isNaN(dateMs)) {
+    const delta = dateMs - Date.now();
+    return delta > 0 ? delta : 0;
+  }
+  return undefined;
+}
+
+function isRetryableMessage(message: string): boolean {
+  const m = message.toLowerCase();
+  if (m.includes('rate limit')) return true;
+  if (m.includes('too many requests')) return true;
+  if (m.includes('quota')) return true;
+  if (m.includes('throttle')) return true;
+  if (m.includes('429')) return true;
+  if (m.includes('timeout')) return true;
+  if (m.includes('timed out')) return true;
+  if (m.includes('econnreset')) return true;
+  if (m.includes('econnrefused')) return true;
+  if (m.includes('etimedout')) return true;
+  if (m.includes('enotfound')) return true;
+  if (m.includes('fetch failed')) return true;
+  if (m.includes('socket hang up')) return true;
+  return false;
+}
+
+export function getRetryDecision(error: unknown): RetryDecision {
+  const status = getStatus(error);
+  if (status === 429) {
+    return { shouldRetry: true, retryAfterMs: parseRetryAfter(getHeader(error, 'retry-after')) };
+  }
+  if (status === 408 || (status !== undefined && status >= 500 && status < 600)) {
+    return { shouldRetry: true };
+  }
+  const message = toErrorMessage(error);
+  if (isRetryableMessage(message)) {
+    return { shouldRetry: true, retryAfterMs: parseRetryAfter(getHeader(error, 'retry-after')) };
+  }
+  return { shouldRetry: false };
+}
+
+function computeDelayMs(attempt: number, options: RetryOptions, retryAfterMs?: number): number {
+  if (retryAfterMs !== undefined && retryAfterMs >= 0) {
+    return Math.min(options.maxDelayMs, retryAfterMs);
+  }
+  const jitter = Math.floor(Math.random() * options.jitterMs);
+  const backoff = options.baseDelayMs * Math.pow(2, attempt);
+  return Math.min(options.maxDelayMs, backoff + jitter);
+}
+
+async function sleep(ms: number, abortSignal?: AbortSignal): Promise<void> {
+  if (ms <= 0) return;
+  if (abortSignal?.aborted) return;
+  await new Promise<void>((resolve) => {
+    const timer = setTimeout(() => resolve(), ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    if (abortSignal) {
+      abortSignal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+export async function* runWithRetry<T>(
+  run: () => AsyncGenerator<T>,
+  options: Partial<RetryOptions> = {}
+): AsyncGenerator<T> {
+  const config: RetryOptions = { ...DEFAULT_OPTIONS, ...options };
+  let attempt = 0;
+  let lastSignature: string | null = null;
+  let sameSignatureCount = 0;
+
+  while (true) {
+    if (config.abortSignal?.aborted) return;
+    try {
+      yield* run();
+      return;
+    } catch (error) {
+      if (config.abortSignal?.aborted) return;
+      const decision = getRetryDecision(error);
+      const signature = getErrorSignature(error);
+      if (signature === lastSignature) {
+        sameSignatureCount += 1;
+      } else {
+        lastSignature = signature;
+        sameSignatureCount = 0;
+      }
+      if (!decision.shouldRetry || attempt >= config.maxRetries) {
+        throw error;
+      }
+      if (sameSignatureCount >= 1) {
+        throw error;
+      }
+      const delay = computeDelayMs(attempt, config, decision.retryAfterMs);
+      await sleep(delay, config.abortSignal);
+      attempt += 1;
+    }
+  }
+}

package/src/agent/provider/reasoning.ts

@@ -0,0 +1,29 @@
+import { findModelsDevModelById, getModelsDevModel } from '../../utils/models';
+
+function normalizeId(value: string): string {
+  return value.trim();
+}
+
+function matchesReasoningHeuristic(modelId: string): boolean {
+  const id = modelId.toLowerCase();
+  return id.includes('reasoning') || id.includes('o1') || id.includes('o3') || id.includes('r1');
+}
+
+export async function shouldEnableReasoning(providerId: string, modelId: string): Promise<boolean> {
+  const provider = normalizeId(providerId);
+  const model = normalizeId(modelId);
+
+  try {
+    const direct = await getModelsDevModel(provider, model);
+    if (direct && typeof direct.reasoning === 'boolean') return direct.reasoning;
+  } catch {
+  }
+
+  try {
+    const byId = await findModelsDevModelById(model);
+    if (byId?.model && typeof byId.model.reasoning === 'boolean') return byId.model.reasoning;
+  } catch {
+  }
+
+  return matchesReasoningHeuristic(model);
+}

package/src/agent/provider/xai.ts

@@ -1,6 +1,8 @@
-import { streamText, CoreMessage } from 'ai';
-import { createXai } from '@ai-sdk/xai';
-import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { streamText, CoreMessage } from 'ai';
+import { createXai } from '@ai-sdk/xai';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { shouldEnableReasoning } from './reasoning';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 export class XaiProvider implements Provider {
   async *sendMessage(
@@ -8,115 +10,117 @@ export class XaiProvider 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 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;
+    try {
+      let stepCounter = 0;
+
+      yield* runWithRetry(async function* () {
+        const result = streamText({
+          model: xai(cleanModel),
+          messages: messages,
+          system: config.systemPrompt,
+          tools: config.tools,
+          maxSteps: config.maxSteps || 100,
+          abortSignal: options?.abortSignal,
+          providerOptions: reasoningEnabled
+            ? {
+              xai: {
+                reasoningEffort: 'high',
+              },
+            }
+            : 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;
+            }
+          }
+        }
+      }, { 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/tools/definitions.ts

@@ -9,6 +9,8 @@ import { grep } from './grep.ts';
 import { edit } from './edit.ts';
 import { question } from './question.ts';
 import { explore } from './explore.ts';
+import { fetch } from './fetch.ts';
+import { plan } from './plan.ts';
 
 export const tools: Record<string, CoreTool> = {
   read,
@@ -20,8 +22,20 @@ export const tools: Record<string, CoreTool> = {
   edit,
   question,
   explore,
+  fetch,
+  plan,
 };
 
 export function getTools(): Record<string, CoreTool> {
+  try {
+    const { getMcpCatalog, isMcpInitialized } = require('../../mcp/index');
+    if (isMcpInitialized()) {
+      const catalog = getMcpCatalog();
+      const mcpTools = catalog.getExposedTools();
+      return { ...tools, ...mcpTools };
+    }
+  } catch {
+    // MCP not available, return internal tools only
+  }
   return tools;
-}
+}