@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/model-gateway/providers/llamacpp/stream.js

@@ -0,0 +1,33 @@
+import { readSseDataFrames } from "../../protocol/sse-data.js";
+import { LlamaCppChatStreamNormalizer } from "./stream-normalizer.js";
+export async function forwardLlamaCppChatStream(body, writer) {
+    const normalizer = new LlamaCppChatStreamNormalizer();
+    for await (const frame of readSseDataFrames(body)) {
+        for (const event of normalizer.consume(frame))
+            writer.emit(event);
+        if (normalizer.hasTerminated)
+            return;
+    }
+    normalizer.finish();
+}
+export async function collectLlamaCppChatStream(body) {
+    let text = "";
+    let thinking = "";
+    let usage;
+    let doneReason;
+    await forwardLlamaCppChatStream(body, {
+        emit(event) {
+            if (event.type === "content")
+                text += event.text;
+            else if (event.type === "thinking")
+                thinking += event.text;
+            else if (event.type === "error")
+                throw new Error(event.error);
+            else {
+                usage = event.usage;
+                doneReason = event.doneReason ?? undefined;
+            }
+        },
+    });
+    return { text, thinking, ...(usage ? { usage } : {}), ...(doneReason ? { doneReason } : {}) };
+}

package/dist/src/model-gateway/providers/openai/embeddings.js

@@ -1,5 +1,6 @@
 import { createEmbeddingModelFingerprint } from "../../embeddings/fingerprint.js";
 import { validateEmbeddingVectors } from "../../embeddings/validation.js";
+import { readOpenAiCompatibleEmbeddingVectors } from "../../protocol/openai-embedding-response.js";
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
 const ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -33,7 +34,7 @@ export async function embedWithOpenAI(params) {
         };
     }
     const body = await response.json().catch(() => undefined);
