@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/model-gateway/providers/openai/sse-data.js

@@ -1,67 +1 @@
-// Decode complete SSE data frames identically for response lifetime and output.
-// Event names are metadata; the Responses payload owns its typed event.
-export class OpenAISseDataDecoder {
-    decoder = new TextDecoder();
-    line = "";
-    data = [];
-    afterCr = false;
-    accept(bytes) {
-        const text = this.decoder.decode(bytes, { stream: true });
-        const frames = [];
-        let start = 0;
-        for (let index = 0; index < text.length; index += 1) {
-            const char = text[index];
-            if (this.afterCr) {
-                this.afterCr = false;
-                if (char === "\n") {
-                    start = index + 1;
-                    continue;
-                }
-            }
-            if (char !== "\r" && char !== "\n")
-                continue;
-            this.line += text.slice(start, index);
-            this.acceptLine(frames);
-            this.line = "";
-            this.afterCr = char === "\r";
-            start = index + 1;
-        }
-        this.line += text.slice(start);
-        return frames;
-    }
-    acceptLine(frames) {
-        if (!this.line) {
-            if (this.data.length)
-                frames.push(this.data.join("\n"));
-            this.data = [];
-            return;
-        }
-        const colon = this.line.indexOf(":");
-        const field = colon < 0 ? this.line : this.line.slice(0, colon);
-        if (field !== "data")
-            return;
-        const value = colon < 0 ? "" : this.line.slice(colon + 1);
-        this.data.push(value.startsWith(" ") ? value.slice(1) : value);
-    }
-}
-export async function* readOpenAIDataFrames(body) {
-    const reader = body.getReader();
-    const decoder = new OpenAISseDataDecoder();
-    let reachedEof = false;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                reachedEof = true;
-                return;
-            }
-            yield* decoder.accept(value);
-        }
-    }
-    finally {
-        // A tee branch cannot await cancellation before the other readers finish.
-        if (!reachedEof)
-            void reader.cancel().catch(() => { });
-        reader.releaseLock();
-    }
-}
+export { SseDataDecoder as OpenAISseDataDecoder, readSseDataFrames as readOpenAIDataFrames } from "../../protocol/sse-data.js";

package/dist/src/model-gateway/providers/registry.js

@@ -1,10 +1,12 @@
 import { createModelProviderAdapterRegistry, } from "./contracts.js";
+import { createLlamaCppProviderAdapter } from "./llamacpp/adapter.js";
 import { createOllamaProviderAdapter } from "./ollama/adapter.js";
 import { createOpenAIProviderAdapter } from "./openai/adapter.js";
 export function createBuiltInModelProviderAdapterRegistry(options) {
     return createModelProviderAdapterRegistry([
         createOllamaProviderAdapter({ fallbackUrl: options.ollamaUrl }),
         createOpenAIProviderAdapter(),
+        createLlamaCppProviderAdapter(),
         ...(options.additionalAdapters ?? []),
     ]);
 }

package/dist/src/model-gateway/server/input-token-count-handler.js

@@ -1,3 +1,4 @@
+import { InputTokenCountDiagnostics } from "../observability/input-token-count-diagnostics.js";
 import { traceDebug } from "../../runtime/observability/debug-logger.js";
 import { resolveModelInvocation } from "../policy/invocation-policy.js";
 import { respondToGatewayHandlerError } from "./errors.js";
