@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/runtime/local-host/rpc-peer.js

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
+import { decodeRpcFrame, encodeRpcFrame, } from "./rpc-protocol.js";
+export class LocalRuntimeRpcPeer {
+    socket;
+    id = randomUUID();
+    pending = new Map();
+    events = new Set();
+    closedListeners = new Set();
+    handler = async () => {
+        throw new Error("local_runtime_client_handler_unavailable");
+    };
+    closed = false;
+    constructor(socket) {
+        this.socket = socket;
+        socket.on("message", (data, binary) => this.receive(data, binary));
+        socket.on("close", () => this.disconnected());
+        socket.on("error", () => this.disconnected());
+    }
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    call(method, args = []) {
+        if (this.closed)
+            return Promise.reject(new Error("local_runtime_connection_lost"));
+        const id = randomUUID();
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                this.send({ kind: "call", id, method, args });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    subscribe(listener) {
+        this.events.add(listener);
+        return () => {
+            this.events.delete(listener);
+        };
+    }
+    onClose(listener) {
+        if (this.closed) {
+            listener();
+            return () => { };
+        }
+        this.closedListeners.add(listener);
+        return () => {
+            this.closedListeners.delete(listener);
+        };
+    }
+    publish(value) {
+        if (this.closed)
+            return;
+        try {
+            this.send({ kind: "event", value });
+        }
+        catch {
+            this.close();
+        }
+    }
+    close() {
+        this.disconnected();
+        this.socket.terminate();
+    }
+    send(frame) {
+        if (this.socket.readyState !== WebSocket.OPEN)
+            throw new Error("local_runtime_connection_lost");
+        this.socket.send(encodeRpcFrame(frame), { binary: true }, (error) => {
+            if (error)
+                this.close();
+        });
+    }
+    receive(raw, binary) {
+        if (this.closed)
+            return;
+        try {
+            if (!binary)
+                throw new Error("local_runtime_invalid_frame");
+            const frame = decodeRpcFrame(toFrameBuffer(raw));
+            if (frame.kind === "call") {
+                void this.respond(frame);
+                return;
+            }
+            if (frame.kind === "event") {
+                for (const listener of this.events)
+                    invokeListener(() => listener(frame.value));
+                return;
+            }
+            const pending = this.pending.get(frame.id);
+            if (!pending)
+                return;
+            this.pending.delete(frame.id);
+            if (frame.kind === "error")
+                pending.reject(restoreRpcError(frame));
+            else
+                pending.resolve(frame.value);
+        }
+        catch {
+            this.close();
+        }
+    }
+    async respond(frame) {
+        try {
+            const value = await this.handler(frame.method, frame.args);
+            if (!this.closed)
+                this.send({ kind: "result", id: frame.id, value });
+        }
+        catch (error) {
+            if (this.closed)
+                return;
+            try {
+                this.send({
+                    kind: "error",
+                    id: frame.id,
+                    message: error instanceof Error ? error.message : String(error),
+                    ...(error instanceof Error ? { name: error.name } : {}),
+                    ...(hasRpcErrorCode(error) ? { code: error.code } : {}),
+                });
+            }
+            catch {
+                this.close();
+            }
+        }
+    }
+    disconnected() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const pending of this.pending.values())
+            pending.reject(new Error("local_runtime_connection_lost"));
+        this.pending.clear();
+        this.events.clear();
+        for (const listener of this.closedListeners)
+            invokeListener(listener);
+        this.closedListeners.clear();
+    }
+}
+function toFrameBuffer(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (Array.isArray(data))
+        return Buffer.concat(data);
+    return Buffer.from(data);
+}
+function invokeListener(listener) {
+    try {
+        listener();
+    }
+    catch {
+        /* Observers cannot break another peer's RPC. */
+    }
+}
+function hasRpcErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    return typeof error.code === "string";
+}
+function restoreRpcError(frame) {
+    const error = new Error(frame.message);
+    if (frame.name !== undefined)
+        error.name = frame.name;
+    if (frame.code !== undefined)
+        Object.assign(error, { code: frame.code });
+    return error;
+}

