@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/agent/provider/mistral.ts

@@ -1,6 +1,7 @@
 import { streamText, CoreMessage } from 'ai';
 import { createMistral } from '@ai-sdk/mistral';
-import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 export class MistralProvider implements Provider {
   async *sendMessage(
@@ -15,103 +16,102 @@ export class MistralProvider implements Provider {
       apiKey: cleanApiKey,
     });
 
-    const result = streamText({
-      model: mistral(cleanModel),
-      messages: messages,
-      system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal
-    });
-
-    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: mistral(cleanModel),
+          messages: messages,
+          system: config.systemPrompt,
+          tools: config.tools,
+          maxSteps: config.maxSteps || 100,
+          abortSignal: options?.abortSignal
+        });
+
+        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/provider/ollama.ts

@@ -1,10 +1,11 @@
 import { Ollama } from 'ollama';
 import { spawn } from 'child_process';
-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';
+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';
+import { getErrorSignature, getRetryDecision } from './rateLimit';
 
 let serveStartPromise: Promise<void> | null = null;
 const pullPromises = new Map<string, Promise<void>>();
@@ -12,6 +13,8 @@ const pullPromises = new Map<string, Promise<void>>();
 const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
 
 function isTransientError(error: unknown): boolean {
+  const decision = getRetryDecision(error);
+  if (decision.shouldRetry) return true;
   const msg = error instanceof Error ? error.message : String(error);
   return (
     msg.includes('ECONNREFUSED') ||
@@ -24,13 +27,27 @@ function isTransientError(error: unknown): boolean {
 
 async function retry<T>(fn: () => Promise<T>, retries: number, baseDelayMs: number): Promise<T> {
   let lastError: unknown;
+  let lastSignature: string | null = null;
+  let sameSignatureCount = 0;
   for (let attempt = 0; attempt <= retries; attempt++) {
     try {
       return await fn();
     } catch (e) {
       lastError = e;
       if (attempt >= retries || !isTransientError(e)) throw e;
-      await sleep(baseDelayMs * Math.max(1, attempt + 1));
+      const signature = getErrorSignature(e);
+      if (signature === lastSignature) {
+        sameSignatureCount += 1;
+      } else {
+        lastSignature = signature;
+        sameSignatureCount = 0;
+      }
+      if (sameSignatureCount >= 1) {
+        throw e;
+      }
+      const decision = getRetryDecision(e);
+      const delay = decision.retryAfterMs ?? (baseDelayMs * Math.max(1, attempt + 1));
+      await sleep(delay);
     }
   }
   throw lastError instanceof Error ? lastError : new Error('Request failed');
@@ -60,7 +77,7 @@ function createCloudOllamaClient(apiKey: string): Ollama {
   } as any);
 }
 
-async function ensureOllamaServe(apiKey?: string): Promise<void> {
+async function ensureOllamaServe(_apiKey?: string): Promise<void> {
   if (serveStartPromise) return serveStartPromise;
 
   serveStartPromise = (async () => {
@@ -197,9 +214,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
@@ -218,17 +235,17 @@ 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 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;
@@ -258,10 +275,10 @@ function toOllamaTools(tools?: Record<string, CoreTool>): any[] | undefined {
   });
 }
 
-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;
@@ -292,28 +309,28 @@ function coreMessagesToOllamaMessages(messages: CoreMessage[]): any[] {
         };
       }
 
-      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);
-}
+      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();
@@ -344,9 +361,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 reasoningEnabled = await shouldEnableReasoning(config.provider, cleanModel);
+    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;
@@ -413,7 +430,7 @@ export class OllamaProvider implements Provider {
     }
 
     const toolsSchema = toOllamaTools(config.tools);
-    const maxSteps = config.maxSteps || 10;
+    const maxSteps = config.maxSteps || 100;
 
     const baseMessages = config.systemPrompt
       ? [{ role: 'system' as const, content: config.systemPrompt }, ...messages]
@@ -435,14 +452,14 @@ export class OllamaProvider implements Provider {
 
         const stream = await retry(
           () =>
-            ollamaClient.chat({
-              model: requestModel,
-              messages: ollamaMessages,
-              tools: toolsSchema,
-              stream: true,
-              think: reasoningEnabled,
-              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
         );
@@ -567,4 +584,4 @@ export class OllamaProvider implements Provider {
       };
     }
   }
-}
+}

package/src/agent/provider/openai.ts

@@ -3,6 +3,7 @@ import { createOpenAI } from '@ai-sdk/openai';
 import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
 import { z } from 'zod';
 import { shouldEnableReasoning } from './reasoning';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 function unwrapOptional(schema: z.ZodTypeAny): z.ZodTypeAny {
   if (schema instanceof z.ZodOptional) {
@@ -103,10 +104,10 @@ export class OpenAIProvider implements Provider {
       }
     };
 
-    const run = async function* (
-      endpoint: OpenAIEndpoint,
-      strictJsonSchema: boolean
-    ): AsyncGenerator<AgentEvent> {
+    const runOnce = async function* (
+      endpoint: OpenAIEndpoint,
+      strictJsonSchema: boolean
+    ): AsyncGenerator<AgentEvent> {
       const toolsToUse =
         endpoint === 'responses'
           ? transformToolsForResponsesApi(config.tools)
@@ -117,7 +118,7 @@ export class OpenAIProvider implements Provider {
         messages: messages,
         system: config.systemPrompt,
         tools: toolsToUse,
-        maxSteps: config.maxSteps ?? 10,
+        maxSteps: config.maxSteps ?? 100,
         abortSignal: options?.abortSignal,
         providerOptions: {
           openai: {
@@ -191,26 +192,23 @@ export class OpenAIProvider implements Provider {
             };
             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;
-    };
+          case 'error': {
+            const err = normalizeError(c.error);
+            const decision = getRetryDecision(err);
+            if (decision.shouldRetry) {
+              throw err;
+            }
+            yield {
+              type: 'error',
+              error: err.message,
+            };
+            break;
+          }
+        }
+      }
+
+      return;
+    };
 
     const classifyEndpointError = (msg: string): OpenAIEndpoint | null => {
       const m = msg || '';
@@ -230,19 +228,25 @@ export class OpenAIProvider implements Provider {
     };
 
     try {
-      yield* run('responses', false);
-    } catch (error) {
-      if (options?.abortSignal?.aborted) return;
-      const msg = error instanceof Error ? error.message : String(error);
-
-      const fallbackEndpoint = classifyEndpointError(msg);
-      if (fallbackEndpoint && fallbackEndpoint !== 'responses') {
-        try {
-          yield* run(fallbackEndpoint, false);
-          return;
-        } catch (endpointError) {
-          if (options?.abortSignal?.aborted) return;
-          const endpointMsg = endpointError instanceof Error ? endpointError.message : String(endpointError);
+      yield* runWithRetry(
+        () => runOnce('responses', false),
+        { abortSignal: options?.abortSignal }
+      );
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      const msg = error instanceof Error ? error.message : String(error);
+
+      const fallbackEndpoint = classifyEndpointError(msg);
+      if (fallbackEndpoint && fallbackEndpoint !== 'responses') {
+        try {
+          yield* runWithRetry(
+            () => runOnce(fallbackEndpoint, false),
+            { abortSignal: options?.abortSignal }
+          );
+          return;
+        } catch (endpointError) {
+          if (options?.abortSignal?.aborted) return;
+          const endpointMsg = endpointError instanceof Error ? endpointError.message : String(endpointError);
           yield {
             type: 'error',
             error: endpointMsg || 'Unknown error occurred',