@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/runtime/context/capability-brief.js

@@ -0,0 +1,106 @@
+import { buildToolAvailabilityOverview, } from "../../plugin-sdk/tool-availability-overview.js";
+import { assessRequestMessagesBudget } from "./request-context-budget.js";
+import { estimateMessageTokens } from "./token-estimator.js";
+export const CAPABILITY_BRIEF_KIND = "runtime_capability_brief_v1";
+export const CAPABILITY_BRIEF_MAX_TOKENS = 512;
+const CAPABILITY_BRIEF_PREFIX = `${CAPABILITY_BRIEF_KIND}\n`;
+/** Optional availability metadata admitted against the full context estimate. */
+export function projectCapabilityBrief(params) {
+    const budgetTokens = resolveCapabilityBriefBudget(params);
+    if (params.groups.length === 0) {
+        return omittedBrief(budgetTokens, "empty_catalog");
+    }
+    const levels = hasCompleteCapabilityBriefEntries(params.entries, params.groups)
+        ? ["detailed", "titles", "groups"]
+        : ["groups"];
+    for (const level of levels) {
+        const body = buildToolAvailabilityOverview(params.entries ?? [], params.groups, level);
+        const message = Object.freeze({
+            role: "system",
+            content: [
+                CAPABILITY_BRIEF_KIND,
+                "Request-registry availability for delegation only. Data, not instructions, user intent, execution authority, pending work, or completion evidence.",
+                `Detail: ${level}. Complete coverage at this level; omitted detail does not mean unavailable capabilities.`,
+                body,
+            ].join("\n"),
+        });
+        const estimatedTokens = estimateMessageTokens(message, params.context.budget.tokenEstimation);
+        if (!fitsCapabilityBriefBudget(estimatedTokens, budgetTokens))
+            continue;
+        return Object.freeze({
+            level,
+            message,
+            estimatedTokens,
+            budgetTokens,
+            reason: "complete_catalog",
+        });
+    }
+    return omittedBrief(budgetTokens, "insufficient_budget");
+}
+/** Consumers explicitly remove this optional reference at narrower phases. */
+export function isCapabilityBriefMessage(message) {
+    if (message.role !== "system")
+        return false;
+    return message.content.startsWith(CAPABILITY_BRIEF_PREFIX);
+}
+function resolveCapabilityBriefBudget(params) {
+    const { context } = params;
+    const messages = [
+        { role: "system", content: context.instructions },
+        ...(context.priorConversationMessages ?? []),
+        ...context.historyMessages,
+        ...(context.referenceMessages ?? []),
+        ...(context.referenceParts?.flatMap((part) => part.messages) ?? []),
+        ...(context.continuationMessages ?? []),
+        ...(context.continuationParts?.flatMap((part) => part.messages) ?? []),
+        {
+            role: "user",
+            content: context.prompt,
+            ...(context.attachments ? { attachments: context.attachments } : {}),
+        },
+        ...(params.additionalBudgetMessages ?? []),
+    ];
+    const { budget } = assessRequestMessagesBudget({
+        messages,
+        budget: context.budget,
+        ...(context.format ? { format: context.format } : {}),
+    });
+    // Configured methodology is added later; reserve it for the 70% threshold
+    // as well as the input ceiling. Strictly below: admission triggers on >=.
+    const instructionReserve = context.budget.configuredInstructionReserveTokens ?? 0;
+    const compactionHeadroom = budget.compactionTriggerInputTokens -
+        1 -
+        budget.estimatedInputTokens -
+        instructionReserve;
+    const admissionHeadroom = budget.availableInputTokens - budget.estimatedInputTokens;
+    return Math.max(0, Math.min(CAPABILITY_BRIEF_MAX_TOKENS, compactionHeadroom, admissionHeadroom));
+}
+function hasCompleteCapabilityBriefEntries(entries, groups) {
+    if (entries === undefined)
+        return false;
+    if (entries.length === 0)
+        return false;
+    const operationIds = new Set(entries.map((entry) => entry.operationId));
+    if (operationIds.size !== entries.length)
+        return false;
+    const counts = new Map();
+    for (const entry of entries) {
+        for (const groupId of new Set(entry.catalogGroups)) {
+            counts.set(groupId, (counts.get(groupId) ?? 0) + 1);
+        }
+    }
+    if (counts.size !== groups.length)
+        return false;
+    return groups.every((group) => counts.get(group.groupId) === group.memberCount);
+}
+function fitsCapabilityBriefBudget(tokens, budget) {
+    return tokens <= budget;
+}
+function omittedBrief(budgetTokens, reason) {
+    return Object.freeze({
+        level: "none",
+        estimatedTokens: 0,
+        budgetTokens,
+        reason,
+    });
+}

