@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/model/invoke-step.js

@@ -1,17 +1,17 @@
-import { projectToolMediaMessages } from "../context/tool-media-projection.js";
 import { resolveModelInvocationStep } from "../../shared/model-step-registry.js";
-import { assessRequestMessagesBudget, resolveRequestBudgetInputTokens, } from "../context/request-context-budget.js";
 import { projectConfiguredStepMessages } from "../config/runner/step-instructions.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { classifyRuntimeErrorType } from "../observability/error-type.js";
 import { resolveRequestSteeringInbox, } from "../request/request-steering.js";
 import { appendRequestSteeringContext } from "../request/request-steering-context.js";
 import { createModelStepAbort } from "../steps/model-step-timeout.js";
-import { countModelInputTokens } from "./input-token-count.js";
+import { acceptModelStepOutput } from "./model-step-acceptance.js";
+import { createModelContextAssessment } from "./model-context-assessment.js";
 import { isModelStepCompactionEligible, resolveModelContextAdmission, } from "./model-context-budget.js";
 import { resolveModelStepTimeout, } from "./model-step-timeout-policy.js";
-import { assertBoundModelStepSteeringCurrent, isModelStepSteeringSuperseded, } from "./model-step-steering.js";
+import { assertBoundModelStepSteeringCurrent, isModelStepSteeringSuperseded, assertModelStepAdmissionCurrent, ModelStepAdmissionSuperseded, } from "./model-step-steering.js";
 import { createModelInvocationIdentity } from "./invocation-identity.js";