@@ -10,6 +11,7 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
     const providerAdapters = resolveProviderAdapters(options);
     return async function inputTokenCountHandler(requestBody, response, context = {}) {
         const abortSignal = context.abortSignal ?? new AbortController().signal;
+        const diagnostics = new InputTokenCountDiagnostics("model-gateway.server", requestBody);
         try {
             abortSignal.throwIfAborted();
             const effectiveRequestBody = applyConfiguredModelPolicy(requestBody, modelPolicy);
@@ -20,7 +22,9 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
             if (messageValidationError) {
                 return sendText(response, 400, messageValidationError);
             }
+            diagnostics.setPhase("resolve");
             const invocation = resolveModelInvocation(effectiveRequestBody);
+            diagnostics.bindInvocation(invocation);
             const providerAdapter = providerAdapters.resolve(invocation.profile.provider);
             const imageValidationError = validateImageInvocationSupport({
                 requestBody: effectiveRequestBody,
@@ -34,6 +38,7 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
             if (!providerAdapter.countInputTokens) {
                 return sendText(response, 501, "model_provider_input_token_count_unsupported");
             }
+            diagnostics.setPhase("provider_count");
             const result = await providerAdapter.countInputTokens({
                 endpoint: "chat",
                 requestBody: effectiveRequestBody,
@@ -42,7 +47,7 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
                     endpoint: "input_tokens",
                     requestBody: effectiveRequestBody,
                     invocation,
-                    fetchImpl,
+                    fetchImpl: diagnostics.observeFetch(fetchImpl),
                     abortSignal,
                 }),
             });
@@ -50,8 +55,10 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
                 return;
             }
             if (result.kind === "error") {
+                diagnostics.failed({ kind: "provider_result", statusCode: result.statusCode, aborted: false });
                 return sendText(response, result.statusCode, result.message);
             }
+            diagnostics.setPhase("measurement_record");
             inputTokenMeasurements?.record({ requestBody: effectiveRequestBody, invocation }, result);
             traceDebug("model-gateway.server", "model.input_tokens.counted", {
                 requestId: typeof effectiveRequestBody.debugRequestId === "string"
@@ -63,6 +70,7 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
                 model: invocation.model,
                 inputTokens: result.inputTokens,
             });
+            diagnostics.setPhase("response_write");
             return sendJson(response, 200, {
                 inputTokens: result.inputTokens,
                 profileId: invocation.profile.id,
@@ -73,6 +81,7 @@ export function createInputTokenCountHandler(options = {}, inputTokenMeasurement
             });
         }
         catch (error) {
+            diagnostics.failed({ kind: "exception", error, aborted: abortSignal.aborted });
             respondToGatewayHandlerError({
                 error,
                 response,

package/dist/src/model-gateway/types.d.ts

@@ -1,6 +1,10 @@
+import type { ModelReasoningBudgetByMode } from "../shared/model-reasoning-modes.js";
+export type { ModelReasoningBudgetByMode } from "../shared/model-reasoning-modes.js";
+import type { ModelReasoningBudget, ModelReasoningPreference } from "../shared/model-reasoning.js";
+export type { ModelReasoningBudget, ModelReasoningPreference } from "../shared/model-reasoning.js";
 import type { AgentMode, ModelReasoningLevel, ModelStep } from "../shared/types.js";
 import type { RuntimeAttachmentReference } from "../shared/attachments.js";
-/** Stable adapter identifier. Built-ins currently register `ollama` and `openai`. */
+/** Stable adapter identifier. Built-ins currently register `ollama`, `openai`, and `llamacpp`. */
 export type ModelProvider = string;
 export type ChatTextMessage = {
     role: "system" | "user" | "assistant";
@@ -102,6 +106,8 @@ export type ModelGenerationConfig = {
     temperature?: number;
     topP?: number;
     reasoningEffort?: ModelReasoningLevel;
+    reasoningBudget?: ModelReasoningBudget;
+    reasoningBudgetByMode?: ModelReasoningBudgetByMode;
 };
 export type ModelTokenEstimationConfig = {
     asciiCharactersPerToken?: number;
@@ -184,6 +190,7 @@ export type ModelGatewayRequest = {
     modelStep?: ModelStep | string;
     modelOverride?: string;
     reasoningOverride?: ModelReasoningLevel | string;
+    reasoningPreference?: ModelReasoningPreference;
     format?: unknown;
     modelPreference?: ModelPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
@@ -198,6 +205,7 @@ export type ModelGatewayInputTokenCountParams = {
     modelStep?: ModelStep;
     modelOverride?: string;
     reasoningOverride?: ModelReasoningLevel;
+    reasoningPreference?: ModelReasoningPreference;
     modelPreference?: ModelPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     abortSignal: AbortSignal;
@@ -233,6 +241,8 @@ export type ResolvedModelInvocation = {
     model: string;
     /** `none` is an explicit disable; only `undefined` permits adapter omission. */
     think?: ModelReasoningLevel;
+    reasoningBudget?: ModelReasoningBudget;
+    reasoningControlSource?: "invocation" | "request" | "configuration" | "agent-mode";
     format?: ModelGatewayFormat;
     instructions?: string[];
 };

package/dist/src/runtime/adapters/long-term-memory/onboarding-provider-availability.d.ts

@@ -0,0 +1,4 @@
+import type { ModelProviderAdapterRegistry } from "../../../model-gateway/index.js";
+import type { LongTermMemoryOnboardingProvider } from "../../long-term-memory/onboarding/contracts.js";
+/** Chat-only adapters must not be advertised as usable embedding connections. */
+export declare function availableEmbeddingProviders(providers: readonly LongTermMemoryOnboardingProvider[], adapters: ModelProviderAdapterRegistry): readonly LongTermMemoryOnboardingProvider[];

package/dist/src/runtime/adapters/long-term-memory/onboarding-provider-availability.js

@@ -0,0 +1,11 @@
+/** Chat-only adapters must not be advertised as usable embedding connections. */
+export function availableEmbeddingProviders(providers, adapters) {
+    return providers.filter((provider) => {
+        try {
+            return typeof adapters.resolve(provider.type).embed === "function";
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/src/runtime/adapters/long-term-memory/onboarding-service.js

@@ -1,3 +1,4 @@
+import { availableEmbeddingProviders } from "./onboarding-provider-availability.js";
 import { discoverEmbeddingModels, executeEmbeddingRequest, } from "../../../model-gateway/index.js";
 import { createLongTermMemoryOnboardingService } from "../../long-term-memory/onboarding/service.js";
 import { createFileLongTermMemoryOnboardingConfigRepository } from "./onboarding-config-repository.js";
@@ -8,7 +9,7 @@ export function createLocalLongTermMemoryOnboardingService(params) {
             rootDir: params.rootDir,
             ...(params.configPath ? { configPath: params.configPath } : {}),
         });
-    return createLongTermMemoryOnboardingService({
+    const service = createLongTermMemoryOnboardingService({
         repository,
         probe: async (input) => {
             const result = await executeEmbeddingRequest({
@@ -32,4 +33,30 @@ export function createLocalLongTermMemoryOnboardingService(params) {
             ...(params.fetchImpl ? { fetchImpl: params.fetchImpl } : {}),
         }),
     });
+    const projectStatus = (status) => Object.freeze({
+        ...status, providers: availableEmbeddingProviders(status.providers, params.providerAdapters),
+    });
+    return Object.freeze({
+        ...service,
+        async enable(input) {
+            const result = await service.enable(input);
+            return { ...result, status: projectStatus(result.status) };
+        },
+        async saveProfile(input) {
+            const result = await service.saveProfile(input);
+            return { ...result, status: projectStatus(result.status) };
+        },
+        async removeProfile(input) {
+            const result = await service.removeProfile(input);
+            return { ...result, status: projectStatus(result.status) };
+        },
+        async disable() {
+            const result = await service.disable();
+            return { ...result, status: projectStatus(result.status) };
+        },
+        async status() {
+            const status = await service.status();
+            return projectStatus(status);
+        },
+    });
 }

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.d.ts

@@ -4,6 +4,7 @@ import { type WorkerCapabilityPayloadRelatedArtifactContext } from "../orchestra
 import type { RoleCallFrame } from "../orchestration/role-calls/contracts.js";
 export declare function resolveRegisteredToolPayloadRelatedArtifactContexts(params: {
     contextScope?: ToolPayloadChannelSpec["contextScope"];
+    allowRelatedArtifactLoading?: boolean;
     targetParam?: string;
     controls: Readonly<Record<string, unknown>>;
     sharedState: ToolExecutionSharedState;

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.js

@@ -4,7 +4,7 @@ import { projectWorkerCapabilityDependencyArtifactReceipts, } from "../orchestra
 import { projectWorkerPayloadPlannerItemProvenance } from "../orchestration/worker-capabilities/payload-source-provenance.js";
 import { WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, } from "../orchestration/worker-capabilities/payload-contracts.js";
 export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params) {
-    if (params.contextScope !== "target_with_artifacts") {
+    if (!canLoadRelatedArtifactContexts(params.contextScope, params.allowRelatedArtifactLoading)) {
         return Object.freeze([]);
     }
     const dependencyReceipts = projectWorkerCapabilityDependencyArtifactReceipts(projectWorkerPayloadPlannerItemProvenance(params.assignmentProvenance, params.call), params.call);
@@ -14,6 +14,11 @@ export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params
     ];
     return loadRelatedArtifactContexts(params, receipts);
 }
+function canLoadRelatedArtifactContexts(contextScope, allowRelatedArtifactLoading) {
+    if (allowRelatedArtifactLoading === false)
+        return false;
+    return contextScope === "target_with_artifacts";
+}
 function projectSameCallArtifactReceipts(results) {
     return results.flatMap((result) => {
         if (result.outcome !== "succeeded")

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/contracts.d.ts

@@ -19,6 +19,7 @@ export type RegisteredToolWorkerCapabilityProviderParams = Readonly<{
     toolPermissionMode: ToolPermissionMode;
     toolApprovalController?: ToolApprovalController;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
+    allowRelatedArtifactLoading?: boolean;
     loadActionSkillContext?(toolName: string): Promise<string>;
     nextApprovalId(): string;
     onEvent?(name: string, payload: Record<string, unknown>): void;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/execution.d.ts

@@ -9,4 +9,5 @@ export declare function projectWorkerAdapters<TContext>(params: Readonly<{
     sharedState: ToolExecutionSharedState;
     diagnostic: RegisteredToolWorkerCapabilityProviderDiagnostic;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
+    allowRelatedArtifactLoading?: boolean;
 }>): readonly WorkerCapabilityAdapter<TContext>[];

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/execution.js

@@ -37,6 +37,7 @@ export function projectWorkerAdapters(params) {
             executor: params.executor,
             sharedState: params.sharedState,
             diagnostic: params.diagnostic,
+            allowRelatedArtifactLoading: params.allowRelatedArtifactLoading ?? true,
             ...(params.payloadAuthor
                 ? { payloadAuthor: params.payloadAuthor }
                 : {}),
@@ -118,6 +119,7 @@ async function prepareRegisteredToolWorkerCapability(params, input, payloadObser
         projection: params.projection,
         executor: payloadObservability.lifecycleEmitter,
         sharedState: params.sharedState,
+        allowRelatedArtifactLoading: params.allowRelatedArtifactLoading ?? true,
         ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
         call: input.call,
         ...(input.assignmentProvenance

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.d.ts

@@ -8,6 +8,7 @@ export declare function prepareOperationPayload(params: Readonly<{
     executor: PayloadLifecycleEmitter;
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
+    allowRelatedArtifactLoading: boolean;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
     assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.js

@@ -9,6 +9,7 @@ export async function prepareOperationPayload(params) {
             handle: params.projection.handle,
             executor: params.executor,
             sharedState: params.sharedState,
+            allowRelatedArtifactLoading: params.allowRelatedArtifactLoading,
             ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
             call: params.call,
             ...(params.assignmentProvenance
@@ -55,6 +56,7 @@ export async function prepareOperationPayload(params) {
         const contextScope = params.projection.payloadContextPlan?.contextScope ?? "standard";
         const relatedArtifactContexts = await resolveRegisteredToolPayloadRelatedArtifactContexts({
             contextScope,
+            allowRelatedArtifactLoading: params.allowRelatedArtifactLoading,
             targetParam: params.projection.payloadContextPlan?.targetParam,
             controls: params.controls,
             sharedState: params.sharedState,

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.d.ts

@@ -10,6 +10,7 @@ export type StagedOperationPayloadParams = Readonly<{
     executor: PayloadLifecycleEmitter;
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
+    allowRelatedArtifactLoading: boolean;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
     assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.js

@@ -170,6 +170,7 @@ class PayloadStageRunner {
                 const contextScope = stage.contextScope ?? "standard";
                 const relatedArtifactContexts = await resolveRegisteredToolPayloadRelatedArtifactContexts({
                     contextScope,
+                    allowRelatedArtifactLoading: this.params.allowRelatedArtifactLoading,
                     targetParam: this.params.plan.targetParam,
                     controls: this.params.controls,
                     sharedState: this.params.sharedState,

package/dist/src/runtime/adapters/registered-tool-worker-capabilities.js

@@ -118,6 +118,7 @@ export function createRegisteredToolWorkerCapabilityProvider(params) {
                     executor,
                     sharedState,
                     diagnostic,
+                    allowRelatedArtifactLoading: params.allowRelatedArtifactLoading ?? true,
                     ...(params.payloadAuthor
                         ? { payloadAuthor: params.payloadAuthor }
                         : {}),

package/dist/src/runtime/adapters/scheduler-runtime.js

@@ -54,6 +54,7 @@ export function createRuntimeScheduler(options) {
             return finish(failedScheduledRequestOutcome("session_deleted"));
         const selection = resolveModelSelection({
             agentMode: job.agentMode,
+            ...(job.reasoningPreference ? { reasoningPreference: job.reasoningPreference } : {}),
             modelPreference: { profileId: job.modelProfileId, scope: "all" },
             modelPolicy: options.config.models,
         });
@@ -82,6 +83,7 @@ export function createRuntimeScheduler(options) {
             sessionId: job.sessionId,
             text: run.prompt,
             agentMode: job.agentMode,
+            ...(job.reasoningPreference ? { reasoningPreference: job.reasoningPreference } : {}),
             modelPreference: { profileId: job.modelProfileId, scope: "all" },
             toolPermissionMode: run.toolPermissionMode ?? "full_access",
         };

package/dist/src/runtime/automations/agent-step-executor.js

@@ -201,6 +201,7 @@ export function createAutomationAgentStepExecutor(options) {
             const outcome = await handleRunRequestWithOutcome(ws, {
                 type: "run_request", requestId, sessionId, text: prompt,
                 agentMode: node.agentMode,
+                ...(node.reasoningPreference ? { reasoningPreference: node.reasoningPreference } : {}),
                 modelPreference: { profileId: node.modelProfileId, scope: "all" },
                 toolPermissionMode: capturedGrant?.mode ?? "full_access",
             }, {

package/dist/src/runtime/automations/catalog.d.ts

@@ -66,6 +66,9 @@ export declare function readAutomationCatalog(input: {
     }>[];
     models: {
         provider?: string | undefined;
+        reasoningControls?: {
+            budgetTokens: boolean;
+        } | undefined;
         id: string;
         label: string;
     }[];

package/dist/src/runtime/automations/catalog.js

@@ -1,3 +1,4 @@
+import { supportsModelReasoningBudget } from "../../shared/model-reasoning.js";
 import { currentAutomationGrant, permitsAutomationOperation } from "./permission-grants.js";
 const EXCLUDED_RUNNING_TOOLS = new Set(["schedules", "automations", "automation_builder"]);
 export async function readAutomationCatalog(input) {
@@ -49,6 +50,7 @@ export async function readAutomationCatalog(input) {
     const models = Object.entries(input.config.models?.profiles ?? {}).map(([id, profile]) => ({
         id,
         label: profile.label ?? id,
+        ...(supportsModelReasoningBudget({ provider: input.config.models?.providers?.[profile.provider ?? ""]?.type ?? "", supportsThinking: profile.supportsThinking }) ? { reasoningControls: { budgetTokens: true } } : {}),
         ...(profile.provider ? { provider: profile.provider } : {}),
     }));
     const latestAgents = new Map();

package/dist/src/runtime/automations/definition-contracts.d.ts

@@ -1,3 +1,4 @@
+import type { ModelReasoningPreference } from "../../shared/model-reasoning.js";
 import type { ToolNormalInvocationInput } from "../../capabilities/normal-invocation/contracts.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { CapabilityJsonValue } from "../orchestration/capability-adapters/result.js";
@@ -72,6 +73,7 @@ export type AgentNode = AutomationNodeBase & Readonly<{
     kind: "agent";
     modelProfileId: string;
     agentMode: AgentMode;
+    reasoningPreference?: ModelReasoningPreference;
     roleInstructions: string;
     prompt: string;
     inputs: Readonly<Record<string, ValueBinding>>;

package/dist/src/runtime/automations/definition-input.js

@@ -1,3 +1,4 @@
+import { parseBoundModelReasoningPreference } from "../../shared/model-reasoning.js";
 import { Buffer } from "node:buffer";
 import { isAutomationRunFileName } from "./run-file-binding.js";
 import { AUTOMATION_GRAPH_LIMITS } from "./limits.js";
@@ -150,8 +151,9 @@ function node(value, path, depth) {
     }
     if (input.kind !== "agent")
         invalid(`${path}.kind`);
-    onlyKeys(input, ["kind", "id", "title", "onFailure", "modelProfileId", "agentMode", "roleInstructions", "prompt", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"], path);
+    onlyKeys(input, ["kind", "id", "title", "onFailure", "modelProfileId", "agentMode", "reasoningPreference", "roleInstructions", "prompt", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"], path);
     text(input.modelProfileId, `${path}.modelProfileId`, 128);
+    parseBoundModelReasoningPreference(input.reasoningPreference, String(input.modelProfileId));
     if (!["fast", "reasoning", "deep"].includes(String(input.agentMode)))
         invalid(`${path}.agentMode`);
     text(input.roleInstructions, `${path}.roleInstructions`);

package/dist/src/runtime/automations/draft-mutations.js

@@ -6,7 +6,7 @@ const DEFINITION_EDITABLE = new Set([
 ]);
 const NODE_EDITABLE = new Set([
     "title", "onFailure", "operation", "controls", "payload", "modelProfileId",
-    "agentMode", "roleInstructions", "prompt", "inputs", "tools", "result",
+    "agentMode", "reasoningPreference", "roleInstructions", "prompt", "inputs", "tools", "result",
     "acceptance", "savedAgentOrigin",
 ]);
 function error(code) {
@@ -131,6 +131,10 @@ function mutateNode(root, mutation) {
                 delete found.node.payload;
                 delete normalized.payload;
             }
+            if (normalized.reasoningPreference === null) {
+                delete found.node.reasoningPreference;
+                delete normalized.reasoningPreference;
+            }
             Object.assign(found.node, normalized);
             return;
         }

package/dist/src/runtime/automations/model-dependency-projection.d.ts

@@ -36,6 +36,8 @@ export declare function projectAutomationModelDependencies(config: RuntimeConfig
             timeoutMs: number;
             model: string;
             think?: import("../../shared/types.js").ModelReasoningLevel;
+            reasoningBudget?: import("../../shared/model-reasoning.js").ModelReasoningBudget;
+            reasoningControlSource?: "invocation" | "request" | "configuration" | "agent-mode";
             format?: import("../../model-gateway/types.js").ModelGatewayFormat;
             instructions: string[] | Readonly<{
                 blockCount: number;
@@ -45,7 +47,7 @@ export declare function projectAutomationModelDependencies(config: RuntimeConfig
             }> | undefined;
             modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
         } | {
-            unavailable: import("../../model-gateway/invocation-policy.js").ModelInvocationResolutionErrorCode;
+            unavailable: string;
             modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
             instructions: Readonly<{
                 blockCount: number;

package/dist/src/runtime/automations/model-dependency-projection.js

@@ -1,3 +1,4 @@
+import { ModelReasoningConfigurationError } from "../../shared/model-reasoning.js";
 import { ModelInvocationResolutionError, resolveModelInvocation, } from "../../model-gateway/invocation-policy.js";
 import { MODEL_STEPS } from "../../shared/model-steps.js";
 import { loadRequestRunnerConfig } from "../config/runner/loader.js";
@@ -35,6 +36,7 @@ function invocationDependency(input) {
     try {
         const invocation = resolveModelInvocation({
             agentMode: input.node.agentMode, modelPreference,
+            ...(input.node.reasoningPreference ? { reasoningPreference: input.node.reasoningPreference } : {}),
             modelStep: input.modelStep, modelPolicy: input.modelPolicy,
         });
         // Unused calibration slots and display labels are not execution dependencies.
@@ -46,7 +48,7 @@ function invocationDependency(input) {
         return { ...dependency, ...invocation, profile, timeoutMs: timeout.timeoutMs };
     }
     catch (error) {
-        if (!(error instanceof ModelInvocationResolutionError))
+        if (!(error instanceof ModelInvocationResolutionError) && !(error instanceof ModelReasoningConfigurationError))
             throw error;
         return { ...dependency, unavailable: error.code };
     }
@@ -62,7 +64,7 @@ export function projectAutomationModelDependencies(config, nodes) {
         : config.models;
     const selected = new Map();
     for (const node of nodes) {
-        const key = JSON.stringify([node.modelProfileId, node.agentMode]);
+        const key = JSON.stringify(node.reasoningPreference ? [node.modelProfileId, node.agentMode, node.reasoningPreference] : [node.modelProfileId, node.agentMode]);
         const hasTools = node.tools.length > 0 || selected.get(key)?.hasTools === true;
         selected.set(key, { node, hasTools });
     }

package/dist/src/runtime/automations/publication-validation.js

@@ -1,3 +1,4 @@
+import { captureRequestReasoningPreference } from "../request/reasoning-preference.js";
 import { resolveModelSelection } from "../model/model-selection.js";
 import { validateToolNormalInvocationInput, validateToolNormalInvocationPayload, } from "../../capabilities/normal-invocation/validator.js";
 import { compileAutomationGraph } from "./graph-validation.js";
@@ -142,6 +143,12 @@ export function validateAutomationPublication(input) {
             modelPolicy: input.config.models,
             modelExecutionPolicies: input.config.modelExecutionPolicies,
         });
+        try {
+            captureRequestReasoningPreference(node.reasoningPreference, selection);
+        }
+        catch (error) {
+            issues.push({ code: "automation_model_unavailable", path: `nodes.${node.id}.reasoningPreference`, message: String(error) });
+        }
         if (selection.execution.primaryProfileId !== node.modelProfileId) {
             issues.push({
                 code: "automation_model_unavailable",

package/dist/src/runtime/automations/saved-agent-management.js

@@ -27,6 +27,7 @@ function snapshotAgent(agent, id) {
         onFailure: agent.onFailure,
         modelProfileId: agent.modelProfileId,
         agentMode: agent.agentMode,
+        ...(agent.reasoningPreference ? { reasoningPreference: agent.reasoningPreference } : {}),
         roleInstructions: agent.roleInstructions,
         prompt: agent.prompt,
         inputs: {},

package/dist/src/runtime/automations/service.d.ts

@@ -155,6 +155,9 @@ export declare function createAutomationService(options: {
         }>[];
         models: {
             provider?: string | undefined;
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             id: string;
             label: string;
         }[];

package/dist/src/runtime/capabilities/automation-builder/payload-schema.js

@@ -1,3 +1,4 @@
+import { modelReasoningPreferenceSchema } from "../../../shared/model-reasoning-schema.js";
 import { AUTOMATION_DRAFT_BATCH_LIMITS } from "../../automations/draft-batch.js";
 import { AUTOMATION_GRAPH_LIMITS, DEFAULT_AUTOMATION_LIMITS } from "../../automations/limits.js";
 import { AUTOMATION_CREATION_RECIPE_LIMITS } from "./creation-recipe.js";
@@ -50,12 +51,13 @@ const agentTools = { $ref: "#/$defs/selectedTools" };
 const savedOrigin = object({ agentId: text(1), revision: integer });
 const sharedNode = { title: text(1), onFailure: choices("stop", "skip") };
 const toolFields = { operation, controls: map(binding), payload: binding };
-const agentFields = { modelProfileId: text(1), agentMode: choices("fast", "reasoning", "deep"),
+const reasoningPreference = { $ref: "#/$defs/reasoningPreference" };
+const agentFields = { reasoningPreference, modelProfileId: text(1), agentMode: choices("fast", "reasoning", "deep"),
     roleInstructions: text(), prompt: text(), inputs: map(binding), tools: agentTools,
     result, acceptance, savedAgentOrigin: savedOrigin };
 const toolNode = object({ kind: choices("tool"), ...sharedNode, ...toolFields }, ["payload"]);
-const agentNode = object({ kind: choices("agent"), ...sharedNode, ...agentFields }, ["acceptance", "savedAgentOrigin"]);
-const editableNodeFields = { ...sharedNode, ...toolFields, ...agentFields, payload: nullable(binding) };
+const agentNode = object({ kind: choices("agent"), ...sharedNode, ...agentFields }, ["acceptance", "savedAgentOrigin", "reasoningPreference"]);
+const editableNodeFields = { ...sharedNode, ...toolFields, ...agentFields, payload: nullable(binding), reasoningPreference: nullable(reasoningPreference) };
 const nodePatch = object(editableNodeFields, Object.keys(editableNodeFields));
 const schedule = { anyOf: [
         object({ kind: choices("timer"), delayMs: integer }),
@@ -92,13 +94,13 @@ const command = { anyOf: [
     ] };
 const recipeStep = { anyOf: [
         object({ key: text(1), kind: choices("tool"), ...sharedNode, ...toolFields }, ["onFailure", "controls", "payload"]),
-        object({ key: text(1), kind: choices("agent"), ...sharedNode, ...agentFields }, ["onFailure", "agentMode", "roleInstructions", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"]),
+        object({ key: text(1), kind: choices("agent"), ...sharedNode, ...agentFields }, ["onFailure", "agentMode", "reasoningPreference", "roleInstructions", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"]),
         object({ key: text(1), kind: choices("parallel"), branches: array(array({ $ref: "#/properties/steps/items" }, AUTOMATION_CREATION_RECIPE_LIMITS.executableNodes, 1), AUTOMATION_GRAPH_LIMITS.branchesPerGroup, 2) }),
     ] };
 const schema = { ...object({ version: { type: "integer", const: 1 },
         commands: array(command, AUTOMATION_DRAFT_BATCH_LIMITS.commands, 1),
         settings: { $ref: "#/$defs/definitionPatch" }, steps: array(recipeStep, AUTOMATION_CREATION_RECIPE_LIMITS.executableNodes),
-    }, ["commands", "settings", "steps"]), $defs: { valueBinding, definitionPatch, operationReference, selectedTools } };
+    }, ["commands", "settings", "steps"]), $defs: { valueBinding, definitionPatch, operationReference, selectedTools, reasoningPreference: modelReasoningPreferenceSchema } };
 /** Structural generation grammar. Canonical parsers own route exclusivity, references, bounds and graph semantics. */
 export const AUTOMATION_BUILDER_PAYLOAD_FORMAT = Object.freeze({
     type: "json_schema", name: "automation_draft_plan", strict: false, schema,

package/dist/src/runtime/capabilities/automations/authoring-catalog.d.ts

@@ -63,6 +63,9 @@ export declare function readAutomationAuthoringCatalog(service: CatalogService,
     };
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;
@@ -177,6 +180,9 @@ export declare function readAutomationAuthoringCatalogIndex(service: CatalogServ
     };
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;
@@ -250,6 +256,9 @@ export declare function projectAutomationAuthoringCatalogIndex(catalog: Authorin
     };
     models: {
         items: {
+            reasoningControls?: {
+                budgetTokens: boolean;
+            } | undefined;
             provider?: string | undefined;
             id: string;
             label: string;