@kirosnn/mosaic 0.0.91 → 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

@@ -2,6 +2,10 @@ 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 { getErrorSignature, getRetryDecision } from './rateLimit';
 
 let serveStartPromise: Promise<void> | null = null;
 const pullPromises = new Map<string, Promise<void>>();
@@ -9,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') ||
@@ -21,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');
@@ -57,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 () => {
@@ -218,21 +238,41 @@ function contentToString(content: CoreMessage['content']): string {
   }
 }
 
+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[] {
@@ -269,6 +309,21 @@ 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),
@@ -308,6 +363,7 @@ export class OllamaProvider implements Provider {
   ): 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);
 
     if (options?.abortSignal?.aborted) {
       return;
@@ -374,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]
@@ -401,7 +457,7 @@ export class OllamaProvider implements Provider {
               messages: ollamaMessages,
               tools: toolsSchema,
               stream: true,
-              think: true,
+              think: reasoningEnabled,
               signal: options?.abortSignal,
             } as any) as any,
           2,
@@ -528,4 +584,4 @@ export class OllamaProvider implements Provider {
       };
     }
   }
-}
+}

package/src/agent/provider/openai.ts

@@ -1,15 +1,91 @@
-import { streamText, CoreMessage } from 'ai';
-import { createOpenAI } from '@ai-sdk/openai';
-import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+import { streamText, CoreMessage, CoreTool } from 'ai';
+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) {
+    return unwrapOptional(schema.unwrap());
+  }
+  if (schema instanceof z.ZodEffects) {
+    const inner = unwrapOptional(schema.innerType());
+    return inner === schema.innerType() ? schema : new z.ZodEffects({
+      ...schema._def,
+      schema: inner,
+    });
+  }
+  return schema;
+}
+
+function makeAllPropertiesRequired(schema: z.ZodTypeAny): z.ZodTypeAny {
+  if (schema instanceof z.ZodEffects) {
+    const innerTransformed = makeAllPropertiesRequired(schema.innerType());
+    return new z.ZodEffects({
+      ...schema._def,
+      schema: innerTransformed,
+    });
+  }
+
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    const newShape: Record<string, z.ZodTypeAny> = {};
+    for (const key in shape) {
+      let fieldSchema = shape[key];
+      fieldSchema = unwrapOptional(fieldSchema);
+      if (fieldSchema instanceof z.ZodObject) {
+        fieldSchema = makeAllPropertiesRequired(fieldSchema);
+      } else if (fieldSchema instanceof z.ZodArray) {
+        const innerType = fieldSchema.element;
+        if (innerType instanceof z.ZodObject) {
+          fieldSchema = z.array(makeAllPropertiesRequired(innerType));
+        }
+      } else if (fieldSchema instanceof z.ZodEffects) {
+        const innerType = fieldSchema.innerType();
+        if (innerType instanceof z.ZodObject) {
+          fieldSchema = new z.ZodEffects({
+            ...fieldSchema._def,
+            schema: makeAllPropertiesRequired(innerType),
+          });
+        }
+      }
+      newShape[key] = fieldSchema;
+    }
+    return z.object(newShape);
+  }
+  return schema;
+}
+
+function transformToolsForResponsesApi(
+  tools: Record<string, CoreTool> | undefined
+): Record<string, CoreTool> | undefined {
+  if (!tools) return tools;
+
+  const transformed: Record<string, CoreTool> = {};
+  for (const [name, tool] of Object.entries(tools)) {
+    const t = tool as any;
+    if (t.parameters) {
+      transformed[name] = {
+        ...t,
+        parameters: makeAllPropertiesRequired(t.parameters),
+      };
+    } else {
+      transformed[name] = tool;
+    }
+  }
+  return transformed;
+}
 
 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, '');
+  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 reasoningEnabled = await shouldEnableReasoning(config.provider, cleanModel);
 
     const openai = createOpenAI({
       apiKey: cleanApiKey,
@@ -28,24 +104,29 @@ export class OpenAIProvider implements Provider {
       }
     };
 
-    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',
-          },
-        },
-      });
+    const runOnce = async function* (
+      endpoint: OpenAIEndpoint,
+      strictJsonSchema: boolean
+    ): AsyncGenerator<AgentEvent> {
+      const toolsToUse =
+        endpoint === 'responses'
+          ? transformToolsForResponsesApi(config.tools)
+          : config.tools;
+
+      const result = streamText({
+        model: pickModel(endpoint),
+        messages: messages,
+        system: config.systemPrompt,
+        tools: toolsToUse,
+        maxSteps: config.maxSteps ?? 100,
+        abortSignal: options?.abortSignal,
+        providerOptions: {
+          openai: {
+            strictJsonSchema,
+            ...(reasoningEnabled ? { reasoningEffort: 'high' } : {}),
+          },
+        },
+      });
 
       let stepCounter = 0;
 
@@ -111,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 || '';
@@ -150,59 +228,25 @@ export class OpenAIProvider implements Provider {
     };
 
     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* 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',
@@ -217,4 +261,4 @@ export class OpenAIProvider implements Provider {
       };
     }
   }
-}
+}