@abot-ai/runtime 1.8.0 → 1.9.0

package/dist/src/runtime/steps/execution-agent/capability-result-context.js

@@ -1,8 +1,9 @@
 import { projectCanonicalRequestToolResult } from "../../context/canonical-capability-result.js";
+import { createSemanticCompactionSha256Fingerprint, } from "../../context/semantic-compaction/contracts.js";
 export const EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND = "runtime_execution_capability_result_v1";
 export const EXECUTION_CAPABILITY_TOOL_NAME = "runtime_capability";
-/** One exact native result representation for active input and saved-source compatibility. */
-export function buildExecutionCapabilityResultMessage(head, execution) {
+/** Canonical bytes stay stable; only the model view may omit an exact duplicate. */
+export function buildExecutionCapabilityResultMessage(head, execution, projection = "canonical") {
     if (execution.status !== "settled" || execution.exactResult === undefined) {
         throw new Error("execution_agent_continuation_result_invalid");
     }
@@ -19,7 +20,9 @@ export function buildExecutionCapabilityResultMessage(head, execution) {
                 capabilityId: execution.capabilityId,
                 outcome: canonical.outcome,
                 observedEffect: canonical.observedEffect,
-                summary: canonical.summary,
+                ...(canOmitDuplicateSummary(projection, canonical)
+                    ? {}
+                    : { summary: canonical.summary }),
                 adapterResult: execution.exactResult,
             },
         }),
@@ -27,3 +30,19 @@ export function buildExecutionCapabilityResultMessage(head, execution) {
         toolName: EXECUTION_CAPABILITY_TOOL_NAME,
     });
 }
+/** Reuse the original native-message identity for compaction and approval resume. */
+export function buildExecutionCapabilityResultSource(head, execution) {
+    const content = JSON.stringify(buildExecutionCapabilityResultMessage(head, execution));
+    return Object.freeze({
+        sourceRef: `tool-result:${execution.executionId}`,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    });
+}
+function canOmitDuplicateSummary(projection, result) {
+    if (projection !== "model")
+        return false;
+    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
+        return false;
+    return result.summary === result.adapterResult.result.output;
+}

package/dist/src/runtime/steps/execution-agent/compaction.d.ts

@@ -1,17 +1,18 @@
 import type { RequestSteeringSnapshot } from "../../request/request-steering.js";
 import type { ModelStep } from "../../../shared/model-steps.js";
-import type { RoleCallFrame } from "../../orchestration/role-calls/index.js";
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import type { RequestExecutionScope } from "../../request/execution-scope.js";
 type ExecutionAgentCompactionOptions = Readonly<{
     call: RoleCallFrame;
     steeringSnapshot: RequestSteeringSnapshot;
-    sourceRevision: number;
+    head: RoleCallLedgerHead;
     consumer?: ModelStep;
     allowedConsumers: readonly ModelStep[];
     scopeSuffix?: string;
 }>;
 export declare function createExecutionAgentCompactionController(request: RequestExecutionScope, options: ExecutionAgentCompactionOptions): Readonly<{
     project(messages: readonly import("../../../model-gateway/types.js").ChatMessage[]): import("../../../model-gateway/types.js").ChatMessage[];
+    projectForCompaction?(messages: readonly import("../../../model-gateway/types.js").ChatMessage[]): readonly import("../../../model-gateway/types.js").ChatMessage[];
     hasExhaustedVerifiedCompactionSources?(messages: readonly import("../../../model-gateway/types.js").ChatMessage[]): boolean;
     getStages(): readonly import("../../model/context-compaction-contracts.js").ModelStepCompactionStage[];
 }>;

package/dist/src/runtime/steps/execution-agent/compaction.js

@@ -1,11 +1,19 @@
 import { executionCompactionScopeId, projectExecutionCompactionObjective, } from "../../context/execution-compaction-objective.js";
 import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
