profclaw 0.0.1-beta.3 → 2.3.0

package/dist/middleware/request-validator.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Request Validation Middleware
+ *
+ * Zod-based body validation for critical API endpoints.
+ * Returns structured 400 errors with field-level details.
+ */
+import { type Context, type Next } from 'hono';
+import { z } from 'zod';
+/**
+ * POST /api/chat/quick
+ */
+export declare const ChatQuickSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    model?: string | undefined;
+    provider?: string | undefined;
+    systemPrompt?: string | undefined;
+    temperature?: number | undefined;
+}, {
+    prompt: string;
+    model?: string | undefined;
+    provider?: string | undefined;
+    systemPrompt?: string | undefined;
+    temperature?: number | undefined;
+}>;
+/**
+ * POST /api/chat/conversations/:id/messages
+ */
+export declare const ChatMessageSchema: z.ZodObject<{
+    content: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    model?: string | undefined;
+    provider?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    content: string;
+    model?: string | undefined;
+    provider?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+}>;
+/**
+ * POST /api/chat/conversations
+ */
+export declare const CreateConversationSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<["chat", "agentic"]>>;
+    presetId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    ticketId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    taskId?: string | undefined;
+    title?: string | undefined;
+    mode?: "chat" | "agentic" | undefined;
+    ticketId?: string | undefined;
+    projectId?: string | undefined;
+    presetId?: string | undefined;
+}, {
+    taskId?: string | undefined;
+    title?: string | undefined;
+    mode?: "chat" | "agentic" | undefined;
+    ticketId?: string | undefined;
+    projectId?: string | undefined;
+    presetId?: string | undefined;
+}>;
+/**
+ * POST /api/tasks
+ */
+export declare const CreateTaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    input: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    priority?: number | undefined;
+    input?: string | undefined;
+}, {
+    title: string;
+    priority?: number | undefined;
+    input?: string | undefined;
+}>;
+/**
+ * POST /api/gateway/execute-secure
+ */
+export declare const GatewayExecuteSchema: z.ZodObject<{
+    task: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title?: string | undefined;
+        id?: string | undefined;
+        input?: string | undefined;
+    }, {
+        title?: string | undefined;
+        id?: string | undefined;
+        input?: string | undefined;
+    }>;
+    preferredAgent: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    autonomous: z.ZodOptional<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    task: {
+        title?: string | undefined;
+        id?: string | undefined;
+        input?: string | undefined;
+    };
+    priority?: number | undefined;
+    autonomous?: boolean | undefined;
+    workflow?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    timeoutMs?: number | undefined;
+    preferredAgent?: string | undefined;
+}, {
+    task: {
+        title?: string | undefined;
+        id?: string | undefined;
+        input?: string | undefined;
+    };
+    priority?: number | undefined;
+    autonomous?: boolean | undefined;
+    workflow?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    timeoutMs?: number | undefined;
+    preferredAgent?: string | undefined;
+}>;
+export type ChatQuickInput = z.infer<typeof ChatQuickSchema>;
+export type ChatMessageInput = z.infer<typeof ChatMessageSchema>;
+export type CreateConversationInput = z.infer<typeof CreateConversationSchema>;
+export type CreateTaskInput = z.infer<typeof CreateTaskSchema>;
+export type GatewayExecuteInput = z.infer<typeof GatewayExecuteSchema>;
+/**
+ * Creates a Hono middleware that validates the JSON request body against a Zod schema.
+ *
+ * On success the parsed data is stored at `c.get('validatedBody')`.
+ * On failure a structured 400 is returned with per-field error details.
+ *
+ * Usage:
+ *   app.post('/api/chat/quick', validateBody(ChatQuickSchema), async (c) => {
+ *     const body = c.get('validatedBody') as ChatQuickInput;
+ *   });
+ */
+export declare function validateBody<T>(schema: z.ZodSchema<T>): (c: Context, next: Next) => Promise<Response | void>;
+//# sourceMappingURL=request-validator.d.ts.map

package/dist/middleware/request-validator.js