-    const vectors = readOrderedVectors(body, params.texts.length);
+    const vectors = readOpenAiCompatibleEmbeddingVectors(body, params.texts.length);
     return Object.freeze({
         kind: "embedded",
         vectors: validateEmbeddingVectors({
@@ -57,31 +58,3 @@ function resolveEmbeddingSettings(params) {
         ...(apiKey ? { apiKey } : {}),
     };
 }
-function readOrderedVectors(value, expectedCount) {
-    const body = value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-    if (!body || !Array.isArray(body.data)) {
-        return [];
-    }
-    const entries = body.data.filter(isRecord);
-    if (!hasContiguousIndices(entries, expectedCount)) {
-        return [];
-    }
-    return [...entries]
-        .sort((left, right) => Number(left.index) - Number(right.index))
-        .map((entry) => entry.embedding);
-}
-function hasContiguousIndices(entries, expectedCount) {
-    if (entries.length !== expectedCount) {
-        return false;
-    }
-    const indices = new Set(entries.map(({ index }) => index));
-    return (indices.size === expectedCount &&
-        [...indices].every((index) => Number.isSafeInteger(index) &&
-            Number(index) >= 0 &&
-            Number(index) < expectedCount));
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}

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

@@ -1,9 +1 @@
-export declare class OpenAISseDataDecoder {
-    private readonly decoder;
-    private line;
-    private data;
-    private afterCr;
-    accept(bytes: Uint8Array): string[];
-    private acceptLine;
-}
-export declare function readOpenAIDataFrames(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;
+export { SseDataDecoder as OpenAISseDataDecoder, readSseDataFrames as readOpenAIDataFrames } from "../../protocol/sse-data.js";

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-normal-invocations/execution/approval.d.ts

@@ -1,7 +1,9 @@
 import type { ToolCall } from "../../../../capabilities/tool-types.js";
 import { type ToolEventExecutorIdentity } from "../shared/event-metadata.js";
 import type { ToolApprovalController, ToolApprovalRequest, ToolApprovalDecision, ToolPermissionMode } from "../../../ports.js";
-import type { RegisteredToolNormalInvocationRejection } from "../shared/contracts.js";
+import type { BoundOperation, RegisteredToolNormalInvocationRejection } from "../shared/contracts.js";
+/** Both accepted source and normalized target must share the core read exemption. */
+export declare function requiresRegisteredToolActionApproval(mode: ToolPermissionMode, source: BoundOperation, target: BoundOperation): boolean;
 export declare function requestNormalInvocationApproval(params: {
     preparedRequest?: ToolApprovalRequest;
     decision?: ToolApprovalDecision;
@@ -17,6 +19,8 @@ export declare function requestNormalInvocationApproval(params: {
     call: ToolCall;
     eventMeta?: Record<string, unknown>;
     force: boolean;
+    /** Captured operation policy; omitted for ordinary direct approval callers. */
+    requiredByOperationPolicy?: boolean;
 }): Promise<Readonly<{
     ok: true;
 }> | Readonly<{

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/approval.js

@@ -1,13 +1,27 @@
 import { requiresToolActionApproval } from "../../../../capabilities/tool-permission-mode.js";
+import { isCoreToolAutomaticRead } from "../../../capabilities/core-tool-contracts.js";
 import { buildToolExecutorEventMetadata, } from "../shared/event-metadata.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
+/** Both accepted source and normalized target must share the core read exemption. */
+export function requiresRegisteredToolActionApproval(mode, source, target) {
+    const force = source.operation.approval === "always" || target.operation.approval === "always";
+    if (!requiresToolActionApproval(mode, force))
+        return false;
+    if (force)
+        return true;
+    if (!isCoreToolAutomaticRead(source.registration.toolName, source.operation))
+        return true;
+    return !isCoreToolAutomaticRead(target.registration.toolName, target.operation);
+}
 function recommendsFullPlusForForcedAction(mode, force) {
     if (mode !== "full_access")
         return false;
     return force;
 }
 export async function requestNormalInvocationApproval(params) {
-    if (!requiresToolActionApproval(params.toolPermissionMode, params.force)) {
+    const required = params.requiredByOperationPolicy ??
+        requiresToolActionApproval(params.toolPermissionMode, params.force);
+    if (!required) {
         return Object.freeze({ ok: true });
     }
     const approvalId = params.preparedRequest?.approvalId ?? params.nextApprovalId();

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/prepared-execution.js

@@ -1,17 +1,17 @@
 import { createRegisteredToolResultBudget, assertRegisteredToolResultMetadataFits, } from "./result-budget.js";
 import { randomUUID } from "node:crypto";
-import { requiresToolActionApproval } from "../../../../capabilities/tool-permission-mode.js";
 import { buildToolCompletedEventActions, buildToolCompletedEventMetadata, buildToolLifecycleEventCopy, } from "../../../../capabilities/tool-event-metadata.js";
 import { buildToolExecutorEventMetadata, } from "../shared/event-metadata.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
-import { requestNormalInvocationApproval } from "./approval.js";
+import { requestNormalInvocationApproval, requiresRegisteredToolActionApproval } from "./approval.js";
 import { createPreparedInvocationRejectionEmitter } from "./rejection-event.js";
 import { createFileOutputPresentation } from "./file-output-presentation.js";
 import { executeWithToolResources } from "./tool-media-execution.js";
 export function createPreparedNormalInvocation(params) {
-    const force = params.source.operation.approval === "always" ||
-        params.target.operation.approval === "always";
-    const approvalRequest = requiresToolActionApproval(params.executor.toolPermissionMode, force)
+    // Keep an already-recorded approval pending across upgrades; new core reads skip it.
+    const requiresApproval = params.restoredApprovalRequest !== undefined ||
+        requiresRegisteredToolActionApproval(params.executor.toolPermissionMode, params.source, params.target);
+    const approvalRequest = requiresApproval
         ? Object.freeze({
             ...(params.restoredApprovalRequest ?? {
                 requestId: params.executor.requestId,
@@ -82,6 +82,8 @@ async function executePreparedNormalInvocation(params) {
     });
     assertRegisteredToolResultMetadataFits(resultBudget);
     const approval = await requestNormalInvocationApproval({
+        requiredByOperationPolicy: params.approvalRequest !== undefined ||
+            requiresRegisteredToolActionApproval(params.executor.toolPermissionMode, params.source, params.target),
         ...(params.approvalRequest
             ? { preparedRequest: params.approvalRequest }
             : {}),

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/prepared-snapshot.js

@@ -3,6 +3,7 @@ import { createRegisteredToolActionFingerprint } from "../shared/action-fingerpr
 import { captureToolCall, resolveExactTargetOperation, validateCompleteCall, } from "./call-binding.js";
 import { captureExecutionBinding } from "./execution-binding.js";
 import { createPreparedNormalInvocation } from "./prepared-execution.js";
+import { requiresRegisteredToolActionApproval } from "./approval.js";
 /** Validate a saved exact call; restoration never invokes normalization or payload authoring. */
 export function restoreNormalInvocation(params) {
     const value = params.snapshot;
@@ -48,8 +49,14 @@ export function restoreNormalInvocation(params) {
         throw invalid();
     const force = source.operation.approval === "always" ||
         target.operation.approval === "always";
-    const required = requiresToolActionApproval(params.executor.toolPermissionMode, force);
-    if (required !== Boolean(value.approvalRequest))
+    const required = requiresRegisteredToolActionApproval(params.executor.toolPermissionMode, source, target);
+    const missingRequiredApproval = required && !value.approvalRequest;
+    if (missingRequiredApproval)
+        throw invalid();
+    // Existing ASK approvals remain valid even when core reads no longer need new ones.
+    const unexpectedRecordedApproval = value.approvalRequest &&
+        !requiresToolActionApproval(params.executor.toolPermissionMode, force);
+    if (unexpectedRecordedApproval)
         throw invalid();
     if (value.approvalRequest) {
         if (!isRequestApproval(value.approvalRequest, params.executor.requestId))

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>>;