+import { buildExecutionCapabilityResultSource } from "./capability-result-context.js";
 export function createExecutionAgentCompactionController(request, options) {
     const objective = projectExecutionCompactionObjective(request.prompt, options.steeringSnapshot.updates);
     const call = Object.freeze({ ...options.call, objective });
     return createModelStepCompactionController(request, {
         call,
-        sourceRevision: options.sourceRevision,
+        sourceRevision: options.head.revision,
+        resultSourceOverrides: options.head.state.capabilityExecutions
+            .filter(function isSettledExecutionOfCall(execution) {
+            if (execution.callId !== call.callId)
+                return false;
+            return execution.status === "settled";
+        })
+            .map((execution) => buildExecutionCapabilityResultSource(options.head, execution)),
         allowedConsumers: options.allowedConsumers,
         consumer: options.consumer,
         scopeId: executionCompactionScopeId({

package/dist/src/runtime/steps/execution-agent/contracts.d.ts

@@ -1,4 +1,6 @@
 import type { MemoryRecallDecision } from "../memory-recall-decision.js";
+import type { MemoryCandidate } from "../../long-term-memory/contracts.js";
+import type { ConversationMemoryAuthoringContext } from "../../long-term-memory/conversation-authoring/context.js";
 import type { ExecutionWorkPlanOptions, ExecutionWorkPlanReport } from "./work-plan-contract.js";
 import type { RoleCapabilitySelectionProjection, RoleCapabilitySelectionReconsiderationCause } from "../../orchestration/role-calls/index.js";
 import { type CapabilityControls, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
@@ -21,6 +23,10 @@ export type ExecutionAgentDecisionPresentation = Readonly<{
 }>;
 export type ExecutionAgentRespondDecision = Readonly<ExecutionAgentDecisionPresentation & {
     action: "respond";
+    /** Exact prevalidated short answer; absent keeps separate presentation. */
+    response?: string;
+    /** Assessed proposals bound to the same accepted direct response. */
+    memoryCandidates?: readonly MemoryCandidate[];
 }>;
 export type ExecutionAgentOpenCapabilityScopeDecision = Readonly<ExecutionAgentDecisionPresentation & {
     action: "open_capability_scope";
@@ -113,6 +119,10 @@ export type ExecutionAgentDecisionContractOptions = Readonly<{
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
     allowRespond?: boolean;
+    directResponseMaxLength?: number;
+    directResponseMemoryAuthoring?: Readonly<{
+        context?: ConversationMemoryAuthoringContext;
+    }>;
     allowMemoryRecall?: boolean;
     allowPlanner?: boolean;
     allowAuditor?: boolean;

package/dist/src/runtime/steps/execution-agent/decision-parsing.js

@@ -1,3 +1,4 @@
+import { parseDirectResponse, parseDirectResponseMemoryCandidates, } from "./direct-response-contract.js";
 import { readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
 import { parseDecisionWithWorkPlan } from "./work-plan-decision-parsing.js";
 import { isMemoryRecallDecisionRecord, parseMemoryRecallDecision, } from "../memory-recall-decision.js";
@@ -62,12 +63,23 @@ function parseExecutionAgentActionOutput(text, options) {
         }
     }
     else if (selectedAction === "respond") {
-        exactKeys(record, ["action", ...presentationKeys(contract)], issues, "decision");
+        const response = parseDirectResponse(record, options.directResponseMaxLength, issues);
+        const memoryCandidates = response !== undefined
+            ? parseDirectResponseMemoryCandidates(record, options.directResponseMemoryAuthoring)
+            : undefined;
+        exactKeys(record, [
+            "action",
+            ...(response !== undefined ? ["response"] : []),
+            ...(memoryCandidates !== undefined ? ["memoryCandidates"] : []),
+            ...presentationKeys(contract),
+        ], issues, "decision");
         if (!contract.allowRespond) {
             issues.push(issue("execution_agent_response_not_allowed", "decision.action", "respond is not available until the canonical completion gate is open."));
         }
         decision = {
             action: "respond",
+            ...(response !== undefined ? { response } : {}),
+            ...(memoryCandidates !== undefined ? { memoryCandidates } : {}),
             ...presentation,
         };
     }

package/dist/src/runtime/steps/execution-agent/direct-response-configuration.d.ts

@@ -0,0 +1,3 @@
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+/** Preserve a separately configured response model/calibration instead of silently bypassing it. */
+export declare function hasCompatibleDirectResponseConfiguration(request: RequestExecutionScope): boolean;

package/dist/src/runtime/steps/execution-agent/direct-response-configuration.js

@@ -0,0 +1,64 @@
+import { isDeepStrictEqual } from "node:util";
+import { resolveModelInvocation } from "../../../model-gateway/invocation-policy.js";
+import { resolveModelStepTimeout } from "../../model/model-step-timeout-policy.js";
+import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STEP, } from "./contracts.js";
+/** Preserve a separately configured response model/calibration instead of silently bypassing it. */
+export function hasCompatibleDirectResponseConfiguration(request) {
+    try {
+        const decision = effectiveConfiguration(request, EXECUTION_AGENT_DECISION_MODEL_STEP);
+        const response = effectiveConfiguration(request, EXECUTION_AGENT_RESPONSE_MODEL_STEP);
+        if (!decision || !response)
+            return false;
+        return isDeepStrictEqual(decision, response);
+    }
+    catch {
+        // Resolution failures keep the existing deferred path and its diagnostics.
+        return false;
+    }
+}
+function effectiveConfiguration(request, modelStep) {
+    const step = request.runnerConfig.steps[modelStep];
+    if (!step)
+        return undefined;
+    const invocation = resolveModelInvocation({
+        modelStep,
+        agentMode: request.agentMode,
+        ...(request.modelPreference
+            ? { modelPreference: request.modelPreference }
+            : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    });
+    if (hasSpecialResponseFormat(modelStep, invocation.format))
+        return undefined;
+    const { profile } = invocation;
+    return {
+        profileId: profile.id,
+        providerId: profile.providerId,
+        provider: profile.provider,
+        model: profile.model,
+        contextWindowTokens: profile.contextWindowTokens,
+        capabilities: profile.capabilities,
+        options: profile.options,
+        generation: profile.generation,
+        context: profile.context,
+        think: invocation.think,
+        instructions: invocation.instructions ?? [],
+        timeoutMs: resolveModelStepTimeout({
+            modelStep,
+            fallbackTimeoutMs: step.timeoutMs,
+            ...(request.modelPreference
+                ? { modelPreference: request.modelPreference }
+                : {}),
+            ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+        }).timeoutMs,
+    };
+}
+function hasSpecialResponseFormat(modelStep, format) {
+    if (modelStep !== EXECUTION_AGENT_RESPONSE_MODEL_STEP)
+        return false;
+    if (format === undefined)
+        return false;
+    if (format && typeof format === "object" && "type" in format)
+        return format.type !== "text";
+    return true;
+}

package/dist/src/runtime/steps/execution-agent/direct-response-contract.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionAgentDecisionContractOptions, ExecutionAgentDecisionValidationIssue } from "./contracts.js";
+import type { MemoryCandidate } from "../../long-term-memory/contracts.js";
+/** A short-answer option, not a conversion from characters to model tokens. */
+export declare const EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH = 1024;
+export declare function directResponseVariants(maxLength: number | undefined, presentation: Record<string, unknown>, memoryAuthoring?: boolean): Record<string, unknown>[];
+export declare function parseDirectResponse(record: Record<string, unknown>, maxLength: number | undefined, issues: ExecutionAgentDecisionValidationIssue[]): string | undefined;
+export declare function parseDirectResponseMemoryCandidates(record: Record<string, unknown>, authoring: ExecutionAgentDecisionContractOptions["directResponseMemoryAuthoring"]): readonly MemoryCandidate[] | undefined;

package/dist/src/runtime/steps/execution-agent/direct-response-contract.js

@@ -0,0 +1,56 @@
+import { conversationMemoryCandidatesSchema, parseConversationMemoryCandidates, } from "../../long-term-memory/conversation-authoring/contract.js";
+import { issue } from "./decision-validation.js";
+/** A short-answer option, not a conversion from characters to model tokens. */
+export const EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH = 1_024;
+export function directResponseVariants(maxLength, presentation, memoryAuthoring = false) {
+    if (!isDirectResponseLimit(maxLength))
+        return [];
+    return [
+        {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                action: { type: "string", enum: ["respond"] },
+                response: { type: "string", minLength: 1, maxLength },
+                ...(memoryAuthoring
+                    ? { memoryCandidates: conversationMemoryCandidatesSchema }
+                    : {}),
+                ...presentation,
+            },
+            required: [
+                "action", "response",
+                ...(memoryAuthoring ? ["memoryCandidates"] : []),
+                ...Object.keys(presentation),
+            ],
+        },
+    ];
+}
+export function parseDirectResponse(record, maxLength, issues) {
+    if (!Object.hasOwn(record, "response"))
+        return undefined;
+    if (!isDirectResponseLimit(maxLength)) {
+        issues.push(issue("execution_agent_direct_response_unavailable", "decision.response", "This request requires the separate response authoring step."));
+        return undefined;
+    }
+    const response = record.response;
+    if (typeof response !== "string" || response.trim().length === 0) {
+        issues.push(issue("execution_agent_direct_response_invalid", "decision.response", "A direct response must contain the complete non-empty answer."));
+        return undefined;
+    }
+    if (response.length > maxLength) {
+        issues.push(issue("execution_agent_direct_response_too_long", "decision.response", `A direct response must fit ${maxLength} characters. Choose respond without response for a longer complete answer; do not shorten or truncate it.`));
+        return undefined;
+    }
+    return response;
+}
+export function parseDirectResponseMemoryCandidates(record, authoring) {
+    if (!authoring)
+        return undefined;
+    return parseConversationMemoryCandidates(record.memoryCandidates, authoring.context);
+}
+function isDirectResponseLimit(value) {
+    return (value !== undefined &&
+        Number.isInteger(value) &&
+        value > 0 &&
+        value <= EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH);
+}

package/dist/src/runtime/steps/execution-agent/direct-response-policy.d.ts

@@ -0,0 +1,9 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import type { ExecutionMemoryProjection } from "../../long-term-memory/initial-context.js";
+/** Request-local offer only; neither prompt classification nor permission to omit required work. */
+export declare function resolveDirectResponseOffer(request: RequestExecutionScope, head: RoleCallLedgerHead, call: RoleCallFrame): Readonly<{
+    reason: string;
+    maxLength?: number;
+}>;
+export declare function canAuthorDirectResponseMemory(maxLength: number | undefined, memory: ExecutionMemoryProjection | undefined): memory is ExecutionMemoryProjection;

package/dist/src/runtime/steps/execution-agent/direct-response-policy.js

@@ -0,0 +1,30 @@
+import { EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH } from "./direct-response-contract.js";
+import { hasCompatibleDirectResponseConfiguration } from "./direct-response-configuration.js";
+/** Request-local offer only; neither prompt classification nor permission to omit required work. */
+export function resolveDirectResponseOffer(request, head, call) {
+    if (request.automationOutputContract)
+        return { reason: "automation_output_contract" };
+    if (request.scheduledExecution)
+        return { reason: "scheduled_execution" };
+    if (request.sessionKind === "spark")
+        return { reason: "spark_session" };
+    if (head.state.capabilityExecutions.length > 0)
+        return { reason: "capability_work" };
+    if (head.state.calls.length !== 1)
+        return { reason: "delegated_work" };
+    if (head.state.results.length > 0)
+        return { reason: "subordinate_results" };
+    if (call.adoptedWorkPlan)
+        return { reason: "work_plan" };
+    if (!hasCompatibleDirectResponseConfiguration(request))
+        return { reason: "response_configuration" };
+    return {
+        reason: "eligible",
+        maxLength: Math.min(EXECUTION_AGENT_DIRECT_RESPONSE_MAX_LENGTH, head.policy.limits.maxResponseChars),
+    };
+}
+export function canAuthorDirectResponseMemory(maxLength, memory) {
+    if (maxLength === undefined)
+        return false;
+    return memory?.authoringEnabled === true;
+}

package/dist/src/runtime/steps/execution-agent/direct-response-prompt.d.ts

@@ -0,0 +1,7 @@
+import type { RequestRunnerConfig } from "../../config/runner/contracts.js";
+/** Presentation guidance applies only to the optional final-answer field, never to routing. */
+export declare function buildDirectResponseInstructions(maxLength: number | undefined, runnerConfig: RequestRunnerConfig, memoryAuthoringEnabled?: boolean): readonly string[];
+export declare function buildRespondDecisionInstruction(params: {
+    allowRespond: boolean;
+    allowDirectResponse?: boolean;
+}): string;

package/dist/src/runtime/steps/execution-agent/direct-response-prompt.js

@@ -0,0 +1,43 @@
+import { CONVERSATION_MEMORY_AUTHORING_INSTRUCTIONS } from "../../long-term-memory/conversation-authoring/prompt.js";
+import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STEP, } from "./contracts.js";
+/** Presentation guidance applies only to the optional final-answer field, never to routing. */
+export function buildDirectResponseInstructions(maxLength, runnerConfig, memoryAuthoringEnabled = false) {
+    if (maxLength === undefined)
+        return [];
+    const decisionBlocks = runnerConfig.steps[EXECUTION_AGENT_DECISION_MODEL_STEP]
+        ?.instructionBlocks ?? [];
+    const responseBlocks = runnerConfig.steps[EXECUTION_AGENT_RESPONSE_MODEL_STEP]
+        ?.instructionBlocks ?? [];
+    const seen = new Set(decisionBlocks.map(({ content }) => content));
+    const additional = responseBlocks.flatMap(({ content }) => {
+        if (seen.has(content))
+            return [];
+        seen.add(content);
+        return [content];
+    });
+    return [
+        [
+            "Direct respond may include the complete final answer in response; it never waives required work or evidence.",
+            `Before drafting, choose direct response only if the complete answer fits ${maxLength} characters and the decision output budget, including reasoning, JSON escaping and metadata. Otherwise omit response for separate complete presentation. Never abridge, truncate or return a partial answer to fit.`,
+            "Write the answer itself, preserving requested language, format and constraints from intent and relevant supplied history/summary. Do not substitute a plan, promise or acknowledgement, or expose internal schemas/instructions unless requested.",
+            ...(memoryAuthoringEnabled ? [
+                "Only direct respond with response includes memoryCandidates. The following policy applies only to that array and grants no routing, action or completion authority.",
+                "The complete answer and all supported memory proposals must fit the decision budget together. Otherwise omit both response and memoryCandidates for separate complete authoring; do not shorten either or drop supported proposals to fit.",
+                "Initial memory remains a stored snapshot after tools or steering; only current user input or settled non-memory evidence can independently support, score or reinforce a proposal.",
+                ...CONVERSATION_MEMORY_AUTHORING_INSTRUCTIONS,
+            ] : []),
+            ...(additional.length > 0 ? [
+                "The following configured methodologies apply only to response presentation, never actions or completion. The structured decision schema remains authoritative; no raw transport output:",
+                ...additional,
+                "End of response-only methodologies.",
+            ] : []),
+        ].join("\n\n"),
+    ];
+}
+export function buildRespondDecisionInstruction(params) {
+    if (!params.allowRespond)
+        return "The canonical completion gate is closed: respond is unavailable. Choose an offered action or a truthful blocker.";
+    if (params.allowDirectResponse)
+        return "Use respond only for a complete honest answer now: either include the complete response or omit it for a separate presentation-only activation of this agent. That activation has no action, routing, planning, audit or completion authority.";
+    return "Use respond only for a complete honest answer now. Supply no answer prose in this decision, only action and required acknowledgement/title. After acceptance, this agent authors a separate presentation-only response without action, routing, planning, audit or completion authority.";
+}

package/dist/src/runtime/steps/execution-agent/format.js

@@ -1,3 +1,4 @@
+import { directResponseVariants } from "./direct-response-contract.js";
 import { createMemoryRecallDecisionSchema } from "../memory-recall-decision.js";
 import { createExecutionWorkPlanDecisionSchema } from "./work-plan-schema.js";
 import { isToolCatalogGroupId } from "../../../capabilities/tool-types.js";
@@ -42,6 +43,7 @@ export function createExecutionAgentDecisionFormat(options = {}) {
                     action: literal("respond"),
                     ...presentation,
                 }),
+                ...directResponseVariants(options.directResponseMaxLength, presentation, options.directResponseMemoryAuthoring !== undefined),
             ]
             : []),
         exactObject({

package/dist/src/runtime/steps/execution-agent/input.d.ts

@@ -1,5 +1,6 @@
 import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
 import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import type { ExecutionMemoryProjection } from "../../long-term-memory/initial-context.js";
 import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import { type CapabilityCatalogGroup, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
 import { type RequestExecutionScope } from "../../request/execution-scope.js";
@@ -25,6 +26,7 @@ type BuildExecutionAgentInputOptions = Readonly<{
     allowPlanner: boolean;
     allowAuditor: boolean;
     memoryRecallMessage?: ChatMessage;
+    memoryContext?: ExecutionMemoryProjection;
 }>;
 export declare function buildExecutionAgentInput(request: RequestExecutionScope, options: BuildExecutionAgentInputOptions): ExecutionAgentInput;
 export {};

package/dist/src/runtime/steps/execution-agent/input.js

@@ -1,8 +1,13 @@
+import { projectAvailableSkillsInstructions } from "../../knowledge-skills/available-skills-projection.js";
 import { buildRuntimeFilesystemScopeMessage, canEstablishRuntimeWorkingDirectory, } from "../../context/runtime-filesystem-scope.js";
+import { canAuthorDirectResponseMemory, resolveDirectResponseOffer } from "./direct-response-policy.js";
+import { buildDirectResponseInstructions } from "./direct-response-prompt.js";
+import { traceDebug } from "../../observability/debug-logger.js";
 import { buildSparkConversationInstructions } from "../../context/spark-conversation-policy.js";
 import { projectRequestContext } from "../../context/request-context.js";
 import { projectRootSessionMemory } from "../../context/session-memory/root-projection.js";
 import { buildConversationMemoryAvailabilityInstructions } from "../../long-term-memory/conversation-authoring/prompt.js";
+import { buildConversationMemoryAuthoringPlainTextMessage } from "../../long-term-memory/conversation-authoring/plain-text-context.js";
 import { canOfferMemoryRecall } from "../../long-term-memory/recall-policy.js";
 import { projectMemoryRecallContinuations } from "../../long-term-memory/recall-continuation.js";
 import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
@@ -11,6 +16,7 @@ import { buildImmediateOperationSupervisionEvidenceMessage } from "../../context
 import { resolveModelContextBudget } from "../../model/model-context-budget.js";
 import { projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
 import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
+import { resolveRequestCapabilityBriefEntries } from "../../request/capability-brief.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
 import { EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID, projectAuditorInputState, } from "../auditor-decision/index.js";
 import { EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX, EXECUTION_AGENT_DECISION_MODEL_STEP, } from "./contracts.js";
@@ -21,6 +27,7 @@ import { buildExecutionAgentInstructions } from "./prompt.js";
 import { buildExecutionCapabilityCatalogMessage, buildExecutionCapabilityGroupCatalogMessage, buildExecutionContinuationMessages, buildExecutionDecisionStateMessage, } from "./state-context.js";
 export function buildExecutionAgentInput(request, options) {
     assertCanonicalSource(request, options.head, options.call);
+    const directResponse = resolveDirectResponseOffer(request, options.head, options.call);
     const allCapabilities = resolveRequestWorkerCapabilities(request).provider.getDescriptors();
     const capabilityCatalogGroups = projectCapabilityCatalogGroups(allCapabilities);
     const activeCapabilityCatalogGroupIds = options.call.workerCapabilityScope?.catalogGroupIds ?? null;
@@ -52,8 +59,16 @@ export function buildExecutionAgentInput(request, options) {
     const memoryRecallMessage = request.longTermMemory?.enabled
         ? options.memoryRecallMessage
         : undefined;
+    const memoryContext = request.longTermMemory?.enabled ? options.memoryContext : undefined;
+    const automaticMemoryMessage = memoryRecallMessage ? undefined : memoryContext?.memoryMessage;
     const workPlan = projectExecutionWorkPlanOptions(options.head, options.call);
+    const directMemoryAuthoring = canAuthorDirectResponseMemory(directResponse.maxLength, memoryContext)
+        ? { ...(memoryContext.authoringContext ? { context: memoryContext.authoringContext } : {}) }
+        : undefined;
     const contract = Object.freeze({
+        ...(directResponse.maxLength !== undefined
+            ? { directResponseMaxLength: directResponse.maxLength } : {}),
+        ...(directMemoryAuthoring ? { directResponseMemoryAuthoring: directMemoryAuthoring } : {}),
         ...(workPlan ? { workPlan } : {}),
         allowMemoryRecall: canOfferMemoryRecall({
             enabled: request.longTermMemory?.enabled === true,
@@ -84,6 +99,7 @@ export function buildExecutionAgentInput(request, options) {
     });
     const instructions = [
         buildExecutionAgentInstructions({
+            allowDirectResponse: directResponse.maxLength !== undefined,
             allowWorkPlan: workPlan !== undefined,
             allowMemoryRecall: contract.allowMemoryRecall,
             hasMemoryRecallContext: memoryRecallMessage !== undefined,
@@ -98,6 +114,7 @@ export function buildExecutionAgentInput(request, options) {
             includeTitle: options.includeTitle,
             includeWorkingDirectory: options.call.workingDirectory === undefined,
         }),
+        ...buildDirectResponseInstructions(directResponse.maxLength, request.runnerConfig, directMemoryAuthoring !== undefined),
         ...buildConversationMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
         ...buildSparkConversationInstructions(request.sessionKind),
     ].join("\n");
@@ -115,6 +132,9 @@ export function buildExecutionAgentInput(request, options) {
     const referenceMessages = [
         ...(filesystemMessage ? [filesystemMessage] : []),
         ...scheduledExecution.referenceMessages,
+        ...(automaticMemoryMessage ? [automaticMemoryMessage] : []),
+        ...(directMemoryAuthoring?.context
+            ? [buildConversationMemoryAuthoringPlainTextMessage(directMemoryAuthoring.context)] : []),
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
             : []),
@@ -124,14 +144,18 @@ export function buildExecutionAgentInput(request, options) {
         ...(operationSupervisionEvidenceMessage
             ? [operationSupervisionEvidenceMessage]
             : []),
-        buildExecutionCapabilityGroupCatalogMessage(capabilityCatalogGroups, allCapabilities),
+        buildExecutionCapabilityGroupCatalogMessage(knownGroupIds, resolveRequestCapabilityBriefEntries(resolveRequestWorkerCapabilities(request), capabilityCatalogGroups)),
         ...(capabilities.length > 0
             ? [buildExecutionCapabilityCatalogMessage(capabilities)]
             : []),
     ];
     const continuationMessages = buildExecutionContinuationMessages(options.head, options.call, projectMemoryRecallContinuations(memoryRecallMessage));
     const sessionMemory = projectRootSessionMemory(request);
-    const context = projectRequestContext({
+    traceDebug("runtime.execution-agent", "direct_response.offer", {
+        requestId: request.requestId, reason: directResponse.reason,
+        maxLength: directResponse.maxLength ?? null,
+    });
+    const contextInput = {
         instructions: scheduledExecution.instructions,
         format,
         ...sessionMemory,
@@ -147,6 +171,15 @@ export function buildExecutionAgentInput(request, options) {
             callId: options.call.callId,
         },
         onEvent: request.onEvent,
+    };
+    const skills = remainingExecutions > 0
+        ? resolveRequestWorkerCapabilities(request).provider.getAvailableSkills?.() ?? []
+        : [];
+    const context = projectRequestContext({
+        ...contextInput,
+        instructions: projectAvailableSkillsInstructions({
+            skills, context: contextInput,
+        }),
     });
     return Object.freeze({
         context,

package/dist/src/runtime/steps/execution-agent/plugin-catalog.d.ts

@@ -0,0 +1,4 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { ToolAvailabilityEntry } from "../../../capabilities/tool-types.js";
+export declare const EXECUTION_CAPABILITY_GROUP_CATALOG_HEADER = "Tool groups:";
+export declare function buildExecutionCapabilityGroupCatalogMessage(catalogGroupIds: readonly string[], entries?: readonly ToolAvailabilityEntry[]): ChatMessage;

package/dist/src/runtime/steps/execution-agent/plugin-catalog.js

@@ -0,0 +1,8 @@
+import { buildPluginDiscoveryCatalogText, PLUGIN_DISCOVERY_CATALOG_HEADER, } from "../../context/capability-descriptions.js";
+export const EXECUTION_CAPABILITY_GROUP_CATALOG_HEADER = PLUGIN_DISCOVERY_CATALOG_HEADER;
+export function buildExecutionCapabilityGroupCatalogMessage(catalogGroupIds, entries = []) {
+    return Object.freeze({
+        role: "user",
+        content: buildPluginDiscoveryCatalogText(catalogGroupIds, entries),
+    });
+}

package/dist/src/runtime/steps/execution-agent/prompt.d.ts

@@ -7,6 +7,7 @@ export declare function buildExecutionAgentInstructions(params: {
     allowWorkPlan?: boolean;
     availableAuditCriterionCount: number;
     allowRespond: boolean;
+    allowDirectResponse?: boolean;
     allowMemoryRecall?: boolean;
     hasMemoryRecallContext?: boolean;
     includeAcknowledgement: boolean;