package/dist/src/runtime/local-host/rpc-protocol.d.ts

@@ -0,0 +1,21 @@
+export type RpcFrame = {
+    kind: "call";
+    id: string;
+    method: string;
+    args: readonly unknown[];
+} | {
+    kind: "result";
+    id: string;
+    value: unknown;
+} | {
+    kind: "error";
+    id: string;
+    message: string;
+    name?: string;
+    code?: string;
+} | {
+    kind: "event";
+    value: unknown;
+};
+export declare function encodeRpcFrame(frame: RpcFrame): Buffer;
+export declare function decodeRpcFrame(data: Buffer): RpcFrame;

package/dist/src/runtime/local-host/rpc-protocol.js

@@ -0,0 +1,46 @@
+import { deserialize, serialize } from "node:v8";
+export function encodeRpcFrame(frame) {
+    return serialize(frame);
+}
+export function decodeRpcFrame(data) {
+    const frame = deserialize(data);
+    if (!isRpcRecord(frame))
+        throw new Error("local_runtime_invalid_frame");
+    if (frame.kind === "event")
+        return { kind: "event", value: frame.value };
+    if (!hasRpcCorrelation(frame))
+        throw new Error("local_runtime_invalid_frame");
+    if (frame.kind === "result")
+        return { kind: "result", id: frame.id, value: frame.value };
+    if (frame.kind === "error" && typeof frame.message === "string")
+        return {
+            kind: "error",
+            id: frame.id,
+            message: frame.message,
+            ...(typeof frame.name === "string" ? { name: frame.name } : {}),
+            ...(typeof frame.code === "string" ? { code: frame.code } : {}),
+        };
+    if (hasRpcInvocation(frame))
+        return {
+            kind: "call",
+            id: frame.id,
+            method: frame.method,
+            args: frame.args,
+        };
+    throw new Error("local_runtime_invalid_frame");
+}
+function isRpcRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return !Array.isArray(value);
+}
+function hasRpcCorrelation(value) {
+    return typeof value.id === "string" && value.id.length > 0;
+}
+function hasRpcInvocation(value) {
+    if (value.kind !== "call")
+        return false;
+    if (typeof value.method !== "string" || !value.method)
+        return false;
+    return Array.isArray(value.args);
+}

package/dist/src/runtime/local-host/startup-connection.d.ts

@@ -0,0 +1,5 @@
+import type { LocalRuntimeConnectionOptions, LocalRuntimeEndpoint } from "./contracts.js";
+import { LocalRuntimeRpcPeer } from "./rpc-peer.js";
+export declare function connectToPublishedRuntimeOwner(options: Pick<LocalRuntimeConnectionOptions, "directory" | "identity">, deadline: number): Promise<LocalRuntimeRpcPeer | undefined>;
+export declare function waitForRuntimeOwnerElection(deadline: number): Promise<void>;
+export declare function connectToRuntimeOwner(endpoint: LocalRuntimeEndpoint, deadline: number): Promise<LocalRuntimeRpcPeer>;

package/dist/src/runtime/local-host/startup-connection.js

