@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/runtime/request/root-execution-kernel.js

@@ -1,11 +1,15 @@
 import { projectRequestToolResults } from "../context/request-tool-results.js";
 import { emitRuntimeStatus } from "../events/runtime-status.js";
+import { isModelStepSteeringSuperseded } from "../model/model-step-steering.js";
 import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
 import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
 import { createRoleCapabilityBinding, isWorkerCapabilityOperationSupervisionLimitError, projectWorkerCapabilityCatalogGroups, } from "../orchestration/worker-capabilities/index.js";
 import { runDegradedFinalization } from "../steps/degraded-finalization/run.js";
 import { projectRequestSteeringSnapshot, resolveRequestSteeringInbox, } from "./request-steering.js";
-import { traceSupervisorRootAcknowledgementPublished, traceSupervisorRootActivationFailed, traceSupervisorRootActivationStarted, traceSupervisorRootObservationHandoffBound, traceSupervisorRootInvocationSuperseded, traceSupervisorRootResponseSuperseded, } from "./supervisor-root-execution-diagnostics.js";
+import { traceSupervisorRootAcknowledgementPublished, traceSupervisorRootActivationFailed, traceSupervisorRootActivationStarted, traceSupervisorRootInvocationSuperseded, traceSupervisorRootResponseSuperseded, } from "./supervisor-root-execution-diagnostics.js";
+import { bindSupervisorObservationHandoff, projectSupervisorFinalObservation, } from "./root-observation-handoff.js";
+import { performRootMemoryRecall } from "./root-memory-recall.js";
+import { projectRootMemoryRecallMessage } from "../long-term-memory/recall-context.js";
 import { createPlainRootAuthoredResponse } from "../orchestration/final-response/authoring-contract.js";
 const CONTINUE_ROOT_EXECUTION = Object.freeze({
     kind: "continue",
@@ -40,7 +44,7 @@ class RootExecutionSession {
         this.requestSteering = resolveRequestSteeringInbox(params.request.requestSteering);
     }
     async run() {
-        // Every non-terminal decision consumes a ledger-bounded child call.
+        // Every accepted continuation reserves its next activation in the ledger.
         for (;;) {
             const control = await this.runActivation();
             if (control.kind === "complete") {
@@ -61,6 +65,10 @@ class RootExecutionSession {
             return await this.executeDecision(decisionActivation, attempt);
         }
         catch (error) {
+            if (isModelStepSteeringSuperseded(error)) {
+                this.traceResponseSuperseded(error.boundSteeringVersion, "after_response");
+                return CONTINUE_ROOT_EXECUTION;
+            }
             traceSupervisorRootActivationFailed({
                 diagnostic: this.diagnostic,
                 failureStage: attempt.failureStage,
@@ -107,6 +115,11 @@ class RootExecutionSession {
         const decisionOutcome = await this.policy.rootContract.decide(this.request, {
             head: activation.head,
             callFrame: activation.call,
+            memoryRecallMessage: projectRootMemoryRecallMessage({
+                head: activation.head,
+                callId: activation.call.callId,
+                steeringVersion: this.requestSteering.snapshot().version,
+            }),
             call: activation.callIdentity,
             toolResults: decisionToolResults,
             includeAcknowledgement: this.resume === undefined && !this.acknowledgementPublished,
@@ -163,6 +176,18 @@ class RootExecutionSession {
     }
     async executeDecision(activation, attempt) {
         const { decision } = activation;
+        if (decision.action === "recall_memory") {
+            attempt.failureStage = "recall_memory";
+            await performRootMemoryRecall({
+                request: this.request,
+                ledger: this.ledger,
+                head: activation.head,
+                call: activation.call,
+                steeringVersion: activation.decisionSteeringVersion,
+                query: decision.query,
+            });
+            return CONTINUE_ROOT_EXECUTION;
+        }
         if (decision.action === "invoke_role") {
             return this.invokeRole(activation, decision, attempt);
         }
@@ -379,6 +404,12 @@ class RootExecutionSession {
         const authoredResponse = decision.action === "blocked"
             ? createPlainRootAuthoredResponse(decision.response)
             : await this.policy.rootContract.authorResponse(this.request, {
+                responseRecommendation: decision.responseRecommendation,
+                memoryRecallMessage: projectRootMemoryRecallMessage({
+                    head: activation.head,
+                    callId: activation.call.callId,
+                    steeringVersion: activation.decisionSteeringVersion,
+                }),
                 head: activation.head,
                 callFrame: activation.call,
                 steeringVersion: activation.decisionSteeringVersion,
@@ -470,41 +501,6 @@ function createRootExecutionFreshness(params) {
         isCurrent: () => params.requestSteering.isCurrent(snapshot.version),
     });
 }
-function bindSupervisorObservationHandoff(params) {
-    const { callerCallId, childCallId, resultRef } = params.returnCommit.effect;
-    if (params.resume.callerCallId !== callerCallId ||
-        params.resume.returnedChildCallId !== childCallId ||
-        params.resume.returnedResultRef !== resultRef ||
-        !params.resume.completedChildren.some((child) => child.callerCallId === callerCallId &&
-            child.childCallId === childCallId &&
-            child.resultRef === resultRef)) {
-        throw new Error("supervisor_observation_handoff_source_invalid");
-    }
-    const handoff = Object.freeze({
-        callerCallId,
-        childCallId,
-        resultRef,
-        finalObservation: params.finalObservation,
-    });
-    traceSupervisorRootObservationHandoffBound({
-        diagnostic: params.diagnostic,
-        callerCallId,
-        childCallId,
-        resultRef,
-        replaced: params.replaced,
-        observationContentLength: params.finalObservation.observationContent.length,
-    });
-    return handoff;
-}
-function projectSupervisorFinalObservation(handoff, resume) {
-    if (resume?.callerCallId !== handoff.callerCallId ||
-        !resume.completedChildren.some((child) => child.callerCallId === handoff.callerCallId &&
-            child.childCallId === handoff.childCallId &&
-            child.resultRef === handoff.resultRef)) {
-        throw new Error("supervisor_observation_handoff_source_invalid");
-    }
-    return handoff.finalObservation;
-}
 function emitSupervisorResumeStatus(request) {
     emitRuntimeStatus(request, {
         stage: "supervisor",

package/dist/src/runtime/request/root-memory-recall.d.ts

@@ -0,0 +1,11 @@
+import { type RoleCallFrame, type RoleCallLedger, type RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+/** One service invocation, one canonical settlement, then the existing root loop resumes. */
+export declare function performRootMemoryRecall(params: {
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    steeringVersion: number;
+    query: string;
+}): Promise<void>;

package/dist/src/runtime/request/root-memory-recall.js

@@ -0,0 +1,71 @@
+import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
+import { boundMemoryRecallResult, unavailableMemoryRecall, } from "../long-term-memory/recall-result.js";
+import { classifyMemoryFailure } from "../long-term-memory/diagnostics.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+/** One service invocation, one canonical settlement, then the existing root loop resumes. */
+export async function performRootMemoryRecall(params) {
+    const { request } = params;
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    request.abortSignal.throwIfAborted();
+    if (!steering.isCurrent(params.steeringVersion))
+        return;
+    if (request.longTermMemory?.enabled !== true) {
+        throw new Error("memory_recall_not_available");
+    }
+    const transactions = resolveRoleCallTransactions(params.ledger);
+    const started = await transactions.beginMemoryRecall({
+        expectedHead: params.head,
+        callId: params.call.callId,
+        invocationAttempt: params.call.activationCount,
+        steeringVersion: params.steeringVersion,
+        query: params.query,
+    });
+    if (!started.ok) {
+        throw new Error(`role_call_ledger_rejected:${started.issueCode}`);
+    }
+    request.abortSignal.throwIfAborted();
+    const retrieved = steering.isCurrent(params.steeringVersion)
+        ? await retrieveRootMemory(params)
+        : supersededMemoryRecall();
+    request.abortSignal.throwIfAborted();
+    const result = steering.isCurrent(params.steeringVersion)
+        ? retrieved
+        : supersededMemoryRecall();
+    const settled = await transactions.settleMemoryRecall({
+        expectedHead: started.commit.head,
+        callId: params.call.callId,
+        recallId: started.commit.effect.recallId,
+        invocationAttempt: params.call.activationCount,
+        steeringVersion: params.steeringVersion,
+        result,
+    });
+    if (!settled.ok) {
+        throw new Error(`role_call_ledger_rejected:${settled.issueCode}`);
+    }
+}
+async function retrieveRootMemory(params) {
+    const { request } = params;
+    try {
+        return boundMemoryRecallResult(await request.longTermMemory.retrieve({
+            query: params.query,
+            context: {
+                requestId: request.requestId,
+                sessionId: request.sessionId,
+                abortSignal: request.abortSignal,
+                onEvent: request.onEvent,
+            },
+        }));
+    }
+    catch (error) {
+        if (request.abortSignal.aborted)
+            throw error;
+        return unavailableMemoryRecall(classifyMemoryFailure(error));
+    }
+}
+function supersededMemoryRecall() {
+    return Object.freeze({
+        outcome: "superseded",
+        records: Object.freeze([]),
+        omittedRecordCount: 0,
+    });
+}

package/dist/src/runtime/request/root-observation-handoff.d.ts

@@ -0,0 +1,17 @@
+import type { RoleCallChildReturnCommit, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
+import type { RequestObservation } from "./result.js";
+import { type SupervisorRootDiagnosticContext } from "./supervisor-root-execution-diagnostics.js";
+export type RootObservationHandoff = Readonly<{
+    callerCallId: string;
+    childCallId: string;
+    resultRef: string;
+    finalObservation: RequestObservation;
+}>;
+export declare function bindSupervisorObservationHandoff(params: {
+    diagnostic: SupervisorRootDiagnosticContext;
+    returnCommit: RoleCallChildReturnCommit;
+    resume: RoleChildReturnContext;
+    finalObservation: RequestObservation;
+    replaced: boolean;
+}): RootObservationHandoff;
+export declare function projectSupervisorFinalObservation(handoff: RootObservationHandoff, resume: RoleChildReturnContext | undefined): RequestObservation;

package/dist/src/runtime/request/root-observation-handoff.js

@@ -0,0 +1,44 @@
+import { traceSupervisorRootObservationHandoffBound, } from "./supervisor-root-execution-diagnostics.js";
+export function bindSupervisorObservationHandoff(params) {
+    const { callerCallId, childCallId, resultRef } = params.returnCommit.effect;
+    const source = { callerCallId, childCallId, resultRef };
+    if (!hasBoundObservationReturn(params.resume, source)) {
+        throw new Error("supervisor_observation_handoff_source_invalid");
+    }
+    const handoff = Object.freeze({
+        ...source,
+        finalObservation: params.finalObservation,
+    });
+    traceSupervisorRootObservationHandoffBound({
+        diagnostic: params.diagnostic,
+        ...source,
+        replaced: params.replaced,
+        observationContentLength: params.finalObservation.observationContent.length,
+    });
+    return handoff;
+}
+export function projectSupervisorFinalObservation(handoff, resume) {
+    if (!hasObservationSource(resume, handoff)) {
+        throw new Error("supervisor_observation_handoff_source_invalid");
+    }
+    return handoff.finalObservation;
+}
+function hasBoundObservationReturn(resume, source) {
+    if (resume.returnedChildCallId !== source.childCallId)
+        return false;
+    if (resume.returnedResultRef !== source.resultRef)
+        return false;
+    return hasObservationSource(resume, source);
+}
+function hasObservationSource(resume, source) {
+    if (resume?.callerCallId !== source.callerCallId)
+        return false;
+    return resume.completedChildren.some((child) => hasObservationIdentity(child, source));
+}
+function hasObservationIdentity(child, source) {
+    if (child.callerCallId !== source.callerCallId)
+        return false;
+    if (child.childCallId !== source.childCallId)
+        return false;
+    return child.resultRef === source.resultRef;
+}

package/dist/src/runtime/request/scheduled-execution.d.ts

@@ -0,0 +1,9 @@
+import type { ScheduleMessageReference } from "../../sessions/schedule-metadata.js";
+import type { RuntimeRequestOptions } from "../composition.js";
+import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { RequestHandlerOptions } from "./contracts.js";
+export declare function withScheduledExecution(options: RuntimeRequestOptions | undefined, run: SchedulerRun): RuntimeRequestOptions;
+export declare function resolveScheduledExecution(options: RequestHandlerOptions, identity: {
+    requestId: string;
+    sessionId: string;
+}): ScheduleMessageReference | undefined;

package/dist/src/runtime/request/scheduled-execution.js

@@ -0,0 +1,32 @@
+// Only scheduler-owned execution can mint this option. It survives host option
+// spreads but cannot be supplied by a decoded public request or RPC payload.
+const scheduledExecution = Symbol("scheduledExecution");
+export function withScheduledExecution(options, run) {
+    const captured = Object.freeze({
+        requestId: run.requestId,
+        sessionId: run.sessionId,
+        reference: Object.freeze({
+            jobId: run.jobId,
+            runId: run.id,
+            title: run.title,
+            scheduledAt: run.scheduledAt,
+            triggerType: run.trigger,
+        }),
+    });
+    const bound = {
+        ...options,
+        [scheduledExecution]: captured,
+    };
+    return bound;
+}
+export function resolveScheduledExecution(options, identity) {
+    const captured = options[scheduledExecution];
+    if (!captured)
+        return undefined;
+    const matchesRequest = captured.requestId === identity.requestId;
+    const matchesSession = captured.sessionId === identity.sessionId;
+    if (!matchesRequest || !matchesSession) {
+        throw new Error("scheduled_request_identity_mismatch");
+    }
+    return captured.reference;
+}

package/dist/src/runtime/request/session-admission.d.ts

@@ -0,0 +1,17 @@
+/** Coordinates background admission with requests from every environment caller. */
+export declare class SessionRequestAdmission {
+    private readonly isDeleted;
+    private readonly active;
+    private readonly reserved;
+    private readonly waiters;
+    private readonly idleWaiters;
+    private closed;
+    constructor(isDeleted: (sessionId: string) => boolean);
+    tryReserve(sessionId: string): (() => void) | null;
+    run<T>(sessionId: string, execute: () => Promise<T>): Promise<T>;
+    close(): void;
+    whenIdle(): Promise<void>;
+    private requireOpenAdmission;
+    isIdle(): boolean;
+    private notifyIdle;
+}

package/dist/src/runtime/request/session-admission.js

@@ -0,0 +1,88 @@
+/** Coordinates background admission with requests from every environment caller. */
+export class SessionRequestAdmission {
+    isDeleted;
+    active = new Map();
+    reserved = new Set();
+    waiters = new Map();
+    idleWaiters = new Set();
+    closed = false;
+    constructor(isDeleted) {
+        this.isDeleted = isDeleted;
+    }
+    tryReserve(sessionId) {
+        if (this.closed)
+            return null;
+        if (this.isDeleted(sessionId))
+            return null;
+        if (this.reserved.has(sessionId))
+            return null;
+        if ((this.active.get(sessionId) ?? 0) > 0)
+            return null;
+        this.reserved.add(sessionId);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.reserved.delete(sessionId);
+            for (const notify of this.waiters.get(sessionId) ?? [])
+                notify();
+            this.waiters.delete(sessionId);
+            this.notifyIdle();
+        };
+    }
+    async run(sessionId, execute) {
+        this.requireOpenAdmission();
+        while (this.reserved.has(sessionId)) {
+            await new Promise((resolve) => {
+                const waiting = this.waiters.get(sessionId) ?? new Set();
+                waiting.add(resolve);
+                this.waiters.set(sessionId, waiting);
+            });
+            this.requireOpenAdmission();
+        }
+        if (this.isDeleted(sessionId))
+            throw new Error("session_deleted");
+        this.active.set(sessionId, (this.active.get(sessionId) ?? 0) + 1);
+        try {
+            return await execute();
+        }
+        finally {
+            const remaining = (this.active.get(sessionId) ?? 1) - 1;
+            if (remaining > 0)
+                this.active.set(sessionId, remaining);
+            else
+                this.active.delete(sessionId);
+            this.notifyIdle();
+        }
+    }
+    close() {
+        this.closed = true;
+        for (const waiting of this.waiters.values()) {
+            for (const notify of waiting)
+                notify();
+        }
+        this.waiters.clear();
+    }
+    whenIdle() {
+        if (this.isIdle())
+            return Promise.resolve();
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    requireOpenAdmission() {
+        if (this.closed)
+            throw new Error("runtime_request_admission_closed");
+    }
+    isIdle() {
+        if (this.active.size > 0)
+            return false;
+        return this.reserved.size === 0;
+    }
+    notifyIdle() {
+        if (!this.isIdle())
+            return;
+        for (const notify of this.idleWaiters)
+            notify();
+        this.idleWaiters.clear();
+    }
+}

package/dist/src/runtime/request/supervisor-root-execution-diagnostics.d.ts

@@ -1,6 +1,6 @@
 import type { RoleCallFrame, RoleCallLedgerHead, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
 import type { RuntimeDelegateRoleId } from "../orchestration/roles.js";
-export type SupervisorRootFailureStage = "project_activation" | "project_worker_catalog" | "decide" | "publish_title" | "publish_acknowledgement" | "apply_root_transition" | "invoke_child" | "project_resume" | "bind_observation" | "project_observation" | "compose_response" | "seal_response" | "commit_response";
+export type SupervisorRootFailureStage = "project_activation" | "project_worker_catalog" | "decide" | "recall_memory" | "publish_title" | "publish_acknowledgement" | "apply_root_transition" | "invoke_child" | "project_resume" | "bind_observation" | "project_observation" | "compose_response" | "seal_response" | "commit_response";
 export type SupervisorRootDiagnosticContext = Readonly<{
     requestId: string;
     allowedRoleIds: readonly RuntimeDelegateRoleId[];

package/dist/src/runtime/request/supervisor-root-execution.js

@@ -11,18 +11,26 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
     async decide(request, options) {
         return runSupervisorDecision(request, {
             call: options.call,
+            memoryRecallCount: options.head.state.memoryRecalls.length,
             toolResults: options.toolResults,
             includeAcknowledgement: options.includeAcknowledgement,
             includeTitle: options.includeTitle,
             allowedRoleIds: options.allowedRoleIds,
             availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
+            ...(options.memoryRecallMessage
+                ? { memoryRecallMessage: options.memoryRecallMessage }
+                : {}),
             ...(options.resume ? { resume: options.resume } : {}),
         });
     },
     async authorResponse(request, options) {
         return runSupervisorAuthoredResponse(request, {
+            responseRecommendation: options.responseRecommendation,
             call: options.call,
             toolResults: options.toolResults,
+            ...(options.memoryRecallMessage
+                ? { memoryRecallMessage: options.memoryRecallMessage }
+                : {}),
             steeringSnapshot: projectRequestSteeringSnapshot(request.requestSteering, options.steeringVersion),
             ...(options.resume ? { resume: options.resume } : {}),
         });

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

@@ -1,6 +1,7 @@
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
+import { type ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 import type { ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-calls/index.js";
 import type { RequestCapabilityCompositionView, RequestCapabilityExecutionView } from "./execution-scope.js";
 type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
@@ -14,5 +15,5 @@ type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
  * Creates one lazy, request-scoped Worker capability source from declarative
  * role config and the neutral runtime Tool Registry.
  */
-export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & ToolAvailabilitySource;
 export {};

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

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { createBundledPluginSkillProvider, createConfiguredSkillProvider, } from "../adapters/configured-skill-provider.js";
 import { createRegisteredToolWorkerCapabilityProvider } from "../adapters/registered-tool-worker-capabilities.js";
 import { createRequestRuntimeToolRegistry } from "../capabilities/request-runtime-tool-registry.js";
+import { projectAvailableTools, } from "../capabilities/tool-availability.js";
 import { createRequestWorkerCapabilityPayloadAuthor } from "./worker-capability-payload.js";
 /**
  * Creates one lazy, request-scoped Worker capability source from declarative
@@ -35,7 +36,7 @@ export function createRequestWorkerCapabilityProvider(params) {
         }
         return requestSkillProvider;
     }
-    return createRegisteredToolWorkerCapabilityProvider({
+    const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
         requestId: params.request.requestId,
         sessionId: params.request.sessionId,
@@ -58,4 +59,8 @@ export function createRequestWorkerCapabilityProvider(params) {
         nextApprovalId: () => `approval:${randomUUID()}`,
         onEvent: params.request.onEvent,
     });
+    return Object.freeze({
+        ...provider,
+        getAvailableTools: () => projectAvailableTools(getRequestToolRegistry().listNormalInvocations?.()),
+    });
 }

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

@@ -138,13 +138,15 @@ function payloadMessages(request, input) {
             : {}),
         ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
     });
-    const requestSource = projectRequestSource({
-        requestId: request.requestId,
-        prompt: request.prompt,
-        modelStep: input.modelStep,
-        callId,
-        historyMessages: request.historyMessages,
-    });
+    const requestSource = input.requestSourceProjection === "full_request"
+        ? projectRequestSource({
+            requestId: request.requestId,
+            prompt: request.prompt,
+            modelStep: input.modelStep,
+            callId,
+            historyMessages: request.historyMessages,
+        })
+        : undefined;
     const projectedContext = projectPayloadContext(input.context);
     traceDebug("runtime.worker_capability_payload_context", "projected", {
         requestId: request.requestId,
@@ -156,6 +158,7 @@ function payloadMessages(request, input) {
         relatedArtifactContextCount: projectedContext.relatedArtifactMessages.length,
         sourceRelatedArtifactContextCount: input.context.relatedArtifactContexts?.length ?? 0,
         hasTargetContext: input.context.targetContext !== undefined,
+        requestSourceProjection: input.requestSourceProjection,
     });
     try {
         return projectRequestContext({
@@ -163,7 +166,7 @@ function payloadMessages(request, input) {
             historyMessages: [],
             prompt: `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`,
             referenceMessages: [
-                buildRequestSourceMessage(requestSource),
+                ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
                 ...projectedContext.relatedArtifactMessages,
             ],
             ...(projectedContext.targetContentMessage

package/dist/src/runtime/runtime-environment.d.ts

@@ -0,0 +1,31 @@
+import { SessionRequestAdmission } from "./request/session-admission.js";
+import type { EventSinkFactory, RuntimeConfig } from "./ports.js";
+import type { RuntimeApplicationOverrides, RuntimeEnvironmentServices } from "./composition.js";
+export declare function createRuntimeEnvironment(config: RuntimeConfig, overrides?: RuntimeApplicationOverrides): {
+    services: Readonly<{
+        config: RuntimeConfig;
+        sessions: import("./ports.js").SessionStore;
+        attachments: import("./index.js").RuntimeAttachmentStore;
+        tools: import("./ports.js").ToolRegistry;
+        models: import("./ports.js").ModelGatewayClient;
+        events: EventSinkFactory;
+        sessionMemoryCompactor: import("./context/session-memory/contracts.js").SessionMemoryCompactor;
+        longTermMemory: import("./index.js").LongTermMemoryService;
+        scheduler?: import("./index.js").SchedulerService;
+        startScheduler?: () => Promise<void>;
+        stopScheduler?: () => Promise<void>;
+        requestAdmission?: SessionRequestAdmission;
+    }>;
+    requests: Readonly<{
+        steer?: (requestId: string, input: Readonly<{
+            steerId: string;
+            text: string;
+        }>) => Promise<import("./request/request-steering.js").RequestSteeringAppendResult>;
+        handle: (ws: import("ws").default, message: import("./request/contracts.js").RunRequestMessage, options?: import("./composition.js").RuntimeRequestOptions) => Promise<void>;
+    }>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    subscribeScheduledEvents: (listener: (event: import("./adapters/scheduled-request-outcome.js").ScheduledRequestEvent) => void) => () => void;
+};
+export declare function recomposeRuntimeEnvironment(config: RuntimeConfig, bound: RuntimeEnvironmentServices | undefined, resolved: RuntimeApplicationOverrides): RuntimeEnvironmentServices;
+export declare function rebindRuntimeEnvironmentEvents(bound: RuntimeEnvironmentServices, events: EventSinkFactory): RuntimeEnvironmentServices | undefined;