@kirosnn/mosaic 0.0.9 → 0.71.0

package/src/agent/provider/openai.ts

@@ -1,15 +1,90 @@
-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';
+
+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,
@@ -32,20 +107,25 @@ export class OpenAIProvider implements Provider {
       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 toolsToUse =
+        endpoint === 'responses'
+          ? transformToolsForResponsesApi(config.tools)
+          : config.tools;
+
+      const result = streamText({
+        model: pickModel(endpoint),
+        messages: messages,
+        system: config.systemPrompt,
+        tools: toolsToUse,
+        maxSteps: config.maxSteps ?? 10,
+        abortSignal: options?.abortSignal,
+        providerOptions: {
+          openai: {
+            strictJsonSchema,
+            ...(reasoningEnabled ? { reasoningEffort: 'high' } : {}),
+          },
+        },
+      });
 
       let stepCounter = 0;
 
@@ -150,59 +230,19 @@ export class OpenAIProvider implements Provider {
     };
 
     try {
-      yield* run('responses', true);
+      yield* run('responses', false);
     } 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);
+          yield* run(fallbackEndpoint, false);
           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',
@@ -217,4 +257,4 @@ export class OpenAIProvider implements Provider {
       };
     }
   }
-}
+}

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,7 @@
-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';
 
 export class XaiProvider implements Provider {
   async *sendMessage(
@@ -8,8 +9,9 @@ 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,
@@ -19,15 +21,17 @@ export class XaiProvider implements Provider {
       model: xai(cleanModel),
       messages: messages,
       system: config.systemPrompt,
-      tools: config.tools,
-      maxSteps: config.maxSteps || 10,
-      abortSignal: options?.abortSignal,
-      providerOptions: {
-        xai: {
-          reasoningEffort: 'high',
-        },
-      },
-    });
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal,
+      providerOptions: reasoningEnabled
+        ? {
+          xai: {
+            reasoningEffort: 'high',
+          },
+        }
+        : undefined,
+    });
 
     try {
       let stepCounter = 0;
@@ -119,4 +123,4 @@ export class XaiProvider implements Provider {
       };
     }
   }
-}
+}

package/src/agent/tools/definitions.ts

@@ -8,7 +8,9 @@ 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';
+import { explore } from './explore.ts';
+import { fetch } from './fetch.ts';
+import { plan } from './plan.ts';
 
 export const tools: Record<string, CoreTool> = {
   read,
@@ -18,10 +20,12 @@ export const tools: Record<string, CoreTool> = {
   glob,
   grep,
   edit,
-  question,
-  explore,
-};
+  question,
+  explore,
+  fetch,
+  plan,
+};
 
 export function getTools(): Record<string, CoreTool> {
   return tools;
-}
+}