@travisennis/acai 0.0.8 → 0.0.10

package/dist/index.js

@@ -2,36 +2,40 @@
 import { mkdirSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { text } from "node:stream/consumers";
 import { parseArgs } from "node:util";
 import { asyncTry, isFailure, syncTry } from "@travisennis/stdlib/try";
 import { isDefined } from "@travisennis/stdlib/typeguards";
 import { Agent } from "./agent/index.js";
-import { Cli } from "./cli.js";
+import { Cli } from "./cli/index.js";
+import { readStdinWithLimits } from "./cli/stdin.js";
 import { CommandManager } from "./commands/manager.js";
-import { config, } from "./config.js";
-import { logger } from "./logger.js";
-import { PromptError, processPrompt } from "./mentions.js";
+import { config } from "./config/index.js";
 import { ModelManager } from "./models/manager.js";
 import { isSupportedModel } from "./models/providers.js";
 import { PromptManager } from "./prompts/manager.js";
-import { systemPrompt } from "./prompts.js";
-import { NewRepl } from "./repl-new.js";
+import { processPrompt } from "./prompts/mentions.js";
+import { systemPrompt } from "./prompts/system-prompt.js";
+import { Repl } from "./repl/index.js";
 import { SessionManager } from "./sessions/manager.js";
+import { writeExitSummary } from "./sessions/summary.js";
 import { setTerminalTitle } from "./terminal/control.js";
 import { select } from "./terminal/select-prompt.js";
 import { TokenCounter } from "./tokens/counter.js";
 import { TokenTracker } from "./tokens/tracker.js";
 import { initTools } from "./tools/index.js";
-import { getPackageVersion } from "./version.js";
+import { logger } from "./utils/logger.js";
+import { getPackageVersion } from "./utils/version.js";
 // Create workspace context from CLI arguments
 export function createWorkspaceContext(addDirArgs = []) {
     const primaryDir = process.cwd();
     mkdirSync("/tmp/acai", { recursive: true });
     const allowedDirs = [
         primaryDir,
+        "/tmp",
         "/tmp/acai",
+        "/var/folders",
         path.join(os.homedir(), ".acai"),
+        path.join(os.homedir(), ".agents"),
         ...addDirArgs,
     ];
     // Remove duplicates while preserving order
@@ -52,7 +56,7 @@ Options
   --resume           Resume a specific session by ID, or most recent if no ID given
   --add-dir          Add additional working directory (can be used multiple times)
   --no-skills        Disable skills discovery and loading
-
+  --no-session       Don't save session to disk
 
   --help, -h         Show help
   --version, -v      Show version
@@ -73,6 +77,7 @@ const parsed = syncTry(() => parseArgs({
         resume: { type: "boolean", default: false },
         "add-dir": { type: "string", multiple: true },
         "no-skills": { type: "boolean", default: false },
+        "no-session": { type: "boolean", default: false },
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" },
     },
@@ -96,49 +101,42 @@ export function handleError(error) {
     logger.error({ error: error }, error.message);
 }
 // Configuration constants
-const DEFAULT_HISTORY_LIMIT = 10;
-const CONTINUE_HISTORY_LIMIT = 1;
+const DEFAULT_HISTORY_LIMIT = 20; // the amount of sessions to retrieve from session history
 // Helper functions for main()
-async function initializeAppState(appConfig, initialPromptInput, stdInPrompt, hasContinueOrResume, resumeSessionId) {
+async function initializeAppState(appConfig, initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId) {
     const appDir = config.app;
     // Parallelize independent async operations
-    const [messageHistoryDir, modelManager] = await Promise.all([
-        appDir.ensurePath("message-history"),
+    const [sessionsDir, modelManager] = await Promise.all([
+        appDir.ensurePath("sessions"),
         initializeModelManager(appDir),
     ]);
     // Initialize synchronous components
     const tokenTracker = new TokenTracker();
     const tokenCounter = new TokenCounter();
     // Initialize dependent components
-    const sessionManager = await initializeSessionManager(messageHistoryDir, modelManager, tokenTracker);
+    const sessionManager = await initializeSessionManager(sessionsDir, modelManager, tokenTracker);
     // Handle conversation history loading
-    await handleConversationHistory(sessionManager, messageHistoryDir, hasContinueOrResume, resumeSessionId);
+    await handleConversationHistory(sessionManager, sessionsDir, hasContinueOrResume, resumeSessionId);
     // Setup prompt manager
     const promptManager = new PromptManager(tokenCounter);
     if (!hasContinueOrResume && isDefined(initialPromptInput)) {
-        try {
-            const modelConfig = modelManager.getModelMetadata("repl");
-            const processedPrompt = await processPrompt(initialPromptInput, {
-                baseDir: process.cwd(),
-                model: modelConfig,
-            });
-            for (const context of processedPrompt.context) {
-                promptManager.addContext(context);
-            }
-            promptManager.set(processedPrompt.message);
-        }
-        catch (error) {
-            if (error instanceof PromptError) {
-                logger.error(`Prompt mention error: ${error.message}`);
-                promptManager.set(initialPromptInput);
-            }
-            else {
-                throw new Error("Failed to process prompt.", { cause: error });
-            }
+        const modelConfig = modelManager.getModelMetadata("repl");
+        const processedPrompt = await processPrompt(initialPromptInput, {
+            baseDir: process.cwd(),
+            model: modelConfig,
+        });
+        for (const context of processedPrompt.context) {
+            promptManager.addContext(context);
         }
+        promptManager.set(processedPrompt.message);
     }
-    if (stdInPrompt) {
-        promptManager.addContext(stdInPrompt);
+    if (stdinContent && stdinContent.trim().length > 0) {
+        if (isDefined(initialPromptInput)) {
+            promptManager.addContext(stdinContent);
+        }
+        else {
+            promptManager.set(stdinContent);
+        }
     }
     const promptHistory = [];
     const commands = new CommandManager({
@@ -195,17 +193,14 @@ function validateCliArguments() {
 async function determineInitialPrompt() {
     const hasContinueOrResume = flags.continue === true || flags.resume === true;
     const positionalPrompt = input.at(0);
-    let stdInPrompt;
-    // Check if there's data available on stdin
-    if (!process.stdin.isTTY) {
-        try {
-            stdInPrompt = await text(process.stdin);
-        }
-        catch (error) {
-            console.error(`Error reading stdin: ${error.message}`);
-        }
+    const { content: stdinContent, wasPiped } = await readStdinWithLimits();
+    if (wasPiped &&
+        (!stdinContent || stdinContent.trim().length === 0) &&
+        !flags.prompt &&
+        !positionalPrompt) {
+        console.error("No input provided via stdin.");
+        process.exit(0);
     }
-    // Check for session ID with --resume
     const resumeSessionId = flags.resume === true && input.length > 0 ? input[0] : undefined;
     const initialPromptInput = typeof flags.prompt === "string" && flags.prompt.length > 0
         ? flags.prompt
@@ -218,7 +213,7 @@ async function determineInitialPrompt() {
     }
     return {
         initialPromptInput,
-        stdInPrompt,
+        stdinContent,
         hasContinueOrResume,
         resumeSessionId,
     };
@@ -226,41 +221,42 @@ async function determineInitialPrompt() {
 async function initializeModelManager(appDir) {
     const chosenModel = isSupportedModel(flags.model)
         ? flags.model
-        : "opencode:minimax-m2-1";
+        : "opencode:minimax-m2.5-free";
+    const projectConfig = await config.getConfig();
+    const devtoolsEnabled = projectConfig.devtools?.enabled ?? false;
     const modelManager = new ModelManager({
         stateDir: await appDir.ensurePath("audit"),
+        devtoolsEnabled,
     });
     modelManager.setModel("repl", chosenModel);
     modelManager.setModel("cli", chosenModel);
     modelManager.setModel("title-conversation", chosenModel);
     modelManager.setModel("conversation-summarizer", chosenModel);
-    modelManager.setModel("tool-repair", chosenModel);
+    modelManager.setModel("tool-repair", "openai:gpt-5.1-codex-mini");
     modelManager.setModel("conversation-analyzer", chosenModel);
     modelManager.setModel("init-project", chosenModel);
-    modelManager.setModel("task-agent", chosenModel);
     modelManager.setModel("handoff-agent", chosenModel);
-    modelManager.setModel("edit-fix", chosenModel);
     return modelManager;
 }
-async function initializeSessionManager(messageHistoryDir, modelManager, tokenTracker) {
-    const messageHistory = new SessionManager({
-        stateDir: messageHistoryDir,
+async function initializeSessionManager(sessionsDir, modelManager, tokenTracker) {
+    const sessionManager = new SessionManager({
+        stateDir: sessionsDir,
         modelManager,
         tokenTracker,
     });
-    messageHistory.on("update-title", (title) => setTerminalTitle(title));
+    sessionManager.on("update-title", (title) => setTerminalTitle(title));
     // Listen for model changes and update session manager when repl model changes
     modelManager.on("set-model", (app, _model) => {
         if (app === "repl") {
             const modelId = modelManager.getModel("repl").modelId;
-            messageHistory.setModelId(modelId);
+            sessionManager.setModelId(modelId);
         }
     });
-    return messageHistory;
+    return sessionManager;
 }
-async function handleConversationHistory(messageHistory, messageHistoryDir, _hasContinueOrResume, resumeSessionId) {
+async function handleConversationHistory(sessionManager, sessionsDir, _hasContinueOrResume, resumeSessionId) {
     if (flags.continue === true) {
-        const histories = await SessionManager.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
+        const histories = await SessionManager.load(sessionsDir, DEFAULT_HISTORY_LIMIT);
         if (histories.length > 0) {
             try {
                 const choice = await select({
@@ -273,7 +269,7 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
                 });
                 const selectedHistory = histories.at(choice);
                 if (selectedHistory) {
-                    messageHistory.restore(selectedHistory);
+                    sessionManager.restore(selectedHistory);
                     logger.info(`Resuming conversation: ${selectedHistory.title}`);
                     setTerminalTitle(selectedHistory.title || `acai: ${process.cwd()}`);
                 }
@@ -298,10 +294,10 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
     }
     else if (flags.resume === true) {
         if (resumeSessionId) {
-            const histories = await SessionManager.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
+            const histories = await SessionManager.load(sessionsDir, DEFAULT_HISTORY_LIMIT);
             const targetHistory = histories.find((h) => h.sessionId === resumeSessionId);
             if (targetHistory) {
-                messageHistory.restore(targetHistory);
+                sessionManager.restore(targetHistory);
                 logger.info(`Resuming conversation: ${targetHistory.title}`);
                 setTerminalTitle(targetHistory.title || `acai: ${process.cwd()}`);
             }
@@ -311,10 +307,10 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
             }
         }
         else {
-            const histories = await SessionManager.load(messageHistoryDir, CONTINUE_HISTORY_LIMIT);
+            const histories = await SessionManager.load(sessionsDir, 1); // read the most recent session
             const latestHistory = histories.at(0);
             if (latestHistory) {
-                messageHistory.restore(latestHistory);
+                sessionManager.restore(latestHistory);
                 console.info(`Resuming conversation: ${latestHistory.title}`);
                 setTerminalTitle(latestHistory.title || `acai: ${process.cwd()}`);
             }
@@ -324,99 +320,134 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
         }
     }
 }
-async function runCliMode(state) {
-    const skillsEnabled = !flags["no-skills"] && (await config.getSkillsEnabled());
+async function runCliMode(state, noSession) {
     const cliProcess = new Cli({
         promptManager: state.promptManager,
-        messageHistory: state.sessionManager,
+        sessionManager: state.sessionManager,
         modelManager: state.modelManager,
         tokenTracker: state.tokenTracker,
         tokenCounter: state.tokenCounter,
         workspace,
-        skillsEnabled,
+        noSession,
     });
     (await asyncTry(cliProcess.run())).recover(handleError);
 }
-async function runReplMode(state) {
-    // Initialize tools before creating REPL (needed for session reload reconstruction)
-    const tools = await initTools({
-        workspace,
-    });
-    const agent = new Agent({
-        sessionManager: state.sessionManager,
-        modelManager: state.modelManager,
-        tokenTracker: state.tokenTracker,
-    });
-    const repl = new NewRepl({
-        agent,
-        promptManager: state.promptManager,
-        config: state.appConfig,
-        messageHistory: state.sessionManager,
-        modelManager: state.modelManager,
-        tokenTracker: state.tokenTracker,
-        commands: state.commands,
-        tokenCounter: state.tokenCounter,
-        promptHistory: state.promptHistory,
-        workspace,
-        tools,
-    });
-    // Initialize TUI
-    await repl.init();
-    // Reconstruct session display if there are existing messages
-    if (!state.sessionManager.isEmpty()) {
-        await repl.rerender();
-    }
-    state.sessionManager.on("clear-history", () => {
+function setupReplEventHandlers(repl, agent, sessionManager, noSession) {
+    sessionManager.on("clear-history", async () => {
         logger.info("Resetting agent state.");
         agent.resetState();
+        agent.setConfig(await config.getConfig());
         void repl.rerender();
     });
-    // Set interrupt callback
     repl.setInterruptCallback(async () => {
-        try {
-            await state.sessionManager.save();
-        }
-        catch (error) {
-            // Log but don't throw - we still want to abort the agent
-            logger.warn({ error }, "Failed to save message history on interrupt");
+        if (!noSession) {
+            try {
+                await sessionManager.save();
+            }
+            catch (error) {
+                logger.warn({ error }, "Failed to save message history on interrupt");
+            }
         }
         agent.abort();
     });
-    // Set exit callback
-    repl.setExitCallback((sessionId) => {
-        if (!state.sessionManager.isEmpty()) {
-            console.info(`\nTo resume this session call acai --resume ${sessionId}`);
+    repl.setExitCallback(async (_sessionId) => {
+        if (!sessionManager.isEmpty()) {
+            await repl.triggerRuleGeneration();
+            writeExitSummary(sessionManager, noSession);
         }
     });
-    // Interactive loop
+}
+async function handleStdinPrompt(state, agent, repl, tools, activeTools, systemPromptResult, noSession) {
+    if (!state.promptManager.isPending()) {
+        return false;
+    }
+    try {
+        const promptText = state.promptManager.get();
+        const userMessage = state.promptManager.getUserMessage();
+        state.sessionManager.appendUserMessage(userMessage);
+        const results = agent.run({
+            systemPrompt: systemPromptResult.prompt,
+            input: promptText,
+            tools,
+            activeTools,
+            abortSignal: agent.abortSignal,
+            maxIterations: state.appConfig.loop.maxIterations,
+        });
+        for await (const result of results) {
+            await repl.handle(result, agent.state);
+        }
+        if (!noSession) {
+            await state.sessionManager.save();
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runInteractiveLoop(repl, agent, tools, activeTools, systemPromptResult, noSession, sessionManager, maxIterations) {
     while (true) {
         const userInput = await repl.getUserInput();
-        const projectConfig = await config.getConfig();
-        const activeTools = projectConfig.tools.activeTools;
-        const skillsEnabled = !flags["no-skills"] && (projectConfig.skills?.enabled ?? true);
         try {
             const results = agent.run({
-                systemPrompt: await systemPrompt({
-                    activeTools,
-                    allowedDirs: workspace.allowedDirs,
-                    skillsEnabled,
-                }),
+                systemPrompt: systemPromptResult.prompt,
                 input: userInput,
                 tools,
                 activeTools,
                 abortSignal: agent.abortSignal,
+                maxIterations,
             });
             for await (const result of results) {
                 await repl.handle(result, agent.state);
             }
-            await state.sessionManager.save();
+            if (!noSession) {
+                await sessionManager.save();
+            }
         }
-        catch (_error) {
-            // Display error in the TUI by adding an error message to the chat
-            // repl.showError((error as Error).message || "Unknown error occurred");
+        catch {
+            // Error displayed in the TUI
         }
     }
 }
+async function runReplMode(state, stdinWasPiped, noSession) {
+    const tools = await initTools({ workspace });
+    const agent = new Agent({
+        config: state.appConfig,
+        sessionManager: state.sessionManager,
+        modelManager: state.modelManager,
+        tokenTracker: state.tokenTracker,
+    });
+    const repl = new Repl({
+        agent,
+        promptManager: state.promptManager,
+        configManager: config,
+        sessionManager: state.sessionManager,
+        modelManager: state.modelManager,
+        tokenTracker: state.tokenTracker,
+        commands: state.commands,
+        tokenCounter: state.tokenCounter,
+        promptHistory: state.promptHistory,
+        workspace,
+        tools,
+        terminalOptions: { useTty: stdinWasPiped },
+        noSession,
+    });
+    await repl.init();
+    if (!state.sessionManager.isEmpty()) {
+        await repl.rerender();
+    }
+    setupReplEventHandlers(repl, agent, state.sessionManager, noSession);
+    const activeTools = state.appConfig.tools.activeTools;
+    const skillsEnabled = !flags["no-skills"] && (state.appConfig.skills?.enabled ?? true);
+    const systemPromptResult = await systemPrompt({
+        activeTools,
+        allowedDirs: workspace.allowedDirs,
+        logsPath: state.appConfig.logs?.path,
+        skillsEnabled,
+    });
+    await handleStdinPrompt(state, agent, repl, tools, activeTools, systemPromptResult, noSession);
+    await runInteractiveLoop(repl, agent, tools, activeTools, systemPromptResult, noSession, state.sessionManager, state.appConfig.loop.maxIterations);
+}
 async function main() {
     try {
         const appConfig = await config.ensureDefaultConfig("acai");
@@ -428,17 +459,29 @@ async function main() {
         // Validate CLI arguments
         validateCliArguments();
         // Determine initial prompt
-        const { initialPromptInput, stdInPrompt, hasContinueOrResume, resumeSessionId, } = await determineInitialPrompt();
+        const { initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId, } = await determineInitialPrompt();
         // Initialize application state
-        const state = await initializeAppState(appConfig, initialPromptInput, stdInPrompt, hasContinueOrResume, resumeSessionId);
+        const state = await initializeAppState(appConfig, initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId);
+        // Add logs directory to allowed directories if configured
+        const logsPath = (await config.getConfig()).logs?.path;
+        if (logsPath) {
+            // Expand ~ to home directory before resolving
+            const expandedLogsPath = logsPath.startsWith("~/") || logsPath === "~"
+                ? path.join(os.homedir(), logsPath.slice(1))
+                : logsPath;
+            const logsDir = path.dirname(path.resolve(expandedLogsPath));
+            if (!workspace.allowedDirs.includes(logsDir)) {
+                workspace.allowedDirs.push(logsDir);
+            }
+        }
         // Set terminal title after all validation is complete
         setTerminalTitle(`acai: ${workspace.primaryDir}`);
         // Handle CLI mode if initial prompt provided
         if (isDefined(initialPromptInput)) {
-            return await runCliMode(state);
+            return await runCliMode(state, flags["no-session"] === true);
         }
         // Setup REPL mode
-        return await runReplMode(state);
+        return await runReplMode(state, stdinContent !== null, flags["no-session"] === true);
     }
     catch (error) {
         handleError(error);

package/dist/middleware/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../source/middleware/cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EAE1B,MAAM,kBAAkB,CAAC;AA+F1B,eAAO,MAAM,eAAe,EAAE,yBAqF7B,CAAC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../source/middleware/cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EAE1B,MAAM,kBAAkB,CAAC;AAyE1B,eAAO,MAAM,eAAe,EAAE,yBA+E7B,CAAC"}

package/dist/middleware/cache.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { logger } from "../logger.js";
+import { logger } from "../utils/logger.js";
 function applyCaching(input, options = {}) {
     const { ttl } = options;
     input.providerOptions = {
@@ -27,53 +27,37 @@ function generateCacheKey(text, salt) {
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
 }
-function getMinTokenThreshold(provider, modelId) {
-    if (provider === "anthropic") {
-        if (modelId?.includes("haiku"))
-            return 2048;
-        if (modelId?.includes("opus"))
-            return 1024;
-        return 1024; // Default for Claude models
-    }
-    return 1024; // Default threshold
+function getMinTokenThreshold(modelId) {
+    if (modelId?.includes("haiku"))
+        return 4096;
+    if (modelId?.includes("opus"))
+        return 4096;
+    if (modelId?.includes("sonnet"))
+        return 1024;
+    return 1024;
 }
-function isEligibleForCaching(text, provider, modelId) {
+function isEligibleForCaching(text, modelId) {
     const tokenCount = estimateTokens(text);
-    const minThreshold = getMinTokenThreshold(provider, modelId);
+    const minThreshold = getMinTokenThreshold(modelId ?? "");
     if (tokenCount < minThreshold) {
-        logger.info(`[Cache] Ineligible: ${tokenCount} tokens < ${minThreshold} threshold`);
         return false;
     }
     return true;
 }
-function detectProvider(providerId, modelId) {
-    if (providerId === "anthropic" ||
-        modelId.includes("anthropic") ||
-        modelId.includes("claude")) {
+function detectProvider(modelId) {
+    if (modelId.includes("sonnet") ||
+        modelId.includes("opus") ||
+        modelId.includes("haiku")) {
         return "anthropic";
     }
-    if (providerId === "openai" || modelId.includes("gpt-")) {
-        return "openai";
-    }
-    if (providerId === "bedrock" ||
-        modelId.includes("bedrock") ||
-        modelId.includes("amazon")) {
-        return "bedrock";
-    }
-    if (modelId.includes("openrouter")) {
-        return "openrouter";
-    }
     return "unknown";
 }
 export const cacheMiddleware = {
     specificationVersion: "v3",
     transformParams: async ({ params, model }) => {
-        const providerId = model.provider;
         const modelId = model.modelId;
-        const provider = detectProvider(providerId, modelId);
-        logger.info(`[Cache] Detected provider: ${provider}, model: ${modelId}`);
+        const provider = detectProvider(modelId);
         if (provider === "unknown") {
-            logger.info("[Cache] Unknown provider, skipping caching");
             return params;
         }
         const msgs = params.prompt;
@@ -89,14 +73,12 @@ export const cacheMiddleware = {
                 : "")
             .join("\n");
         // Check if system prompt is eligible for caching
-        const isEligible = isEligibleForCaching(systemText, provider, modelId);
+        const isEligible = isEligibleForCaching(systemText, modelId);
         if (!isEligible) {
-            logger.info("[Cache] System prompt not eligible for caching");
             return params;
         }
         // Generate deterministic cache key
         const cacheKey = generateCacheKey(systemText, provider);
-        logger.info(`[Cache] Generated cache key: ${cacheKey.substring(0, 8)}...`);
         // Apply caching to system messages
         for (const systemMsg of systemMessages) {
             applyCaching(systemMsg, { ttl: "1h" });
@@ -128,7 +110,7 @@ export const cacheMiddleware = {
             provider,
             eligible: isEligible,
             systemTokens: estimateTokens(systemText),
-            threshold: getMinTokenThreshold(provider, modelId),
+            threshold: getMinTokenThreshold(modelId),
             timestamp: Date.now(),
         };
         logger.info(`[Cache] Applied caching for ${provider} model`);

package/dist/models/ai-config.d.ts

@@ -3,6 +3,7 @@ import type { ModelMetadata } from "./providers.ts";
 export declare class AiConfig {
     private modelMetadata;
     private prompt;
+    private thinkingLevel;
     constructor({ modelMetadata, prompt, }: {
         modelMetadata: ModelMetadata;
         prompt: string;

package/dist/models/ai-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-config.d.ts","sourceRoot":"","sources":["../../source/models/ai-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AA2CpD,qBAAa,QAAQ;IACnB,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,MAAM,CAAS;gBACX,EACV,aAAa,EACb,MAAM,GACP,EAAE;QAAE,aAAa,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAKnD,eAAe;IAUf,WAAW;IAKX,IAAI;IAMJ,eAAe,IAAI,wBAAwB;CA+D5C"}
+{"version":3,"file":"ai-config.d.ts","sourceRoot":"","sources":["../../source/models/ai-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AA2CpD,qBAAa,QAAQ;IACnB,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAA0C;gBAEnD,EACV,aAAa,EACb,MAAM,GACP,EAAE;QAAE,aAAa,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAMnD,eAAe;IASf,WAAW;IAKX,IAAI;IAMJ,eAAe,IAAI,wBAAwB;CA+D5C"}

package/dist/models/ai-config.js

@@ -30,15 +30,16 @@ function calculateThinkingLevel(userInput) {
 export class AiConfig {
     modelMetadata;
     prompt;
+    thinkingLevel;
     constructor({ modelMetadata, prompt, }) {
         this.modelMetadata = modelMetadata;
         this.prompt = prompt;
+        this.thinkingLevel = calculateThinkingLevel(this.prompt);
     }
     maxOutputTokens() {
         const modelConfig = this.modelMetadata;
-        const thinkingLevel = calculateThinkingLevel(this.prompt);
         const maxTokens = modelConfig.provider === "anthropic" && modelConfig.supportsReasoning
-            ? modelConfig.maxOutputTokens - thinkingLevel.tokenBudget
+            ? modelConfig.maxOutputTokens - this.thinkingLevel.tokenBudget
             : modelConfig.maxOutputTokens;
         return modelConfig.provider === "opencode" ? 8000 : maxTokens;
     }
@@ -54,7 +55,7 @@ export class AiConfig {
     }
     providerOptions() {
         const modelConfig = this.modelMetadata;
-        const thinkingLevel = calculateThinkingLevel(this.prompt);
+        const thinkingLevel = this.thinkingLevel;
         const meta = {
             [modelConfig.provider]: {},
         };

package/dist/models/anthropic-provider.d.ts

@@ -2,22 +2,19 @@ import type { ModelMetadata } from "./providers.ts";
 declare const anthropicModels: {
     readonly opus: import("@ai-sdk/provider").LanguageModelV3;
     readonly sonnet: import("@ai-sdk/provider").LanguageModelV3;
-    readonly sonnet37: import("@ai-sdk/provider").LanguageModelV3;
-    readonly "sonnet37-token-efficient-tools": import("@ai-sdk/provider").LanguageModelV3;
-    readonly "sonnet37-128k": import("@ai-sdk/provider").LanguageModelV3;
-    readonly sonnet35: import("@ai-sdk/provider").LanguageModelV3;
     readonly haiku: import("@ai-sdk/provider").LanguageModelV3;
 };
 type ModelName = `anthropic:${keyof typeof anthropicModels}`;
 export declare const anthropicModelNames: ModelName[];
 export declare const anthropicProvider: {
     anthropic: import("@ai-sdk/provider").ProviderV3 & {
-        languageModel(modelId: "opus" | "sonnet" | "sonnet37" | "sonnet37-token-efficient-tools" | "sonnet37-128k" | "sonnet35" | "haiku"): import("@ai-sdk/provider").LanguageModelV3;
+        languageModel(modelId: "opus" | "sonnet" | "haiku"): import("@ai-sdk/provider").LanguageModelV3;
         embeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV3;
         imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV3;
         transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV3;
         rerankingModel(modelId: string): import("@ai-sdk/provider").RerankingModelV3;
         speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV3;
+        videoModel(modelId: string): import("@ai-sdk/provider").Experimental_VideoModelV3;
     };
 };
 export declare const anthropicModelRegistry: {