profclaw 2.0.0 → 2.3.0

package/dist/providers/types.d.ts

@@ -238,7 +238,7 @@ export declare const ChatMessageSchema: z.ZodObject<{
     id: string;
     timestamp: string;
     content: string;
-    role: "user" | "system" | "assistant" | "tool";
+    role: "user" | "system" | "tool" | "assistant";
     name?: string | undefined;
     tokensUsed?: number | undefined;
     toolCallId?: string | undefined;
@@ -247,7 +247,7 @@ export declare const ChatMessageSchema: z.ZodObject<{
     id: string;
     timestamp: string;
     content: string;
-    role: "user" | "system" | "assistant" | "tool";
+    role: "user" | "system" | "tool" | "assistant";
     name?: string | undefined;
     tokensUsed?: number | undefined;
     toolCallId?: string | undefined;
@@ -270,7 +270,7 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -279,7 +279,7 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -311,7 +311,7 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -328,14 +328,14 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         description: string;
         parameters: Record<string, unknown>;
     }[] | undefined;
-    systemPrompt?: string | undefined;
     maxTokens?: number | undefined;
+    systemPrompt?: string | undefined;
 }, {
     messages: {
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -352,9 +352,9 @@ export declare const ChatCompletionRequestSchema: z.ZodObject<{
         description: string;
         parameters: Record<string, unknown>;
     }[] | undefined;
+    maxTokens?: number | undefined;
     systemPrompt?: string | undefined;
     temperature?: number | undefined;
-    maxTokens?: number | undefined;
 }>;
 export type ChatCompletionRequest = z.infer<typeof ChatCompletionRequestSchema>;
 export declare const ChatCompletionResponseSchema: z.ZodObject<{
@@ -374,7 +374,7 @@ export declare const ChatCompletionResponseSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -383,7 +383,7 @@ export declare const ChatCompletionResponseSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -425,7 +425,7 @@ export declare const ChatCompletionResponseSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -452,7 +452,7 @@ export declare const ChatCompletionResponseSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -494,7 +494,7 @@ export declare const ConversationSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -503,7 +503,7 @@ export declare const ConversationSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -530,7 +530,7 @@ export declare const ConversationSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;
@@ -552,7 +552,7 @@ export declare const ConversationSchema: z.ZodObject<{
         id: string;
         timestamp: string;
         content: string;
-        role: "user" | "system" | "assistant" | "tool";
+        role: "user" | "system" | "tool" | "assistant";
         name?: string | undefined;
         tokensUsed?: number | undefined;
         toolCallId?: string | undefined;

package/dist/routes/agents.js

@@ -43,5 +43,55 @@ agents.get('/types', (c) => {
         types: registry.getAdapterTypes(),
     });
 });
+// --- Multi-Agent Orchestration ---
+import { z } from 'zod';
+import { orchestrate, cancelOrchestration, listActiveOrchestrations } from '../agents/orchestrator.js';
+const subAgentSchema = z.object({
+    id: z.string().optional(),
+    name: z.string(),
+    prompt: z.string(),
+    systemPrompt: z.string().optional(),
+    model: z.string().optional(),
+    maxTokens: z.number().optional(),
+    timeoutMs: z.number().optional(),
+    allowedTools: z.array(z.string()).optional(),
+    effort: z.enum(['low', 'medium', 'high']).optional(),
+});
+const orchestrateSchema = z.object({
+    name: z.string().min(1).max(200),
+    pattern: z.enum(['fan_out', 'pipeline', 'debate', 'custom']),
+    agents: z.array(subAgentSchema).min(1).max(10),
+    synthesizerPrompt: z.string().optional(),
+    judgePrompt: z.string().optional(),
+    timeoutMs: z.number().optional(),
+    failFast: z.boolean().optional(),
+});
+/** Execute a multi-agent orchestration */
+agents.post('/orchestrate', async (c) => {
+    const body = await c.req.json();
+    const parsed = orchestrateSchema.safeParse(body);
+    if (!parsed.success) {
+        return c.json({ success: false, error: { code: 'VALIDATION_ERROR', message: parsed.error.message } }, 400);
+    }
+    const config = {
+        id: crypto.randomUUID(),
+        ...parsed.data,
+        agents: parsed.data.agents.map((a, i) => ({
+            ...a,
+            id: a.id || `agent-${i}`,
+        })),
+    };
+    const result = await orchestrate(config);
+    return c.json({ success: result.success, data: result });
+});
+/** Cancel a running orchestration */
+agents.post('/orchestrate/:id/cancel', (c) => {
+    const cancelled = cancelOrchestration(c.req.param('id'));
+    return c.json({ success: cancelled });
+});
+/** List active orchestrations */
+agents.get('/orchestrate/active', (c) => {
+    return c.json({ success: true, data: listActiveOrchestrations() });
+});
 export { agents as agentsRoutes };
 //# sourceMappingURL=agents.js.map

package/dist/routes/auth.js

@@ -99,8 +99,15 @@ authRoutes.post('/signup', signupLimiter, async (c) => {
         // Check registration mode
         const settings = await getSettingsRaw();
         const mode = settings.system.registrationMode;
+        // Allow first user signup without invite code (bootstrap admin)
+        const db = getDb();
+        let isFirstUser = false;
+        if (db) {
+            const existingUsers = await db.select({ id: users.id }).from(users).limit(1);
+            isFirstUser = existingUsers.length === 0;
+        }
         let inviteRecord;
-        if (mode === 'invite') {
+        if (mode === 'invite' && !isFirstUser) {
             if (!inviteCode) {
                 return c.json({ error: 'Registration requires an invite code' }, 403);
             }

package/dist/routes/chat.js

@@ -9,8 +9,18 @@ import { streamText } from "hono/streaming";
 import { zValidator } from "@hono/zod-validator";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
+import { routeQuery, recordRoutingDecision, isSmartRouterEnabled, getCostComparison, } from "../providers/smart-router.js";
 import { logger } from "../utils/logger.js";
+import { rateLimit } from "../middleware/rate-limit.js";
+import { contentFilter } from "../middleware/content-filter.js";
 const chatRoutes = new Hono();
+// Per-IP sliding-window rate limiter for chat send endpoints
+const chatMaxRequests = parseInt(process.env['CHAT_RATE_LIMIT'] ?? '20', 10);
+const chatRateLimiter = rateLimit({
+    maxRequests: chatMaxRequests,
+    windowMs: 60_000,
+    message: `Chat rate limit exceeded. Maximum ${chatMaxRequests} messages per minute.`,
+});
 let chatRuntimePromise = null;
 let ProviderTypeSchema;
 let aiProvider;
@@ -26,6 +36,7 @@ let listConversations;
 let deleteConversation;
 let addMessage;
 let getConversationMessages;
+let deleteMessage;
 let getRecentConversationsWithPreview;
 let compactMessages;
 let getMemoryStats;
@@ -65,6 +76,7 @@ async function ensureChatRuntime() {
             deleteConversation = chatModule.deleteConversation;
             addMessage = chatModule.addMessage;
             getConversationMessages = chatModule.getConversationMessages;
+            deleteMessage = chatModule.deleteMessage;
             getRecentConversationsWithPreview =
                 chatModule.getRecentConversationsWithPreview;
             compactMessages = chatModule.compactMessages;
@@ -168,6 +180,84 @@ chatRoutes.get("/model-capability", async (c) => {
     const resolved = MODEL_ALIASES[model.toLowerCase()]?.model ?? model;
     return c.json(getModelRouting(resolved));
 });
+/**
+ * POST /api/chat/send
+ * Simple one-shot chat - send a message and get a response
+ */
+chatRoutes.post("/send", chatRateLimiter, contentFilter(), zValidator("json", z.object({
+    message: z.string(),
+    model: z.string().optional(),
+    systemPrompt: z.string().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+})), async (c) => {
+    const body = c.req.valid("json");
+    try {
+        const messages = [
+            {
+                id: randomUUID(),
+                role: "user",
+                content: body.message,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+        // Smart routing: auto-select model if none specified
+        let routing;
+        let modelToUse = body.model;
+        if (!body.model && isSmartRouterEnabled()) {
+            const providers = new Set(aiProvider.getConfiguredProviders());
+            routing = routeQuery(body.message, providers);
+            modelToUse = routing.selectedModel.id;
+            recordRoutingDecision(routing);
+        }
+        const response = await aiProvider.chat({
+            messages,
+            model: modelToUse,
+            systemPrompt: body.systemPrompt,
+            temperature: body.temperature,
+            maxTokens: body.maxTokens,
+        });
+        // Track token usage for cost dashboard
+        if (response.usage?.totalTokens && response.model) {
+            await ensureChatRuntime();
+            trackChatUsage(response.model, response.usage.totalTokens, response.usage.promptTokens, response.usage.completionTokens);
+        }
+        return c.json({
+            id: response.id,
+            provider: response.provider,
+            model: response.model,
+            reply: response.content,
+            finishReason: response.finishReason,
+            usage: response.usage,
+            duration: response.duration,
+            ...(routing && {
+                routing: {
+                    smartRouted: true,
+                    complexity: routing.complexity.tier,
+                    confidence: Math.round(routing.complexity.confidence * 100),
+                    reasoning: routing.complexity.reasoning,
+                    savings: `${routing.savingsPercent}%`,
+                    estimatedCost: `$${routing.estimatedCost.toFixed(4)}`,
+                    summary: getCostComparison(routing),
+                    ...(routing.missingProviderHint && {
+                        tip: {
+                            addProvider: routing.missingProviderHint.provider,
+                            reason: routing.missingProviderHint.reason,
+                            savings: routing.missingProviderHint.estimatedSavings,
+                            signupUrl: routing.missingProviderHint.signupUrl,
+                        },
+                    }),
+                },
+            }),
+        });
+    }
+    catch (error) {
+        logger.error("[Chat] Send error:", error instanceof Error ? error : undefined);
+        return c.json({
+            error: error instanceof Error ? error.message : "Chat send failed",
+        }, 500);
+    }
+});
 /**
  * POST /api/chat/completions
  * Generate a chat completion
@@ -183,11 +273,37 @@ chatRoutes.post("/completions", zValidator("json", ChatCompletionSchema), async
     }));
     // Handle streaming
     if (body.stream) {
+        // Smart route for streaming too
+        let streamRouting;
+        let streamModel = body.model;
+        if (!body.model && isSmartRouterEnabled()) {
+            const lastUserMsg = [...body.messages].reverse().find((m) => m.role === "user");
+            if (lastUserMsg) {
+                const providers = new Set(aiProvider.getConfiguredProviders());
+                streamRouting = routeQuery(lastUserMsg.content, providers, {
+                    conversationLength: body.messages.length,
+                });
+                streamModel = streamRouting.selectedModel.id;
+                recordRoutingDecision(streamRouting);
+            }
+        }
         return streamText(c, async (stream) => {
             try {
+                // Send routing info as first event in stream
+                if (streamRouting) {
+                    await stream.write(`data: ${JSON.stringify({
+                        routing: {
+                            smartRouted: true,
+                            complexity: streamRouting.complexity.tier,
+                            savings: `${streamRouting.savingsPercent}%`,
+                            model: streamRouting.selectedModel.id,
+                            provider: streamRouting.selectedModel.provider,
+                        },
+                    })}\n\n`);
+                }
                 const response = await aiProvider.chatStream({
                     messages,
-                    model: body.model,
+                    model: streamModel,
                     systemPrompt: body.systemPrompt,
                     temperature: body.temperature,
                     maxTokens: body.maxTokens,
@@ -216,9 +332,23 @@ chatRoutes.post("/completions", zValidator("json", ChatCompletionSchema), async
     }
     // Non-streaming
     try {
+        // Smart routing for completions
+        let routing;
+        let modelToUse = body.model;
+        if (!body.model && isSmartRouterEnabled()) {
+            const lastUserMsg = [...body.messages].reverse().find((m) => m.role === "user");
+            if (lastUserMsg) {
+                const providers = new Set(aiProvider.getConfiguredProviders());
+                routing = routeQuery(lastUserMsg.content, providers, {
+                    conversationLength: body.messages.length,
+                });
+                modelToUse = routing.selectedModel.id;
+                recordRoutingDecision(routing);
+            }
+        }
         const response = await aiProvider.chat({
             messages,
-            model: body.model,
+            model: modelToUse,
             systemPrompt: body.systemPrompt,
             temperature: body.temperature,
             maxTokens: body.maxTokens,
@@ -234,6 +364,15 @@ chatRoutes.post("/completions", zValidator("json", ChatCompletionSchema), async
             finishReason: response.finishReason,
             usage: response.usage,
             duration: response.duration,
+            ...(routing && {
+                routing: {
+                    smartRouted: true,
+                    complexity: routing.complexity.tier,
+                    savings: `${routing.savingsPercent}%`,
+                    estimatedCost: `$${routing.estimatedCost.toFixed(4)}`,
+                    summary: getCostComparison(routing),
+                },
+            }),
         });
     }
     catch (error) {
@@ -751,14 +890,62 @@ chatRoutes.post("/conversations/:id/compact", async (c) => {
         return c.json({ error: "Failed to compact conversation" }, 500);
     }
 });
+/**
+ * DELETE /api/chat/conversations/:id/messages/:messageId
+ * Delete a single message from a conversation
+ */
+chatRoutes.delete("/conversations/:id/messages/:messageId", async (c) => {
+    const conversationId = c.req.param("id");
+    const messageId = c.req.param("messageId");
+    try {
+        const conversation = await getConversation(conversationId);
+        if (!conversation) {
+            return c.json({ error: "Conversation not found" }, 404);
+        }
+        await deleteMessage(conversationId, messageId);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        logger.error("[Chat] Delete message error:", error instanceof Error ? error : undefined);
+        return c.json({ error: "Failed to delete message" }, 500);
+    }
+});
+/**
+ * GET /api/chat/conversations/:id/export
+ * Export a conversation as JSON
+ */
+chatRoutes.get("/conversations/:id/export", async (c) => {
+    const conversationId = c.req.param("id");
+    try {
+        const conversation = await getConversation(conversationId);
+        if (!conversation) {
+            return c.json({ error: "Conversation not found" }, 404);
+        }
+        const messages = await getConversationMessages(conversationId);
+        return c.json({
+            conversation: {
+                id: conversation.id,
+                title: conversation.title,
+                createdAt: conversation.createdAt,
+            },
+            messages,
+            exportedAt: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        logger.error("[Chat] Export conversation error:", error instanceof Error ? error : undefined);
+        return c.json({ error: "Failed to export conversation" }, 500);
+    }
+});
 /**
  * POST /api/chat/conversations/:id/messages
  * Send a message in a conversation (with context and history)
  */
-chatRoutes.post("/conversations/:id/messages", zValidator("json", z.object({
+chatRoutes.post("/conversations/:id/messages", chatRateLimiter, contentFilter(), zValidator("json", z.object({
     content: z.string(),
     model: z.string().optional(),
     temperature: z.number().min(0).max(2).optional(),
+    stream: z.boolean().optional(),
 })), async (c) => {
     const conversationId = c.req.param("id");
     const body = c.req.valid("json");
@@ -870,7 +1057,56 @@ chatRoutes.post("/conversations/:id/messages", zValidator("json", z.object({
             content: m.content,
             timestamp: m.createdAt,
         }));
-        // Send to AI
+        // Streaming branch
+        if (body.stream) {
+            return streamText(c, async (stream) => {
+                try {
+                    let fullContent = "";
+                    const response = await aiProvider.chatStream({
+                        messages: chatMessages,
+                        model: body.model,
+                        systemPrompt,
+                        temperature: body.temperature,
+                    }, (chunk) => {
+                        fullContent += chunk;
+                        stream
+                            .write(`data: ${JSON.stringify({ content: chunk })}\n\n`)
+                            .catch((err) => {
+                            logger.error("[Chat] Stream write error:", err instanceof Error ? err : undefined);
+                        });
+                    });
+                    // Save assistant response after streaming completes
+                    const assistantMessage = await addMessage({
+                        conversationId,
+                        role: "assistant",
+                        content: fullContent || response.content,
+                        model: response.model,
+                        provider: response.provider,
+                        tokenUsage: response.usage
+                            ? {
+                                prompt: response.usage.promptTokens,
+                                completion: response.usage.completionTokens,
+                                total: response.usage.totalTokens,
+                            }
+                            : undefined,
+                        cost: response.usage?.cost,
+                    });
+                    await stream.write(`data: ${JSON.stringify({
+                        done: true,
+                        usage: response.usage,
+                        messageId: assistantMessage.id,
+                        compaction: compactionInfo,
+                    })}\n\n`);
+                }
+                catch (error) {
+                    logger.error("[Chat] Conversation stream error:", error instanceof Error ? error : undefined);
+                    await stream.write(`data: ${JSON.stringify({
+                        error: error instanceof Error ? error.message : "Failed to send message",
+                    })}\n\n`);
+                }
+            });
+        }
+        // Send to AI (non-streaming)
         const response = await aiProvider.chat({
             messages: chatMessages,
             model: body.model,
@@ -915,7 +1151,7 @@ chatRoutes.post("/conversations/:id/messages", zValidator("json", z.object({
  * POST /api/chat/conversations/:id/messages/with-tools
  * Send a message in a conversation with native tool calling enabled
  */
-chatRoutes.post("/conversations/:id/messages/with-tools", zValidator("json", z.object({
+chatRoutes.post("/conversations/:id/messages/with-tools", chatRateLimiter, contentFilter(), zValidator("json", z.object({
     content: z.string(),
     model: z.string().optional(),
     temperature: z.number().min(0).max(2).optional(),
@@ -993,6 +1229,10 @@ chatRoutes.post("/conversations/:id/messages/with-tools", zValidator("json", z.o
         const tools = enableTools
             ? getChatToolsForModel(modelId, { conversationId })
             : [];
+        logger.info(`[Chat] Tools for ${modelId}: ${tools.length} (enableTools=${enableTools})`, {
+            component: 'Chat',
+            toolNames: tools.map(t => t.name).join(', '),
+        });
         // Build system prompt with context and tool mode
         const systemPrompt = await buildSystemPrompt(conversation.presetId, context, {
             enableTools: enableTools && tools.length > 0,
@@ -1322,7 +1562,7 @@ chatRoutes.post("/with-tools", zValidator("json", z.object({
  * - complete - Session complete
  * - error - Error occurred
  */
-chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.object({
+chatRoutes.post("/conversations/:id/messages/agentic", chatRateLimiter, contentFilter(), zValidator("json", z.object({
     content: z.string(),
     model: z.string().optional(),
     provider: z.string().optional(),
@@ -1385,8 +1625,6 @@ chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.obje
             conversationId,
             sessionOverride,
         };
-        // Get tools - agentic mode uses model-aware filtering
-        const tools = getChatToolsForModel(resolvedRef.model, { conversationId, includeAll: true });
         // Build system prompt with agent mode (uses AGENT_MODE_SUFFIX)
         const systemPrompt = await buildSystemPrompt(conversation.presetId, context, {
             agentMode: true,
@@ -1429,11 +1667,14 @@ chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.obje
             content: m.content,
             timestamp: m.createdAt,
         }));
-        // Create tool handler
+        // Create tool handler (triggers tool registration if first call)
         const toolHandler = await createChatToolHandler({
             conversationId,
             securityMode: "full", // Full access in agentic mode (tools are pre-approved)
         });
+        // Get tools AFTER handler init (registry is now populated)
+        const tools = getChatToolsForModel(resolvedRef.model, { conversationId });
+        logger.info(`[Chat/Agentic] Tools for model ${resolvedRef.model}: ${tools.length}`);
         // Set up SSE streaming response
         c.header("Content-Type", "text/event-stream");
         c.header("Cache-Control", "no-cache");
@@ -1491,11 +1732,15 @@ chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.obje
                     provider: body.provider,
                     temperature: body.temperature,
                     toolHandler,
-                    tools: tools.map((t) => ({
-                        name: t.name,
-                        description: t.description,
-                        parameters: t.parameters,
-                    })),
+                    tools: (() => {
+                        const mapped = tools.map((t) => ({
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.parameters,
+                        }));
+                        logger.info(`[Chat/Agentic] Sending ${mapped.length} tools: [${mapped.map(t => t.name).join(', ')}]`);
+                        return mapped;
+                    })(),
                     showThinking: body.showThinking,
                     maxSteps: body.maxSteps,
                     maxBudget: body.maxBudget,

package/dist/routes/costs.js

@@ -2,6 +2,7 @@ import { Hono } from 'hono';
 import { getUsageSummary } from '../costs/token-tracker.js';
 import { getBudgetStatus } from '../costs/budget.js';
 import { getStorage } from '../storage/index.js';
+import { getRoutingStats, getCostOptimizationAdvice } from '../providers/smart-router.js';
 const costs = new Hono();
 // Get usage summary
 costs.get('/summary', (c) => {
@@ -19,6 +20,37 @@ costs.get('/analytics', async (c) => {
     const analytics = await storage.getCostAnalytics();
     return c.json(analytics);
 });
+// Get smart routing stats (savings from auto-routing)
+costs.get('/routing', (_c) => {
+    const stats = getRoutingStats();
+    return _c.json({
+        success: true,
+        data: {
+            ...stats,
+            totalSaved: `$${stats.totalSaved.toFixed(4)}`,
+            avgSavingsPercent: `${Math.round(stats.avgSavingsPercent)}%`,
+            message: stats.totalRouted > 0
+                ? `Smart routing saved $${stats.totalSaved.toFixed(2)} across ${stats.totalRouted} requests (avg ${Math.round(stats.avgSavingsPercent)}% savings)`
+                : 'No queries routed yet. Smart routing will show savings as you use profClaw.',
+        },
+    });
+});
+// Get cost optimization advice
+costs.get('/optimize', async (c) => {
+    // Get configured providers dynamically
+    const { aiProvider } = await import('../providers/ai-sdk.js');
+    const providers = new Set(aiProvider.getConfiguredProviders());
+    const advice = getCostOptimizationAdvice(providers);
+    return c.json({
+        success: true,
+        data: {
+            configuredProviders: [...providers],
+            providerCount: providers.size,
+            recommendations: advice,
+            optimalSetup: advice.some(a => a.action.includes('cost-optimal')),
+        },
+    });
+});
 // Export cost report as CSV
 costs.get('/export', async (c) => {
     const format = c.req.query('format') || 'csv';