@kirosnn/mosaic 0.0.91 → 0.73.0

package/src/agent/provider/anthropic.ts

@@ -1,6 +1,8 @@
-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';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 export class AnthropicProvider implements Provider {
   async *sendMessage(
@@ -8,115 +10,117 @@ 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,
     });
 
-    const result = streamText({
-      model: anthropic(cleanModel),
-      messages: messages,
-      system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal,
-      experimental_providerMetadata: {
-        anthropic: {
-          thinkingBudgetTokens: 10000,
-        },
-      },
-    });
-
-    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 {
+    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;
+            }
+          }
+        }
+      }, { 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

@@ -1,6 +1,8 @@
-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';
+import { getRetryDecision, normalizeError, runWithRetry } from './rateLimit';
 
 export class GoogleProvider implements Provider {
   async *sendMessage(
@@ -8,117 +10,119 @@ 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,
     });
 
-    const result = streamText({
-      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',
-          },
-        },
-      },
-    });
-
-    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 {
+    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;
+            }
+          }
+        }
+      }, { abortSignal: options?.abortSignal });
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      yield {
         type: 'error',
         error: error instanceof Error ? error.message : 'Unknown error occurred',
       };
     }
   }
-}
+}