@abot-ai/runtime 1.0.0 → 1.2.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/model-step-compaction.js

@@ -1,3 +1,4 @@
+import { OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND } from "./operation-supervision-evidence.js";
 import { SEMANTIC_COMPACTION_CONTEXT_LANE, assertValidSemanticCompactionCheckpoint, createSemanticCompactionSha256Fingerprint, generateSemanticCompactionCandidateBatched, sameSemanticCompactionCheckpointBinding, } from "./semantic-compaction/index.js";
 const PAYLOAD_CONTEXT_PREFIX = "Canonical runtime context:\n";
 export function createModelStepCompactionController(request, options) {
@@ -183,6 +184,11 @@ function resolveMessageSources(message, resultSourceOverrides) {
         }));
     }
     const record = parseJsonRecord(message.content);
+    if (record?.kind === OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND) {
+        return Object.freeze([
+            createMessageSource(hashedMessageSourceRef("operation-supervision-evidence", message.content), message),
+        ]);
+    }
     if (record?.kind === "runtime_request_tool_results_v1") {
         return Object.freeze(readRecordArray(record.results).flatMap((result) => {
             const source = resolveScannableResultSource(result, undefined, resultSourceOverrides);

package/dist/src/runtime/context/operation-supervision-evidence.d.ts

@@ -0,0 +1,37 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import { type RoleCallFrame, type RoleCallLedgerHead, type RoleCapabilityExecution, type RoleOperationSupervisionNotice } from "../orchestration/role-calls/index.js";
+import { type CapabilityAdapterResult } from "../orchestration/capability-adapters/result.js";
+import { type AcceptedCapabilityAction } from "./accepted-capability-action.js";
+export declare const OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND: "runtime_operation_supervision_evidence_v1";
+export type OperationSupervisionEvidenceReceipt = Readonly<{
+    executionId: string;
+    callId: string;
+    invocationAttempt: number;
+    capabilityId: string;
+    declaredEffect: RoleCapabilityExecution["declaredEffect"];
+    outcome: Exclude<RoleCapabilityExecution["outcome"], null>;
+    observedEffect: Exclude<RoleCapabilityExecution["observedEffect"], null>;
+    summary: string;
+    referenceData?: string;
+    references?: RoleCapabilityExecution["references"];
+}>;
+export type OperationSupervisionEvidenceAcceptedAction = AcceptedCapabilityAction;
+export type OperationSupervisionEvidenceEntry = Readonly<{
+    originExecutionId: string;
+    notice: RoleOperationSupervisionNotice;
+    evidence: Readonly<{
+        kind: "existing_exact_capability_result_lane";
+        executionId: string;
+    }> | Readonly<{
+        kind: "embedded_cross_call_exact_result";
+        acceptedAction: OperationSupervisionEvidenceAcceptedAction;
+        receipt: OperationSupervisionEvidenceReceipt;
+        adapterResult: CapabilityAdapterResult;
+    }>;
+}>;
+/**
+ * Resolves exact canonical evidence only for supervision notices created for
+ * this activation. The capsule is derived on demand and never changes result
+ * ownership or request-wide result projection.
+ */
+export declare function buildImmediateOperationSupervisionEvidenceMessage(head: RoleCallLedgerHead, call: RoleCallFrame): ChatMessage | undefined;

package/dist/src/runtime/context/operation-supervision-evidence.js

@@ -0,0 +1,90 @@
+import { projectImmediateRoleOperationSupervisionNotices, } from "../orchestration/role-calls/index.js";
+import { normalizeCapabilityAdapterResult, } from "../orchestration/capability-adapters/result.js";
+import { projectAcceptedCapabilityAction, } from "./accepted-capability-action.js";
+export const OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND = "runtime_operation_supervision_evidence_v1";
+/**
+ * Resolves exact canonical evidence only for supervision notices created for
+ * this activation. The capsule is derived on demand and never changes result
+ * ownership or request-wide result projection.
+ */
+export function buildImmediateOperationSupervisionEvidenceMessage(head, call) {
+    const notices = projectImmediateRoleOperationSupervisionNotices(head, call);
+    if (notices.length === 0)
+        return undefined;
+    const entries = notices.map((notice) => projectLinkedEvidenceEntry(head, call, notice));
+    return Object.freeze({
+        role: "user",
+        content: JSON.stringify({
+            kind: OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND,
+            authority: "canonical_role_call_ledger",
+            purpose: "supply_exact_immediate_operation_supervision_evidence",
+            applicability: "bound_activation_decision_or_its_immediate_presentation_handoff",
+            presenceEffect: "passive_evidence_not_user_intent_action_authority_or_new_execution",
+            sourceRevision: head.revision,
+            binding: {
+                callId: call.callId,
+                invocationAttempt: call.activationCount,
+                consumers: ["activation_decision", "immediate_presentation_handoff"],
+            },
+            coverage: "complete_for_immediate_operation_supervision_notices",
+            entries,
+        }),
+    });
+}
+function projectLinkedEvidenceEntry(head, call, notice) {
+    const execution = head.state.capabilityExecutions.find(({ executionId }) => executionId === notice.originExecutionId);
+    if (!isLinkedSettledExecution(execution, notice)) {
+        throw new Error("operation_supervision_evidence_origin_invalid");
+    }
+    const exactResult = normalizeCapabilityAdapterResult(execution.exactResult);
+    if (!exactResult.ok) {
+        throw new Error("operation_supervision_evidence_result_invalid");
+    }
+    const entry = {
+        originExecutionId: notice.originExecutionId,
+        notice,
+    };
+    if (execution.callId === call.callId) {
+        return Object.freeze({
+            ...entry,
+            evidence: Object.freeze({
+                kind: "existing_exact_capability_result_lane",
+                executionId: execution.executionId,
+            }),
+        });
+    }
+    return Object.freeze({
+        ...entry,
+        evidence: Object.freeze({
+            kind: "embedded_cross_call_exact_result",
+            acceptedAction: projectAcceptedCapabilityAction(head, execution),
+            receipt: Object.freeze({
+                executionId: execution.executionId,
+                callId: execution.callId,
+                invocationAttempt: execution.invocationAttempt,
+                capabilityId: execution.capabilityId,
+                declaredEffect: execution.declaredEffect,
+                outcome: execution.outcome,
+                observedEffect: execution.observedEffect,
+                summary: execution.summary,
+                ...(execution.referenceData
+                    ? { referenceData: execution.referenceData }
+                    : {}),
+                ...(execution.references
+                    ? { references: Object.freeze([...execution.references]) }
+                    : {}),
+            }),
+            adapterResult: exactResult.value,
+        }),
+    });
+}
+function isLinkedSettledExecution(execution, notice) {
+    return (execution !== undefined &&
+        execution.status === "settled" &&
+        execution.executionId === notice.originExecutionId &&
+        execution.actionFingerprint === notice.actionFingerprint &&
+        execution.outcome === notice.priorOutcome &&
+        execution.outcomeFingerprint === notice.outcomeFingerprint &&
+        execution.observedEffect !== null &&
+        execution.summary !== null);
+}

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

@@ -3,6 +3,7 @@ import type { ModelStep } from "../../shared/model-steps.js";
 import { type RoleCallLedger, type RoleCallLedgerHead, type RoleCapabilityDeclaredEffect, type RoleCapabilityExecutionOutcome, type RoleCapabilityObservedEffect, type RoleCapabilityResultReference } from "../orchestration/role-calls/index.js";
 import { type CapabilityAdapterResult } from "../orchestration/capability-adapters/result.js";
 import { type SemanticCompactionCheckpoint } from "./semantic-compaction/index.js";
+import { type AcceptedCapabilityAction } from "./accepted-capability-action.js";
 export declare const REQUEST_TOOL_RESULTS_MESSAGE_KIND: "runtime_request_tool_results_v1";
 export type RequestToolResult = Readonly<{
     executionId: string;
@@ -15,6 +16,8 @@ export type RequestToolResult = Readonly<{
     summary: string;
     referenceData?: string;
     references?: readonly RoleCapabilityResultReference[];
+    /** Exact accepted action, projected only to the call that produced it. */
+    acceptedAction?: AcceptedCapabilityAction;
     /** Exact canonical evidence, projected only to the call that produced it. */
     adapterResult?: CapabilityAdapterResult;
     summaryProjection?: "superseded_target_evidence";
@@ -23,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,14 +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 = [];
@@ -18,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;
@@ -59,11 +65,18 @@ export function projectRequestToolResults(params) {
                 ...(execution.references
                     ? { references: Object.freeze([...execution.references]) }
                     : {}),
+                ...(execution.actionFingerprint
+                    ? {
+                        acceptedAction: projectAcceptedCapabilityAction(params.head, execution),
+                    }
+                    : {}),
                 adapterResult: exactResult.value,
             });
             sourceProjected.push(sourceResult);
+            if (plannerItemScoped && execution.callId !== params.callId)
+                continue;
             if (execution.callId !== params.callId) {
-                const { referenceData: _referenceData, adapterResult: _adapterResult, ...summaryOnlyResult } = sourceResult;
+                const { referenceData: _referenceData, adapterResult: _adapterResult, acceptedAction: _acceptedAction, ...summaryOnlyResult } = sourceResult;
                 projected.push(Object.freeze(summaryOnlyResult));
             }
             else {
@@ -74,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;
@@ -85,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);
@@ -121,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
@@ -271,10 +288,13 @@ export function projectCurrentRequestToolResults(results) {
     return projected;
 }
 function equivalentObservationKey(result, targets) {
+    const acceptedAction = result.acceptedAction;
     return JSON.stringify([
         result.capabilityId,
         [...targets].sort(),
-        result.summary,
+        ...(acceptedAction
+            ? [acceptedAction.controls, acceptedAction.workingDirectory]
+            : [result.summary]),
     ]);
 }
 function isDeclaredEffect(value) {

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

@@ -1,6 +1,7 @@
 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;
@@ -11,6 +12,7 @@ export type DefaultRuntimeHostBindings = Readonly<{
     sessionStore?: SessionStore;
     attachmentStore?: RuntimeAttachmentStore;
     toolRegistry?: ToolRegistry;
+    longTermMemoryService?: LongTermMemoryService;
     services?: RuntimeEnvironmentServices;
     requestHandler?: RuntimeRequestHandler;
     requestHandlerFactory?: (services: RuntimeEnvironmentServices) => RuntimeRequestHandler;
@@ -25,5 +27,6 @@ export declare function createDefaultSkillProvider(config?: RuntimeConfig, optio
 }): 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;

package/dist/src/runtime/default-adapters.js

@@ -1,6 +1,8 @@
+import { join } from "node:path";
 import { startAgentBridge } from "../bridge/start-agent-bridge.js";
 import { buildContextBuckets, buildContextWindow } from "../sessions/index.js";
-import { createModelGatewayClient, invokeModelGateway, invokeRawModelGateway, } from "../model-gateway/client.js";
+import { createModelGatewayClient, embedModelGateway, invokeModelGateway, invokeRawModelGateway, } from "../model-gateway/client.js";
+import { MAX_MODEL_GATEWAY_EMBEDDING_BATCH_SIZE } from "../model-gateway/embeddings/constants.js";
 import { createBundledPluginSkillProvider, createConfiguredSkillProvider, } from "./adapters/configured-skill-provider.js";
 import { createFileSessionStore } from "./adapters/file-session-store.js";
 import { createFileAttachmentStore, } from "./attachments/store.js";
@@ -11,6 +13,9 @@ import { createConfiguredToolRegistry } from "./capabilities/configured-tool-reg
 import { loadBundledRuntimePlugins, loadConfiguredRuntimePlugins, runtimePluginsToToolModules, } from "./plugins/loader.js";
 import { handleRunRequest } from "./request/handler.js";
 import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
+import { createFileLongTermMemoryRepository } from "./adapters/long-term-memory/file-repository.js";
+import { createInMemoryLongTermMemoryRepository } from "./adapters/long-term-memory/in-memory-repository.js";
+import { createLongTermMemoryService, } from "./long-term-memory/index.js";
 export function createDefaultRuntimeHost(config, defaults = {}) {
     return {
         start(options = {}) {
@@ -90,13 +95,19 @@ function resolveRuntimeHostEnvironmentServices(params) {
         (mayUseLegacyDefaults ? params.defaults.eventSinkFactory : undefined) ??
         createDefaultEventSinkFactory(runtimeConfig);
     const sessionMemoryCompactor = bound?.sessionMemoryCompactor ?? createModelSessionMemoryCompactor();
-    if (mayReuseBound &&
+    const mayReuseBoundLongTermMemory = mayReuseBound && models === bound?.models;
+    const longTermMemory = params.options.longTermMemoryService ??
+        (mayReuseBoundLongTermMemory ? bound?.longTermMemory : undefined) ??
+        createDefaultLongTermMemoryService(runtimeConfig, models);
+    const reusesAllBoundServices = mayReuseBound &&
         sessions === bound.sessions &&
         attachments === bound.attachments &&
         tools === bound.tools &&
         models === bound.models &&
         events === bound.events &&
-        sessionMemoryCompactor === bound.sessionMemoryCompactor) {
+        sessionMemoryCompactor === bound.sessionMemoryCompactor &&
+        longTermMemory === bound.longTermMemory;
+    if (reusesAllBoundServices) {
         return bound;
     }
     return Object.freeze({
@@ -107,6 +118,7 @@ function resolveRuntimeHostEnvironmentServices(params) {
         models,
         events,
         sessionMemoryCompactor,
+        longTermMemory,
     });
 }
 function resolveRuntimeHostRequestHandler(services, defaults) {
@@ -124,6 +136,7 @@ export function createBoundRuntimeRequestHandler(services) {
         attachmentStore: services.attachments,
         toolRegistry: services.tools,
         sessionMemoryCompactor: services.sessionMemoryCompactor,
+        longTermMemory: services.longTermMemory,
     };
     return Object.freeze({
         handle(ws, message, requestOptions = {}) {
@@ -171,6 +184,7 @@ export function createDefaultModelGatewayClient(config) {
         return {
             invoke: invokeModelGateway,
             invokeRaw: invokeRawModelGateway,
+            embed: embedModelGateway,
         };
     }
     return createModelGatewayClient({
@@ -179,6 +193,53 @@ export function createDefaultModelGatewayClient(config) {
         ...(config.models ? { modelPolicy: config.models } : {}),
     });
 }
+export function createDefaultLongTermMemoryService(config, models) {
+    const memoryConfig = config?.longTermMemory ?? {
+        enabled: false,
+        emitClientEvents: false,
+    };
+    const repository = config
+        ? createFileLongTermMemoryRepository(join(config.paths.runtimeDir, "long-term-memory"))
+        : createInMemoryLongTermMemoryRepository();
+    const embeddings = memoryConfig.enabled && config
+        ? createLongTermMemoryEmbeddingClient({ config, models })
+        : undefined;
+    return createLongTermMemoryService({
+        repository,
+        enabled: memoryConfig.enabled,
+        emitClientEvents: memoryConfig.emitClientEvents,
+        ...(embeddings ? { embeddings } : {}),
+    });
+}
+function createLongTermMemoryEmbeddingClient(params) {
+    const profileId = params.config.longTermMemory?.embeddingProfileId;
+    if (!profileId) {
+        throw new Error("long_term_memory_embedding_profile_required");
+    }
+    if (!params.models.embed) {
+        throw new Error("long_term_memory_embedding_gateway_unavailable");
+    }
+    const embed = params.models.embed;
+    return Object.freeze({
+        maxBatchSize: MAX_MODEL_GATEWAY_EMBEDDING_BATCH_SIZE,
+        async embed(input) {
+            const result = await embed({
+                profileId,
+                texts: input.texts,
+                modelPolicy: params.config.models,
+                abortSignal: input.abortSignal,
+                ...(input.debugRequestId
+                    ? { debugRequestId: input.debugRequestId }
+                    : {}),
+            });
+            return Object.freeze({
+                modelFingerprint: result.modelFingerprint,
+                dimensions: result.dimensions,
+                vectors: result.vectors,
+            });
+        },
+    });
+}
 export function createDefaultEventSinkFactory(config) {
     if (config) {
         configureDebugLogger({

package/dist/src/runtime/index.d.ts

@@ -9,4 +9,5 @@ export * from "./adapters/in-memory-session-store.js";
 export * from "./adapters/multi-workspace-provider.js";
 export * from "./adapters/source-workspace-provider.js";
 export * from "./attachments/store.js";
+export * from "./long-term-memory/index.js";
 export * from "./observability/debug-logger.js";