@abot-ai/runtime 1.0.0 → 1.1.0

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/failure-outcome-fingerprint.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+/**
+ * Owns stable failure interpretation for the registered-tool adapter. The
+ * generic capability engine receives only the resulting opaque identity.
+ */
+export function createRegisteredToolWorkerFailureOutcomeFingerprint(exactResult) {
+    try {
+        if (exactResult.kind === "runtime_capability_rejection_v1") {
+            return digest([
+                "registered_tool_runtime_rejection_v1",
+                exactResult.stage,
+                exactResult.code,
+            ]);
+        }
+        if (exactResult.kind === "registered_tool_execution_result_v1") {
+            const discriminants = registeredToolFailureDiscriminants(exactResult.result);
+            if (discriminants.length > 0) {
+                return digest(["registered_tool_execution_failure_v1", discriminants]);
+            }
+        }
+        return digest([
+            "registered_tool_canonical_failure_v1",
+            canonicalValue(exactResult),
+        ]);
+    }
+    catch {
+        return null;
+    }
+}
+function digest(value) {
+    return `sha256:${createHash("sha256")
+        .update(JSON.stringify(value))
+        .digest("hex")}`;
+}
+function registeredToolFailureDiscriminants(input) {
+    const discriminants = [];
+    const errorCode = input.errorCode?.trim();
+    if (errorCode) {
+        discriminants.push(Object.freeze(["error_code", errorCode]));
+    }
+    if (input.exitCode !== undefined) {
+        if (!Number.isFinite(input.exitCode)) {
+            throw new Error("registered_tool_failure_exit_code_invalid");
+        }
+        discriminants.push(Object.freeze(["exit_code", input.exitCode]));
+    }
+    return Object.freeze(discriminants);
+}
+function canonicalValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error("registered_tool_failure_number_invalid");
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return Object.freeze(value.map((entry) => canonicalValue(entry)));
+    }
+    if (!isPlainRecord(value)) {
+        throw new Error("registered_tool_failure_value_invalid");
+    }
+    return Object.freeze(Object.entries(value)
+        .sort(([left], [right]) => compareText(left, right))
+        .map(([key, entry]) => Object.freeze([key, canonicalValue(entry)])));
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

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

@@ -1,21 +1,22 @@
 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 { RegisteredToolWorkerCapabilityProviderDiagnostic } from "../registered-tool-worker-capability-diagnostics.js";
+import type { RegisteredToolNormalInvocationProjection } from "../registered-tool-normal-invocations.js";
+import type { PayloadLifecycleEmitter, PayloadStageMaterializationDetails } from "./payload-observability.js";
 export declare function prepareOperationPayload(params: Readonly<{
     projection: RegisteredToolNormalInvocationProjection;
-    executor: RegisteredToolNormalInvocationExecutor;
+    executor: PayloadLifecycleEmitter;
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
     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;
 }>): Promise<Readonly<{
     status: "ready";

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

@@ -14,12 +14,15 @@ export async function prepareOperationPayload(params) {
             executionId: params.executionId,
             descriptor: params.descriptor,
             intent: params.intent,
+            ...(params.authoringObjective
+                ? { authoringObjective: params.authoringObjective }
+                : {}),
             controls: params.controls,
             ...(params.dependencyResults
                 ? { dependencyResults: params.dependencyResults }
                 : {}),
             settledCapabilityResults: params.settledCapabilityResults,
-            diagnostic: params.diagnostic,
+            deferPayloadStageMaterialized: params.deferPayloadStageMaterialized,
             ...(params.executionFreshness
                 ? { executionFreshness: params.executionFreshness }
                 : {}),
@@ -58,6 +61,9 @@ export async function prepareOperationPayload(params) {
             call: params.call,
             executionId: params.executionId,
             descriptor: params.descriptor,
+            ...(params.authoringObjective
+                ? { authoringObjective: params.authoringObjective }
+                : {}),
             controls: params.controls,
             contextScope,
             ...(params.dependencyResults

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,24 @@
 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"];
     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,4 @@
 import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadRelatedArtifactContexts, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
-import { traceRegisteredToolWorkerCapabilityPayloadStageMaterialized, } from "../registered-tool-worker-capability-diagnostics.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) {
@@ -179,6 +178,9 @@ class PayloadStageRunner {
                     call: this.params.call,
                     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 +269,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/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;