@@ -0,0 +1,72 @@
+import WebSocket from "ws";
+import { isLocalRuntimeProcessAlive, readLocalRuntimeEndpoint, } from "./endpoint.js";
+import { localRuntimeIdentityHeader } from "./owner-server.js";
+import { LocalRuntimeRpcPeer } from "./rpc-peer.js";
+export async function connectToPublishedRuntimeOwner(options, deadline) {
+    const endpoint = await readLocalRuntimeEndpoint(options.directory);
+    if (!endpoint)
+        return undefined;
+    if (!isLocalRuntimeProcessAlive(endpoint.pid))
+        return undefined;
+    assertRuntimeOwnerIdentity(endpoint, options.identity);
+    try {
+        return await connectToRuntimeOwner(endpoint, deadline);
+    }
+    catch (error) {
+        if (!isTransientRuntimeOwnerHandshakeFailure(error))
+            throw error;
+        return undefined;
+    }
+}
+export async function waitForRuntimeOwnerElection(deadline) {
+    assertRuntimeOwnerStartupTimeRemaining(deadline);
+    await new Promise((resolve) => setTimeout(resolve, Math.min(25, deadline - Date.now())));
+    assertRuntimeOwnerStartupTimeRemaining(deadline);
+}
+export async function connectToRuntimeOwner(endpoint, deadline) {
+    assertRuntimeOwnerStartupTimeRemaining(deadline);
+    return new Promise((resolve, reject) => {
+        const socket = new WebSocket(`ws://127.0.0.1:${endpoint.port}`, {
+            headers: {
+                authorization: `Bearer ${endpoint.token}`,
+                "x-abot-runtime-identity": localRuntimeIdentityHeader(endpoint.identity),
+            },
+            handshakeTimeout: Math.max(1, deadline - Date.now()),
+            maxPayload: 64 * 1024 * 1024,
+            perMessageDeflate: false,
+        });
+        const peer = new LocalRuntimeRpcPeer(socket);
+        const failed = (error) => {
+            peer.close();
+            reject(error);
+        };
+        socket.once("error", failed);
+        socket.once("open", () => {
+            socket.removeListener("error", failed);
+            resolve(peer);
+        });
+    });
+}
+function assertRuntimeOwnerIdentity(endpoint, identity) {
+    if (endpoint.identity !== identity)
+        throw new Error("local_runtime_identity_mismatch");
+}
+function assertRuntimeOwnerStartupTimeRemaining(deadline) {
+    if (Date.now() >= deadline)
+        throw new Error("local_runtime_owner_start_timeout");
+}
+function isTransientRuntimeOwnerHandshakeFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (!("code" in error))
+        return false;
+    switch (error.code) {
+        case "ECONNREFUSED":
+        case "ECONNRESET":
+        case "EPIPE":
+        case "ETIMEDOUT":
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/src/runtime/local-host/transport.d.ts

@@ -0,0 +1,3 @@
+import type { LocalRuntimeConnection, LocalRuntimeConnectionOptions } from "./contracts.js";
+export type { LocalRuntimeCallHandler, LocalRuntimeConnection, LocalRuntimeConnectionOptions, LocalRuntimeOwner, LocalRuntimePeer, } from "./contracts.js";
+export declare function createLocalRuntimeConnection(options: LocalRuntimeConnectionOptions): Promise<LocalRuntimeConnection>;

package/dist/src/runtime/local-host/transport.js

@@ -0,0 +1,88 @@
+import { join } from "node:path";
+import { acquireFileLock } from "../adapters/long-term-memory/file-lock/acquisition.js";
+import { ensurePrivateRuntimeDirectory, removeLocalRuntimeEndpoint, writeLocalRuntimeEndpoint, } from "./endpoint.js";
+import { startLocalRuntimeOwnerServer } from "./owner-server.js";
+import { releaseRuntimeOwnerWhenIdle } from "./owner-retirement.js";
+import { connectToPublishedRuntimeOwner, connectToRuntimeOwner, waitForRuntimeOwnerElection, } from "./startup-connection.js";
+export async function createLocalRuntimeConnection(options) {
+    if (!options.identity)
+        throw new Error("local_runtime_identity_required");
+    await ensurePrivateRuntimeDirectory(options.directory);
+    const deadline = Date.now() + (options.startupTimeoutMs ?? 10_000);
+    for (;;) {
+        const release = await tryAcquireRuntimeOwner(options.directory);
+        if (release)
+            return establishRuntimeOwner(options, release);
+        const peer = await connectToPublishedRuntimeOwner(options, deadline);
+        if (peer)
+            return createConnection(peer, "client", async () => {
+                peer.close();
+            });
+        await waitForRuntimeOwnerElection(deadline);
+    }
+}
+async function establishRuntimeOwner(options, release) {
+    let host;
+    let owner;
+    try {
+        owner = await options.createOwner();
+        host = await startLocalRuntimeOwnerServer(options.identity, owner);
+        await writeLocalRuntimeEndpoint(options.directory, host.endpoint);
+        const peer = await connectToRuntimeOwner(host.endpoint, Date.now() + 10_000);
+        return createConnection(peer, "owner", async () => {
+            try {
+                await host.close();
+            }
+            finally {
+                try {
+                    await removeLocalRuntimeEndpoint(options.directory, host.endpoint.token);
+                }
+                finally {
+                    await releaseRuntimeOwnerWhenIdle(owner, release);
+                }
+            }
+        });
+    }
+    catch (error) {
+        try {
+            if (host) {
+                await host.close();
+                await removeLocalRuntimeEndpoint(options.directory, host.endpoint.token);
+            }
+            else
+                await owner?.stop();
+        }
+        finally {
+            await releaseRuntimeOwnerWhenIdle(owner, release);
+        }
+        throw error;
+    }
+}
+function createConnection(peer, ownership, close) {
+    let shutdown;
+    return Object.freeze({
+        ownership,
+        call: (method, args) => peer.call(method, args),
+        subscribe: (listener) => peer.subscribe(listener),
+        setClientHandler: (handler) => peer.setHandler(handler),
+        onClose: (listener) => peer.onClose(listener),
+        close: () => {
+            shutdown ??= close();
+            return shutdown;
+        },
+    });
+}
+async function tryAcquireRuntimeOwner(directory) {
+    try {
+        return await acquireFileLock(join(directory, "owner"), {
+            waitMs: 0,
+            releaseMode: "synchronous",
+        });
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message === "long_term_memory_store_lock_timeout")
+            return undefined;
+        throw error;
+    }
+}

