@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-observability.d.ts

@@ -0,0 +1,35 @@
+import type { RoleCallFrame } from "../../orchestration/role-calls/index.js";
+import type { RegisteredToolNormalInvocationExecutor } from "../registered-tool-normal-invocations.js";
+import { type RegisteredToolWorkerCapabilityProviderDiagnostic } from "../registered-tool-worker-capability-diagnostics.js";
+export type PayloadStageMaterializationDetails = Readonly<{
+    payloadStage: number;
+    payloadStageCount: number;
+    source: "manifest_literal";
+    byteCount: number;
+}>;
+/**
+ * Keeps tool-payload lifecycle and its adapter diagnostic provisional during
+ * preparation. Canonically admitted execution releases them in their original
+ * order; discarded preparations never publish them.
+ */
+export declare function createDeferredPayloadObservability(params: {
+    executor: RegisteredToolNormalInvocationExecutor;
+    diagnostic: RegisteredToolWorkerCapabilityProviderDiagnostic;
+    operationId: string;
+    call: RoleCallFrame;
+}): Readonly<{
+    lifecycleEmitter: Readonly<{
+        emitPayloadLifecycle(input: Parameters<RegisteredToolNormalInvocationExecutor["emitPayloadLifecycle"]>[0]): Readonly<{
+            status: "rejected";
+            code: string;
+            message: string;
+        }> | Readonly<{
+            status: "emitted";
+        }>;
+    }>;
+    deferPayloadStageMaterialized(details: PayloadStageMaterializationDetails): void;
+    release(executionId: string): void;
+}>;
+export type PayloadLifecycleEmitter = Readonly<{
+    emitPayloadLifecycle: RegisteredToolNormalInvocationExecutor["emitPayloadLifecycle"];
+}>;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-observability.js

