whale-code 6.5.4 → 6.5.5

package/dist/server/lib/server-agent-loop.js

@@ -8,7 +8,7 @@
  * Consolidates: streaming, prompt caching, context management betas, compaction,
  * loop detection, parallel tool execution, subagent delegation, retry, cost tracking.
  */
-import { LoopDetector, getContextManagement, getMaxOutputTokens, getThinkingConfig, addPromptCaching, estimateCostUsd, isRetryableError, sanitizeError, routeModel, resolveToolChoice, emitCostWarningIfNeeded, demoteSubagentModel, COMPACTION_TRIGGER_TOKENS, COMPACTION_TOTAL_BUDGET, DEFAULT_SESSION_COST_BUDGET_USD, } from "../../shared/agent-core.js";
+import { LoopDetector, getContextManagement, getMaxOutputTokens, getThinkingConfig, addPromptCaching, estimateCostUsd, isRetryableError, sanitizeError, routeModel, resolveToolChoice, emitCostWarningIfNeeded, demoteSubagentModel, COMPACTION_TOTAL_BUDGET, DEFAULT_SESSION_COST_BUDGET_USD, } from "../../shared/agent-core.js";
 import { processStreamWithCallbacks } from "../../shared/sse-parser.js";
 import { MODELS } from "../../shared/constants.js";
 import { dispatchTools, buildAssistantContent } from "../../shared/tool-dispatch.js";