package/dist/src/runtime/local-host/windows-private-access.d.ts

@@ -0,0 +1 @@
+export declare function verifyWindowsPrivateAccess(path: string, newlyCreatedDirectory?: boolean): Promise<void>;

package/dist/src/runtime/local-host/windows-private-access.js

@@ -0,0 +1,51 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+// Paths travel through an environment value, never through shell interpolation.
+const privateAccessScript = `
+$ErrorActionPreference = 'Stop'
+$target = $env:ABOT_LOCAL_HOST_PRIVATE_PATH
+$current = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$item = Get-Item -LiteralPath $target -Force
+if (($item.Attributes -band [System.IO.FileAttributes]::ReparsePoint) -ne 0) { exit 2 }
+if ($env:ABOT_LOCAL_HOST_CREATE_PRIVATE -eq '1') {
+  $acl = New-Object System.Security.AccessControl.DirectorySecurity
+  $acl.SetOwner($current)
+  $acl.SetAccessRuleProtection($true, $false)
+  $inherit = [System.Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit'
+  $propagate = [System.Security.AccessControl.PropagationFlags]::None
+  $allow = [System.Security.AccessControl.AccessControlType]::Allow
+  $rule = New-Object System.Security.AccessControl.FileSystemAccessRule($current, 'FullControl', $inherit, $propagate, $allow)
+  $acl.AddAccessRule($rule)
+  Set-Acl -LiteralPath $target -AclObject $acl
+}
+$observed = Get-Acl -LiteralPath $target
+$owner = $observed.GetOwner([System.Security.Principal.SecurityIdentifier]).Value
+if ($owner -ne $current.Value) { exit 3 }
+$allowed = @($current.Value, 'S-1-5-18', 'S-1-5-32-544')
+$rules = $observed.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
+$currentCanRead = $false
+foreach ($rule in $rules) {
+  if ($rule.AccessControlType -ne [System.Security.AccessControl.AccessControlType]::Allow) { continue }
+  if ($rule.IdentityReference.Value -notin $allowed) { exit 4 }
+  if ($rule.IdentityReference.Value -eq $current.Value) { $currentCanRead = $true }
+}
+if (-not $currentCanRead) { exit 5 }
+`;
+export async function verifyWindowsPrivateAccess(path, newlyCreatedDirectory = false) {
+    await execute("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        Buffer.from(privateAccessScript, "utf16le").toString("base64"),
+    ], {
+        windowsHide: true,
+        timeout: 10_000,
+        maxBuffer: 16_384,
+        env: {
+            ...process.env,
+            ABOT_LOCAL_HOST_PRIVATE_PATH: path,
+            ABOT_LOCAL_HOST_CREATE_PRIVATE: newlyCreatedDirectory ? "1" : "0",
+        },
+    });
+}