@@ -0,0 +1,32 @@
+import { traceRegisteredToolWorkerCapabilityPayloadStageMaterialized, } from "../registered-tool-worker-capability-diagnostics.js";
+/**
+ * Keeps tool-payload lifecycle and its adapter diagnostic provisional during
+ * preparation. Canonically admitted execution releases them in their original
+ * order; discarded preparations never publish them.
+ */
+export function createDeferredPayloadObservability(params) {
+    const deferred = [];
+    const lifecycleEmitter = Object.freeze({
+        emitPayloadLifecycle(input) {
+            const prepared = params.executor.preparePayloadLifecycle(input);
+            if (prepared.status === "rejected")
+                return prepared;
+            deferred.push(() => {
+                prepared.emit();
+            });
+            return Object.freeze({ status: "emitted" });
+        },
+    });
+    return Object.freeze({
+        lifecycleEmitter,
+        deferPayloadStageMaterialized(details) {
+            deferred.push((executionId) => {
+                traceRegisteredToolWorkerCapabilityPayloadStageMaterialized(params.diagnostic, params.operationId, params.call, executionId, details);
+            });
+        },
+        release(executionId) {
+            for (const publish of deferred)
+                publish(executionId);
+        },
+    });
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-rejection.d.ts

@@ -1,11 +1,11 @@
 import type { CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 import type { WorkerCapabilityAdapterResult, WorkerCapabilityExecutionFreshness } from "../../orchestration/worker-capabilities/index.js";
-import type { RegisteredToolNormalInvocationExecutor } from "../registered-tool-normal-invocations.js";
+import type { PayloadLifecycleEmitter } from "./payload-observability.js";
 export declare const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION: "steering_superseded_before_external_execution";
 export declare const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
-export type PayloadLifecycleContext = Readonly<Omit<Parameters<RegisteredToolNormalInvocationExecutor["emitPayloadLifecycle"]>[0], "phase" | "errorCode">>;
+export type PayloadLifecycleContext = Readonly<Omit<Parameters<PayloadLifecycleEmitter["emitPayloadLifecycle"]>[0], "phase" | "errorCode">>;
 export declare function rejectPayloadLifecycle(params: {
-    executor: RegisteredToolNormalInvocationExecutor;
+    executor: PayloadLifecycleEmitter;
     lifecycle: PayloadLifecycleContext;
     code: string;
     message: string;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-rejection.js

@@ -1,4 +1,5 @@
 import { boundedSummary, requireCapabilityAdapterResult, } from "./result-observer.js";
+import { createRegisteredToolWorkerFailureOutcomeFingerprint } from "./failure-outcome-fingerprint.js";
 export const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION = "steering_superseded_before_external_execution";
 export const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
 export function rejectPayloadLifecycle(params) {
@@ -12,22 +13,26 @@ export function rejectPayloadLifecycle(params) {
         : (params.fallback ?? payloadRejection(params.code, params.message));
 }
 export function payloadRejection(sourceIssueCode, summary) {
+    const exactResult = requireCapabilityAdapterResult({
+        kind: "runtime_capability_rejection_v1",
+        authority: "runtime",
+        status: "rejected",
+        stage: "before_external_execution",
+        code: sourceIssueCode,
+        message: summary,
+    });
     return Object.freeze({
         status: "rejected",
         result: Object.freeze({
             outcome: "failed",
             observedEffect: "none",
             summary: boundedSummary(summary),
+            failureOutcomeFingerprint: sourceIssueCode === STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION
+                ? null
+                : createRegisteredToolWorkerFailureOutcomeFingerprint(exactResult),
         }),
         sourceIssueCode,
-        exactResult: requireCapabilityAdapterResult({
-            kind: "runtime_capability_rejection_v1",
-            authority: "runtime",
-            status: "rejected",
-            stage: "before_external_execution",
-            code: sourceIssueCode,
-            message: summary,
-        }),
+        exactResult,
     });
 }
 export function executionFreshnessRejection(freshness) {

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.d.ts

@@ -1,23 +1,25 @@
 import type { ToolExecutionSharedState } from "../../../capabilities/tool-types.js";
 import type { CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 import type { WorkerCapabilityAdapterResult, WorkerCapabilityExecutionFreshness, WorkerCapabilityPayloadAuthor } from "../../orchestration/worker-capabilities/index.js";
-import type { RegisteredToolNormalInvocationExecutor, RegisteredToolNormalInvocationProjection } from "../registered-tool-normal-invocations.js";
+import type { RegisteredToolNormalInvocationProjection } from "../registered-tool-normal-invocations.js";
 import { type RegisteredToolStagedPayloadPlan } from "../registered-tool-payload-plan.js";
-import { type RegisteredToolWorkerCapabilityProviderDiagnostic } from "../registered-tool-worker-capability-diagnostics.js";
+import type { PayloadLifecycleEmitter, PayloadStageMaterializationDetails } from "./payload-observability.js";
 export type StagedOperationPayloadParams = Readonly<{
     plan: RegisteredToolStagedPayloadPlan;
     handle: RegisteredToolNormalInvocationProjection["handle"];
-    executor: RegisteredToolNormalInvocationExecutor;
+    executor: PayloadLifecycleEmitter;
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
+    assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;
     descriptor: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["descriptor"];
     intent: string;
+    authoringObjective?: string;
     controls: Readonly<Record<string, unknown>>;
     dependencyResults?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["dependencyResults"];
     settledCapabilityResults: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["settledCapabilityResults"];
-    diagnostic: RegisteredToolWorkerCapabilityProviderDiagnostic;
+    deferPayloadStageMaterialized(details: PayloadStageMaterializationDetails): void;
     executionFreshness?: WorkerCapabilityExecutionFreshness;
 }>;
 export type StagedOperationPayloadResult = Readonly<{

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.js

@@ -1,5 +1,5 @@
-import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadRelatedArtifactContexts, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
-import { traceRegisteredToolWorkerCapabilityPayloadStageMaterialized, } from "../registered-tool-worker-capability-diagnostics.js";
+import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-related-artifacts.js";
+import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
 import { normalizePayloadAuthoringResult } from "./payload-authoring-result.js";
 import { executionFreshnessRejection, payloadRejection, rejectPayloadLifecycle, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "./payload-rejection.js";
 export async function prepareStagedOperationPayload(params) {
@@ -173,12 +173,22 @@ class PayloadStageRunner {
                     targetParam: this.params.plan.targetParam,
                     controls: this.params.controls,
                     sharedState: this.params.sharedState,
+                    call: this.params.call,
+                    ...(this.params.assignmentProvenance
+                        ? { assignmentProvenance: this.params.assignmentProvenance }
+                        : {}),
                     settledCapabilityResults: this.params.settledCapabilityResults,
                 });
                 rawAuthored = await payloadAuthor.author({
                     call: this.params.call,
+                    ...(this.params.assignmentProvenance
+                        ? { assignmentProvenance: this.params.assignmentProvenance }
+                        : {}),
                     executionId: this.params.executionId,
                     descriptor: this.params.descriptor,
+                    ...(this.params.authoringObjective
+                        ? { authoringObjective: this.params.authoringObjective }
+                        : {}),
                     controls: this.params.controls,
                     contextScope,
                     ...(this.params.dependencyResults
@@ -267,7 +277,7 @@ class PayloadStageRunner {
     }
     completeStage(input) {
         if (input.stageInputs.literalResolution.status === "matched") {
-            traceRegisteredToolWorkerCapabilityPayloadStageMaterialized(this.params.diagnostic, this.params.descriptor.capabilityId, this.params.call, this.params.executionId, {
+            this.params.deferPayloadStageMaterialized({
                 payloadStage: input.started.stageIndex,
                 payloadStageCount: input.started.stageCount,
                 source: "manifest_literal",

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-observer.js

@@ -1,14 +1,22 @@
 import { executionProtocolError } from "./errors.js";
+import { createRegisteredToolWorkerFailureOutcomeFingerprint } from "./failure-outcome-fingerprint.js";
 import { boundedSummary, captureRegisteredToolResult, projectMutationGrounding, projectObservationOutput, projectToolTargetReferences, summarizeCompletedMutation, validateToolExecutionResult, } from "./result-evidence.js";
 import { isPlainRecord, nonEmpty, safeIssueCode } from "./values.js";
 export function observeExternalResult(input, expectedEffect, directRoot) {
     const observed = observeExternalResultLegacy(input, expectedEffect, directRoot);
+    const exactResult = captureRegisteredToolResult(input);
     return Object.freeze({
         ...observed,
-        result: Object.freeze({
-            ...observed.result,
-            exactResult: captureRegisteredToolResult(input),
-        }),
+        result: observed.result.outcome === "failed"
+            ? Object.freeze({
+                ...observed.result,
+                exactResult,
+                failureOutcomeFingerprint: createRegisteredToolWorkerFailureOutcomeFingerprint(exactResult),
+            })
+            : Object.freeze({
+                ...observed.result,
+                exactResult,
+            }),
     });
 }
 function observeExternalResultLegacy(input, expectedEffect, directRoot) {

package/dist/src/runtime/capabilities/request-bound-tool-registry.js

@@ -1,3 +1,4 @@
+import { projectAvailableTools } from "./tool-availability.js";
 /**
  * Adds trusted request services to an already config-filtered Tool Registry.
  * Tools remain opaque to the request flow.
@@ -54,27 +55,3 @@ export function bindRequestToolRegistry(params) {
         }),
     });
 }
-function projectAvailableTools(registrations) {
-    if (registrations === undefined)
-        return undefined;
-    const entries = registrations.flatMap((registration) => registration.contract.operations.map((operation) => Object.freeze({
-        toolName: registration.toolName,
-        operationId: operation.operationId,
-        summary: operation.summary,
-        catalogGroups: Object.freeze([
-            ...(registration.definition.catalogGroups ?? ["other"]),
-        ]),
-        effect: operation.effect,
-    })));
-    entries.sort(compareAvailableTools);
-    return Object.freeze(entries);
-}
-function compareAvailableTools(left, right) {
-    const byOperation = compareAscii(left.operationId, right.operationId);
-    return byOperation !== 0
-        ? byOperation
-        : compareAscii(left.toolName, right.toolName);
-}
-function compareAscii(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/src/runtime/capabilities/tool-availability.d.ts

@@ -0,0 +1,6 @@
+import type { RegisteredToolNormalInvocation, ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
+/** Passive request-effective tool facts, independent of execution services. */
+export interface ToolAvailabilitySource {
+    getAvailableTools(): readonly ToolAvailabilityEntry[] | undefined;
+}
+export declare function projectAvailableTools(registrations: readonly RegisteredToolNormalInvocation[] | undefined): readonly ToolAvailabilityEntry[] | undefined;

package/dist/src/runtime/capabilities/tool-availability.js

@@ -0,0 +1,28 @@
+export function projectAvailableTools(registrations) {
+    if (registrations === undefined)
+        return undefined;
+    const entries = registrations.flatMap((registration) => registration.contract.operations.map((operation) => Object.freeze({
+        toolName: registration.toolName,
+        operationId: operation.operationId,
+        summary: operation.summary,
+        catalogGroups: Object.freeze([
+            ...(registration.definition.catalogGroups ?? ["other"]),
+        ]),
+        effect: operation.effect,
+    })));
+    entries.sort(compareAvailableTools);
+    return Object.freeze(entries);
+}
+function compareAvailableTools(left, right) {
+    const byOperation = compareAscii(left.operationId, right.operationId);
+    return byOperation !== 0
+        ? byOperation
+        : compareAscii(left.toolName, right.toolName);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

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

@@ -3,6 +3,7 @@ import type { EventSinkFactory, ModelGatewayClient, RuntimeConfig, RuntimeHost,
 import type { RuntimeAttachmentStore } from "./attachments/store.js";
 import type { RequestHandlerOptions, RunRequestMessage } from "./request/contracts.js";
 import { type SessionMemoryCompactor } from "./context/session-memory/index.js";
+import type { LongTermMemoryService } from "./long-term-memory/contracts.js";
 export type RuntimeEnvironmentServices = Readonly<{
     config: RuntimeConfig;
     sessions: SessionStore;
@@ -11,6 +12,7 @@ export type RuntimeEnvironmentServices = Readonly<{
     models: ModelGatewayClient;
     events: EventSinkFactory;
     sessionMemoryCompactor: SessionMemoryCompactor;
+    longTermMemory: LongTermMemoryService;
 }>;
 export type RuntimeRequestOptions = Pick<RequestHandlerOptions, "toolApprovalController" | "requestSteering">;
 export type RuntimeRequestHandler = Readonly<{
@@ -30,6 +32,7 @@ export type RuntimeDependencies = {
     models: ModelGatewayClient;
     events: EventSinkFactory;
     sessionMemoryCompactor: SessionMemoryCompactor;
+    longTermMemory: LongTermMemoryService;
 };
 export type RuntimeDependencyOverrides = Partial<Omit<RuntimeDependencies, "config">>;
 export type RuntimeApplicationOverrides = RuntimeDependencyOverrides;

package/dist/src/runtime/composition.js

@@ -1,16 +1,19 @@
-import { createBoundRuntimeRequestHandler, createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, createDefaultRuntimeHost, createDefaultSessionStore, createDefaultToolRegistry, } from "./default-adapters.js";
+import { createBoundRuntimeRequestHandler, createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, createDefaultLongTermMemoryService, createDefaultRuntimeHost, createDefaultSessionStore, createDefaultToolRegistry, } from "./default-adapters.js";
 import { loadRuntimeConfig } from "./config.js";
 import { createModelSessionMemoryCompactor, } from "./context/session-memory/index.js";
 export function createRuntimeApplication(config = loadRuntimeConfig(), overrides = {}) {
     const tools = overrides.tools ?? createDefaultToolRegistry(config);
+    const models = overrides.models ?? createDefaultModelGatewayClient(config);
     const services = Object.freeze({
         config,
         sessions: overrides.sessions ?? createDefaultSessionStore(config),
         attachments: overrides.attachments ?? createDefaultAttachmentStore(config),
         tools,
-        models: overrides.models ?? createDefaultModelGatewayClient(config),
+        models,
         events: overrides.events ?? createDefaultEventSinkFactory(config),
         sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
+        longTermMemory: overrides.longTermMemory ??
+            createDefaultLongTermMemoryService(config, models),
     });
     const requests = createRuntimeRequestHandler(services);
     const host = overrides.host ??

package/dist/src/runtime/config/builders.js

@@ -378,6 +378,33 @@ function buildModelProviders(providers) {
     }
     return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }
+function buildEmbeddingProfiles(profiles) {
+    if (!isRecord(profiles)) {
+        return undefined;
+    }
+    const entries = [];
+    for (const [profileId, value] of Object.entries(profiles)) {
+        if (!isRecord(value)) {
+            continue;
+        }
+        const provider = readNestedConfigString(value, "provider");
+        const model = readNestedConfigString(value, "model");
+        if (!provider || !model) {
+            continue;
+        }
+        const label = readNestedConfigString(value, "label");
+        entries.push([
+            profileId,
+            {
+                provider,
+                model,
+                ...(label ? { label } : {}),
+                ...(isRecord(value.options) ? { options: { ...value.options } } : {}),
+            },
+        ]);
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
 function buildModelProfiles(profiles, options) {
     if (!isRecord(profiles)) {
         return {};
@@ -461,14 +488,20 @@ export function buildRuntimeModelConfiguration(config, options) {
     }
     const providers = buildModelProviders(config.models.providers);
     const builtProfiles = buildModelProfiles(config.models.profiles, options);
+    const embeddingProfiles = buildEmbeddingProfiles(config.models.embeddingProfiles);
     const invocationProfiles = buildModelInvocationProfiles(config.models.invocationProfiles);
     const defaults = buildModelDefaults(config.models.defaults);
-    const modelPolicy = providers || builtProfiles.gatewayProfiles || invocationProfiles || defaults
+    const modelPolicy = providers ||
+        builtProfiles.gatewayProfiles ||
+        embeddingProfiles ||
+        invocationProfiles ||
+        defaults
         ? {
             ...(providers ? { providers } : {}),
             ...(builtProfiles.gatewayProfiles
                 ? { profiles: builtProfiles.gatewayProfiles }
                 : {}),
+            ...(embeddingProfiles ? { embeddingProfiles } : {}),
             ...(invocationProfiles ? { invocationProfiles } : {}),
             ...(defaults ? { defaults } : {}),
         }

package/dist/src/runtime/config/effective-model-config-validation.js

@@ -53,7 +53,13 @@ function validateInvocationTarget(params) {
         params.issues.push(`${params.field} references unknown model or invocation profile ${params.targetId}`);
     }
 }
+function isImplicitRunnerStepTarget(params) {
+    return (params.acceptsIdentityDefault === true && params.targetId === params.stepId);
+}
 function validateStepTarget(params) {
+    if (isImplicitRunnerStepTarget(params)) {
+        return;
+    }
     if (hasConfiguredProfile(params.profiles, params.targetId) ||
         hasConfiguredInvocationProfile(params.invocationProfiles, params.targetId) ||
         hasConfiguredCalibrationSlot(params.profiles, params.targetId)) {
@@ -139,6 +145,7 @@ export function validateEffectiveRuntimeModelConfig(params) {
         validateStepTarget({
             issues,
             field: `models.defaults.steps.${stepId}`,
+            stepId,
             targetId,
             profiles,
             invocationProfiles,
@@ -154,9 +161,11 @@ export function validateEffectiveRuntimeModelConfig(params) {
         validateStepTarget({
             issues,
             field: `requestRunner.models.defaults.steps.${stepId}`,
+            stepId,
             targetId,
             profiles,
             invocationProfiles,
+            acceptsIdentityDefault: true,
         });
     }
     if (issues.length > 0) {

package/dist/src/runtime/config/embedding-profiles.d.ts

@@ -0,0 +1,5 @@
+export declare function validateEmbeddingProfiles(params: {
+    issues: string[];
+    models: Record<string, unknown>;
+    allowIncompleteSetup: boolean;
+}): void;

package/dist/src/runtime/config/embedding-profiles.js

@@ -0,0 +1,66 @@
+import { hasOwnValue, isRecord } from "./utils.js";
+export function validateEmbeddingProfiles(params) {
+    if (!hasOwnValue(params.models, "embeddingProfiles")) {
+        return;
+    }
+    const profiles = params.models.embeddingProfiles;
+    if (!isRecord(profiles)) {
+        params.issues.push("models.embeddingProfiles must be an object");
+        return;
+    }
+    for (const [profileId, profile] of Object.entries(profiles)) {
+        validateEmbeddingProfile({ ...params, profileId, profile });
+    }
+}
+function validateEmbeddingProfile(params) {
+    const displayKey = `models.embeddingProfiles.${params.profileId}`;
+    if (!params.profileId.trim()) {
+        params.issues.push("models.embeddingProfiles keys must be non-empty strings");
+    }
+    if (!isRecord(params.profile)) {
+        params.issues.push(`${displayKey} must be an object`);
+        return;
+    }
+    const profile = params.profile;
+    rejectUnsupportedFields(params.issues, profile, displayKey);
+    validateOptionalString(params.issues, profile, "label", displayKey);
+    validateRequiredString({ ...params, profile }, "provider", displayKey);
+    validateRequiredString({ ...params, profile }, "model", displayKey);
+    if (hasOwnValue(profile, "options") && !isRecord(profile.options)) {
+        params.issues.push(`${displayKey}.options must be an object`);
+    }
+    validateProviderReference({ ...params, profile }, displayKey);
+}
+function rejectUnsupportedFields(issues, profile, displayKey) {
+    const supported = new Set(["label", "provider", "model", "options"]);
+    for (const key of Object.keys(profile)) {
+        if (!supported.has(key)) {
+            issues.push(`${displayKey}.${key} is not supported for embeddings`);
+        }
+    }
+}
+function validateRequiredString(params, key, displayKey) {
+    if (params.allowIncompleteSetup && !hasOwnValue(params.profile, key)) {
+        return;
+    }
+    const value = params.profile[key];
+    if (typeof value !== "string" || !value.trim()) {
+        params.issues.push(`${displayKey}.${key} must be a non-empty string`);
+    }
+}
+function validateOptionalString(issues, profile, key, displayKey) {
+    const value = profile[key];
+    if (value !== undefined && (typeof value !== "string" || !value.trim())) {
+        issues.push(`${displayKey}.${key} must be a non-empty string`);
+    }
+}
+function validateProviderReference(params, displayKey) {
+    const providerId = params.profile.provider;
+    if (typeof providerId !== "string" || !providerId.trim()) {
+        return;
+    }
+    const providers = params.models.providers;
+    if (!isRecord(providers) || !Object.hasOwn(providers, providerId.trim())) {
+        params.issues.push(`${displayKey}.provider references unknown provider ${providerId.trim()}`);
+    }
+}

package/dist/src/runtime/config/fields.js

@@ -194,6 +194,11 @@ export const RUNTIME_CONFIG_SCHEMA_FIELDS = [
         type: "object-map",
         description: "Host-defined model profiles keyed by profile id for model-gateway policy.",
     },
+    {
+        path: "models.embeddingProfiles",
+        type: "object-map",
+        description: "Provider and model bindings for non-generative embedding operations.",
+    },
     {
         path: "models.profiles.<profileId>.configRef",
         type: "non-empty-string",
@@ -246,6 +251,23 @@ export const RUNTIME_CONFIG_SCHEMA_FIELDS = [
         type: "non-empty-string",
         description: "Path to the runtime request-runner config file, resolved relative to the runtime config file.",
     },
+    {
+        path: "longTermMemory.enabled",
+        type: "boolean",
+        defaultValue: "false",
+        description: "Whether passive cross-session memory retrieval and collection are enabled.",
+    },
+    {
+        path: "longTermMemory.emitClientEvents",
+        type: "boolean",
+        defaultValue: "false",
+        description: "Whether bounded memory lifecycle events are visible to clients.",
+    },
+    {
+        path: "longTermMemory.embeddingProfileId",
+        type: "non-empty-string",
+        description: "Embedding profile used by passive long-term memory when enabled.",
+    },
     {
         path: "features",
         type: "feature-flag-map",

package/dist/src/runtime/config/long-term-memory.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeLongTermMemoryConfig } from "../ports.js";
+import type { RuntimeConfigFile } from "./types.js";
+export declare const DEFAULT_LONG_TERM_MEMORY_CONFIG: RuntimeLongTermMemoryConfig;
+export declare function buildLongTermMemoryConfig(config: RuntimeConfigFile): RuntimeLongTermMemoryConfig;
+export declare function validateLongTermMemoryConfig(params: {
+    issues: string[];
+    value: unknown;
+    embeddingProfiles: unknown;
+}): void;

package/dist/src/runtime/config/long-term-memory.js

@@ -0,0 +1,71 @@
+import { isRecord } from "./utils.js";
+export const DEFAULT_LONG_TERM_MEMORY_CONFIG = Object.freeze({
+    enabled: false,
+    emitClientEvents: false,
+});
+export function buildLongTermMemoryConfig(config) {
+    if (!isRecord(config.longTermMemory)) {
+        return DEFAULT_LONG_TERM_MEMORY_CONFIG;
+    }
+    const embeddingProfileId = readOptionalString(config.longTermMemory.embeddingProfileId);
+    return Object.freeze({
+        enabled: config.longTermMemory.enabled === true,
+        emitClientEvents: config.longTermMemory.emitClientEvents === true,
+        ...(embeddingProfileId ? { embeddingProfileId } : {}),
+    });
+}
+export function validateLongTermMemoryConfig(params) {
+    if (params.value === undefined) {
+        return;
+    }
+    if (!isRecord(params.value)) {
+        params.issues.push("longTermMemory must be an object");
+        return;
+    }
+    rejectUnsupportedKeys(params.issues, params.value);
+    validateOptionalBoolean(params.issues, params.value, "enabled");
+    validateOptionalBoolean(params.issues, params.value, "emitClientEvents");
+    validateOptionalProfileId(params.issues, params.value);
+    validateEnabledProfileBinding(params);
+}
+function rejectUnsupportedKeys(issues, config) {
+    const supported = new Set([
+        "enabled",
+        "emitClientEvents",
+        "embeddingProfileId",
+    ]);
+    for (const key of Object.keys(config)) {
+        if (!supported.has(key)) {
+            issues.push(`longTermMemory.${key} is not a supported configuration field`);
+        }
+    }
+}
+function validateOptionalBoolean(issues, config, key) {
+    if (config[key] !== undefined && typeof config[key] !== "boolean") {
+        issues.push(`longTermMemory.${key} must be a boolean`);
+    }
+}
+function validateOptionalProfileId(issues, config) {
+    const value = config.embeddingProfileId;
+    if (value !== undefined &&
+        (typeof value !== "string" || value.trim().length === 0)) {
+        issues.push("longTermMemory.embeddingProfileId must be a non-empty string");
+    }
+}
+function validateEnabledProfileBinding(params) {
+    if (!isRecord(params.value) || params.value.enabled !== true) {
+        return;
+    }
+    const profileId = readOptionalString(params.value.embeddingProfileId);
+    if (!profileId) {
+        params.issues.push("longTermMemory.embeddingProfileId is required when longTermMemory.enabled is true");
+        return;
+    }
+    if (!isRecord(params.embeddingProfiles) ||
+        !Object.hasOwn(params.embeddingProfiles, profileId)) {
+        params.issues.push(`longTermMemory.embeddingProfileId references unknown embedding profile ${profileId}`);
+    }
+}
+function readOptionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/dist/src/runtime/config/runner/config-normalization.d.ts

@@ -0,0 +1,16 @@
+import { type RequestContextConfig, type RequestRunnerConfig } from "./contracts.js";
+export type ParsedModelDefaults = Readonly<{
+    profileId: string;
+    rawStepTargets: Record<string, unknown>;
+}>;
+export declare function assertRegisteredModelStepKeys(value: Record<string, unknown>, configPath: string, field: string): void;
+export declare function parseRequestRunnerModelDefaults(root: Record<string, unknown>, configPath: string): ParsedModelDefaults;
+export declare function parseRequestRunnerContext(root: Record<string, unknown>, configPath: string): RequestContextConfig;
+export declare function materializeRequestRunnerConfig(params: {
+    configPath: string;
+    context: RequestContextConfig;
+    defaultTimeoutMs: number;
+    modelDefaults: ParsedModelDefaults;
+    rawSteps: Record<string, unknown>;
+    requireConfiguredTimeout: boolean;
+}): RequestRunnerConfig;