@agentforge-io/core 2.0.23 → 2.0.24

package/dist/ai/index.d.ts

@@ -2,6 +2,8 @@ export { AGENT_FORGE_CONFIG, AGENT_QUEUE_NAME, CURRENT_USER, } from '../constant
 export type { AgentDefinition, AnthropicConfig, McpServerConfig, AgentForgeConfig, DatabaseConfig, RedisConfig, QueueConfig, } from '../types/config.types';
 export type { AgentResponse, AgentOverrides, StreamChunk, TokenUsage, ToolCallRecord, AgentToolDefinition, AgentJobPayload, AgentJobResult, AnthropicMessage, } from '../types/agent.types';
 export type { SdkHooks, UsageEvent, TurnCompleteEvent, ToolCallEvent, } from '../types/hooks';
+export type { ModelStrategy, ModelTier, EscalateRule, FallbackRule, TurnSignals, ModelSelection, } from '../types/model-strategy';
+export { selectModel, DEFAULT_LONG_CONTEXT_TOKENS, DEFAULT_SHORT_INPUT_TOKENS, } from '../types/model-strategy';
 export { ToolRegistryService, type Logger } from '../services/tool-registry.service';
 export { AgentRunnerService } from '../services/agent-runner.service';
 export { OrchestratorService } from '../services/orchestrator.service';

package/dist/ai/index.js

@@ -8,12 +8,16 @@
 //
 // Files still co-located physically; this is a logical seam.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryJobQueue = exports.JOB_QUEUE = exports.InMemoryPreparedStreamStore = exports.PREPARED_STREAM_STORE = exports.AgentJobWorker = exports.AgentForbiddenError = exports.AgentService = exports.ConversationNotFoundError = exports.ConversationService = exports.PreparedStreamError = exports.PreparedStreamService = exports.OrchestratorService = exports.AgentRunnerService = exports.ToolRegistryService = exports.CURRENT_USER = exports.AGENT_QUEUE_NAME = exports.AGENT_FORGE_CONFIG = void 0;
+exports.InMemoryJobQueue = exports.JOB_QUEUE = exports.InMemoryPreparedStreamStore = exports.PREPARED_STREAM_STORE = exports.AgentJobWorker = exports.AgentForbiddenError = exports.AgentService = exports.ConversationNotFoundError = exports.ConversationService = exports.PreparedStreamError = exports.PreparedStreamService = exports.OrchestratorService = exports.AgentRunnerService = exports.ToolRegistryService = exports.DEFAULT_SHORT_INPUT_TOKENS = exports.DEFAULT_LONG_CONTEXT_TOKENS = exports.selectModel = exports.CURRENT_USER = exports.AGENT_QUEUE_NAME = exports.AGENT_FORGE_CONFIG = void 0;
 // ─── Constants ─────────────────────────────────────────────────────────────
 var constants_1 = require("../constants");
 Object.defineProperty(exports, "AGENT_FORGE_CONFIG", { enumerable: true, get: function () { return constants_1.AGENT_FORGE_CONFIG; } });
 Object.defineProperty(exports, "AGENT_QUEUE_NAME", { enumerable: true, get: function () { return constants_1.AGENT_QUEUE_NAME; } });
 Object.defineProperty(exports, "CURRENT_USER", { enumerable: true, get: function () { return constants_1.CURRENT_USER; } });
+var model_strategy_1 = require("../types/model-strategy");
+Object.defineProperty(exports, "selectModel", { enumerable: true, get: function () { return model_strategy_1.selectModel; } });
+Object.defineProperty(exports, "DEFAULT_LONG_CONTEXT_TOKENS", { enumerable: true, get: function () { return model_strategy_1.DEFAULT_LONG_CONTEXT_TOKENS; } });
+Object.defineProperty(exports, "DEFAULT_SHORT_INPUT_TOKENS", { enumerable: true, get: function () { return model_strategy_1.DEFAULT_SHORT_INPUT_TOKENS; } });
 // ─── Services ──────────────────────────────────────────────────────────────
 var tool_registry_service_1 = require("../services/tool-registry.service");
 Object.defineProperty(exports, "ToolRegistryService", { enumerable: true, get: function () { return tool_registry_service_1.ToolRegistryService; } });