package/dist/src/runtime/long-term-memory/onboarding/configuration.js

@@ -18,6 +18,9 @@ export function projectOnboardingStatus(config) {
 }
 export function buildEnabledMemoryConfig(params) {
     const models = isRecord(params.config.models) ? params.config.models : {};
+    const memory = isRecord(params.config.longTermMemory)
+        ? params.config.longTermMemory
+        : {};
     const profiles = readEmbeddingProfiles(params.config);
     const existingProfile = profiles[params.profileId];
     const existingOptions = readMatchingProfileOptions({
@@ -43,6 +46,9 @@ export function buildEnabledMemoryConfig(params) {
             enabled: true,
             emitClientEvents: params.emitClientEvents,
             embeddingProfileId: params.profileId,
+            ...(memory.maxRecallCallsPerRequest === undefined
+                ? {}
+                : { maxRecallCallsPerRequest: memory.maxRecallCallsPerRequest }),
         },
     };
 }

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

@@ -0,0 +1,3 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+/** Bind every consuming invocation so steering rebuilds context at the root. */
+export declare function resolveMemoryRecallSteeringVersion(message: ChatMessage | undefined, requestId: string, callId: string): number | undefined;

package/dist/src/runtime/long-term-memory/recall-binding.js

@@ -0,0 +1,27 @@
+import { isRecord } from "../validation/strict-record.js";
+import { MEMORY_RECALL_REFERENCE_KIND } from "./recall-context.js";
+/** Bind every consuming invocation so steering rebuilds context at the root. */
+export function resolveMemoryRecallSteeringVersion(message, requestId, callId) {
+    if (!message)
+        return undefined;
+    const reference = JSON.parse(message.content);
+    if (!hasMemoryRecallBinding(reference, requestId, callId)) {
+        throw new Error("memory_recall_context_binding_invalid");
+    }
+    return reference.steeringVersion;
+}
+function hasMemoryRecallBinding(value, requestId, callId) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind !== MEMORY_RECALL_REFERENCE_KIND)
+        return false;
+    if (value.authority !== "passive_reference")
+        return false;
+    if (value.requestId !== requestId)
+        return false;
+    if (value.callId !== callId)
+        return false;
+    if (!Number.isSafeInteger(value.steeringVersion))
+        return false;
+    return value.steeringVersion >= 0;
+}

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

@@ -0,0 +1,20 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { LongTermMemoryRecord } from "./contracts.js";
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+export declare const MEMORY_RECALL_REFERENCE_KIND = "runtime_memory_recall_reference_v1";
+export type RecallProjection = Readonly<{
+    recallId: string;
+    invocationAttempt: number;
+    completedChildCount: number;
+    query: string;
+    outcome: string;
+    memories: readonly LongTermMemoryRecord[];
+    omittedRecordCount: number;
+    reason?: string;
+}>;
+/** Derive context only from settled receipts belonging to the current root intent. */
+export declare function projectRootMemoryRecallMessage(params: {
+    head: RoleCallLedgerHead;
+    callId: string;
+    steeringVersion: number;
+}): ChatMessage | undefined;

package/dist/src/runtime/long-term-memory/recall-context.js