@@ -50,10 +50,16 @@ function mapToolChoiceForAnthropic(tc) {
 // UNIFIED AGENT LOOP
 // ============================================================================
 export async function runServerAgentLoop(opts) {
-    const { anthropic, model, systemPrompt, messages, tools: inputTools, maxTurns, temperature, enableDelegation = true, enablePromptCaching = true, enableStreaming = true, maxConcurrentTools = DEFAULT_MAX_CONCURRENT_TOOLS, maxCostUsd: maxCostUsdOpt, onText, onToolStart, onCitation, documents, clientDisconnected = { value: false }, startedAt = Date.now(), maxDurationMs = 15 * 60 * 1000, } = opts;
-    // Resolve cost budget: explicit opt > env var > default
+    const { anthropic, model, systemPrompt, messages, tools: inputTools, maxTurns, temperature, enableDelegation = true, enablePromptCaching = true, enableStreaming = true, enableModelRouting = true, maxConcurrentTools = DEFAULT_MAX_CONCURRENT_TOOLS, maxCostUsd: maxCostUsdOpt, onText, onToolStart, onCitation, documents, clientDisconnected = { value: false }, startedAt = Date.now(), maxDurationMs = 15 * 60 * 1000, } = opts;
+    // Resolve cost budget: context_config > explicit opt > env var > default
+    const ctxOverrides = opts.contextOverrides;
     const envBudget = parseFloat(process.env.WHALE_COST_BUDGET_USD || "");
-    const maxCostUsd = maxCostUsdOpt ?? (isFinite(envBudget) ? envBudget : DEFAULT_SESSION_COST_BUDGET_USD);
+    const maxCostUsd = ctxOverrides?.session_cost_budget_usd
+        ?? maxCostUsdOpt
+        ?? (isFinite(envBudget) ? envBudget : DEFAULT_SESSION_COST_BUDGET_USD);
+    // Resolve compaction budget from overrides (used for compaction exhaustion checks)
+    const effectiveCompactionTrigger = ctxOverrides?.compaction_trigger_tokens ?? 150_000;
+    const effectiveCompactionBudget = ctxOverrides?.compaction_total_budget ?? COMPACTION_TOTAL_BUDGET;
     // Auto-inject delegate_task for all models (subagents always use Claude Haiku/Sonnet)
     // activeTools is mutable — discover_tools adds to it during the session
     const activeTools = [...inputTools];
@@ -122,7 +128,8 @@ export async function runServerAgentLoop(opts) {
         loopDetector.resetTurn();
         // Route model on the FIRST turn only — subsequent turns use the requested model
         // since the conversation may have become complex after tool results.
-        const effectiveModel = turnCount === 1
+        // enableModelRouting=false prevents downgrade (e.g. Opus agents that should stay Opus)
+        const effectiveModel = (turnCount === 1 && enableModelRouting)
             ? routeModel(firstUserText, model)
             : model;
         if (turnCount === 1 && effectiveModel !== model) {
@@ -130,7 +137,7 @@ export async function runServerAgentLoop(opts) {
         }
         // Per-turn model config — uses effectiveModel so routed models get correct settings
         const maxTokens = opts.maxTokens ?? getMaxOutputTokens(effectiveModel);
-        const ctxMgmt = getContextManagement(effectiveModel);
+        const ctxMgmt = getContextManagement(effectiveModel, opts.contextOverrides);
         const thinkingCfg = getThinkingConfig(effectiveModel, true);
         // Prepare tool definitions — use pre-computed cache, only rebuild when tools change
         // (discover_tools can add tools mid-session, detected via length change)
@@ -288,8 +295,8 @@ export async function runServerAgentLoop(opts) {
                 compactionCount++;
                 log.info({ compactionCount }, "compaction — preserving last 2 messages, resuming");
                 // Budget enforcement: if cumulative compaction cost exceeds budget, force wrap-up
-                if (compactionCount * COMPACTION_TRIGGER_TOKENS >= COMPACTION_TOTAL_BUDGET) {
-                    log.warn({ compactionCount, triggerTokens: COMPACTION_TRIGGER_TOKENS, estimatedTokens: compactionCount * COMPACTION_TRIGGER_TOKENS }, "compaction budget exhausted");
+                if (compactionCount * effectiveCompactionTrigger >= effectiveCompactionBudget) {
+                    log.warn({ compactionCount, triggerTokens: effectiveCompactionTrigger, estimatedTokens: compactionCount * effectiveCompactionTrigger }, "compaction budget exhausted");
                     onText?.("\n[Context budget reached — wrapping up.]");
                     // Rebuild messages: compaction summary + wrap-up instruction
                     const compactedMessages = [
@@ -462,7 +469,7 @@ export async function runServerAgentLoop(opts) {
             if (response.stop_reason === "compaction" && nsCompactionContent !== null) {
                 compactionCount++;
                 log.info({ compactionCount, streaming: false }, "compaction — preserving last 2 messages");
-                if (compactionCount * COMPACTION_TRIGGER_TOKENS >= COMPACTION_TOTAL_BUDGET) {
+                if (compactionCount * effectiveCompactionTrigger >= effectiveCompactionBudget) {
                     onText?.("\n[Context budget reached — wrapping up.]");
                     const compactedMessages = [
                         { role: "assistant", content: [{ type: "compaction", content: nsCompactionContent }] },
@@ -548,7 +555,8 @@ function makeToolExecutor(opts, tools, allToolNames, subagentTokens, discoveredT
         if (name === "delegate_task") {
             const subPrompt = String(input.prompt || "");
             const subModel = demoteSubagentModel(input.model ? String(input.model) : undefined);
-            const subMaxTurns = Math.min(Math.max(1, Number(input.max_turns) || 6), 12);
+            const defaultSubMaxTurns = opts.subagentMaxTurns ?? 6;
+            const subMaxTurns = Math.min(Math.max(1, Number(input.max_turns) || defaultSubMaxTurns), 12);
             const subTools = tools.filter((t) => t.name !== "delegate_task");
             const subId = `sub-${Date.now().toString(36)}`;
             onSubagentProgress?.({ subagentId: subId, event: "started", model: subModel });
@@ -558,6 +566,8 @@ function makeToolExecutor(opts, tools, allToolNames, subagentTokens, discoveredT
                 maxTurns: subMaxTurns, tools: subTools,
                 executeTool: async (toolName, args) => executeTool(toolName, args, "server_subagent"),
                 onProgress: onSubagentProgress, clientDisconnected, startedAt, maxDurationMs,
+                maxOutputTokens: opts.subagentMaxTokens,
+                temperature: opts.subagentTemperature,
             });
             onSubagentProgress?.({ subagentId: subId, event: "done", output: subResult.output });
             // Audit log

package/dist/server/lib/server-subagent.d.ts

@@ -54,6 +54,8 @@ export interface RunServerSubagentOptions {
     };
     startedAt: number;
     maxDurationMs: number;
+    maxOutputTokens?: number;
+    temperature?: number;
 }
 export declare const DELEGATE_TASK_TOOL_DEF: {
     name: string;

package/dist/server/lib/server-subagent.js

@@ -64,7 +64,9 @@ export async function runServerSubagent(opts) {
     let cacheRead = 0;
     // Enable thinking for capable models; adjust max tokens for Opus
     const shouldThink = modelAlias === "opus" || modelAlias === "sonnet";
-    const effectiveMaxTokens = modelAlias === "opus" ? 16384 : SUBAGENT_MAX_OUTPUT_TOKENS;
+    const baseMaxTokens = opts.maxOutputTokens ?? SUBAGENT_MAX_OUTPUT_TOKENS;
+    const effectiveMaxTokens = modelAlias === "opus" ? Math.max(16384, baseMaxTokens) : baseMaxTokens;
+    const effectiveTemperature = opts.temperature ?? 0.3;
     // Context management for subagent: clear at 60K, keep 2, no compaction
     const apiConfig = buildAPIRequest({
         model: modelId,
@@ -99,7 +101,7 @@ export async function runServerSubagent(opts) {
                 return await anthropic.beta.messages.create({
                     model: modelId,
                     max_tokens: apiConfig.maxTokens,
-                    temperature: shouldThink ? 1 : 0.3, // Anthropic requires temp=1 with thinking
+                    temperature: shouldThink ? 1 : effectiveTemperature, // Anthropic requires temp=1 with thinking
                     system,
                     tools: cachedTools,
                     messages: cachedMessages,

package/dist/server/providers/anthropic.js

@@ -8,16 +8,16 @@
  * output token limits, and compaction config for Anthropic/Claude models.
  */
 import Anthropic from "@anthropic-ai/sdk";
-import { sanitizeError } from "../../shared/agent-core.js";
+import { sanitizeError, AGENT_DEFAULTS } from "../../shared/agent-core.js";
 import { getCapabilities } from "../lib/provider-capabilities.js";
 import { registerProvider } from "./registry.js";
 import { jsonResponse, writeSSEHeaders } from "./shared.js";
 // ============================================================================
 // CONSTANTS — Anthropic-specific model config
 // ============================================================================
-const COMPACTION_TRIGGER_TOKENS = 120_000;
-const COMPACTION_TOTAL_BUDGET = 2_000_000;
-const DEFAULT_OUTPUT_TOKENS = 16384;
+const COMPACTION_TRIGGER_TOKENS = AGENT_DEFAULTS.compactionTriggerTokens;
+const COMPACTION_TOTAL_BUDGET = AGENT_DEFAULTS.compactionTotalBudget;
+const DEFAULT_OUTPUT_TOKENS = 16384; // Per-response cap (model max is separate)
 const MODEL_MAX_OUTPUT_TOKENS = {
     "claude-opus-4-6": 128000,
     "claude-sonnet-4-6": 64000,

package/dist/server/providers/bedrock.js

@@ -8,16 +8,16 @@
  * output token limits, and compaction config for Bedrock Claude models.
  */
 import { BedrockRuntimeClient, InvokeModelWithResponseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
-import { sanitizeError } from "../../shared/agent-core.js";
+import { sanitizeError, AGENT_DEFAULTS } from "../../shared/agent-core.js";
 import { getCapabilities } from "../lib/provider-capabilities.js";
 import { registerProvider } from "./registry.js";
 import { jsonResponse, writeSSEHeaders, resolveProviderCredentials } from "./shared.js";
 // ============================================================================
 // CONSTANTS — Bedrock-specific model config
 // ============================================================================
-const COMPACTION_TRIGGER_TOKENS = 120_000;
-const COMPACTION_TOTAL_BUDGET = 2_000_000;
-const DEFAULT_OUTPUT_TOKENS = 16384;
+const COMPACTION_TRIGGER_TOKENS = AGENT_DEFAULTS.compactionTriggerTokens;
+const COMPACTION_TOTAL_BUDGET = AGENT_DEFAULTS.compactionTotalBudget;
+const DEFAULT_OUTPUT_TOKENS = 16384; // Per-response cap (model max is separate)
 const MODEL_MAX_OUTPUT_TOKENS = {
     "anthropic.claude-sonnet-4-6": 64000,
     "us.anthropic.claude-sonnet-4-20250514-v1:0": 64000,

package/dist/server/tool-router.d.ts

@@ -70,6 +70,19 @@ export interface AgentConfig {
         max_history_chars?: number;
         max_tool_result_chars?: number;
         max_message_chars?: number;
+        compaction_trigger_tokens?: number;
+        compaction_total_budget?: number;
+        clear_thinking_keep?: number;
+        clear_tool_uses_trigger?: number;
+        clear_tool_uses_keep?: number;
+        session_cost_budget_usd?: number;
+        max_concurrent_tools?: number;
+        enable_delegation?: boolean;
+        max_duration_ms?: number;
+        enable_model_routing?: boolean;
+        subagent_max_tokens?: number;
+        subagent_max_turns?: number;
+        subagent_temperature?: number;
     } | null;
 }
 export interface ToolLoadResult {

package/dist/server/tool-router.js

@@ -45,6 +45,7 @@ import { handleKali } from "./handlers/kali.js";
 import { handleLocalAgent } from "./handlers/local-agent.js";
 import { handleEnrichment } from "./handlers/enrichment.js";
 import { handleStorefront } from "./handlers/storefront.js";
+import { handleApiDocs } from "./handlers/api-docs.js";
 import { handleClickHouse } from "./handlers/clickhouse.js";
 import { summarizeResult, withTimeout } from "./lib/utils.js";
 // ============================================================================
@@ -300,6 +301,7 @@ export const TOOL_HANDLERS = {
     browser: { handler: handleBrowser, timeout: 120_000, requiresStore: true },
     discovery: { handler: handleDiscovery, timeout: DEFAULT_TIMEOUT, requiresStore: false },
     api_keys: { handler: handleAPIKeys, timeout: DEFAULT_TIMEOUT, requiresStore: true },
+    api_docs: { handler: handleApiDocs, timeout: 5000, requiresStore: false },
     // --- Advertising ---
     meta_ads: { handler: handleMetaAds, timeout: 300_000, requiresStore: true },
     // --- Security & Local ---
@@ -371,7 +373,7 @@ const TOOL_CATEGORIES = {
     llm: "ai", embeddings: "ai", creations: "media",
     // Platform
     web_search: "platform", browser: "platform", discovery: "platform",
-    api_keys: "platform",
+    api_keys: "platform", api_docs: "platform",
     // Security
     kali: "security", local_agent: "platform",
     // Advertising

package/dist/shared/agent-core.d.ts

@@ -52,7 +52,17 @@ export interface ContextManagementConfig {
         edits: Array<Record<string, unknown>>;
     };
 }
-/** Compaction trigger threshold — shared so agent loops can track budget */
+/** Overrides from ai_agent_config.context_config JSONB — all optional, falls back to defaults */
+export interface ContextManagementOverrides {
+    compaction_trigger_tokens?: number;
+    compaction_total_budget?: number;
+    clear_thinking_keep?: number;
+    clear_tool_uses_trigger?: number;
+    clear_tool_uses_keep?: number;
+    session_cost_budget_usd?: number;
+}
+/** Legacy compaction trigger — used by getCompactionConfig() for non-Anthropic providers.
+ *  For Anthropic models, getContextManagement() with DB overrides takes precedence. */
 export declare const COMPACTION_TRIGGER_TOKENS = 120000;
 /** Max cumulative tokens before forcing wrap-up (prevents runaway compaction cost) */
 export declare const COMPACTION_TOTAL_BUDGET = 2000000;
@@ -75,7 +85,7 @@ export declare function getCompactionConfig(model: string): CompactionConfig;
  * - All other Claude models: clear thinking + clear tools at 80K/keep 3
  * - Non-Anthropic models (Gemini, OpenAI): no betas, no context management
  */
-export declare function getContextManagement(model: string): ContextManagementConfig;
+export declare function getContextManagement(model: string, overrides?: ContextManagementOverrides): ContextManagementConfig;
 export declare function getMaxOutputTokens(model: string, agentMax?: number): number;
 /**
  * Add prompt cache breakpoints to tools and messages.
@@ -163,12 +173,6 @@ export declare function categorizeError(err: unknown): {
     retryable: boolean;
 };
 export declare function isRetryableError(err: unknown): boolean;
-/** @deprecated — Anthropic context_management handles limits. Use SAFETY_MAX_CHARS in tool-dispatch instead. */
-export declare function truncateToolResult(content: string, maxChars: number): string;
-/** @deprecated — Anthropic context_management handles limits. */
-export declare function getMaxToolResultChars(contextConfig?: {
-    max_tool_result_chars?: number;
-} | null): number;
 /**
  * Demote subagent model requests — single source of truth for server + CLI.
  * - explore/research: always haiku
@@ -177,4 +181,78 @@ export declare function getMaxToolResultChars(contextConfig?: {
  * - default/undefined: haiku
  */
 export declare function demoteSubagentModel(requested: string | undefined, agentType?: string): "haiku" | "sonnet";
+export type CallPath = "sse" | "workflow" | "channel";
+/** Documented defaults — replaces scattered magic numbers across call paths */
+export declare const AGENT_DEFAULTS: {
+    readonly maxTurns: 10;
+    readonly temperature: 0.7;
+    readonly maxConcurrentTools: 7;
+    readonly enableDelegation: true;
+    readonly maxDurationMs: 900000;
+    readonly maxDurationMsWorkflow: 120000;
+    readonly enableModelRouting: true;
+    readonly subagentMaxTokens: 8192;
+    readonly subagentMaxTurns: 6;
+    readonly subagentTemperature: 0.3;
+    readonly maxMessageChars: 100000;
+    readonly maxHistoryChars: 400000;
+    readonly compactionTriggerTokens: 150000;
+    readonly compactionTotalBudget: 2000000;
+    readonly sessionCostBudgetUsd: 5;
+};
+/** Context config shape from ai_agent_config.context_config JSONB */
+export interface AgentContextConfig {
+    includeLocations?: boolean;
+    locationIds?: string[];
+    includeCustomers?: boolean;
+    customerSegments?: string[];
+    max_history_chars?: number;
+    max_tool_result_chars?: number;
+    max_message_chars?: number;
+    compaction_trigger_tokens?: number;
+    compaction_total_budget?: number;
+    clear_thinking_keep?: number;
+    clear_tool_uses_trigger?: number;
+    clear_tool_uses_keep?: number;
+    session_cost_budget_usd?: number;
+    max_concurrent_tools?: number;
+    enable_delegation?: boolean;
+    max_duration_ms?: number;
+    enable_model_routing?: boolean;
+    subagent_max_tokens?: number;
+    subagent_max_turns?: number;
+    subagent_temperature?: number;
+}
+export interface ResolvedAgentLoopConfig {
+    maxTurns: number;
+    temperature: number;
+    maxTokens: number;
+    maxConcurrentTools: number;
+    enableDelegation: boolean;
+    maxDurationMs: number;
+    enableModelRouting: boolean;
+    maxMessageChars: number;
+    maxHistoryChars: number;
+    contextOverrides: ContextManagementOverrides;
+    subagentMaxTokens: number;
+    subagentMaxTurns: number;
+    subagentTemperature: number;
+    /** Which fields fell back to AGENT_DEFAULTS (transparency for logging) */
+    defaultsUsed: string[];
+}
+/**
+ * Resolve all agent loop behavioral knobs from DB config.
+ * All 3 call paths MUST use this — structurally prevents hardcoded constants.
+ *
+ * @param agent - Agent config (DB row or subset)
+ * @param callPath - Which call path is invoking ("sse" | "workflow" | "channel")
+ * @param workflowMaxTurns - Optional cap from workflow step config (workflow path only)
+ */
+export declare function resolveAgentLoopConfig(agent: {
+    max_tool_calls: number;
+    temperature: number;
+    max_tokens: number;
+    model: string;
+    context_config: AgentContextConfig | null;
+}, callPath: CallPath, workflowMaxTurns?: number): ResolvedAgentLoopConfig;
 export declare function sanitizeError(err: unknown): string;

package/dist/shared/agent-core.js

@@ -51,7 +51,8 @@ export function resolveToolChoice(opts) {
 // ============================================================================
 // MODEL-AWARE CONTEXT MANAGEMENT
 // ============================================================================
-/** Compaction trigger threshold — shared so agent loops can track budget */
+/** Legacy compaction trigger — used by getCompactionConfig() for non-Anthropic providers.
+ *  For Anthropic models, getContextManagement() with DB overrides takes precedence. */
 export const COMPACTION_TRIGGER_TOKENS = 120_000;
 /** Max cumulative tokens before forcing wrap-up (prevents runaway compaction cost) */
 export const COMPACTION_TOTAL_BUDGET = 2_000_000;
@@ -76,7 +77,7 @@ export function getCompactionConfig(model) {
  * - All other Claude models: clear thinking + clear tools at 80K/keep 3
  * - Non-Anthropic models (Gemini, OpenAI): no betas, no context management
  */
-export function getContextManagement(model) {
+export function getContextManagement(model, overrides) {
     // Non-Anthropic models don't use Anthropic betas or context management
     const provider = getProvider(model);
     if (provider === "gemini" || provider === "openai") {
@@ -85,29 +86,34 @@ export function getContextManagement(model) {
     const edits = [];
     const betas = ["context-management-2025-06-27"];
     // Thinking block clearing — must come FIRST in edits array (API requirement).
-    // Keeps last 2 turns of thinking to maintain reasoning continuity while
-    // preventing unbounded growth from extended thinking.
+    // Default: keep 1 thinking turn (matches Claude Code / Anthropic API defaults).
+    const clearThinkingKeep = overrides?.clear_thinking_keep ?? 1;
     edits.push({
         type: "clear_thinking_20251015",
-        keep: { type: "thinking_turns", value: 2 },
+        keep: { type: "thinking_turns", value: clearThinkingKeep },
     });
     // Server-side compaction for models that support compact_20260112.
+    // Default trigger: 150K tokens (matches Anthropic API default).
     // pause_after_compaction: true enables the loop to preserve recent messages
     // and track compaction count for budget enforcement.
     const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
+    const compactionTrigger = overrides?.compaction_trigger_tokens ?? 150_000;
     if (supportsCompaction) {
         edits.push({
             type: "compact_20260112",
-            trigger: { type: "input_tokens", value: COMPACTION_TRIGGER_TOKENS },
+            trigger: { type: "input_tokens", value: compactionTrigger },
             pause_after_compaction: true,
             instructions: "Summarize the conversation preserving: (1) task goals and constraints, (2) files created/modified with paths, (3) decisions made and rationale, (4) errors encountered and resolutions, (5) exact next steps. Be concise but preserve all state needed to continue work without repeating mistakes.",
         });
         betas.push("compact-2026-01-12");
     }
+    // Clear tool uses — default: trigger at 100K, keep 3 (matches Anthropic API defaults).
+    const clearToolUsesTrigger = overrides?.clear_tool_uses_trigger ?? 100_000;
+    const clearToolUsesKeep = overrides?.clear_tool_uses_keep ?? 3;
     edits.push({
         type: "clear_tool_uses_20250919",
-        trigger: { type: "input_tokens", value: 80_000 },
-        keep: { type: "tool_uses", value: 3 },
+        trigger: { type: "input_tokens", value: clearToolUsesTrigger },
+        keep: { type: "tool_uses", value: clearToolUsesKeep },
     });
     return { betas, config: { edits } };
 }
@@ -551,17 +557,6 @@ export function isRetryableError(err) {
 // ============================================================================
 // TOOL RESULT TRUNCATION (deprecated — Anthropic context_management handles limits)
 // ============================================================================
-/** @deprecated — Anthropic context_management handles limits. Use SAFETY_MAX_CHARS in tool-dispatch instead. */
-export function truncateToolResult(content, maxChars) {
-    if (content.length <= maxChars)
-        return content;
-    return content.slice(0, maxChars) + `\n\n... (truncated — ${content.length.toLocaleString()} chars total)`;
-}
-/** @deprecated — Anthropic context_management handles limits. */
-export function getMaxToolResultChars(contextConfig) {
-    return contextConfig?.max_tool_result_chars || 80_000;
-}
-// ============================================================================
 // UTILITY — sanitize errors (strip API keys, passwords)
 // ============================================================================
 /**
@@ -582,6 +577,86 @@ export function demoteSubagentModel(requested, agentType) {
         return agentType === "plan" ? "sonnet" : "haiku";
     return "haiku";
 }
+/** Documented defaults — replaces scattered magic numbers across call paths */
+export const AGENT_DEFAULTS = {
+    maxTurns: 10,
+    temperature: 0.7,
+    maxConcurrentTools: 7,
+    enableDelegation: true,
+    maxDurationMs: 900_000, // 15 minutes (SSE default)
+    maxDurationMsWorkflow: 120_000, // 2 minutes (workflow/channel)
+    enableModelRouting: true,
+    subagentMaxTokens: 8192,
+    subagentMaxTurns: 6,
+    subagentTemperature: 0.3,
+    maxMessageChars: 100_000,
+    maxHistoryChars: 400_000,
+    compactionTriggerTokens: 150_000,
+    compactionTotalBudget: 2_000_000,
+    sessionCostBudgetUsd: 5.00,
+};
+/**
+ * Resolve all agent loop behavioral knobs from DB config.
+ * All 3 call paths MUST use this — structurally prevents hardcoded constants.
+ *
+ * @param agent - Agent config (DB row or subset)
+ * @param callPath - Which call path is invoking ("sse" | "workflow" | "channel")
+ * @param workflowMaxTurns - Optional cap from workflow step config (workflow path only)
+ */
+export function resolveAgentLoopConfig(agent, callPath, workflowMaxTurns) {
+    const cc = agent.context_config;
+    const defaultsUsed = [];
+    function resolve(dbValue, defaultValue, name) {
+        if (dbValue != null)
+            return dbValue;
+        defaultsUsed.push(name);
+        return defaultValue;
+    }
+    // Core agent behavior
+    const agentMaxTurns = agent.max_tool_calls || AGENT_DEFAULTS.maxTurns;
+    if (!agent.max_tool_calls)
+        defaultsUsed.push("maxTurns");
+    const temperature = agent.temperature ?? AGENT_DEFAULTS.temperature;
+    if (agent.temperature == null)
+        defaultsUsed.push("temperature");
+    const maxTokens = getMaxOutputTokens(agent.model || "claude-sonnet-4-6", agent.max_tokens);
+    if (!agent.max_tokens)
+        defaultsUsed.push("maxTokens");
+    // Call-path-specific duration defaults
+    const durationDefault = callPath === "sse"
+        ? AGENT_DEFAULTS.maxDurationMs
+        : AGENT_DEFAULTS.maxDurationMsWorkflow;
+    // Call-path-specific turn caps
+    let maxTurns = agentMaxTurns;
+    if (callPath === "channel")
+        maxTurns = Math.min(agentMaxTurns, 15);
+    if (callPath === "workflow" && workflowMaxTurns != null) {
+        maxTurns = Math.min(agentMaxTurns, workflowMaxTurns);
+    }
+    return {
+        maxTurns,
+        temperature,
+        maxTokens,
+        maxConcurrentTools: resolve(cc?.max_concurrent_tools, AGENT_DEFAULTS.maxConcurrentTools, "maxConcurrentTools"),
+        enableDelegation: resolve(cc?.enable_delegation, AGENT_DEFAULTS.enableDelegation, "enableDelegation"),
+        maxDurationMs: resolve(cc?.max_duration_ms, durationDefault, "maxDurationMs"),
+        enableModelRouting: resolve(cc?.enable_model_routing, AGENT_DEFAULTS.enableModelRouting, "enableModelRouting"),
+        maxMessageChars: resolve(cc?.max_message_chars, AGENT_DEFAULTS.maxMessageChars, "maxMessageChars"),
+        maxHistoryChars: resolve(cc?.max_history_chars, AGENT_DEFAULTS.maxHistoryChars, "maxHistoryChars"),
+        contextOverrides: {
+            compaction_trigger_tokens: cc?.compaction_trigger_tokens ?? undefined,
+            compaction_total_budget: cc?.compaction_total_budget ?? undefined,
+            clear_thinking_keep: cc?.clear_thinking_keep ?? undefined,
+            clear_tool_uses_trigger: cc?.clear_tool_uses_trigger ?? undefined,
+            clear_tool_uses_keep: cc?.clear_tool_uses_keep ?? undefined,
+            session_cost_budget_usd: cc?.session_cost_budget_usd ?? undefined,
+        },
+        subagentMaxTokens: resolve(cc?.subagent_max_tokens, AGENT_DEFAULTS.subagentMaxTokens, "subagentMaxTokens"),
+        subagentMaxTurns: resolve(cc?.subagent_max_turns, AGENT_DEFAULTS.subagentMaxTurns, "subagentMaxTurns"),
+        subagentTemperature: resolve(cc?.subagent_temperature, AGENT_DEFAULTS.subagentTemperature, "subagentTemperature"),
+        defaultsUsed,
+    };
+}
 export function sanitizeError(err) {
     const msg = String(err);
     return msg

package/dist/shared/api-client.d.ts

@@ -18,6 +18,7 @@ export declare function buildAPIRequest(opts: {
     contextProfile: ContextProfile;
     thinkingEnabled?: boolean;
     maxOutputTokens?: number;
+    contextOverrides?: import("./agent-core.js").ContextManagementOverrides;
 }): APIRequestConfig;
 export interface CallServerProxyConfig {
     proxyUrl: string;

package/dist/shared/api-client.js

@@ -23,7 +23,7 @@ const RETRY_BASE_DELAY_MS = 1000;
  * - 'teammate': clear at 80K/keep 3, no compaction
  */
 export function buildAPIRequest(opts) {
-    const { model, contextProfile, thinkingEnabled = false, maxOutputTokens } = opts;
+    const { model, contextProfile, thinkingEnabled = false, maxOutputTokens, contextOverrides } = opts;
     // Context management config per profile
     // Non-Anthropic models (Gemini, OpenAI, etc.) don't support Anthropic betas or context management
     const provider = getProvider(model);
@@ -32,7 +32,7 @@ export function buildAPIRequest(opts) {
     let edits = [];
     switch (contextProfile) {
         case "main": {
-            const ctxMgmt = getContextManagement(model);
+            const ctxMgmt = getContextManagement(model, contextOverrides);
             betas = [...ctxMgmt.betas];
             edits = ctxMgmt.config.edits;
             break;

package/dist/shared/tool-dispatch.d.ts

@@ -11,8 +11,6 @@ export interface ToolDispatchOptions {
     loopDetector: LoopDetector;
     /** Max concurrent tool executions (7 for main, 1 for sequential) */
     maxConcurrent?: number;
-    /** @deprecated — Anthropic context_management handles limits. Only SAFETY_MAX_CHARS applies. */
-    maxResultChars?: number;
     /** Per-tool execution timeout in ms (default 120000 = 2 minutes) */
     toolTimeoutMs?: number;
     /** Called when a tool starts executing */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whale-code",
-  "version": "6.5.4",
+  "version": "6.5.5",
   "description": "whale code — local-first AI agent CLI for inventory, orders, and analytics powered by MCP",
   "type": "module",
   "main": "dist/index.js",