@abot-ai/runtime 1.0.0

package/dist/src/runtime/steps/supervisor-decision/run.js

@@ -0,0 +1,221 @@
+import { invokeStructuredModelStep, StructuredModelInvalidOutputError, } from "../../model/invoke-structured-step.js";
+import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
+import { createSessionMemoryAwareCompactionController } from "../../context/session-memory/index.js";
+import { resolveRequestSteeringInbox, } from "../../request/request-steering.js";
+import { SUPERVISOR_DECISION_MODEL_STEP, } from "./contracts.js";
+import { traceSupervisorDecisionPhaseSuperseded, traceSupervisorModelCompleted, traceSupervisorModelFailed, traceSupervisorModelStarted, traceSupervisorWorkingDirectoryModelStarted, } from "./diagnostics.js";
+import { buildSupervisorDecisionInput } from "./input.js";
+import { parseSupervisorDecisionOutput } from "./parser.js";
+import { buildSupervisorWorkingDirectoryInput, mergeSupervisorWorkingDirectory, parseSupervisorWorkingDirectoryOutput, } from "./working-directory.js";
+import { SUPERVISOR_RESPONSE_MODEL_STEP } from "../supervisor-response/contracts.js";
+export async function runSupervisorDecision(request, options) {
+    const baseDiagnostic = {
+        requestId: request.requestId,
+        modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+        ...options.call,
+    };
+    const routingDiagnostic = Object.freeze({
+        ...baseDiagnostic,
+        decisionPhase: "routing",
+    });
+    const workingDirectoryDiagnostic = Object.freeze({
+        ...baseDiagnostic,
+        decisionPhase: "working_directory",
+    });
+    const input = buildSupervisorDecisionInput(request, {
+        toolResults: options.toolResults,
+        ...(options.includeAcknowledgement === undefined
+            ? {}
+            : { includeAcknowledgement: options.includeAcknowledgement }),
+        ...(options.includeTitle === undefined
+            ? {}
+            : { includeTitle: options.includeTitle }),
+        ...(options.allowedRoleIds === undefined
+            ? {}
+            : { allowedRoleIds: options.allowedRoleIds }),
+        ...(options.resume === undefined ? {} : { resume: options.resume }),
+        ...(options.workerCapabilityAffordances === undefined
+            ? {}
+            : {
+                workerCapabilityAffordances: options.workerCapabilityAffordances,
+            }),
+        ...(options.availableWorkerCapabilityCatalog === undefined
+            ? {}
+            : {
+                availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
+            }),
+        diagnostic: routingDiagnostic,
+    });
+    const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
+    const contextCompaction = createSessionMemoryAwareCompactionController(request, createModelStepCompactionController(request, {
+        call: {
+            roleId: "supervisor",
+            callId: options.call.callId,
+            objective: request.prompt,
+        },
+        sourceRevision: options.toolResults.sourceRevision,
+        allowedConsumers: Object.freeze([
+            SUPERVISOR_DECISION_MODEL_STEP,
+            SUPERVISOR_RESPONSE_MODEL_STEP,
+        ]),
+    }));
+    for (;;) {
+        const routing = await runRoutingPhase({
+            request,
+            requestSteering,
+            input,
+            diagnostic: routingDiagnostic,
+            contextCompaction,
+        });
+        if (!requiresWorkingDirectory(routing.decision)) {
+            return createDecisionOutcome(routing.decision, routing.steeringVersion);
+        }
+        if (!requestSteering.isCurrent(routing.steeringVersion)) {
+            tracePhaseSuperseded({
+                diagnostic: workingDirectoryDiagnostic,
+                requestSteering,
+                routingSteeringVersion: routing.steeringVersion,
+                checkpoint: "before_working_directory",
+            });
+            continue;
+        }
+        const workingDirectoryInput = buildSupervisorWorkingDirectoryInput(input.context, {
+            frozenDecision: routing.decision,
+            diagnostic: workingDirectoryDiagnostic,
+        });
+        const workingDirectory = await runWorkingDirectoryPhase({
+            request,
+            requestSteering,
+            input: workingDirectoryInput,
+            frozenDecision: routing.decision,
+            diagnostic: workingDirectoryDiagnostic,
+            contextCompaction,
+        });
+        const merged = mergeSupervisorWorkingDirectory(routing.decision, workingDirectory.decision);
+        if (workingDirectory.steeringVersion !== routing.steeringVersion ||
+            !requestSteering.isCurrent(workingDirectory.steeringVersion)) {
+            tracePhaseSuperseded({
+                diagnostic: workingDirectoryDiagnostic,
+                requestSteering,
+                routingSteeringVersion: routing.steeringVersion,
+                workingDirectorySteeringVersion: workingDirectory.steeringVersion,
+                checkpoint: "after_working_directory",
+            });
+            continue;
+        }
+        return createDecisionOutcome(merged, workingDirectory.steeringVersion);
+    }
+}
+function createDecisionOutcome(decision, steeringVersion) {
+    return Object.freeze({ decision, steeringVersion });
+}
+async function runRoutingPhase(params) {
+    const startedAt = Date.now();
+    traceSupervisorModelStarted({
+        diagnostic: params.diagnostic,
+        messageCount: params.input.context.messages.length,
+        messageCharacterCount: params.input.context.messages.reduce((total, message) => total + message.content.length, 0),
+        includeAcknowledgement: params.input.includeAcknowledgement,
+        includeTitle: params.input.includeTitle,
+        allowedRoleIds: params.input.allowedRoleIds,
+        availableWorkerCapabilityCatalog: params.input.availableWorkerCapabilityCatalog,
+    });
+    try {
+        const accepted = await invokeStructuredModelStep({
+            request: params.request,
+            modelStep: params.input.modelStep,
+            format: params.input.format,
+            messages: params.input.context.messages,
+            contextCompaction: params.contextCompaction,
+            timeoutReason: "supervisor_decision_timeout",
+            invalidOutputReason: "invalid_supervisor_decision",
+            parse: (text) => captureAcceptedPhase(parseSupervisorDecisionOutput(text, {
+                includeAcknowledgement: params.input.includeAcknowledgement,
+                includeTitle: params.input.includeTitle,
+                allowedRoleIds: params.input.allowedRoleIds,
+                availableWorkerCapabilityCatalog: params.input.availableWorkerCapabilityCatalog,
+                diagnostic: params.diagnostic,
+            }), params.requestSteering),
+        });
+        traceSupervisorModelCompleted({
+            diagnostic: params.diagnostic,
+            decision: accepted.decision,
+            durationMs: Date.now() - startedAt,
+        });
+        return accepted;
+    }
+    catch (error) {
+        tracePhaseFailure(params.diagnostic, startedAt, error);
+        throw error;
+    }
+}
+async function runWorkingDirectoryPhase(params) {
+    const startedAt = Date.now();
+    traceSupervisorWorkingDirectoryModelStarted({
+        diagnostic: params.diagnostic,
+        messageCount: params.input.messages.length,
+        messageCharacterCount: params.input.messages.reduce((total, message) => total + message.content.length, 0),
+        frozenDecision: params.frozenDecision,
+    });
+    try {
+        const accepted = await invokeStructuredModelStep({
+            request: params.request,
+            modelStep: params.input.modelStep,
+            format: params.input.format,
+            messages: params.input.messages,
+            contextCompaction: params.contextCompaction,
+            timeoutReason: "supervisor_decision_timeout",
+            invalidOutputReason: "invalid_supervisor_decision",
+            parse: (text) => captureAcceptedPhase(parseSupervisorWorkingDirectoryOutput(text, {
+                diagnostic: params.diagnostic,
+            }), params.requestSteering),
+        });
+        traceSupervisorModelCompleted({
+            diagnostic: params.diagnostic,
+            decision: mergeSupervisorWorkingDirectory(params.frozenDecision, accepted.decision),
+            durationMs: Date.now() - startedAt,
+        });
+        return accepted;
+    }
+    catch (error) {
+        tracePhaseFailure(params.diagnostic, startedAt, error);
+        throw error;
+    }
+}
+function captureAcceptedPhase(parsed, requestSteering) {
+    if (!parsed.ok) {
+        return parsed;
+    }
+    return Object.freeze({
+        ok: true,
+        decision: Object.freeze({
+            decision: parsed.decision,
+            steeringVersion: requestSteering.snapshot().version,
+        }),
+    });
+}
+function requiresWorkingDirectory(decision) {
+    return (decision.action === "invoke_role" &&
+        (decision.roleId === "planner" || decision.roleId === "worker"));
+}
+function tracePhaseFailure(diagnostic, startedAt, error) {
+    traceSupervisorModelFailed({
+        diagnostic,
+        durationMs: Date.now() - startedAt,
+        errorType: error instanceof Error && error.name ? error.name : typeof error,
+        invalidStructuredOutput: error instanceof StructuredModelInvalidOutputError,
+    });
+}
+function tracePhaseSuperseded(params) {
+    traceSupervisorDecisionPhaseSuperseded({
+        diagnostic: params.diagnostic,
+        routingSteeringVersion: params.routingSteeringVersion,
+        currentSteeringVersion: params.requestSteering.snapshot().version,
+        ...(params.workingDirectorySteeringVersion === undefined
+            ? {}
+            : {
+                workingDirectorySteeringVersion: params.workingDirectorySteeringVersion,
+            }),
+        checkpoint: params.checkpoint,
+    });
+}