package/dist/src/runtime/context/request-tool-results-message-binding.d.ts

@@ -0,0 +1,6 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { RequestToolResultsView } from "./request-tool-results.js";
+/** Mints one frozen message bound to its exact canonical result view. */
+export declare function bindRequestToolResultsMessage(view: RequestToolResultsView, content: string): ChatMessage;
+/** Accepts only a message minted for this exact canonical result view. */
+export declare function isRequestToolResultsMessageBoundToView(message: ChatMessage, view: RequestToolResultsView): boolean;

package/dist/src/runtime/context/request-tool-results-message-binding.js

@@ -0,0 +1,30 @@
+const REQUEST_TOOL_RESULTS_MESSAGE_AUTHORITY = Symbol("requestToolResultsMessageAuthority");
+/** Mints one frozen message bound to its exact canonical result view. */
+export function bindRequestToolResultsMessage(view, content) {
+    const message = { role: "user", content };
+    const authority = Object.freeze({ message, view });
+    Object.defineProperty(message, REQUEST_TOOL_RESULTS_MESSAGE_AUTHORITY, {
+        value: authority,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return Object.freeze(message);
+}
+/** Accepts only a message minted for this exact canonical result view. */
+export function isRequestToolResultsMessageBoundToView(message, view) {
+    const descriptor = Object.getOwnPropertyDescriptor(message, REQUEST_TOOL_RESULTS_MESSAGE_AUTHORITY);
+    if (!descriptor)
+        return false;
+    const authority = descriptor.value;
+    if (typeof authority !== "object" || authority === null)
+        return false;
+    if (!Object.isFrozen(authority))
+        return false;
+    const candidate = authority;
+    return (candidate.message === message &&
+        candidate.view === view &&
+        descriptor.enumerable === false &&
+        descriptor.configurable === false &&
+        descriptor.writable === false);
+}

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

@@ -0,0 +1,3 @@
+import type { RequestToolResultsView } from "./request-tool-results.js";
+/** Requires Planner-item views to carry only their exact call lane. */
+export declare function isRequestToolResultsViewValidForCallScope(view: RequestToolResultsView, callId: string, callScoped: boolean): boolean;

package/dist/src/runtime/context/request-tool-results-scope.js

@@ -0,0 +1,8 @@
+/** Requires Planner-item views to carry only their exact call lane. */
+export function isRequestToolResultsViewValidForCallScope(view, callId, callScoped) {
+    if (!callScoped)
+        return view.scope === undefined;
+    return (view.scope?.kind === "call" &&
+        view.scope.callId === callId &&
+        view.results.every((result) => result.callId === callId));
+}

package/dist/src/runtime/context/request-tool-results.d.ts

@@ -26,12 +26,16 @@ export type RequestToolResult = Readonly<{
 export type RequestToolResultsView = Readonly<{
     sourceRevision: number;
     results: readonly RequestToolResult[];
+    scope?: Readonly<{
+        kind: "call";
+        callId: string;
+    }>;
 }>;
 /**
- * Projects every settled capability result in canonical ledger order.
- * Summaries remain request-wide. Complete reference data is projected only
- * back to the exact call that produced it; callers consume the settled child
- * result instead of receiving a second copy of the capability payload.
+ * Projects settled capability results in canonical ledger order. Direct
+ * Planner-owned Workers receive only their exact call lane; other roles keep
+ * request-wide summaries. Complete reference data is projected only back to
+ * the exact call that produced it.
  */
 export declare function projectRequestToolResults(params: Readonly<{
     ledger: RoleCallLedger;

package/dist/src/runtime/context/request-tool-results.js

@@ -1,15 +1,17 @@
 import { isRoleCapabilityId, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../orchestration/role-calls/index.js";
+import { projectWorkerCapabilityPlannerItemBinding } from "../orchestration/worker-capabilities/assignment-provenance.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { normalizeCapabilityAdapterResult, } from "../orchestration/capability-adapters/result.js";
+import { bindRequestToolResultsMessage } from "./request-tool-results-message-binding.js";
 import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/index.js";
 import { projectAcceptedCapabilityAction, } from "./accepted-capability-action.js";
 export const REQUEST_TOOL_RESULTS_MESSAGE_KIND = "runtime_request_tool_results_v1";
 const REQUEST_TOOL_RESULTS_LOG_SCOPE = "runtime.request_tool_results";
 /**
- * Projects every settled capability result in canonical ledger order.
- * Summaries remain request-wide. Complete reference data is projected only
- * back to the exact call that produced it; callers consume the settled child
- * result instead of receiving a second copy of the capability payload.
+ * Projects settled capability results in canonical ledger order. Direct
+ * Planner-owned Workers receive only their exact call lane; other roles keep
+ * request-wide summaries. Complete reference data is projected only back to
+ * the exact call that produced it.
  */
 export function projectRequestToolResults(params) {
     const projected = [];
@@ -19,9 +21,12 @@ export function projectRequestToolResults(params) {
         if (params.ledger.current() !== params.head) {
             throw new Error("request_tool_results_head_stale");
         }
-        if (!params.head.state.calls.some(({ callId }) => callId === params.callId)) {
+        const call = params.head.state.calls.find(({ callId }) => callId === params.callId);
+        if (!call) {
             throw new Error("request_tool_results_call_invalid");
         }
+        const plannerItemScoped = projectWorkerCapabilityPlannerItemBinding(params.head, call) !==
+            undefined;
         for (const execution of params.head.state.capabilityExecutions) {
             if (execution.status === "running") {
                 runningExecutionCount += 1;
@@ -68,6 +73,8 @@ export function projectRequestToolResults(params) {
                 adapterResult: exactResult.value,
             });
             sourceProjected.push(sourceResult);
+            if (plannerItemScoped && execution.callId !== params.callId)
+                continue;
             if (execution.callId !== params.callId) {
                 const { referenceData: _referenceData, adapterResult: _adapterResult, acceptedAction: _acceptedAction, ...summaryOnlyResult } = sourceResult;
                 projected.push(Object.freeze(summaryOnlyResult));
@@ -80,6 +87,14 @@ export function projectRequestToolResults(params) {
         const view = Object.freeze({
             sourceRevision: params.head.revision,
             results: Object.freeze(currentResults),
+            ...(plannerItemScoped
+                ? {
+                    scope: Object.freeze({
+                        kind: "call",
+                        callId: params.callId,
+                    }),
+                }
+                : {}),
         });
         traceProjection("projected", params, currentResults, runningExecutionCount, undefined, sourceProjected);
         return view;
@@ -91,15 +106,13 @@ export function projectRequestToolResults(params) {
 }
 export function buildRequestToolResultsMessage(view) {
     const results = projectModelVisibleRequestToolResults(view.results);
-    return Object.freeze({
-        role: "user",
-        content: JSON.stringify({
-            kind: REQUEST_TOOL_RESULTS_MESSAGE_KIND,
-            authority: "reference_data",
-            sourceRevision: view.sourceRevision,
-            results,
-        }),
-    });
+    return bindRequestToolResultsMessage(view, JSON.stringify({
+        kind: REQUEST_TOOL_RESULTS_MESSAGE_KIND,
+        authority: "reference_data",
+        sourceRevision: view.sourceRevision,
+        ...(view.scope ? { coverage: view.scope } : {}),
+        results,
+    }));
 }
 export function buildCompactedRequestToolResultsMessage(view, checkpoint) {
     const modelVisibleResults = projectModelVisibleRequestToolResults(view.results);
@@ -127,30 +140,28 @@ export function buildCompactedRequestToolResultsMessage(view, checkpoint) {
     })) {
         throw new Error("request_tool_results_compaction_fingerprint_mismatch");
     }
-    return Object.freeze({
-        role: "user",
-        content: JSON.stringify({
-            kind: REQUEST_TOOL_RESULTS_MESSAGE_KIND,
-            authority: "reference_data",
-            sourceRevision: view.sourceRevision,
-            semanticCheckpoint: {
-                kind: checkpoint.kind,
-                scopeId: checkpoint.scopeId,
-                roleId: checkpoint.roleId,
-                callId: checkpoint.callId,
-                checkpointSourceRevision: checkpoint.sourceRevision,
-                presenceEffect: "passive_role_continuation_not_user_intent_or_completion",
-                coveredSources: checkpoint.sourceDigests.map(({ sourceRef, sourceFingerprint, digest }) => ({
-                    sourceRef,
-                    sourceFingerprint,
-                    digest,
-                })),
-                continuation: checkpoint.continuation,
-                coveredResults,
-            },
-            results: modelVisibleResults.filter(({ executionId }) => !coveredExecutionIds.has(executionId)),
-        }),
-    });
+    return bindRequestToolResultsMessage(view, JSON.stringify({
+        kind: REQUEST_TOOL_RESULTS_MESSAGE_KIND,
+        authority: "reference_data",
+        sourceRevision: view.sourceRevision,
+        ...(view.scope ? { coverage: view.scope } : {}),
+        semanticCheckpoint: {
+            kind: checkpoint.kind,
+            scopeId: checkpoint.scopeId,
+            roleId: checkpoint.roleId,
+            callId: checkpoint.callId,
+            checkpointSourceRevision: checkpoint.sourceRevision,
+            presenceEffect: "passive_role_continuation_not_user_intent_or_completion",
+            coveredSources: checkpoint.sourceDigests.map(({ sourceRef, sourceFingerprint, digest }) => ({
+                sourceRef,
+                sourceFingerprint,
+                digest,
+            })),
+            continuation: checkpoint.continuation,
+            coveredResults,
+        },
+        results: modelVisibleResults.filter(({ executionId }) => !coveredExecutionIds.has(executionId)),
+    }));
 }
 /**
  * Keeps the canonical settled-result view intact while ensuring that the

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

@@ -0,0 +1,10 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { RequestExecutionSeed } from "../request/contracts.js";
+export declare const SCHEDULED_EXECUTION_CONTEXT_KIND: "runtime_scheduled_execution_v1";
+type ScheduledExecutionPhase = "decision" | "response";
+export declare function projectScheduledExecutionContext(request: Pick<RequestExecutionSeed, "requestId" | "scheduledExecution">, instructions: string, phase: ScheduledExecutionPhase): Readonly<{
+    instructions: string;
+    referenceMessages: readonly ChatMessage[];
+}>;
+export declare function isScheduledExecutionContextMessage(message: ChatMessage): boolean;
+export {};

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

@@ -0,0 +1,52 @@
+export const SCHEDULED_EXECUTION_CONTEXT_KIND = "runtime_scheduled_execution_v1";
+const SCHEDULED_EXECUTION_CONTEXT_POLICY = [
+    "runtime_scheduled_execution_v1 is trusted request-local state from the runtime scheduler, bound to this request and Job run. The current user message contains the saved task to execute now.",
+    "This Job run has already been triggered; do not reinterpret its saved task as a new request to create or configure this schedule.",
+    "Preserve who performs the requested action: a reminder asks you to notify the user; a task delegated to you asks you to perform the assigned work. Execution origin does not change the saved task or its actor.",
+    "This state does not add user intent, grant additional authorization, or establish completion. It is not a user fact or a memory candidate.",
+].join("\n");
+const SCHEDULED_EXECUTION_PHASE_POLICY = Object.freeze({
+    decision: "Choose the action needed for this current run under the saved task and existing authority; the origin does not select a capability or require an external action for a reminder notification.",
+    response: "Present the requested outcome of this current run, preserving the task's actor. Do not claim you were asked to perform an action that the saved task asks the user to perform.",
+});
+export function projectScheduledExecutionContext(request, instructions, phase) {
+    const reference = request.scheduledExecution;
+    if (!hasScheduledExecutionOrigin(reference)) {
+        return Object.freeze({
+            instructions,
+            referenceMessages: Object.freeze([]),
+        });
+    }
+    const capsule = Object.freeze({
+        kind: SCHEDULED_EXECUTION_CONTEXT_KIND,
+        authority: "runtime_scheduler",
+        purpose: "execute_saved_task_for_current_run",
+        requestId: request.requestId,
+        jobId: reference.jobId,
+        runId: reference.runId,
+        scheduledAt: reference.scheduledAt,
+        triggerType: reference.triggerType,
+        presenceEffect: "execution_origin_only_not_new_intent_authorization_or_completion",
+    });
+    return Object.freeze({
+        instructions: [
+            instructions,
+            SCHEDULED_EXECUTION_CONTEXT_POLICY,
+            SCHEDULED_EXECUTION_PHASE_POLICY[phase],
+        ].join("\n\n"),
+        referenceMessages: Object.freeze([
+            Object.freeze({
+                role: "system",
+                content: JSON.stringify(capsule),
+            }),
+        ]),
+    });
+}
+function hasScheduledExecutionOrigin(reference) {
+    return reference !== undefined;
+}
+export function isScheduledExecutionContextMessage(message) {
+    if (message.role !== "system")
+        return false;
+    return message.content.startsWith(`{"kind":${JSON.stringify(SCHEDULED_EXECUTION_CONTEXT_KIND)},`);
+}

package/dist/src/runtime/default-adapters.d.ts

@@ -1,32 +1,3 @@
-import { type RuntimeAttachmentStore } from "./attachments/store.js";
-import type { ConversationContextProvider, EventSink, EventSinkFactory, ModelGatewayClient, RuntimeConfig, RuntimeHost, SessionStore, SkillProvider, ToolRegistry, WorkspaceProvider } from "./ports.js";
-import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "./composition.js";
-import { type LongTermMemoryService } from "./long-term-memory/index.js";
-export declare function createDefaultRuntimeHost(config?: RuntimeConfig, defaults?: DefaultRuntimeHostBindings): RuntimeHost;
-export type DefaultRuntimeHostBindings = Readonly<{
-    runtimeId?: string;
-    agentBridgeUrl?: string;
-    agentBridgeToken?: string;
-    eventSinkFactory?: EventSinkFactory;
-    modelGatewayClient?: ModelGatewayClient;
-    sessionStore?: SessionStore;
-    attachmentStore?: RuntimeAttachmentStore;
-    toolRegistry?: ToolRegistry;
-    longTermMemoryService?: LongTermMemoryService;
-    services?: RuntimeEnvironmentServices;
-    requestHandler?: RuntimeRequestHandler;
-    requestHandlerFactory?: (services: RuntimeEnvironmentServices) => RuntimeRequestHandler;
-}>;
-export declare function createBoundRuntimeRequestHandler(services: RuntimeEnvironmentServices): RuntimeRequestHandler;
-export declare function createDefaultAttachmentStore(config: RuntimeConfig): RuntimeAttachmentStore;
-export declare function createDefaultSessionStore(config?: RuntimeConfig): SessionStore;
-export declare function createDefaultConversationContextProvider(): ConversationContextProvider;
-export declare function createDefaultToolRegistry(config?: RuntimeConfig): ToolRegistry;
-export declare function createDefaultSkillProvider(config?: RuntimeConfig, options?: {
-    toolRegistry?: Pick<ToolRegistry, "listDefinitions">;
-}): SkillProvider;
-export declare function createDefaultWorkspaceProvider(config?: RuntimeConfig): WorkspaceProvider;
-export declare function createDefaultModelGatewayClient(config?: RuntimeConfig): ModelGatewayClient;
-export declare function createDefaultLongTermMemoryService(config: RuntimeConfig | undefined, models: ModelGatewayClient): LongTermMemoryService;
-export declare function createDefaultEventSinkFactory(config?: RuntimeConfig): EventSinkFactory;
-export declare function createNoopEventSink(): EventSink;
+export { createDefaultAttachmentStore, createDefaultConversationContextProvider, createDefaultEventSinkFactory, createDefaultLongTermMemoryService, createDefaultModelGatewayClient, createDefaultSessionStore, createDefaultSkillProvider, createDefaultToolRegistry, createDefaultWorkspaceProvider, createNoopEventSink, } from "./default-environment-adapters.js";
+export { createDefaultRuntimeHost, type DefaultRuntimeHostBindings, } from "./runtime-host.js";
+export { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";