package/dist/services/agent-runner.service.js

@@ -7,6 +7,7 @@ exports.AgentRunnerService = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const crypto_1 = require("crypto");
 const tool_approval_gate_1 = require("./tool-approval-gate");
+const model_strategy_1 = require("../types/model-strategy");
 const noopLogger = {
     log: () => { }, warn: () => { }, debug: () => { }, error: () => { },
 };
@@ -29,17 +30,44 @@ class AgentRunnerService {
     // ─── Run (non-streaming) ──────────────────────────────────────────────────
     async run(agent, messages, context, overrides) {
         const messageId = (0, crypto_1.randomUUID)();
-        const model = overrides?.model ?? agent.model ?? this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
+        const runnerDefault = this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
+        const baseModel = overrides?.model ?? agent.model ?? runnerDefault;
         const maxTokens = overrides?.maxTokens ?? agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
         const temperature = overrides?.temperature ?? agent.temperature ?? 1;
         const { tools, extras } = this.buildToolList(agent, overrides);
         const systemPrompt = this.buildSystemPrompt(agent, tools, overrides);
         const toolCalls = [];
         let currentMessages = [...messages];
+        // Pre-compute the signals the model router reads. `hasTools` and
+        // `hasApprovalTool` are constant across the agentic loop (we
+        // don't add tools mid-conversation); `estimatedInputTokens`
+        // starts from a word-count heuristic and gets replaced by the
+        // real `usage.input_tokens` once we have a response.
+        const turnSignals = {
+            hasTools: !!tools && tools.length > 0,
+            hasApprovalTool: hasApprovalGatedTool(agent),
+            estimatedInputTokens: estimateInputTokens(systemPrompt, currentMessages),
+        };
         let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
         let finalContent = '';
         let stopReason = 'end_turn';
+        // Last model id the router chose. Surfaced on the response so
+        // callers (and the conversation/usage logs) record what
+        // actually ran, not what the agent's `model` field says.
+        let lastModel = baseModel;
         while (true) {
+            // Per-turn model selection. When overrides force a model we
+            // honour it (manual `agent.runMessage({ overrides: { model }})`
+            // beats the strategy). Otherwise the strategy decides; absent
+            // strategy → behave exactly like before this feature landed.
+            const selection = overrides?.model
+                ? { model: overrides.model, reason: 'forced' }
+                : (0, model_strategy_1.selectModel)(agent.modelStrategy, turnSignals, baseModel);
+            const model = selection.model;
+            lastModel = model;
+            if (this.logger && selection.reason !== 'default' && selection.reason !== 'forced') {
+                this.logger.debug(`[modelRouter] agent=${agent.id} ${selection.reason}=${selection.trigger} → ${model}`);
+            }
             const response = await this.client.messages.create({
                 model,
                 max_tokens: maxTokens,
@@ -48,6 +76,10 @@ class AgentRunnerService {
                 messages: currentMessages,
                 tools: tools,
             });
+            // Update the signal for the NEXT iteration of the loop — the
+            // tool-result feedback we're about to add can balloon the
+            // context past the long-context threshold.
+            turnSignals.estimatedInputTokens = response.usage.input_tokens;
             totalUsage = {
                 inputTokens: totalUsage.inputTokens + response.usage.input_tokens,
                 outputTokens: totalUsage.outputTokens + response.usage.output_tokens,
@@ -117,7 +149,7 @@ class AgentRunnerService {
             role: 'assistant',
             toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
             usage: totalUsage,
-            model,
+            model: lastModel,
             stopReason,
             createdAt: new Date(),
         };
@@ -125,14 +157,28 @@ class AgentRunnerService {
     // ─── Run (streaming) ──────────────────────────────────────────────────────
     async *stream(agent, messages, context, overrides) {
         const messageId = (0, crypto_1.randomUUID)();
-        const model = overrides?.model ?? agent.model ?? this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
+        const runnerDefault = this.anthropicConfig.defaultModel ?? 'claude-opus-4-6';
+        const baseModel = overrides?.model ?? agent.model ?? runnerDefault;
         const maxTokens = overrides?.maxTokens ?? agent.maxTokens ?? this.anthropicConfig.defaultMaxTokens ?? 4096;
         const temperature = overrides?.temperature ?? agent.temperature ?? 1;
         const { tools, extras } = this.buildToolList(agent, overrides);
         const systemPrompt = this.buildSystemPrompt(agent, tools, overrides);
         let currentMessages = [...messages];
         let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        // See `run()` above for the rationale on these signals.
+        const turnSignals = {
+            hasTools: !!tools && tools.length > 0,
+            hasApprovalTool: hasApprovalGatedTool(agent),
+            estimatedInputTokens: estimateInputTokens(systemPrompt, currentMessages),
+        };
         while (true) {
+            const selection = overrides?.model
+                ? { model: overrides.model, reason: 'forced' }
+                : (0, model_strategy_1.selectModel)(agent.modelStrategy, turnSignals, baseModel);
+            const model = selection.model;
+            if (this.logger && selection.reason !== 'default' && selection.reason !== 'forced') {
+                this.logger.debug(`[modelRouter] agent=${agent.id} ${selection.reason}=${selection.trigger} → ${model}`);
+            }
             const stream = this.client.messages.stream({
                 model,
                 max_tokens: maxTokens,
@@ -168,6 +214,12 @@ class AgentRunnerService {
                 }
             }
             const finalMessage = await stream.finalMessage();
+            // Refresh the input-token signal so the next iteration of the
+            // tool loop has the post-tool-result context length, not the
+            // initial estimate.
+            if (typeof finalMessage.usage?.input_tokens === 'number') {
+                turnSignals.estimatedInputTokens = finalMessage.usage.input_tokens;
+            }
             if (finalMessage.stop_reason === 'tool_use') {
                 currentMessages = [...currentMessages, { role: 'assistant', content: finalMessage.content }];
                 const toolResults = [];
@@ -311,3 +363,47 @@ class AgentRunnerService {
     }
 }
 exports.AgentRunnerService = AgentRunnerService;
+/** Cheap word-based token estimate for the first turn — Anthropic
+ *  reports real `usage.input_tokens` from the response onwards, so
+ *  this only needs to be accurate enough to fire `longContext` /
+ *  `shortInput` rules on the FIRST request before any usage is back.
+ *  Rough rule of thumb (verified against Anthropic's tokenizer on
+ *  English prose): ~0.75 tokens per whitespace-split word. */
+function estimateInputTokens(systemPrompt, messages) {
+    let words = systemPrompt.trim().split(/\s+/).filter(Boolean).length;
+    for (const m of messages) {
+        if (typeof m.content === 'string') {
+            words += m.content.trim().split(/\s+/).filter(Boolean).length;
+            continue;
+        }
+        if (Array.isArray(m.content)) {
+            for (const block of m.content) {
+                if (block &&
+                    typeof block === 'object' &&
+                    'type' in block &&
+                    block.type === 'text' &&
+                    typeof block.text === 'string') {
+                    words += block.text
+                        .trim()
+                        .split(/\s+/)
+                        .filter(Boolean).length;
+                }
+            }
+        }
+    }
+    return Math.ceil(words / 0.75);
+}
+/** True when at least one declared tool requires human approval at
+ *  runtime. Read off `agent.tools` only — `extraTools` (per-call
+ *  connector tools attached at request time) follow the host's own
+ *  per-tenant policy and aren't visible to this scope. */
+function hasApprovalGatedTool(agent) {
+    const tools = agent.tools;
+    if (!tools)
+        return false;
+    for (const t of tools) {
+        if (typeof t === 'object' && t && t.mode === 'approval')
+            return true;
+    }
+    return false;
+}

package/dist/services/agent.service.js

@@ -212,7 +212,12 @@ class AgentService {
         // caller's userId, which is the historical personal-agent path.
         const resolvedExtras = await this.resolveExtraTools(agent.connectorOwnerUserId ?? params.userId);
         const filter = params.overrides?.extraToolsFilter;
-        const extraTools = filter && resolvedExtras ? filter(resolvedExtras) : resolvedExtras;
+        const fromConnectors = filter && resolvedExtras ? filter(resolvedExtras) : resolvedExtras;
+        // Merge connector tools with whatever the caller passed in
+        // `overrides.extraTools` (e.g. the remote-tool wrappers from
+        // ChatStreamController). Caller wins on name collisions so an
+        // explicit override always trumps an inherited connector tool.
+        const extraTools = mergeExtraTools(params.overrides?.extraTools, fromConnectors);
         const response = await this.runner.run(agent, messages, {
             userId: params.userId,
             conversationId: params.conversationId,
@@ -278,7 +283,8 @@ class AgentService {
         // toolbelt regardless of which visitor session is streaming.
         const resolvedExtras = await this.resolveExtraTools(agent.connectorOwnerUserId ?? params.userId);
         const filter = params.overrides?.extraToolsFilter;
-        const extraTools = filter && resolvedExtras ? filter(resolvedExtras) : resolvedExtras;
+        const fromConnectors = filter && resolvedExtras ? filter(resolvedExtras) : resolvedExtras;
+        const extraTools = mergeExtraTools(params.overrides?.extraTools, fromConnectors);
         try {
             for await (const chunk of this.runner.stream(agent, messages, {
                 userId: params.userId,
@@ -509,3 +515,30 @@ function toAgentDefinition(record) {
         ...(extra.appearance !== undefined ? { appearance: extra.appearance } : {}),
     };
 }
+/**
+ * Merge two `extraTools` arrays so an explicit caller-provided list
+ * (e.g. remote-tool wrappers from a chat-stream controller) doesn't get
+ * shadowed by an `undefined` result from the connector resolver.
+ *
+ * Caller wins on name collisions — the caller passed the tool
+ * deliberately and knows the host context; an inherited connector tool
+ * with the same name is almost certainly stale or coincidental.
+ *
+ * Returns `undefined` (not `[]`) when both inputs are empty so the
+ * runner's "if (!extras?.length) skip overrides" path keeps working.
+ */
+function mergeExtraTools(caller, connectors) {
+    if (!caller?.length && !connectors?.length)
+        return undefined;
+    if (!caller?.length)
+        return connectors;
+    if (!connectors?.length)
+        return caller;
+    const callerNames = new Set(caller.map((t) => t.name));
+    const merged = [...caller];
+    for (const t of connectors) {
+        if (!callerNames.has(t.name))
+            merged.push(t);
+    }
+    return merged;
+}

package/dist/types/config.types.d.ts

@@ -72,8 +72,15 @@ export interface AgentDefinition {
     name: string;
     /** Agent description (shown to users) */
     description?: string;
-    /** Claude model to use */
+    /** Claude model to use. Ignored when `modelStrategy` is set —
+     *  the strategy's `default` takes precedence as the base tier. */
     model?: string;
+    /** Adaptive model selection per turn. When present the runner
+     *  calls `selectModel(strategy, signals)` and routes between
+     *  Haiku / Sonnet / Opus according to operator-declared rules.
+     *  When absent the runner falls back to the legacy `model` /
+     *  `defaultModel` chain — zero breaking change. */
+    modelStrategy?: import('./model-strategy').ModelStrategy;
     /** System prompt */
     systemPrompt: string;
     /** Max tokens per response */

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './agent.types';
 export * from './config.types';
 export * from './hooks';
+export * from './model-strategy';

package/dist/types/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent.types"), exports);
 __exportStar(require("./config.types"), exports);
 __exportStar(require("./hooks"), exports);
+__exportStar(require("./model-strategy"), exports);

package/dist/types/model-strategy.d.ts

@@ -0,0 +1,97 @@
+/** The three Claude tiers the platform routes between today. New
+ *  providers / families will land here once the SDK speaks them. */
+export type ModelTier = 'haiku' | 'sonnet' | 'opus';
+/** Conditions that can push a turn UP to the escalation tier. */
+export type EscalateRule = 
+/** The agent has at least one tool attached to this turn. Tool use
+ *  benefits disproportionately from a stronger reasoner — Haiku
+ *  often picks the wrong tool or skips required arguments. */
+'toolUse'
+/** Estimated input tokens exceed `thresholds.longContextTokens`.
+ *  Long context degrades quality fastest on cheaper tiers. */
+ | 'longContext'
+/** At least one of the attached tools is in `approval` mode (a
+ *  human will gate the run). Escalate so the reasoning the human
+ *  reviews is as good as we can afford on a critical path. */
+ | 'approvalRequired';
+/** Conditions that can drop a turn DOWN to the fallback tier. Only
+ *  applied when no escalate rule fires — escalation always wins. */
+export type FallbackRule = 
+/** Estimated input tokens below `thresholds.shortInputTokens`.
+ *  "Hola", "thanks", confirmations, one-line clarifications —
+ *  Haiku is more than enough and costs ~12× less than Opus. */
+'shortInput';
+export interface ModelStrategy {
+    kind: 'fixed' | 'tiered';
+    /** The base model. Used as-is when `kind === 'fixed'`, and as the
+     *  middle tier when `kind === 'tiered'` (every turn that doesn't
+     *  trigger an escalate / fallback rule lands here). Free-form
+     *  string so future Anthropic model ids drop in without a SDK
+     *  release. */
+    default: string;
+    /** Concrete model ids for each tier. Only consulted when
+     *  `kind === 'tiered'`. Missing tiers mean "stay on default" so the
+     *  operator can declare a partial ladder (e.g. only the Haiku
+     *  fallback, no Opus escalation). */
+    tiers?: {
+        haiku?: string;
+        sonnet?: string;
+        opus?: string;
+    };
+    /** Conditions that escalate the turn to `tiers.opus`. Order does
+     *  not matter — any rule firing escalates. */
+    escalate?: EscalateRule[];
+    /** Conditions that drop the turn to `tiers.haiku`. Only applied
+     *  when no escalate rule fires. */
+    fallback?: FallbackRule[];
+    /** Thresholds the rules read. Sensible defaults below; operators
+     *  can override per agent. */
+    thresholds?: {
+        /** `longContext` fires when estimated input exceeds this. */
+        longContextTokens?: number;
+        /** `shortInput` fires when estimated input is below this. */
+        shortInputTokens?: number;
+    };
+}
+/** Defaults applied when the operator doesn't set thresholds. Picked
+ *  from the Anthropic cost / quality curve we've seen in practice:
+ *
+ *  - 8k input tokens is where Sonnet's quality on long contexts
+ *    starts to noticeably drift from Opus.
+ *  - 200 tokens covers single-sentence inputs (greetings,
+ *    confirmations) where Haiku is indistinguishable from Sonnet for
+ *    the user.
+ */
+export declare const DEFAULT_LONG_CONTEXT_TOKENS = 8000;
+export declare const DEFAULT_SHORT_INPUT_TOKENS = 200;
+/** Inputs the runner provides per turn so the selector can decide
+ *  without re-deriving anything. All optional — missing signals just
+ *  cause the corresponding rules to no-op. */
+export interface TurnSignals {
+    /** Estimated input tokens for this turn (system prompt + history
+     *  + new message). The runner can use `usage.input_tokens` from
+     *  the previous turn as a proxy; for the first turn a crude
+     *  word-count heuristic is good enough. */
+    estimatedInputTokens?: number;
+    /** True if the agent has at least one tool attached to this turn
+     *  (whether or not the model ends up calling it). */
+    hasTools?: boolean;
+    /** True if any attached tool is in `mode: 'approval'`. */
+    hasApprovalTool?: boolean;
+}
+export interface ModelSelection {
+    /** The model id the runner should pass to `messages.create`. */
+    model: string;
+    /** Which leg of the strategy fired. `default` = neither escalate
+     *  nor fallback matched; `escalate` / `fallback` = a rule fired
+     *  AND the corresponding tier was declared. `forced` = the
+     *  strategy is `fixed`. */
+    reason: 'forced' | 'default' | 'escalate' | 'fallback';
+    /** When `reason === 'escalate' | 'fallback'`, the rule that fired.
+     *  Used in telemetry so an operator can see why their bill
+     *  spiked. */
+    trigger?: EscalateRule | FallbackRule;
+}
+/** Pure decision function. The runner calls this once per turn just
+ *  before `messages.create`. */
+export declare function selectModel(strategy: ModelStrategy | undefined, signals: TurnSignals, runnerDefault: string): ModelSelection;

package/dist/types/model-strategy.js

@@ -0,0 +1,83 @@
+"use strict";
+// Adaptive model selection for a single agent turn.
+//
+// An agent may declare ONE of two strategies:
+//
+//   - `fixed`  → use `agent.model` (or the runner's default) for every
+//                turn. The historical behaviour. Zero overhead, zero
+//                variance. Use this when cost is a non-issue or the
+//                domain is uniform (e.g. always-creative writing).
+//
+//   - `tiered` → at each turn the runner inspects the request and
+//                may escalate to a more capable model OR fall back to
+//                a cheaper one based on a small set of heuristics
+//                declared by the operator. No LLM-router overhead —
+//                the decision is a pure function of the turn's shape
+//                (estimated input tokens, whether tools are attached,
+//                whether the turn will route through human approval).
+//
+// The decision lives in `selectModel(strategy, signals)` below so the
+// runner only calls one function and the policy stays testable in
+// isolation.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHORT_INPUT_TOKENS = exports.DEFAULT_LONG_CONTEXT_TOKENS = void 0;
+exports.selectModel = selectModel;
+/** Defaults applied when the operator doesn't set thresholds. Picked
+ *  from the Anthropic cost / quality curve we've seen in practice:
+ *
+ *  - 8k input tokens is where Sonnet's quality on long contexts
+ *    starts to noticeably drift from Opus.
+ *  - 200 tokens covers single-sentence inputs (greetings,
+ *    confirmations) where Haiku is indistinguishable from Sonnet for
+ *    the user.
+ */
+exports.DEFAULT_LONG_CONTEXT_TOKENS = 8_000;
+exports.DEFAULT_SHORT_INPUT_TOKENS = 200;
+/** Pure decision function. The runner calls this once per turn just
+ *  before `messages.create`. */
+function selectModel(strategy, signals, runnerDefault) {
+    // No strategy → behave exactly like before this feature landed.
+    if (!strategy) {
+        return { model: runnerDefault, reason: 'default' };
+    }
+    if (strategy.kind === 'fixed') {
+        return { model: strategy.default || runnerDefault, reason: 'forced' };
+    }
+    // Tiered. Escalate beats fallback (a long-context tool-use turn is
+    // not a `shortInput` even if the new message is two words).
+    const longCtx = strategy.thresholds?.longContextTokens ?? exports.DEFAULT_LONG_CONTEXT_TOKENS;
+    const shortIn = strategy.thresholds?.shortInputTokens ?? exports.DEFAULT_SHORT_INPUT_TOKENS;
+    const escalate = strategy.escalate ?? [];
+    const fallback = strategy.fallback ?? [];
+    for (const rule of escalate) {
+        if (rule === 'toolUse' && signals.hasTools) {
+            return pickTier(strategy, 'opus', 'escalate', rule);
+        }
+        if (rule === 'longContext' &&
+            typeof signals.estimatedInputTokens === 'number' &&
+            signals.estimatedInputTokens > longCtx) {
+            return pickTier(strategy, 'opus', 'escalate', rule);
+        }
+        if (rule === 'approvalRequired' && signals.hasApprovalTool) {
+            return pickTier(strategy, 'opus', 'escalate', rule);
+        }
+    }
+    for (const rule of fallback) {
+        if (rule === 'shortInput' &&
+            typeof signals.estimatedInputTokens === 'number' &&
+            signals.estimatedInputTokens < shortIn) {
+            return pickTier(strategy, 'haiku', 'fallback', rule);
+        }
+    }
+    return { model: strategy.default || runnerDefault, reason: 'default' };
+}
+function pickTier(strategy, tier, reason, trigger) {
+    const tiered = strategy.tiers?.[tier];
+    // No model declared for this tier → don't escalate/fallback to a
+    // ghost id; stay on default. Surface the rule that WOULD have
+    // fired so telemetry still captures the near-miss.
+    if (!tiered) {
+        return { model: strategy.default, reason: 'default', trigger };
+    }
+    return { model: tiered, reason, trigger };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-io/core",
-  "version": "2.0.23",
+  "version": "2.0.24",
   "description": "Framework-free AI runtime SDK. Owns: agent loop (Anthropic), conversations, tools, streaming, agent-job queue, SdkHooks. Identity, billing, infra (email/uploads/secrets) live in the host's modules — not here.",
   "license": "MIT",
   "main": "dist/index.js",