+import { admitCompactedContext, requiresContextCompaction, } from "./context-compaction-admission.js";
 /** Binds the immutable request services used by every model step in a request. */
 export class RequestModelStepInvoker {
     request;
@@ -71,11 +71,23 @@ class ModelStepInvocation {
     }
     async run() {
         for (;;) {
+            this.input.request.abortSignal.throwIfAborted();
             assertBoundModelStepSteeringCurrent(this.input.requestSteering, this.input.params.boundSteeringVersion);
-            const attempt = await this.beginAttempt();
+            const beginning = await this.beginAttempt();
+            if (beginning.kind === "superseded") {
+                this.resolveOutputDisposition(beginning.steeringSnapshot);
+                continue;
+            }
+            const attempt = beginning.attempt;
             let outputDiagnostics;
             try {
-                assertBoundModelStepSteeringCurrent(this.input.requestSteering, this.input.params.boundSteeringVersion);
+                assertModelStepAdmissionCurrent({
+                    abortSignal: this.input.request.abortSignal,
+                    requestSteering: this.input.requestSteering,
+                    boundSteeringVersion: this.input.params.boundSteeringVersion,
+                    ownsRequestSteering: this.input.ownsRequestSteering,
+                    steeringSnapshot: attempt.steeringSnapshot,
+                });
                 const response = await attempt.invokeProvider();
                 this.input.request.abortSignal.throwIfAborted();
                 attempt.signal.throwIfAborted();
@@ -85,11 +97,23 @@ class ModelStepInvocation {
                 if (this.resolveOutputDisposition(attempt.steeringSnapshot, outputDiagnostics) === "superseded") {
                     continue;
                 }
-                const accepted = this.input.params.accept(response.text, outputDiagnostics);
+                const acceptedDiagnostics = outputDiagnostics;
+                const accepted = await acceptModelStepOutput(() => this.input.params.accept(response.text, acceptedDiagnostics, attempt.signal), attempt.signal);
+                this.input.request.abortSignal.throwIfAborted();
+                attempt.signal.throwIfAborted();
+                assertBoundModelStepSteeringCurrent(this.input.requestSteering, this.input.params.boundSteeringVersion);
+                if (this.resolveOutputDisposition(attempt.steeringSnapshot, outputDiagnostics) === "superseded")
+                    continue;
                 this.recordCompletion(attempt.steeringSnapshot, outputDiagnostics);
                 return accepted;
             }
             catch (error) {
+                if (error instanceof ModelStepAdmissionSuperseded) {
+                    this.input.request.abortSignal.throwIfAborted();
+                    attempt.signal.throwIfAborted();
+                    this.resolveOutputDisposition(error.steeringSnapshot);
+                    continue;
+                }
                 if (isModelStepSteeringSuperseded(error))
                     throw error;
                 this.recordFailure(attempt, error, outputDiagnostics);
@@ -103,9 +127,29 @@ class ModelStepInvocation {
         }
     }
     async beginAttempt() {
+        try {
+            return { kind: "ready", attempt: await this.prepareAttempt() };
+        }
+        catch (error) {
+            this.input.request.abortSignal.throwIfAborted();
+            if (error instanceof ModelStepAdmissionSuperseded) {
+                return { kind: "superseded", steeringSnapshot: error.steeringSnapshot };
+            }
+            throw error;
+        }
+    }
+    async prepareAttempt() {
         const { request, params } = this.input;
         request.abortSignal.throwIfAborted();
         const steeringSnapshot = this.input.requestSteering.snapshot();
+        const assertCurrent = () => assertModelStepAdmissionCurrent({
+            abortSignal: request.abortSignal,
+            requestSteering: this.input.requestSteering,
+            boundSteeringVersion: params.boundSteeringVersion,
+            ownsRequestSteering: this.input.ownsRequestSteering,
+            steeringSnapshot,
+        });
+        assertCurrent();
         const configuredInstructionProjection = projectConfiguredStepMessages({
             runnerConfig: request.runnerConfig,
             modelStep: params.modelStep,
@@ -132,127 +176,41 @@ class ModelStepInvocation {
             ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
             ...(params.format ? { requestFormat: params.format } : {}),
         });
-        const calibrationInstructions = (admission.invocation.instructions ?? [])
-            .map((instruction) => instruction.trim())
-            .filter((instruction) => instruction.length > 0);
-        const effectiveFormat = admission.effectiveFormat;
-        const projectMedia = (candidate) => projectToolMediaMessages({
-            messages: candidate,
-            store: request.toolResources?.media,
-            modelStep: params.modelStep,
-            supportsImages: admission.invocation.profile.capabilities.inputModalities.includes("image"),
+        const { assess, projectMedia } = createModelContextAssessment({
+            request,
+            params,
+            admission,
+            assertCurrent,
         });
-        const assess = async (candidateMessages) => {
-            const projected = projectMedia(candidateMessages);
-            const measuredInputTokens = await countModelInputTokens({
-                request,
-                invocation: admission.invocation,
-                modelStep: params.modelStep,
-                messages: projected,
-                ...(params.format !== undefined ? { format: params.format } : {}),
-            });
-            return assessRequestMessagesBudget({
-                messages: calibrationInstructions.length > 0
-                    ? [
-                        {
-                            role: "system",
-                            content: calibrationInstructions.join("\n"),
-                        },
-                        ...projected,
-                    ]
-                    : projected,
-                ...(isSchemaFormat(effectiveFormat)
-                    ? { format: { schema: effectiveFormat.schema } }
-                    : {}),
-                budget: admission.budget,
-                ...(measuredInputTokens !== undefined ? { measuredInputTokens } : {}),
-            });
-        };
         let assessment = await assess(messages);
         const invocationId = this.input.nextInvocationId();
-        const compactionRequired = compactionTriggerEligible &&
-            (!assessment.fits ||
-                resolveRequestBudgetInputTokens(assessment.budget) >=
-                    assessment.budget.compactionTriggerInputTokens);
-        if (compactionRequired) {
-            const before = assessment;
-            const compactionScope = contextCompaction?.compactionScope;
-            this.input.onContextEvent?.("context.compaction.started", {
-                stage: "context_compaction",
-                phase: "started",
-                requestId: request.requestId,
-                invocationId,
-                modelStep: params.modelStep,
-                profileId: admission.invocation.profile.id,
-                reason: "context_window_threshold",
-                compactionScope,
-                contextWindowTokens: before.budget.contextWindowTokens,
-                beforeInputTokens: resolveRequestBudgetInputTokens(before.budget),
-                beforeUsedContextPercent: before.budget.usedContextPercent,
-                triggerInputTokens: before.budget.compactionTriggerInputTokens,
-            });
-            if (!contextCompaction) {
-                this.input.onContextEvent?.("context.compaction.failed", {
-                    stage: "context_compaction",
-                    phase: "failed",
-                    requestId: request.requestId,
-                    invocationId,
-                    modelStep: params.modelStep,
-                    profileId: admission.invocation.profile.id,
-                    reason: "context_compaction_controller_unavailable",
-                    beforeInputTokens: resolveRequestBudgetInputTokens(before.budget),
-                });
-                throw new Error("request_context_compaction_required");
-            }
-            try {
-                const prepared = await contextCompaction.prepare(messages);
-                const compactedAssessment = await assess(prepared.messages);
-                if (!compactedAssessment.fits ||
-                    resolveRequestBudgetInputTokens(compactedAssessment.budget) >=
-                        compactedAssessment.budget.compactionTriggerInputTokens ||
-                    resolveRequestBudgetInputTokens(compactedAssessment.budget) >=
-                        resolveRequestBudgetInputTokens(before.budget)) {
-                    throw new Error("context_compaction_projection_not_reduced");
-                }
-                await prepared.commit();
-                messages = prepared.messages;
-                assessment = compactedAssessment;
-                this.input.onContextEvent?.("context.compaction.completed", {
-                    stage: "context_compaction",
-                    phase: "completed",
+        if (requiresContextCompaction(compactionTriggerEligible, assessment)) {
+            const admitted = await admitCompactedContext({
+                messages,
+                assessment,
+                controller: contextCompaction,
+                assess,
+                assertCurrent,
+                abortSignal: request.abortSignal,
+                identity: {
                     requestId: request.requestId,
                     invocationId,
                     modelStep: params.modelStep,
                     profileId: admission.invocation.profile.id,
-                    reason: "context_window_threshold",
-                    compactionScope,
-                    scopeId: prepared.scopeId,
-                    sourceRevision: prepared.sourceRevision,
-                    coveredSourceCount: prepared.coveredSourceCount,
-                    contextWindowTokens: assessment.budget.contextWindowTokens,
-                    beforeInputTokens: resolveRequestBudgetInputTokens(before.budget),
-                    beforeUsedContextPercent: before.budget.usedContextPercent,
-                    afterInputTokens: resolveRequestBudgetInputTokens(assessment.budget),
-                    afterUsedContextPercent: assessment.budget.usedContextPercent,
-                    triggerInputTokens: assessment.budget.compactionTriggerInputTokens,
-                });
-            }
-            catch (error) {
-                this.input.onContextEvent?.("context.compaction.failed", {
-                    stage: "context_compaction",
-                    phase: "failed",
-                    requestId: request.requestId,
-                    invocationId,
-                    modelStep: params.modelStep,
-                    profileId: admission.invocation.profile.id,
-                    reason: "semantic_checkpoint_rejected",
-                    compactionScope,
-                    beforeInputTokens: resolveRequestBudgetInputTokens(before.budget),
-                    issueCode: error instanceof Error ? error.message : "unknown_error",
-                });
-                throw error;
-            }
+                    provider: admission.invocation.profile.provider,
+                    model: admission.invocation.model,
+                    ...(request.modelInvocationScope
+                        ? { modelInvocationScope: request.modelInvocationScope }
+                        : {}),
+                },
+                ...(this.input.onContextEvent
+                    ? { onEvent: this.input.onContextEvent }
+                    : {}),
+            });
+            messages = [...admitted.messages];
+            assessment = admitted.assessment;
         }
+        assertCurrent();
         traceDebug("runtime.context", "budget.assessed", {
             requestId: request.requestId,
             modelStep: params.modelStep,
@@ -472,11 +430,6 @@ class ModelStepAttempt {
         this.input.stepAbort.dispose();
     }
 }
-function isSchemaFormat(format) {
-    return (typeof format === "object" &&
-        format !== null &&
-        Object.prototype.hasOwnProperty.call(format, "schema"));
-}
 function projectOutputDiagnostics(text, meta, steeringVersion) {
     const usage = meta.usage && typeof meta.usage === "object" && !Array.isArray(meta.usage)
         ? meta.usage
@@ -507,7 +460,8 @@ function projectOutputDiagnostics(text, meta, steeringVersion) {
     });
 }
 function projectFormatDiagnostics(format) {
-    if (format === undefined) {
+    const requestsPlainText = format === undefined || (typeof format === "object" && format.type === "text");
+    if (requestsPlainText) {
         return {
             outputContract: "text",
             schemaCharacterCount: 0,

package/dist/src/runtime/model/invoke-structured-step.d.ts

@@ -39,5 +39,5 @@ export declare function invokeStructuredModelStep<T>(params: {
     invalidOutputReason: string;
     contextRetention?: "exact";
     contextCompaction?: ModelStepContextCompactionController;
-    parse: (text: string) => StructuredModelParseResult<T>;
+    parse: (text: string, abortSignal: AbortSignal) => StructuredModelParseResult<T> | Promise<StructuredModelParseResult<T>>;
 }): Promise<T>;

package/dist/src/runtime/model/invoke-structured-step.js

@@ -35,7 +35,7 @@ export async function invokeStructuredModelStep(params) {
             ...(params.contextCompaction
                 ? { contextCompaction: params.contextCompaction }
                 : {}),
-            accept(text, outputDiagnostics) {
+            async accept(text, outputDiagnostics, abortSignal) {
                 const incompleteError = resolveOutputIncompleteError(outputDiagnostics, params.modelStep);
                 if (incompleteError) {
                     params.request.abortSignal.throwIfAborted();
@@ -48,7 +48,8 @@ export async function invokeStructuredModelStep(params) {
                     });
                     throw incompleteError;
                 }
-                const parsed = params.parse(text);
+                const parsed = await params.parse(text, abortSignal);
+                abortSignal.throwIfAborted();
                 if (parsed.ok) {
                     return Object.freeze({ ok: true, value: parsed.decision });
                 }

package/dist/src/runtime/model/model-context-assessment.d.ts

@@ -0,0 +1,17 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { RequestModelInvocationView } from "../request/contracts.js";
+import type { ResolvedModelContextAdmission } from "./model-context-budget.js";
+import type { ModelStepInvocationInput } from "./model-step-port.js";
+/** Measures every candidate through the same media, provider-count and estimate path. */
+export declare function createModelContextAssessment(input: {
+    request: RequestModelInvocationView;
+    params: Pick<ModelStepInvocationInput<unknown>, "modelStep" | "format">;
+    admission: ResolvedModelContextAdmission;
+    assertCurrent(): void;
+}): {
+    assess: (candidateMessages: readonly ChatMessage[]) => Promise<Readonly<{
+        fits: boolean;
+        budget: import("../context/request-context-contracts.js").RequestContextBudgetEstimate;
+    }>>;
+    projectMedia: (candidate: readonly ChatMessage[]) => ChatMessage[];
+};

package/dist/src/runtime/model/model-context-assessment.js

@@ -0,0 +1,51 @@
+import { assessRequestMessagesBudget } from "../context/request-context-budget.js";
+import { projectToolMediaMessages } from "../context/tool-media-projection.js";
+import { countModelInputTokens } from "./input-token-count.js";
+/** Measures every candidate through the same media, provider-count and estimate path. */
+export function createModelContextAssessment(input) {
+    const { request, params, admission, assertCurrent } = input;
+    const calibrationInstructions = (admission.invocation.instructions ?? [])
+        .map((instruction) => instruction.trim())
+        .filter((instruction) => instruction.length > 0);
+    const effectiveFormat = admission.effectiveFormat;
+    const projectMedia = (candidate) => projectToolMediaMessages({
+        messages: candidate,
+        store: request.toolResources?.media,
+        modelStep: params.modelStep,
+        supportsImages: admission.invocation.profile.capabilities.inputModalities.includes("image"),
+    });
+    const assess = async (candidateMessages) => {
+        assertCurrent();
+        const projected = projectMedia(candidateMessages);
+        const measuredInputTokens = await countModelInputTokens({
+            request,
+            invocation: admission.invocation,
+            modelStep: params.modelStep,
+            messages: projected,
+            ...(params.format !== undefined ? { format: params.format } : {}),
+        });
+        assertCurrent();
+        return assessRequestMessagesBudget({
+            messages: calibrationInstructions.length > 0
+                ? [
+                    {
+                        role: "system",
+                        content: calibrationInstructions.join("\n"),
+                    },
+                    ...projected,
+                ]
+                : projected,
+            ...(isSchemaFormat(effectiveFormat)
+                ? { format: { schema: effectiveFormat.schema } }
+                : {}),
+            budget: admission.budget,
+            ...(measuredInputTokens !== undefined ? { measuredInputTokens } : {}),
+        });
+    };
+    return { assess, projectMedia };
+}
+function isSchemaFormat(format) {
+    return (typeof format === "object" &&
+        format !== null &&
+        Object.prototype.hasOwnProperty.call(format, "schema"));
+}

package/dist/src/runtime/model/model-context-budget.js

@@ -20,6 +20,7 @@ export function resolveModelContextAdmission(params) {
     const invocation = resolveModelInvocation({
         agentMode: params.agentMode,
         modelStep: params.modelStep,
+        ...(params.requestFormat === undefined ? {} : { format: params.requestFormat }),
         ...(params.modelPreference
             ? { modelPreference: params.modelPreference }
             : {}),

package/dist/src/runtime/model/model-step-acceptance.d.ts

@@ -0,0 +1,4 @@
+/** Bound asynchronous validation to the same deadline as its provider attempt.
+ * The callback must also pass this signal to its own asynchronous work.
+ */
+export declare function acceptModelStepOutput<T>(accept: () => T | Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/src/runtime/model/model-step-acceptance.js

@@ -0,0 +1,28 @@
+/** Bound asynchronous validation to the same deadline as its provider attempt.
+ * The callback must also pass this signal to its own asynchronous work.
+ */
+export function acceptModelStepOutput(accept, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        Promise.resolve()
+            .then(() => {
+            signal.throwIfAborted();
+            return accept();
+        })
+            .then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            if (signal.aborted)
+                reject(signal.reason);
+            else
+                resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(signal.aborted ? signal.reason : error);
+        });
+    });
+}

package/dist/src/runtime/model/model-step-port.d.ts

@@ -1,5 +1,7 @@
 import type { ChatMessage } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
+import type { ModelStepContextCompactionController } from "./context-compaction-contracts.js";
+export type { ModelStepCompactionScope, ModelStepCompactionStage, ModelStepCompactionStageOutcome, ModelStepContextCompactionController, ModelStepContextCompactionPreparation, } from "./context-compaction-contracts.js";
 export type ModelStepOutputDiagnostics = Readonly<{
     outputLength: number;
     /** Runtime-owned steering snapshot used by this provider attempt. */
@@ -11,20 +13,6 @@ export type ModelStepOutputDiagnostics = Readonly<{
     providerOutputTokens?: number;
     providerTotalTokens?: number;
 }>;
-export type ModelStepContextCompactionPreparation = Readonly<{
-    messages: ChatMessage[];
-    commit(): void | Promise<void>;
-    scopeId: string;
-    sourceRevision: number | string;
-    coveredSourceCount: number;
-}>;
-export type ModelStepContextCompactionController = Readonly<{
-    compactionScope: "active_request" | "session_history";
-    /** Replaces already-covered exact working messages before assessment. */
-    project(messages: readonly ChatMessage[]): ChatMessage[];
-    /** Generates one replacement checkpoint without committing it yet. */
-    prepare(messages: readonly ChatMessage[]): Promise<ModelStepContextCompactionPreparation>;
-}>;
 export type ModelStepInvocationInput<T> = Readonly<{
     modelStep: ModelStep;
     messages: ChatMessage[];
@@ -35,7 +23,8 @@ export type ModelStepInvocationInput<T> = Readonly<{
     /** Exact input bypasses compaction, but must fit the shared input budget. */
     contextRetention?: "exact";
     contextCompaction?: ModelStepContextCompactionController;
-    accept(text: string, diagnostics: ModelStepOutputDiagnostics): T;
+    /** Async validators must forward this attempt signal to their own work. */
+    accept(text: string, diagnostics: ModelStepOutputDiagnostics, abortSignal: AbortSignal): T | Promise<T>;
 }>;
 /** Request-owned port shared by every model step in one accepted request. */
 export type RequestModelStepPort = Readonly<{

package/dist/src/runtime/model/model-step-steering.d.ts

@@ -1,4 +1,4 @@
-import type { RequestSteeringInbox } from "../request/request-steering.js";
+import type { RequestSteeringInbox, RequestSteeringSnapshot } from "../request/request-steering.js";
 /** Returns a decision-bound invocation to its caller when that decision is stale. */
 export declare class ModelStepSteeringSupersededError extends Error {
     readonly boundSteeringVersion: number;
@@ -6,3 +6,16 @@ export declare class ModelStepSteeringSupersededError extends Error {
 }
 export declare function isModelStepSteeringSuperseded(error: unknown): error is ModelStepSteeringSupersededError;
 export declare function assertBoundModelStepSteeringCurrent(requestSteering: RequestSteeringInbox, boundSteeringVersion: number | undefined): void;
+/** Internal control transfer, caught before it can leave the invocation loop. */
+export declare class ModelStepAdmissionSuperseded extends Error {
+    readonly steeringSnapshot: RequestSteeringSnapshot;
+    constructor(steeringSnapshot: RequestSteeringSnapshot);
+}
+export declare function assertModelStepAdmissionCurrent(params: {
+    abortSignal: AbortSignal;
+    requestSteering: RequestSteeringInbox;
+    boundSteeringVersion: number | undefined;
+    ownsRequestSteering: boolean;
+    steeringSnapshot: RequestSteeringSnapshot;
+}): void;
+export declare function isCompactionSteeringSuperseded(error: unknown): boolean;

package/dist/src/runtime/model/model-step-steering.js

@@ -17,3 +17,26 @@ export function assertBoundModelStepSteeringCurrent(requestSteering, boundSteeri
         return;
     throw new ModelStepSteeringSupersededError(boundSteeringVersion);
 }
+/** Internal control transfer, caught before it can leave the invocation loop. */
+export class ModelStepAdmissionSuperseded extends Error {
+    steeringSnapshot;
+    constructor(steeringSnapshot) {
+        super("model_step_steering_superseded");
+        this.steeringSnapshot = steeringSnapshot;
+        this.name = "ModelStepAdmissionSuperseded";
+    }
+}
+export function assertModelStepAdmissionCurrent(params) {
+    params.abortSignal.throwIfAborted();
+    assertBoundModelStepSteeringCurrent(params.requestSteering, params.boundSteeringVersion);
+    if (!params.ownsRequestSteering)
+        return;
+    if (params.requestSteering.isCurrent(params.steeringSnapshot.version))
+        return;
+    throw new ModelStepAdmissionSuperseded(params.steeringSnapshot);
+}
+export function isCompactionSteeringSuperseded(error) {
+    if (error instanceof ModelStepAdmissionSuperseded)
+        return true;
+    return isModelStepSteeringSuperseded(error);
+}

package/dist/src/runtime/orchestration/capability-adapters/result.d.ts

@@ -1,3 +1,4 @@
+import { type ToolContextTextField } from "../../../capabilities/tool-context-text.js";
 import { type ToolImageEvidence } from "../../../capabilities/tool-media.js";
 export declare const CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES: number;
 export type CapabilityJsonPrimitive = string | number | boolean | null;
@@ -10,6 +11,7 @@ export type CapabilityResultReference = Readonly<{
     target: string;
 }>;
 export type CanonicalToolExecutionResult = Readonly<{
+    contextTextFields?: readonly ToolContextTextField[];
     media?: readonly ToolImageEvidence[];
     ok: boolean;
     tool: string;
@@ -65,7 +67,8 @@ export type CapabilityAdapterResultNormalization = Readonly<{
 /**
  * Captures one typed exact result without truncating or semantically rewriting
  * plugin-authored content. Bounds come from the explicit envelope schema and
- * the hard serialized-result producer limit.
+ * the metadata envelope limit. Declared text stays exact and is budgeted at
+ * model invocation, where the existing context compactor can see it.
  */
 export declare function normalizeCapabilityAdapterResult(input: unknown): CapabilityAdapterResultNormalization;
 /**

package/dist/src/runtime/orchestration/capability-adapters/result.js

@@ -1,10 +1,13 @@
+import { assessResultEnvelopeBytes, CAPABILITY_RESULT_ENVELOPE_MAX_BYTES } from "../../../capabilities/result-budget.js";
+import { hasValidToolContextText, measureToolContextTextBytes, } from "../../../capabilities/tool-context-text.js";
 import { isToolResultMedia } from "../../../capabilities/tool-media.js";
 import { ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, } from "../role-calls/contracts.js";
-export const CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES = 256 * 1024;
+export const CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 /**
  * Captures one typed exact result without truncating or semantically rewriting
  * plugin-authored content. Bounds come from the explicit envelope schema and
- * the hard serialized-result producer limit.
+ * the metadata envelope limit. Declared text stays exact and is budgeted at
+ * model invocation, where the existing context compactor can see it.
  */
 export function normalizeCapabilityAdapterResult(input) {
     try {
@@ -152,6 +155,7 @@ function captureToolExecutionResult(input) {
             "error",
             "errorCode",
             "media",
+            "contextTextFields",
         ]) ||
         typeof input.ok !== "boolean" ||
         typeof input.tool !== "string" ||
@@ -168,6 +172,7 @@ function captureToolExecutionResult(input) {
         (input.errorCode !== undefined && typeof input.errorCode !== "string") ||
         !validActions(input.actions) ||
         !isToolResultMedia(input.media) ||
+        !hasValidToolContextText(input) ||
         !validToolData(input.data)) {
         return undefined;
     }
@@ -299,11 +304,10 @@ function invalid(code) {
     return Object.freeze({ ok: false, code });
 }
 function acceptBoundedResult(value) {
-    const serialized = JSON.stringify(value);
-    if (serialized === undefined)
-        return invalid("result_not_json_safe");
-    if (Buffer.byteLength(serialized, "utf8") >
-        CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES) {
+    const contextTextBytes = value.kind === "registered_tool_execution_result_v1"
+        ? measureToolContextTextBytes(value.result)
+        : 0;
+    if (!assessResultEnvelopeBytes(value, contextTextBytes).fits) {
         return invalid("result_too_large");
     }
     return Object.freeze({ ok: true, value });

package/dist/src/runtime/orchestration/role-calls/child-return.d.ts

@@ -1,4 +1,4 @@
-import { type RoleCallCommitEffect, type RoleCallLedger, type RoleCallLedgerCommitResult, type RoleCallLedgerHead, type RoleCallWorkerCapabilityScope } from "./contracts.js";
+import { type RoleCallCommitEffect, type RoleCallLedger, type RoleCallLedgerCommitResult, type RoleCallLedgerHead, type RoleCallPolicy, type RoleCallState, type RoleCallWorkerCapabilityScope } from "./contracts.js";
 import { type RuntimeDelegateRoleId } from "../roles.js";
 import { type RoleCallResultReceipt } from "./result-receipt.js";
 import { type RoleCallWorkResultLineage } from "./work-result-lineage.js";
@@ -34,3 +34,7 @@ export type RoleCallChildReturnCommit = Readonly<{
 }>;
 export declare function requireRoleCallChildReturnCommit(commit: RoleCallLedgerCommitResult): RoleCallChildReturnCommit;
 export declare function projectRoleChildReturnContext(ledger: RoleCallLedger, commit: RoleCallLedgerCommitResult): RoleChildReturnContext;
+export declare function projectStoredCompletedRoleChild(state: RoleCallState, refs: Readonly<{
+    callerCallId: string;
+    childCallId: string;
+}>, policy: RoleCallPolicy): CompletedRoleChildResult;

package/dist/src/runtime/orchestration/role-calls/child-return.js

@@ -45,12 +45,12 @@ export function projectRoleChildReturnContext(ledger, commit) {
     });
 }
 function projectCompletedChildren(state, caller, policy) {
-    return Object.freeze(caller.childCallIds.map((completedChildCallId) => projectCompletedChild(state, {
+    return Object.freeze(caller.childCallIds.map((completedChildCallId) => projectStoredCompletedRoleChild(state, {
         callerCallId: caller.callId,
         childCallId: completedChildCallId,
     }, policy)));
 }
-function projectCompletedChild(state, refs, policy) {
+export function projectStoredCompletedRoleChild(state, refs, policy) {
     const child = state.calls.find((call) => call.callId === refs.childCallId);
     const result = state.results.find((candidate) => candidate.resultRef === child?.resultRef);
     if (child?.status !== "completed" ||