@@ -0,0 +1,93 @@
+/**
+ * Request Validation Middleware
+ *
+ * Zod-based body validation for critical API endpoints.
+ * Returns structured 400 errors with field-level details.
+ */
+import { z } from 'zod';
+// ─── Schemas ─────────────────────────────────────────────────────────────────
+/**
+ * POST /api/chat/quick
+ */
+export const ChatQuickSchema = z.object({
+    prompt: z.string().min(1).max(100_000),
+    model: z.string().max(100).optional(),
+    provider: z.string().max(50).optional(),
+    systemPrompt: z.string().max(10_000).optional(),
+    temperature: z.number().min(0).max(2).optional(),
+});
+/**
+ * POST /api/chat/conversations/:id/messages
+ */
+export const ChatMessageSchema = z.object({
+    content: z.string().min(1).max(100_000),
+    model: z.string().max(100).optional(),
+    provider: z.string().max(50).optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().int().positive().optional(),
+});
+/**
+ * POST /api/chat/conversations
+ */
+export const CreateConversationSchema = z.object({
+    mode: z.enum(['chat', 'agentic']).optional(),
+    presetId: z.string().max(100).optional(),
+    title: z.string().max(200).optional(),
+    taskId: z.string().max(100).optional(),
+    ticketId: z.string().max(100).optional(),
+    projectId: z.string().max(100).optional(),
+});
+/**
+ * POST /api/tasks
+ */
+export const CreateTaskSchema = z.object({
+    title: z.string().min(1).max(500),
+    input: z.string().min(1).max(100_000).optional(),
+    priority: z.number().int().min(1).max(10).optional(),
+});
+/**
+ * POST /api/gateway/execute-secure
+ */
+export const GatewayExecuteSchema = z.object({
+    task: z.object({
+        id: z.string().max(100).optional(),
+        title: z.string().min(1).max(500).optional(),
+        input: z.string().max(100_000).optional(),
+    }),
+    preferredAgent: z.string().max(100).optional(),
+    workflow: z.string().max(50).optional(),
+    timeoutMs: z.number().int().min(0).max(600_000).optional(),
+    priority: z.number().int().min(1).max(10).optional(),
+    autonomous: z.boolean().optional(),
+    context: z.record(z.unknown()).optional(),
+});
+// ─── Middleware factory ───────────────────────────────────────────────────────
+/**
+ * Creates a Hono middleware that validates the JSON request body against a Zod schema.
+ *
+ * On success the parsed data is stored at `c.get('validatedBody')`.
+ * On failure a structured 400 is returned with per-field error details.
+ *
+ * Usage:
+ *   app.post('/api/chat/quick', validateBody(ChatQuickSchema), async (c) => {
+ *     const body = c.get('validatedBody') as ChatQuickInput;
+ *   });
+ */
+export function validateBody(schema) {
+    return async (c, next) => {
+        const body = await c.req.json().catch(() => null);
+        if (body === null || typeof body !== 'object' || Array.isArray(body)) {
+            return c.json({ error: 'Invalid JSON body' }, 400);
+        }
+        const result = schema.safeParse(body);
+        if (!result.success) {
+            return c.json({
+                error: 'Validation failed',
+                details: result.error.flatten().fieldErrors,
+            }, 400);
+        }
+        c.set('validatedBody', result.data);
+        await next();
+    };
+}
+//# sourceMappingURL=request-validator.js.map

package/dist/plugins/sdk.d.ts

