@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/request/super-context-failure-integrity.js

@@ -0,0 +1,130 @@
+import { validateRoleCallCandidate } from "../orchestration/role-calls/reducer.js";
+import { isCurrentRoleCallLedgerHead } from "../orchestration/role-calls/ledger.js";
+import { SuperContextFailure } from "../context/super-context-failure.js";
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, } from "../context/semantic-compaction/super-source-integrity.js";
+/** Error identity is not integrity proof: independently validate every authority. */
+export function hasSafeSuperContextFailureReturn(params) {
+    if (!isOwnedSuperContextFailureInvocation(params))
+        return false;
+    return hasSafeSuperContextState(params);
+}
+/** Output failures also require independently healthy canonical state. */
+export function hasSafeSuperContextState(params) {
+    if (!hasCurrentSuperContextStateAuthority(params))
+        return false;
+    const head = params.expectedHead;
+    try {
+        const store = params.request.contextCompactionStore;
+        if (!store?.snapshot)
+            return false;
+        const integrity = {
+            requestId: params.request.requestId,
+            prompt: params.request.prompt,
+            head,
+            store,
+        };
+        assertSuperCompactionSourceIntegrity(integrity);
+        for (const checkpoint of store.snapshot().checkpoints) {
+            assertSuperCompactionCheckpointIntegrity({ ...integrity, checkpoint });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasCurrentSuperFailureAuthority(params) {
+    if (!isOwnedSuperContextFailureInvocation(params))
+        return false;
+    return hasCurrentSuperContextStateAuthority(params);
+}
+function hasCurrentSuperContextStateAuthority(params) {
+    if (!hasSuperContextContract(params.request.executionPolicy.authority, params.contractId))
+        return false;
+    if (!hasSuperContextContract(params.expectedHead.policy.authority, params.contractId))
+        return false;
+    if (params.request.requestId !== params.expectedHead.state.requestId)
+        return false;
+    const expectedContract = params.call.roleId === "supervisor"
+        ? "supervisor"
+        : `delegated.${params.call.roleId}`;
+    if (params.contractId !== expectedContract)
+        return false;
+    if (!isCurrentRoleCallLedgerHead(params.ledger, params.expectedHead))
+        return false;
+    const head = params.expectedHead;
+    if (head.state.phase !== "running")
+        return false;
+    if (head.state.activeCallId !== params.call.callId)
+        return false;
+    if (params.call.status !== "active")
+        return false;
+    if (head.state.calls.find((call) => call.callId === params.call.callId) !==
+        params.call)
+        return false;
+    if (params.request.abortSignal.aborted)
+        return false;
+    try {
+        if (validateRoleCallCandidate({ state: head.state, policy: head.policy })
+            .length > 0)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isOwnedSuperContextFailureInvocation(params) {
+    const failure = params.error;
+    if (!(failure instanceof SuperContextFailure))
+        return false;
+    if (failure.code === "context_compaction_snapshot_source_incompatible")
+        return false;
+    if (!hasSuperContextContract(params.request.executionPolicy.authority, params.contractId))
+        return false;
+    if (!hasSuperContextContract(params.expectedHead.policy.authority, params.contractId))
+        return false;
+    const binding = failure.binding;
+    if (binding.requestId !== params.request.requestId)
+        return false;
+    if (binding.requestId !== params.expectedHead.state.requestId)
+        return false;
+    if (binding.callId !== params.call.callId)
+        return false;
+    if (binding.parentCallId !== params.call.parentCallId)
+        return false;
+    if (binding.contractId !== params.contractId)
+        return false;
+    if (binding.invocationAttempt !== params.call.activationCount)
+        return false;
+    if (binding.sourceRevision !== params.expectedHead.revision)
+        return false;
+    if (!isFailureStepOwnedByContract(binding.modelStep, params.contractId))
+        return false;
+    const scope = params.call.roleId === "worker"
+        ? `worker:${params.call.callId}:request-tool-results`
+        : `role:${params.call.roleId}:${params.call.callId}:continuation`;
+    return binding.scopeId === scope;
+}
+function isFailureStepOwnedByContract(step, contract) {
+    if (step === "context.compact")
+        return true;
+    switch (contract) {
+        case "supervisor":
+            return step === "supervisor.decision" || step === "supervisor.response";
+        case "delegated.planner":
+            return step === "planner.decision";
+        case "delegated.worker":
+            return [
+                "worker.decision",
+                "worker.result",
+                "capability.controls",
+                "tool_payload.raw",
+            ].includes(step);
+        case "delegated.reviewer":
+            return step === "reviewer.decision";
+        default:
+            return false;
+    }
+}

package/dist/src/runtime/request/super-context-scope.d.ts

@@ -0,0 +1,9 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+/** Repeated parent-driven invocation cannot revive a quarantined owned scope. */
+export declare function requireLiveSuperContextScope(params: {
+    request: RequestExecutionScope;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    contractId: string;
+}): void;

package/dist/src/runtime/request/super-context-scope.js

@@ -0,0 +1,65 @@
+import { withSuperCompactionFailure } from "../context/super-compaction-failure-owner.js";
+import { createOwnedSuperContextFailure } from "../context/super-context-failure.js";
+import { InvalidatedCompactionScopeError, freezeCompactionInvalidation, } from "../context/semantic-compaction/scope-quarantine.js";
+import { assertSuperCompactionCheckpointBinding, assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, } from "../context/semantic-compaction/super-source-integrity.js";
+/** Repeated parent-driven invocation cannot revive a quarantined owned scope. */
+export function requireLiveSuperContextScope(params) {
+    const store = params.request.contextCompactionStore;
+    // Payload failures settle through the existing capability path. Re-check the
+    // canonical inventory at the fresh activation before any further inference.
+    if (store?.snapshot) {
+        const integrity = {
+            requestId: params.request.requestId,
+            prompt: params.request.prompt,
+            head: params.head,
+            store,
+        };
+        assertSuperCompactionSourceIntegrity(integrity);
+        for (const checkpoint of store.snapshot().checkpoints) {
+            const owner = checkpoint.callId === params.call.callId
+                ? {
+                    head: params.head,
+                    binding: {
+                        requestId: params.request.requestId,
+                        callId: params.call.callId,
+                        parentCallId: params.call.parentCallId,
+                        contractId: params.contractId,
+                        invocationAttempt: params.call.activationCount,
+                        sourceRevision: params.head.revision,
+                        modelStep: "context.compact",
+                        phase: "scope_preflight",
+                        scopeId: checkpoint.scopeId,
+                    },
+                }
+                : undefined;
+            withSuperCompactionFailure(owner, () => assertSuperCompactionCheckpointIntegrity({ ...integrity, checkpoint }));
+        }
+    }
+    const records = store?.snapshot?.().invalidatedScopes ?? [];
+    const record = records.find((candidate) => candidate.binding.callId === params.call.callId);
+    if (!record)
+        return;
+    const validated = freezeCompactionInvalidation(record);
+    assertSuperCompactionCheckpointBinding({
+        requestId: params.request.requestId,
+        prompt: params.request.prompt,
+        head: params.head,
+        checkpoint: { ...validated.binding, scopeId: validated.scopeId },
+    });
+    throw createOwnedSuperContextFailure({
+        code: "context_compaction_scope_invalidated",
+        head: params.head,
+        binding: {
+            requestId: params.request.requestId,
+            callId: params.call.callId,
+            parentCallId: params.call.parentCallId,
+            contractId: params.contractId,
+            invocationAttempt: params.call.activationCount,
+            sourceRevision: params.head.revision,
+            modelStep: "context.compact",
+            phase: "scope_reuse",
+            scopeId: validated.scopeId,
+        },
+        cause: new InvalidatedCompactionScopeError(validated),
+    });
+}

package/dist/src/runtime/request/super-failure-explanation.d.ts

@@ -0,0 +1,22 @@
+import type { RequestExecutionBudgets } from "../orchestration/lifecycle/execution-budgets.js";
+import type { DegradedFinalizationInput } from "../steps/degraded-finalization/contract.js";
+import { type SuperFailureExplanation } from "../steps/degraded-finalization/super.js";
+import type { RequestExecutionSeed } from "./contracts.js";
+import type { CompiledRequestExecutionPolicy } from "./execution-scope.js";
+export type SuperFailureFinalization = Readonly<{
+    agentMode: RequestExecutionSeed["agentMode"];
+    remember(error: unknown, stage: string): void;
+    primaryError(): unknown;
+    explain(params: {
+        error: unknown;
+        input: DegradedFinalizationInput;
+        maxResponseChars: number;
+        steeringVersion?: number;
+    }): Promise<SuperFailureExplanation>;
+}>;
+/** Activation-local authoring cache only; lifecycle/persistence stay with their owners. */
+export declare function createSuperFailureFinalization(params: {
+    request: RequestExecutionSeed;
+    executionPolicy: CompiledRequestExecutionPolicy;
+    readBudgets?: () => RequestExecutionBudgets;
+}): SuperFailureFinalization | undefined;

package/dist/src/runtime/request/super-failure-explanation.js

@@ -0,0 +1,77 @@
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { projectOutputLimitCause } from "../steps/degraded-finalization/output-limit-cause.js";
+import { boundedSuperFailureCode, createSuperFailureFallback, runSuperDegradedFinalization, } from "../steps/degraded-finalization/super.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+/** Activation-local authoring cache only; lifecycle/persistence stay with their owners. */
+export function createSuperFailureFinalization(params) {
+    if (!hasSuperContextContract(params.executionPolicy.authority, params.executionPolicy.rootContract.contractId))
+        return undefined;
+    const request = projectTrustedFailureRequest(params.request);
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    let primary;
+    let attempt;
+    const remember = (error, stage) => {
+        primary ??= Object.freeze({
+            error,
+            stage: boundedFailureStage(stage),
+            code: boundedSuperFailureCode(error),
+        });
+    };
+    return Object.freeze({
+        agentMode: request.agentMode,
+        remember,
+        primaryError: () => primary?.error,
+        async explain(input) {
+            remember(input.error, input.input.problem.stage);
+            const steeringVersion = input.steeringVersion ?? steering.snapshot().version;
+            const problem = {
+                stage: primary.stage,
+                code: primary.code,
+                ...projectOutputLimitCause(primary.error),
+            };
+            if (!attempt) {
+                // Install the promise before invoking model services or callbacks.
+                attempt = Promise.resolve().then(() => runSuperDegradedFinalization({
+                    request,
+                    input: { ...input.input, problem },
+                    maxResponseChars: input.maxResponseChars,
+                    steeringVersion,
+                    ...(params.readBudgets ? { readBudgets: params.readBudgets } : {}),
+                }));
+            }
+            const explanation = await attempt;
+            if (explanation.steeringVersion !== steeringVersion)
+                return createSuperFailureFallback({ problem, progress: null }, steeringVersion);
+            return explanation;
+        },
+    });
+}
+function projectTrustedFailureRequest(seed) {
+    return Object.freeze({
+        requestId: seed.requestId,
+        sessionId: seed.sessionId,
+        prompt: seed.prompt,
+        historyMessages: [],
+        shouldGenerateSessionTitle: false,
+        runnerConfig: seed.runnerConfig,
+        agentMode: seed.agentMode,
+        modelGatewayClient: seed.modelGatewayClient,
+        toolPermissionMode: seed.toolPermissionMode,
+        abortSignal: seed.abortSignal,
+        ...(seed.modelPreference ? { modelPreference: seed.modelPreference } : {}),
+        ...(seed.modelPolicy ? { modelPolicy: seed.modelPolicy } : {}),
+        ...(seed.modelInvocationScope
+            ? { modelInvocationScope: seed.modelInvocationScope }
+            : {}),
+        ...(seed.requestSteering ? { requestSteering: seed.requestSteering } : {}),
+        onAcknowledgement: () => undefined,
+        onSessionTitle: async () => undefined,
+        onAnswerToken: () => undefined,
+        onThinkingDelta: seed.onThinkingDelta,
+        onThinkingTrace: seed.onThinkingTrace,
+        onEvent: seed.onEvent,
+    });
+}
+function boundedFailureStage(stage) {
+    return /^[a-z][a-z0-9_.-]{0,119}$/iu.test(stage) ? stage : "request_failure";
+}

package/dist/src/runtime/request/super-failure-message.d.ts

@@ -0,0 +1,10 @@
+import type { SessionTerminalMessage } from "../../sessions/request-lifecycle/contracts.js";
+import type { SuperFailureFinalization } from "./super-failure-explanation.js";
+import type { RequestSteeringInbox } from "./request-steering.js";
+/** Presentation uses trusted request services only, never a failed role ledger. */
+export declare function composeSuperFailureMessage(params: {
+    requestId: string;
+    error: unknown;
+    finalization?: SuperFailureFinalization | undefined;
+    steering: RequestSteeringInbox;
+}): Promise<SessionTerminalMessage>;

package/dist/src/runtime/request/super-failure-message.js

@@ -0,0 +1,40 @@
+import { traceDebug } from "../observability/debug-logger.js";
+import { ROLE_CALL_RESPONSE_MAX_LENGTH } from "../orchestration/role-calls/index.js";
+import { projectOutputLimitCause } from "../steps/degraded-finalization/output-limit-cause.js";
+import { boundedSuperFailureCode, createSuperFailureFallback, } from "../steps/degraded-finalization/super.js";
+/** Presentation uses trusted request services only, never a failed role ledger. */
+export async function composeSuperFailureMessage(params) {
+    const input = {
+        problem: {
+            stage: "request_failure",
+            code: boundedSuperFailureCode(params.error),
+            ...projectOutputLimitCause(params.error),
+        },
+        progress: null,
+    };
+    const version = params.steering.snapshot().version;
+    const explanation = params.finalization
+        ? await params.finalization.explain({
+            error: params.error,
+            input,
+            maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
+            steeringVersion: version,
+        })
+        : createSuperFailureFallback(input, version);
+    const currentVersion = params.steering.snapshot().version;
+    const output = currentVersion === explanation.steeringVersion
+        ? explanation.output
+        : createSuperFailureFallback(input, currentVersion).output;
+    await params.steering.close();
+    traceDebug("runtime.request", "super.failure_message_prepared", {
+        requestId: params.requestId,
+        primaryCode: input.problem.code,
+        secondaryCode: explanation.secondaryCode,
+        source: currentVersion === explanation.steeringVersion
+            ? explanation.source
+            : "runtime_fallback",
+        route: "request_failure",
+        steeringVersion: currentVersion,
+    });
+    return { content: output, grounding: "conversation" };
+}

package/dist/src/runtime/request/super-payload-context-failure.d.ts

@@ -0,0 +1,11 @@
+import type { WorkerCapabilityPayloadModelRequest } from "../orchestration/worker-capabilities/payload-contracts.js";
+import type { RequestContextCompactionStore } from "../context/semantic-compaction/store.js";
+type PayloadRequest = Readonly<{
+    requestId: string;
+    prompt: string;
+    abortSignal: AbortSignal;
+    contextCompactionStore?: RequestContextCompactionStore;
+}>;
+/** Preserve normal failed-capability settlement; never create a role commit here. */
+export declare function quarantineOwnedSuperPayloadCheckpoint(request: PayloadRequest, input: WorkerCapabilityPayloadModelRequest, error: unknown): void;
+export {};

package/dist/src/runtime/request/super-payload-context-failure.js

@@ -0,0 +1,55 @@
+import { SuperContextFailure } from "../context/super-context-failure.js";
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { validateRoleCallCandidate } from "../orchestration/role-calls/reducer.js";
+import { quarantineProvenOwnedSuperCheckpoint } from "./super-checkpoint-quarantine.js";
+import { traceDebug } from "../observability/debug-logger.js";
+/** Preserve normal failed-capability settlement; never create a role commit here. */
+export function quarantineOwnedSuperPayloadCheckpoint(request, input, error) {
+    if (request.abortSignal.aborted || !(error instanceof SuperContextFailure))
+        return;
+    const sidecar = input.superWorkerCompaction;
+    if (!sidecar || !request.contextCompactionStore)
+        return;
+    const head = sidecar.head;
+    if (!hasSuperContextContract(head.policy.authority, "delegated.worker"))
+        return;
+    const call = head.state.calls.find((candidate) => candidate.callId === sidecar.callId);
+    if (!call || call.roleId !== "worker" || call.status !== "active")
+        return;
+    if (head.state.phase !== "running" || head.state.activeCallId !== call.callId)
+        return;
+    if (head.state.requestId !== request.requestId ||
+        sidecar.requestId !== request.requestId)
+        return;
+    if (sidecar.sourceRevision !== head.revision ||
+        sidecar.invocationAttempt !== call.activationCount)
+        return;
+    const binding = error.binding;
+    if (binding.requestId !== request.requestId || binding.callId !== call.callId)
+        return;
+    if (binding.parentCallId !== call.parentCallId ||
+        binding.contractId !== "delegated.worker")
+        return;
+    if (binding.sourceRevision !== head.revision ||
+        binding.invocationAttempt !== call.activationCount)
+        return;
+    if (binding.scopeId !== `worker:${call.callId}:request-tool-results` ||
+        binding.modelStep !== input.modelStep)
+        return;
+    if (validateRoleCallCandidate({ state: head.state, policy: head.policy }).length)
+        return;
+    const validation = quarantineProvenOwnedSuperCheckpoint({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        head,
+        store: request.contextCompactionStore,
+        scopeId: binding.scopeId,
+    });
+    if (validation)
+        traceDebug("runtime.context.compaction", "payload_checkpoint.quarantined", {
+            ...binding,
+            code: error.code,
+            validationCode: validation,
+            route: "settle_then_fresh_activation",
+        });
+}

package/dist/src/runtime/request/super-root-failure-finalization.d.ts

@@ -0,0 +1,23 @@
+import type { ModelOutputFailure } from "../model/invalid-output-failure.js";
+import { type RoleCallLedger, type RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+import type { RequestRunnerResult } from "./result.js";
+import type { SupervisorRootFailureStage } from "./supervisor-root-execution-diagnostics.js";
+/** A valid root transaction is separate from the outer failed request lifecycle. */
+export declare function finalizeSuperRootFailure(params: {
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    expectedHead: RoleCallLedgerHead | undefined;
+    failureStage: SupervisorRootFailureStage;
+    steeringVersion: number;
+    publishDeferredTitle?: (() => Promise<void>) | undefined;
+    error: unknown;
+    failure?: (ModelOutputFailure & Readonly<{
+        steeringVersion?: number;
+    }>) | undefined;
+}): Promise<Readonly<{
+    kind: "continue";
+}> | Readonly<{
+    kind: "complete";
+    result: RequestRunnerResult;
+}> | undefined>;

package/dist/src/runtime/request/super-root-failure-finalization.js

@@ -0,0 +1,112 @@
+import { SuperContextFailure } from "../context/super-context-failure.js";
+import { traceDebug } from "../observability/debug-logger.js";
+import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
+import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
+import { boundedSuperFailureCode, fitsSuperFailureResponse, } from "../steps/degraded-finalization/super.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+import { projectInvalidOutputProgress } from "./root-invalid-output-progress.js";
+import { commitSupervisorResponse } from "./root-response-commit.js";
+import { hasSafeSuperContextFailureReturn, hasSafeSuperContextState, } from "./super-context-failure-integrity.js";
+/** A valid root transaction is separate from the outer failed request lifecycle. */
+export async function finalizeSuperRootFailure(params) {
+    const finalization = params.request.superFailureFinalization;
+    if (!finalization)
+        return undefined;
+    params.request.abortSignal.throwIfAborted();
+    const steering = resolveRequestSteeringInbox(params.request.requestSteering);
+    const steeringVersion = params.failure?.steeringVersion ?? params.steeringVersion;
+    if (!steering.isCurrent(steeringVersion))
+        return { kind: "continue" };
+    finalization.remember(params.error, params.failure?.validationStage ?? params.failureStage);
+    const head = params.ledger.current();
+    const root = head.state.calls.find(({ callId }) => callId === head.state.rootCallId);
+    if (!canCommitSuperFailure(head, params.expectedHead, root))
+        return undefined;
+    if (!isOwnedSuperRootFailure(params, head, root))
+        return undefined;
+    const explanation = await finalization.explain({
+        error: params.error,
+        input: {
+            problem: {
+                stage: params.failure?.validationStage ?? params.failureStage,
+                code: boundedSuperFailureCode(params.error),
+            },
+            progress: projectInvalidOutputProgress(head),
+        },
+        maxResponseChars: head.policy.limits.maxResponseChars,
+        steeringVersion,
+    });
+    params.request.abortSignal.throwIfAborted();
+    if (!steering.isCurrent(steeringVersion))
+        return { kind: "continue" };
+    if (params.ledger.current() !== head)
+        throw params.error;
+    if (!isOwnedSuperRootFailure(params, head, root))
+        throw params.error;
+    if (!fitsSuperFailureResponse(explanation.output, head.policy.limits.maxResponseChars)) {
+        traceDebug("runtime.request", "super.failure_response_limit_invalid", {
+            requestId: params.request.requestId,
+            primaryCode: boundedSuperFailureCode(params.error),
+            secondaryCode: "degraded_finalization_response_limit_invalid",
+        });
+        throw params.error;
+    }
+    if (!steering.seal(steeringVersion))
+        return { kind: "continue" };
+    try {
+        await params.publishDeferredTitle?.();
+        params.request.abortSignal.throwIfAborted();
+        if (params.ledger.current() !== head)
+            throw params.error;
+        if (!isOwnedSuperRootFailure(params, head, root))
+            throw params.error;
+        const output = await commitSupervisorResponse({
+            transactions: resolveRoleCallTransactions(params.ledger),
+            expectedHead: head,
+            callId: root.callId,
+            response: explanation.output,
+        });
+        traceDebug("runtime.request", "super.failure_finalized", {
+            requestId: params.request.requestId,
+            callId: root.callId,
+            primaryCode: boundedSuperFailureCode(params.error),
+            source: explanation.source,
+            disposition: "blocked",
+        });
+        return { kind: "complete", result: { output, disposition: "blocked" } };
+    }
+    catch (error) {
+        params.request.abortSignal.throwIfAborted();
+        traceDebug("runtime.request", "super.failure_commit_failed", {
+            requestId: params.request.requestId,
+            primaryCode: boundedSuperFailureCode(params.error),
+            secondaryCode: boundedSuperFailureCode(error),
+        });
+        throw params.error;
+    }
+}
+function canCommitSuperFailure(head, expectedHead, root) {
+    if (head !== expectedHead)
+        return false;
+    if (!root || root.roleId !== RUNTIME_ROOT_ROLE_ID)
+        return false;
+    if (root.status !== "active")
+        return false;
+    if (head.state.activeCallId !== root.callId)
+        return false;
+    return head.state.phase === "running";
+}
+function isOwnedSuperRootFailure(params, head, root) {
+    const state = {
+        request: params.request,
+        ledger: params.ledger,
+        expectedHead: head,
+        call: root,
+        contractId: params.request.executionPolicy.rootContract.contractId,
+    };
+    if (params.failure)
+        return hasSafeSuperContextState(state);
+    if (!(params.error instanceof SuperContextFailure))
+        return false;
+    return hasSafeSuperContextFailureReturn({ ...state, error: params.error });
+}

package/dist/src/runtime/request/worker-capability-composition.d.ts

@@ -1,3 +1,5 @@
+import type { RuntimeModelPluginConfig } from "../config/model-plugin-config.js";
+import type { RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
@@ -7,7 +9,9 @@ import type { RequestCapabilityCompositionView, RequestCapabilityExecutionView }
 type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
     request: TRequest;
     requestWorkingDirectory?: string;
+    filesystemScope?: RuntimeFilesystemScope;
     executionPolicyAuthority?: ExecutionPolicyAuthoritySnapshot;
+    modelPlugins?: RuntimeModelPluginConfig;
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;
     toolRegistryOverride?: ToolRegistry;

package/dist/src/runtime/request/worker-capability-composition.js

@@ -16,6 +16,7 @@ export function createRequestWorkerCapabilityProvider(params) {
             request: params.request,
             requestWorkingDirectory: params.requestWorkingDirectory,
             toolPermissionMode: params.request.toolPermissionMode,
+            ...(params.modelPlugins ? { modelPlugins: params.modelPlugins } : {}),
             ...(params.requestAttachments
                 ? { requestAttachments: params.requestAttachments }
                 : {}),
@@ -41,7 +42,9 @@ export function createRequestWorkerCapabilityProvider(params) {
     const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
         requestId: params.request.requestId,
-        ...(params.request.toolResources ? { toolResources: params.request.toolResources } : {}),
+        ...(params.request.toolResources
+            ? { toolResources: params.request.toolResources }
+            : {}),
         sessionId: params.request.sessionId,
         requestContext: Object.freeze({
             agentMode: params.request.agentMode,
@@ -57,10 +60,13 @@ export function createRequestWorkerCapabilityProvider(params) {
                 toolApprovalController: params.request.toolApprovalController,
             }
             : {}),
-        payloadAuthor: createRequestWorkerCapabilityPayloadAuthor(params.request, params.executionPolicyAuthority?.capabilityAuthorities),
+        payloadAuthor: createRequestWorkerCapabilityPayloadAuthor(params.request, params.executionPolicyAuthority?.capabilityAuthorities, params.filesystemScope),
         loadActionSkillContext: (toolName) => getRequestSkillProvider().getActionContext(toolName),
         nextApprovalId: () => `approval:${randomUUID()}`,
         onEvent: params.request.onEvent,
+        ...(params.request.effectPersistence
+            ? { effectPersistence: params.request.effectPersistence }
+            : {}),
     });
     return Object.freeze({
         ...provider,

package/dist/src/runtime/request/worker-capability-payload.d.ts

@@ -1,7 +1,8 @@
+import { type RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import { type WorkerCapabilityPayloadAuthor } from "../orchestration/worker-capabilities/index.js";
 import type { ExecutionPolicyCapabilityAuthority } from "../orchestration/role-calls/index.js";
 import type { BoundRequestModelInvocationContext, RequestExecutionSeed } from "./contracts.js";
 type RequestWorkerCapabilityPayloadContext = BoundRequestModelInvocationContext & Pick<RequestExecutionSeed, "prompt" | "historyMessages" | "onEvent" | "contextCompactionStore">;
 /** Binds the neutral payload-author port to one request's model boundary. */
-export declare function createRequestWorkerCapabilityPayloadAuthor(request: RequestWorkerCapabilityPayloadContext, capabilityAuthorities?: readonly ExecutionPolicyCapabilityAuthority[]): WorkerCapabilityPayloadAuthor;
+export declare function createRequestWorkerCapabilityPayloadAuthor(request: RequestWorkerCapabilityPayloadContext, capabilityAuthorities?: readonly ExecutionPolicyCapabilityAuthority[], filesystemScope?: RuntimeFilesystemScope): WorkerCapabilityPayloadAuthor;
 export {};