@@ -0,0 +1,101 @@
+import { projectMemoryRecallContinuations } from "./recall-continuation.js";
+import { ROLE_MEMORY_RECALL_RECORD_LIMIT_MAX, ROLE_MEMORY_RECALL_RESULT_MAX_LENGTH, } from "../orchestration/role-calls/memory-recall-contract.js";
+export const MEMORY_RECALL_REFERENCE_KIND = "runtime_memory_recall_reference_v1";
+/** Derive context only from settled receipts belonging to the current root intent. */
+export function projectRootMemoryRecallMessage(params) {
+    if (params.callId !== params.head.state.rootCallId)
+        return undefined;
+    const recalls = params.head.state.memoryRecalls.filter((recall) => isCurrentSettledMemoryRecall(recall, params));
+    if (recalls.length === 0)
+        return undefined;
+    const scope = {
+        requestId: params.head.state.requestId,
+        callId: params.callId,
+        steeringVersion: params.steeringVersion,
+        recallCount: recalls.length,
+        recordCount: recalls.reduce((count, recall) => count +
+            recall.result.records.length +
+            recall.result.omittedRecordCount, 0),
+    };
+    const selected = [];
+    const includedIds = new Set();
+    for (const recall of [...recalls].reverse()) {
+        const projection = selectRecallProjection(recall, selected, includedIds, scope);
+        if (!projection)
+            continue;
+        selected.unshift(projection);
+        for (const record of projection.memories)
+            includedIds.add(record.id);
+    }
+    return Object.freeze({
+        role: "system",
+        content: serializeRecallProjection(scope, selected),
+    });
+}
+function isCurrentSettledMemoryRecall(recall, scope) {
+    if (recall.callId !== scope.callId)
+        return false;
+    if (recall.steeringVersion !== scope.steeringVersion)
+        return false;
+    if (recall.status !== "settled")
+        return false;
+    return recall.result?.outcome !== "superseded";
+}
+function selectRecallProjection(recall, selected, includedIds, scope) {
+    const result = recall.result;
+    const base = {
+        recallId: recall.recallId,
+        invocationAttempt: recall.invocationAttempt,
+        completedChildCount: recall.completedChildCount,
+        query: recall.query,
+        outcome: result.outcome,
+        ...(result.reason ? { reason: result.reason } : {}),
+    };
+    const records = [];
+    const project = () => ({
+        ...base,
+        memories: Object.freeze([...records]),
+        omittedRecordCount: result.omittedRecordCount + result.records.length - records.length,
+    });
+    if (!fitsRecallProjection(scope, [project(), ...selected]))
+        return undefined;
+    for (const record of result.records) {
+        if (includedIds.has(record.id))
+            continue;
+        if (includedIds.size + records.length >=
+            ROLE_MEMORY_RECALL_RECORD_LIMIT_MAX)
+            break;
+        records.push(record);
+        if (!fitsRecallProjection(scope, [project(), ...selected]))
+            records.pop();
+    }
+    return Object.freeze(project());
+}
+function fitsRecallProjection(scope, recalls) {
+    const content = serializeRecallProjection(scope, recalls);
+    if (content.length > ROLE_MEMORY_RECALL_RESULT_MAX_LENGTH)
+        return false;
+    const continuations = projectMemoryRecallContinuations({
+        role: "system",
+        content,
+    });
+    return (JSON.stringify(continuations.flatMap(({ messages }) => messages)).length <=
+        ROLE_MEMORY_RECALL_RESULT_MAX_LENGTH);
+}
+function serializeRecallProjection(scope, recalls) {
+    const shownRecords = recalls.reduce((count, recall) => count + recall.memories.length, 0);
+    return JSON.stringify({
+        kind: MEMORY_RECALL_REFERENCE_KIND,
+        authority: "passive_reference",
+        purpose: "answer_the_active_roots_explicit_memory_queries",
+        requestId: scope.requestId,
+        callId: scope.callId,
+        steeringVersion: scope.steeringVersion,
+        applicability: "only_this_root_request_and_steering_version",
+        presenceEffect: "not_user_intent_assignment_action_authority_or_completion_evidence",
+        omissionPolicy: "newest_recalls_first_whole_records_newest_occurrence_per_memory_id",
+        omittedRecallCount: scope.recallCount - recalls.length,
+        omittedRecordCount: scope.recordCount - shownRecords,
+        recalls,
+    });
+}

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

@@ -0,0 +1,8 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+export type MemoryRecallContinuation = Readonly<{
+    invocationAttempt: number;
+    completedChildCount: number;
+    messages: readonly ChatMessage[];
+}>;
+/** Present only the settled, bounded records selected by the memory owner. */
+export declare function projectMemoryRecallContinuations(message: ChatMessage | undefined): readonly MemoryRecallContinuation[];