@@ -27,9 +27,31 @@ export interface ProfClawPlugin {
     skills?: Array<{
         id: string;
         name: string;
+        description?: string;
     }>;
     searchProvider?: unknown;
     activate?(): Promise<void>;
     deactivate?(): Promise<void>;
+    /** Middleware hooks for intercepting tool execution */
+    hooks?: {
+        beforeToolExec?: (toolName: string, args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        afterToolExec?: (toolName: string, result: unknown) => Promise<unknown>;
+        beforePrompt?: (prompt: string) => Promise<string>;
+    };
 }
+/**
+ * Helper for plugin authors to define a plugin with type safety.
+ *
+ * @example
+ * ```ts
+ * import { definePlugin } from '@profclaw/sdk';
+ *
+ * export default definePlugin({
+ *   metadata: { id: 'my-plugin', name: 'My Plugin', version: '1.0.0' },
+ *   tools: [myCustomTool],
+ *   activate: async () => console.log('Plugin loaded!'),
+ * });
+ * ```
+ */
+export declare function definePlugin(plugin: ProfClawPlugin): ProfClawPlugin;
 //# sourceMappingURL=sdk.d.ts.map

package/dist/plugins/sdk.js

@@ -4,5 +4,21 @@
  * Public types and interfaces for building profClaw plugins.
  * Third-party plugins implement ProfClawPlugin to extend the system.
  */
-export {};
+/**
+ * Helper for plugin authors to define a plugin with type safety.
+ *
+ * @example
+ * ```ts
+ * import { definePlugin } from '@profclaw/sdk';
+ *
+ * export default definePlugin({
+ *   metadata: { id: 'my-plugin', name: 'My Plugin', version: '1.0.0' },
+ *   tools: [myCustomTool],
+ *   activate: async () => console.log('Plugin loaded!'),
+ * });
+ * ```
+ */
+export function definePlugin(plugin) {
+    return plugin;
+}
 //# sourceMappingURL=sdk.js.map

package/dist/projects/types.d.ts

@@ -28,7 +28,7 @@ export declare const ProjectExternalLinkSchema: z.ZodObject<{
     id: string;
     createdAt: string;
     projectId: string;
-    platform: "jira" | "linear" | "github" | "plane" | "monday";
+    platform: "jira" | "linear" | "github" | "monday" | "plane";
     externalId: string;
     syncEnabled: boolean;
     syncDirection: "push" | "bidirectional" | "pull";
@@ -39,7 +39,7 @@ export declare const ProjectExternalLinkSchema: z.ZodObject<{
     id: string;
     createdAt: string;
     projectId: string;
-    platform: "jira" | "linear" | "github" | "plane" | "monday";
+    platform: "jira" | "linear" | "github" | "monday" | "plane";
     externalId: string;
     externalUrl?: string | undefined;
     syncEnabled?: boolean | undefined;
@@ -136,11 +136,11 @@ export declare const CreateProjectSchema: z.ZodObject<{
         externalId: z.ZodString;
         externalUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     }, {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     }>>;
@@ -157,7 +157,7 @@ export declare const CreateProjectSchema: z.ZodObject<{
     boardView?: boolean | undefined;
     lead?: string | undefined;
     externalLink?: {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     } | undefined;
@@ -174,7 +174,7 @@ export declare const CreateProjectSchema: z.ZodObject<{
     boardView?: boolean | undefined;
     lead?: string | undefined;
     externalLink?: {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     } | undefined;
@@ -197,11 +197,11 @@ export declare const UpdateProjectSchema: z.ZodObject<Omit<{
         externalId: z.ZodString;
         externalUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     }, {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     }>>>;
@@ -217,7 +217,7 @@ export declare const UpdateProjectSchema: z.ZodObject<Omit<{
     boardView?: boolean | undefined;
     lead?: string | undefined;
     externalLink?: {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     } | undefined;
@@ -233,7 +233,7 @@ export declare const UpdateProjectSchema: z.ZodObject<Omit<{
     boardView?: boolean | undefined;
     lead?: string | undefined;
     externalLink?: {
-        platform: "jira" | "linear" | "github" | "plane" | "monday";
+        platform: "jira" | "linear" | "github" | "monday" | "plane";
         externalId: string;
         externalUrl?: string | undefined;
     } | undefined;

package/dist/providers/ai-sdk.d.ts

@@ -53,6 +53,17 @@ declare class AIProviderManager {
         provider: ProviderType;
         model: string;
     };
+    /**
+     * Get the default model for a provider, respecting runtime config.
+     * For Azure, uses the deployment name instead of the static "gpt-4o".
+     */
+    getDefaultModelForProvider(provider: ProviderType): string;
+    /**
+     * Resolve a model name to an Azure deployment.
+     * Azure uses deployment names (e.g. "gpt4o") instead of model IDs (e.g. "gpt-4o").
+     * Checks: configured deployment name → env var → strip dashes from model name.
+     */
+    private resolveToAzureDeployment;
     getModel(provider: ProviderType, modelId: string): Promise<LanguageModel>;
     getModelInfo(modelId: string): ModelInfo | undefined;
     getModelsForProvider(provider: ProviderType): ModelInfo[];

package/dist/providers/ai-sdk.js

@@ -26,8 +26,12 @@ async function withRetry(fn, maxRetries = AI_MAX_RETRIES) {
             return await fn();
         }
         catch (error) {
-            const isRetryable = error instanceof Error &&
-                (/429|503|rate.limit|too.many|service.unavailable|ECONNRESET|ETIMEDOUT|fetch.failed/i.test(error.message));
+            const msg = error instanceof Error ? error.message : '';
+            // Don't retry quota exhaustion — it won't resolve with backoff
+            const isQuotaError = /quota|exceeded your current|billing/i.test(msg);
+            const isRetryable = !isQuotaError &&
+                error instanceof Error &&
+                (/429|503|rate.limit|too.many|service.unavailable|ECONNRESET|ETIMEDOUT|fetch.failed/i.test(msg));
             if (!isRetryable || attempt === maxRetries)
                 throw error;
             const delay = Math.min(1000 * 2 ** attempt, 10000);
@@ -43,6 +47,26 @@ async function withRetry(fn, maxRetries = AI_MAX_RETRIES) {
 // Core types & data — single source of truth in core/
 import { ProviderType, PROVIDER_STATUS, } from './core/types.js';
 import { MODEL_ALIASES, MODEL_CATALOG } from './core/models.js';
+/** Sensible default model per provider (used when no model is specified). */
+const PROVIDER_DEFAULT_MODEL = {
+    ollama: 'llama3.2',
+    anthropic: 'claude-sonnet-4-5-20250929',
+    openai: 'gpt-4o',
+    google: 'gemini-2.0-flash',
+    azure: 'gpt-4o', // Resolved at runtime via deploymentName config
+    groq: 'llama-3.3-70b-versatile',
+    cerebras: 'llama-3.3-70b',
+    fireworks: 'accounts/fireworks/models/llama-v3p1-70b-instruct',
+    together: 'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo',
+    deepseek: 'deepseek-chat',
+    mistral: 'mistral-large-latest',
+    xai: 'grok-2',
+    cohere: 'command-r-plus',
+    perplexity: 'sonar',
+    bedrock: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+    replicate: 'meta/meta-llama-3-70b-instruct',
+    openrouter: 'anthropic/claude-sonnet-4-5-20250929',
+};
 // Re-export for consumers that import from providers/ai-sdk or providers/index
 export { ProviderType, PROVIDER_STATUS, MODEL_ALIASES, MODEL_CATALOG, };
 // Pre-compiled regex patterns for performance (avoid recompilation on each call)
@@ -152,17 +176,17 @@ class AIProviderManager {
                 enabled: true,
             });
         }
-        // Azure OpenAI (supports both standard and Foundry modes)
+        // Azure OpenAI (supports both base URL and resource name modes)
         if (process.env.AZURE_OPENAI_API_KEY) {
-            // Check if using Foundry (custom base URL) or standard (resource name)
             const baseUrl = process.env.AZURE_OPENAI_BASE_URL || process.env.AZURE_OPENAI_ENDPOINT;
-            const resourceName = process.env.AZURE_OPENAI_RESOURCE_NAME;
+            const resourceName = process.env.AZURE_OPENAI_RESOURCE_NAME || process.env.AZURE_RESOURCE_NAME;
             if (baseUrl || resourceName) {
                 this.configure('azure', {
                     type: 'azure',
                     apiKey: process.env.AZURE_OPENAI_API_KEY,
+                    // Prefer explicit base URL over resource name (resource name constructs URL automatically)
                     baseUrl: baseUrl,
-                    resourceName: resourceName,
+                    resourceName: baseUrl ? undefined : resourceName, // Don't use resourceName if baseUrl is set
                     deploymentName: process.env.AZURE_OPENAI_DEPLOYMENT_NAME,
                     apiVersion: process.env.AZURE_OPENAI_API_VERSION,
                     enabled: true,
@@ -669,7 +693,7 @@ class AIProviderManager {
         }
     }
     resolveModel(modelOrAlias) {
-        // Check if it's a full provider/model path
+        // Check if it's a full provider/model path (e.g. "azure/gpt4o", "ollama/llama3.2")
         if (modelOrAlias.includes('/')) {
             const [provider, model] = modelOrAlias.split('/');
             return { provider: provider, model };
@@ -680,15 +704,35 @@ class AIProviderManager {
             // For Azure, use the configured deployment name instead of the default alias model
             if (alias.provider === 'azure') {
                 const azureConfig = this.configs.get('azure');
-                if (azureConfig?.defaultModel) {
-                    return { provider: 'azure', model: azureConfig.defaultModel };
+                const azureModel = azureConfig?.defaultModel
+                    || azureConfig?.deploymentName
+                    || process.env.AZURE_OPENAI_DEPLOYMENT_NAME;
+                if (azureModel) {
+                    return { provider: 'azure', model: azureModel };
                 }
             }
-            return alias;
+            // If the alias points to a configured provider, use it directly
+            if (this.isConfigured(alias.provider)) {
+                return alias;
+            }
+            // If the alias provider isn't configured, try Azure as a fallback
+            // (Azure can serve OpenAI models like gpt-4o via deployment names)
+            if (this.isConfigured('azure') && (alias.provider === 'openai')) {
+                return this.resolveToAzureDeployment(modelOrAlias);
+            }
         }
         // Try to find in catalog
         const catalogModel = MODEL_CATALOG.find((m) => m.id === modelOrAlias);
         if (catalogModel) {
+            // If the catalog provider is configured, use it
+            if (this.isConfigured(catalogModel.provider)) {
+                return { provider: catalogModel.provider, model: catalogModel.id };
+            }
+            // OpenAI models can be served by Azure via deployment names
+            if (catalogModel.provider === 'openai' && this.isConfigured('azure')) {
+                return this.resolveToAzureDeployment(modelOrAlias);
+            }
+            // Fallback: use catalog as-is (will fail at API call time with clear error)
             return { provider: catalogModel.provider, model: catalogModel.id };
         }
         // Default to the auto-selected default provider
@@ -697,6 +741,38 @@ class AIProviderManager {
         const defaultModel = defaultConfig?.defaultModel || modelOrAlias;
         return { provider: this.defaultProvider, model: defaultModel };
     }
+    /**
+     * Get the default model for a provider, respecting runtime config.
+     * For Azure, uses the deployment name instead of the static "gpt-4o".
+     */
+    getDefaultModelForProvider(provider) {
+        if (provider === 'azure') {
+            const config = this.configs.get('azure');
+            return config?.deploymentName
+                || config?.defaultModel
+                || process.env.AZURE_OPENAI_DEPLOYMENT_NAME
+                || PROVIDER_DEFAULT_MODEL.azure
+                || 'gpt-4o';
+        }
+        return PROVIDER_DEFAULT_MODEL[provider] || 'llama3.2';
+    }
+    /**
+     * Resolve a model name to an Azure deployment.
+     * Azure uses deployment names (e.g. "gpt4o") instead of model IDs (e.g. "gpt-4o").
+     * Checks: configured deployment name → env var → strip dashes from model name.
+     */
+    resolveToAzureDeployment(modelOrAlias) {
+        const azureConfig = this.configs.get('azure');
+        // Use configured deployment name if it looks like it matches the requested model
+        const deployment = azureConfig?.deploymentName
+            || process.env.AZURE_OPENAI_DEPLOYMENT_NAME;
+        if (deployment) {
+            return { provider: 'azure', model: deployment };
+        }
+        // Try stripping dashes (gpt-4o → gpt4o) as Azure often uses this convention
+        const stripped = modelOrAlias.replace(/-/g, '');
+        return { provider: 'azure', model: stripped };
+    }
     async getModel(provider, modelId) {
         await this.ensureProvider(provider);
         const key = this.providerKey(provider);
@@ -738,9 +814,12 @@ class AIProviderManager {
         // Azure uses .chat() method for deployment-based access
         if (provider === 'azure') {
             let deployment = modelId;
-            if (modelId === 'default') {
+            if (deployment === 'default' || !deployment) {
                 const azureConfig = this.configs.get('azure');
-                deployment = azureConfig?.defaultModel || modelId;
+                deployment = azureConfig?.defaultModel
+                    || azureConfig?.deploymentName
+                    || process.env.AZURE_OPENAI_DEPLOYMENT_NAME
+                    || 'default';
                 if (deployment === 'default') {
                     throw new Error('Azure deployment not configured. Set defaultModel in Azure config or AZURE_OPENAI_DEPLOYMENT_NAME.');
                 }
@@ -773,7 +852,7 @@ class AIProviderManager {
         // Resolve model
         const modelRef = request.model
             ? this.resolveModel(request.model)
-            : { provider: this.defaultProvider, model: 'llama3.2' };
+            : { provider: this.defaultProvider, model: this.getDefaultModelForProvider(this.defaultProvider) };
         const model = await this.getModel(modelRef.provider, modelRef.model);
         // Convert messages to AI SDK format
         const messages = request.messages.map((msg) => ({
@@ -831,7 +910,7 @@ class AIProviderManager {
         // Resolve model
         const modelRef = request.model
             ? this.resolveModel(request.model)
-            : { provider: this.defaultProvider, model: 'llama3.2' };
+            : { provider: this.defaultProvider, model: this.getDefaultModelForProvider(this.defaultProvider) };
         const model = await this.getModel(modelRef.provider, modelRef.model);
         // Convert messages
         const messages = request.messages.map((msg) => ({
@@ -911,7 +990,7 @@ class AIProviderManager {
         // Resolve model
         const modelRef = request.model
             ? this.resolveModel(request.model)
-            : { provider: this.defaultProvider, model: 'llama3.2' };
+            : { provider: this.defaultProvider, model: this.getDefaultModelForProvider(this.defaultProvider) };
         const model = await this.getModel(modelRef.provider, modelRef.model);
         // Check if model supports native tools
         const toolSupport = this.modelSupportsTools(modelRef.model || modelRef.provider + '/' + modelRef.model);
@@ -1058,7 +1137,7 @@ class AIProviderManager {
     modelSupportsTools(modelOrAlias) {
         const modelRef = modelOrAlias
             ? this.resolveModel(modelOrAlias)
-            : { provider: this.defaultProvider, model: 'llama3.2' };
+            : { provider: this.defaultProvider, model: this.getDefaultModelForProvider(this.defaultProvider) };
         // Azure OpenAI: All GPT-4, GPT-4o, and GPT-3.5-turbo models support function calling
         // We check provider first since Azure deployment names won't be in MODEL_CATALOG
         if (modelRef.provider === 'azure') {
@@ -1103,7 +1182,7 @@ class AIProviderManager {
         // Resolve model
         const modelRef = request.model
             ? this.resolveModel(request.model)
-            : { provider: this.defaultProvider, model: 'llama3.2' };
+            : { provider: this.defaultProvider, model: this.getDefaultModelForProvider(this.defaultProvider) };
         const model = await this.getModel(modelRef.provider, modelRef.model);
         // Check if model supports native tool calling
         const toolSupport = this.modelSupportsTools(request.model);
@@ -1277,7 +1356,7 @@ class AIProviderManager {
         // Resolve model
         const modelRef = request.model
             ? this.resolveModel(request.model)
-            : { provider: this.defaultProvider, model: 'llama3.2' };
+            : { provider: this.defaultProvider, model: this.getDefaultModelForProvider(this.defaultProvider) };
         const model = await this.getModel(modelRef.provider, modelRef.model);
         // Convert messages
         const messages = toAiMessages(request.messages);