package/dist/src/runtime/steps/supervisor-decision/worker-affordances.d.ts

@@ -0,0 +1,7 @@
+import type { WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+import type { SupervisorWorkerCapabilityAffordance } from "./contracts.js";
+/**
+ * Projects only the facts the Supervisor needs to decide whether Worker can
+ * own the next outcome. Execution identity and controls remain Worker-private.
+ */
+export declare function projectSupervisorWorkerCapabilityAffordances(descriptors: readonly WorkerCapabilityDescriptor[]): readonly SupervisorWorkerCapabilityAffordance[];

package/dist/src/runtime/steps/supervisor-decision/worker-affordances.js

@@ -0,0 +1,10 @@
+/**
+ * Projects only the facts the Supervisor needs to decide whether Worker can
+ * own the next outcome. Execution identity and controls remain Worker-private.
+ */
+export function projectSupervisorWorkerCapabilityAffordances(descriptors) {
+    return Object.freeze(descriptors.map((descriptor) => Object.freeze({
+        purpose: descriptor.summary,
+        effect: descriptor.effect,
+    })));
+}

package/dist/src/runtime/steps/supervisor-decision/working-directory.d.ts

@@ -0,0 +1,17 @@
+import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import { SUPERVISOR_DECISION_MODEL_STEP, type SupervisorDecision, type SupervisorDecisionDiagnosticContext, type SupervisorWorkingDirectoryDecision, type SupervisorWorkingDirectoryParseResult, type SupervisorWorkingDirectoryRoutingDecision } from "./contracts.js";
+export declare const SUPERVISOR_FROZEN_INVOCATION_KIND: "runtime_supervisor_frozen_invocation_v1";
+export declare function createSupervisorWorkingDirectoryFormat(): ModelGatewayJsonSchemaFormat;
+export declare function buildSupervisorWorkingDirectoryInput(sourceContext: RequestContextProjection, options: Readonly<{
+    frozenDecision: SupervisorWorkingDirectoryRoutingDecision;
+    diagnostic?: SupervisorDecisionDiagnosticContext;
+}>): Readonly<{
+    messages: ChatMessage[];
+    format: ModelGatewayJsonSchemaFormat;
+    modelStep: typeof SUPERVISOR_DECISION_MODEL_STEP;
+}>;
+export declare function parseSupervisorWorkingDirectoryOutput(text: string, options?: Readonly<{
+    diagnostic?: SupervisorDecisionDiagnosticContext;
+}>): SupervisorWorkingDirectoryParseResult;
+export declare function mergeSupervisorWorkingDirectory(frozenDecision: SupervisorWorkingDirectoryRoutingDecision, scope: SupervisorWorkingDirectoryDecision): SupervisorDecision;

package/dist/src/runtime/steps/supervisor-decision/working-directory.js

@@ -0,0 +1,174 @@
+import { normalizeRoleCallWorkingDirectory, ROLE_CALL_WORKING_DIRECTORY_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { SUPERVISOR_DECISION_MODEL_STEP, } from "./contracts.js";
+import { traceSupervisorWorkingDirectoryContextProjected, traceSupervisorWorkingDirectoryOutputAccepted, traceSupervisorWorkingDirectoryOutputRejected, } from "./diagnostics.js";
+import { buildSupervisorWorkingDirectoryInstructions } from "./prompt.js";
+export const SUPERVISOR_FROZEN_INVOCATION_KIND = "runtime_supervisor_frozen_invocation_v1";
+export function createSupervisorWorkingDirectoryFormat() {
+    return {
+        type: "json_schema",
+        name: "supervisor_working_directory",
+        strict: true,
+        postValidatedSchemaConstraints: Object.freeze([
+            Object.freeze({
+                keyword: "maxLength",
+                path: "/properties/workingDirectory/maxLength",
+            }),
+        ]),
+        schema: {
+            type: "object",
+            properties: {
+                workingDirectory: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: ROLE_CALL_WORKING_DIRECTORY_MAX_LENGTH,
+                    description: "The narrowest exact existing or new project directory relative to the configured agent work root; use '.' only when no narrower project directory owns the frozen outcome.",
+                },
+            },
+            required: ["workingDirectory"],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildSupervisorWorkingDirectoryInput(sourceContext, options) {
+    const [sourceInstructions, ...sourceMessages] = sourceContext.messages;
+    if (sourceInstructions?.role !== "system") {
+        throw new Error("supervisor_working_directory_source_context_invalid");
+    }
+    const diagnostic = options.diagnostic
+        ? Object.freeze({
+            ...options.diagnostic,
+            decisionPhase: "working_directory",
+        })
+        : undefined;
+    const format = createSupervisorWorkingDirectoryFormat();
+    const messages = [
+        Object.freeze({
+            role: "system",
+            content: buildSupervisorWorkingDirectoryInstructions(),
+        }),
+        ...sourceMessages,
+        Object.freeze({
+            role: "user",
+            content: JSON.stringify({
+                kind: SUPERVISOR_FROZEN_INVOCATION_KIND,
+                authority: "canonical_runtime_state",
+                roleId: options.frozenDecision.roleId,
+                objective: options.frozenDecision.objective,
+            }),
+        }),
+    ];
+    if (diagnostic) {
+        traceSupervisorWorkingDirectoryContextProjected({
+            diagnostic,
+            sourceContext,
+            messages,
+            format,
+            frozenDecision: options.frozenDecision,
+        });
+    }
+    return Object.freeze({
+        messages,
+        format,
+        modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+    });
+}
+export function parseSupervisorWorkingDirectoryOutput(text, options = {}) {
+    let decoded;
+    try {
+        decoded = JSON.parse(text.trim());
+    }
+    catch {
+        return rejectWorkingDirectoryOutput({
+            diagnostic: options.diagnostic,
+            outputLength: text.length,
+            stage: "json_envelope",
+            issues: [
+                issue("supervisor_working_directory_output_not_json", "workingDirectory", "Expected one JSON object containing only workingDirectory."),
+            ],
+        });
+    }
+    const record = asRecord(decoded);
+    if (!record) {
+        return rejectWorkingDirectoryOutput({
+            diagnostic: options.diagnostic,
+            outputLength: text.length,
+            stage: "json_envelope",
+            issues: [
+                issue("supervisor_working_directory_output_not_object", "workingDirectory", "Expected one JSON object containing only workingDirectory."),
+            ],
+        });
+    }
+    if (Object.keys(record).length !== 1 ||
+        !Object.prototype.hasOwnProperty.call(record, "workingDirectory")) {
+        return rejectWorkingDirectoryOutput({
+            diagnostic: options.diagnostic,
+            outputLength: text.length,
+            stage: "json_envelope",
+            issues: [
+                issue("supervisor_working_directory_shape_invalid", "workingDirectory", "Return exactly one workingDirectory field."),
+            ],
+        });
+    }
+    const workingDirectory = normalizeRoleCallWorkingDirectory(record.workingDirectory);
+    if (!workingDirectory) {
+        return rejectWorkingDirectoryOutput({
+            diagnostic: options.diagnostic,
+            outputLength: text.length,
+            stage: "domain_parser",
+            issues: [
+                issue("supervisor_working_directory_invalid", "workingDirectory", "workingDirectory must be a bounded project directory relative to the configured agent work root."),
+            ],
+        });
+    }
+    const decision = Object.freeze({
+        workingDirectory,
+    });
+    if (options.diagnostic) {
+        traceSupervisorWorkingDirectoryOutputAccepted({
+            diagnostic: options.diagnostic,
+            outputLength: text.length,
+            workingDirectoryLength: workingDirectory.length,
+        });
+    }
+    return Object.freeze({ ok: true, decision });
+}
+export function mergeSupervisorWorkingDirectory(frozenDecision, scope) {
+    const merged = {
+        ...frozenDecision,
+        workingDirectory: scope.workingDirectory,
+    };
+    return deepFreeze(structuredClone(merged));
+}
+function rejectWorkingDirectoryOutput(params) {
+    if (params.diagnostic) {
+        traceSupervisorWorkingDirectoryOutputRejected({
+            diagnostic: params.diagnostic,
+            outputLength: params.outputLength,
+            validationStage: params.stage,
+            issues: params.issues,
+        });
+    }
+    return Object.freeze({
+        ok: false,
+        stage: params.stage,
+        issues: Object.freeze([...params.issues]),
+    });
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function issue(code, path, message) {
+    return Object.freeze({ code, path, message });
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null || seen.has(value)) {
+        return value;
+    }
+    seen.add(value);
+    for (const child of Object.values(value)) {
+        deepFreeze(child, seen);
+    }
+    return Object.freeze(value);
+}

package/dist/src/runtime/steps/supervisor-response/contracts.d.ts

@@ -0,0 +1,13 @@
+import type { SupervisorDecisionCallIdentity, SupervisorResumeContext } from "../supervisor-decision/index.js";
+export declare const SUPERVISOR_RESPONSE_MODEL_STEP: "supervisor.response";
+export type SupervisorResponseCallIdentity = SupervisorDecisionCallIdentity;
+export type SupervisorResponseResumeContext = SupervisorResumeContext;
+export type SupervisorResponseDiagnosticContext = Readonly<{
+    requestId: string;
+    modelStep: typeof SUPERVISOR_RESPONSE_MODEL_STEP;
+    rootCallId: string;
+    callId: string;
+    parentCallId: string | null;
+    depth: number;
+    invocationAttempt: number;
+}>;

package/dist/src/runtime/steps/supervisor-response/contracts.js

@@ -0,0 +1,2 @@
+import { MODEL_STEPS } from "../../../shared/model-steps.js";
+export const SUPERVISOR_RESPONSE_MODEL_STEP = MODEL_STEPS.SUPERVISOR_RESPONSE;

package/dist/src/runtime/steps/supervisor-response/diagnostics.d.ts

@@ -0,0 +1,27 @@
+import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import type { SupervisorResponseDiagnosticContext } from "./contracts.js";
+export declare function traceSupervisorResponseContextProjected(params: {
+    diagnostic: SupervisorResponseDiagnosticContext;
+    context: RequestContextProjection;
+    historyMessageCount: number;
+    attachmentCount: number;
+    referenceMessageCount: number;
+    continuationMessageCount: number;
+    completedChildResultCount: number;
+    completedChildSummaryLength: number;
+}): void;
+export declare function traceSupervisorResponseModelStarted(params: {
+    diagnostic: SupervisorResponseDiagnosticContext;
+    messageCount: number;
+    messageCharacterCount: number;
+}): void;
+export declare function traceSupervisorResponseModelCompleted(params: {
+    diagnostic: SupervisorResponseDiagnosticContext;
+    durationMs: number;
+    outputLength: number;
+}): void;
+export declare function traceSupervisorResponseModelFailed(params: {
+    diagnostic: SupervisorResponseDiagnosticContext;
+    durationMs: number;
+    errorType: string;
+}): void;

package/dist/src/runtime/steps/supervisor-response/diagnostics.js

@@ -0,0 +1,55 @@
+import { traceDebug } from "../../observability/debug-logger.js";
+const SUPERVISOR_LOG_SCOPE = "runtime.supervisor";
+export function traceSupervisorResponseContextProjected(params) {
+    traceDebug(SUPERVISOR_LOG_SCOPE, "response.context.projected", {
+        ...baseFields(params.diagnostic),
+        historyMessageCount: params.historyMessageCount,
+        selectedHistoryMessageCount: params.context.selectedHistoryMessageIds.length,
+        omittedHistoryMessageCount: params.context.omittedHistoryMessageIds.length,
+        messageCount: params.context.messages.length,
+        messageCharacterCount: params.context.messages.reduce((total, message) => total + message.content.length, 0),
+        attachmentCount: params.attachmentCount,
+        referenceMessageCount: params.referenceMessageCount,
+        continuationMessageCount: params.continuationMessageCount,
+        completedChildResultCount: params.completedChildResultCount,
+        completedChildSummaryLength: params.completedChildSummaryLength,
+        projectContextIncluded: false,
+        plannedWorkContextIncluded: false,
+        capabilityContextIncluded: false,
+        estimatedInputTokens: params.context.budget.estimatedInputTokens,
+        availableInputTokens: params.context.budget.availableInputTokens,
+    });
+}
+export function traceSupervisorResponseModelStarted(params) {
+    traceDebug(SUPERVISOR_LOG_SCOPE, "response.model.started", {
+        ...baseFields(params.diagnostic),
+        messageCount: params.messageCount,
+        messageCharacterCount: params.messageCharacterCount,
+    });
+}
+export function traceSupervisorResponseModelCompleted(params) {
+    traceDebug(SUPERVISOR_LOG_SCOPE, "response.model.completed", {
+        ...baseFields(params.diagnostic),
+        durationMs: params.durationMs,
+        outputLength: params.outputLength,
+    });
+}
+export function traceSupervisorResponseModelFailed(params) {
+    traceDebug(SUPERVISOR_LOG_SCOPE, "response.model.failed", {
+        ...baseFields(params.diagnostic),
+        durationMs: params.durationMs,
+        errorType: params.errorType,
+    });
+}
+function baseFields(diagnostic) {
+    return {
+        requestId: diagnostic.requestId,
+        role: "supervisor",
+        modelStep: diagnostic.modelStep,
+        rootCallId: diagnostic.rootCallId,
+        callId: diagnostic.callId,
+        parentCallId: diagnostic.parentCallId,
+        depth: diagnostic.depth,
+        invocationAttempt: diagnostic.invocationAttempt,
+    };
+}

package/dist/src/runtime/steps/supervisor-response/index.d.ts

@@ -0,0 +1,4 @@
+export { SUPERVISOR_RESPONSE_MODEL_STEP, type SupervisorResponseCallIdentity, type SupervisorResponseDiagnosticContext, type SupervisorResponseResumeContext, } from "./contracts.js";
+export { buildSupervisorResponseInput } from "./input.js";
+export { buildSupervisorResponseInstructions } from "./prompt.js";
+export { runSupervisorResponse } from "./run.js";

package/dist/src/runtime/steps/supervisor-response/index.js

@@ -0,0 +1,4 @@
+export { SUPERVISOR_RESPONSE_MODEL_STEP, } from "./contracts.js";
+export { buildSupervisorResponseInput } from "./input.js";
+export { buildSupervisorResponseInstructions } from "./prompt.js";
+export { runSupervisorResponse } from "./run.js";

package/dist/src/runtime/steps/supervisor-response/input.d.ts

@@ -0,0 +1,13 @@
+import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import { type RequestToolResultsView } from "../../context/request-tool-results.js";
+import type { RequestExecutionSeed } from "../../request/contracts.js";
+import { SUPERVISOR_RESPONSE_MODEL_STEP, type SupervisorResponseCallIdentity, type SupervisorResponseResumeContext } from "./contracts.js";
+export type SupervisorResponseInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "onEvent" | "sessionMemory">>;
+export declare function buildSupervisorResponseInput(request: SupervisorResponseInputRequest, options: Readonly<{
+    call: SupervisorResponseCallIdentity;
+    toolResults: RequestToolResultsView;
+    resume?: SupervisorResponseResumeContext;
+}>): {
+    context: RequestContextProjection;
+    modelStep: typeof SUPERVISOR_RESPONSE_MODEL_STEP;
+};

package/dist/src/runtime/steps/supervisor-response/input.js

@@ -0,0 +1,73 @@
+import { projectRequestContext } from "../../context/request-context.js";
+import { projectRootSessionMemory } from "../../context/session-memory/root-projection.js";
+import { buildRequestToolResultsMessage, } from "../../context/request-tool-results.js";
+import { resolveModelContextBudget } from "../../model/model-context-budget.js";
+import { buildSupervisorContinuationPart } from "../supervisor-decision/index.js";
+import { SUPERVISOR_RESPONSE_MODEL_STEP, } from "./contracts.js";
+import { traceSupervisorResponseContextProjected } from "./diagnostics.js";
+import { buildSupervisorResponseInstructions } from "./prompt.js";
+export function buildSupervisorResponseInput(request, options) {
+    const diagnostic = {
+        requestId: request.requestId,
+        modelStep: SUPERVISOR_RESPONSE_MODEL_STEP,
+        ...options.call,
+    };
+    const decisionContinuationPart = options.resume
+        ? buildSupervisorContinuationPart({
+            resume: options.resume,
+            currentCallId: options.call.callId,
+            currentInvocationAttempt: options.call.invocationAttempt,
+        })
+        : undefined;
+    if (decisionContinuationPart && !decisionContinuationPart.compactMessages) {
+        throw new Error("supervisor_response_result_projection_unavailable");
+    }
+    const roleContinuationPart = decisionContinuationPart?.compactMessages !== undefined
+        ? Object.freeze({
+            ...decisionContinuationPart,
+            messages: decisionContinuationPart.compactMessages,
+        })
+        : undefined;
+    const referenceMessages = options.toolResults.results.length > 0
+        ? [buildRequestToolResultsMessage(options.toolResults)]
+        : [];
+    const budget = resolveModelContextBudget({
+        runnerConfig: request.runnerConfig,
+        agentMode: request.agentMode,
+        modelStep: SUPERVISOR_RESPONSE_MODEL_STEP,
+        ...(request.modelPreference
+            ? { modelPreference: request.modelPreference }
+            : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    });
+    const sessionMemory = projectRootSessionMemory(request);
+    const context = projectRequestContext({
+        instructions: buildSupervisorResponseInstructions({
+            hasCompletedChildResult: options.resume !== undefined,
+            hasRequestToolResults: options.toolResults.results.length > 0,
+        }),
+        ...sessionMemory,
+        prompt: request.prompt,
+        currentMessagePlacement: "after_continuation",
+        ...(request.attachments ? { attachments: request.attachments } : {}),
+        ...(referenceMessages.length > 0 ? { referenceMessages } : {}),
+        ...(roleContinuationPart
+            ? { continuationParts: [roleContinuationPart] }
+            : {}),
+        budget,
+        diagnostic,
+        ...(request.onEvent ? { onEvent: request.onEvent } : {}),
+        deferCompactionFailure: true,
+    });
+    traceSupervisorResponseContextProjected({
+        diagnostic,
+        context,
+        historyMessageCount: sessionMemory.historyMessages.length,
+        attachmentCount: request.attachments?.length ?? 0,
+        referenceMessageCount: referenceMessages.length,
+        continuationMessageCount: roleContinuationPart?.messages.length ?? 0,
+        completedChildResultCount: options.resume?.completedChildren.length ?? 0,
+        completedChildSummaryLength: options.resume?.completedChildren.reduce((total, child) => total + child.summary.length, 0) ?? 0,
+    });
+    return { context, modelStep: SUPERVISOR_RESPONSE_MODEL_STEP };
+}

package/dist/src/runtime/steps/supervisor-response/prompt.d.ts

@@ -0,0 +1,6 @@
+import type { RawModelRepairHintInput } from "../../model/invoke-raw-step.js";
+export declare function buildSupervisorResponseInstructions(params: {
+    hasCompletedChildResult: boolean;
+    hasRequestToolResults: boolean;
+}): string;
+export declare function buildSupervisorResponseRepairHint(params: RawModelRepairHintInput): string;