@abot-ai/runtime 1.0.0

package/dist/src/plugin-sdk/bounds.js

@@ -0,0 +1,48 @@
+export function boundText(value, options) {
+    if (!Number.isSafeInteger(options.maxChars) || options.maxChars < 0) {
+        throw new RangeError("maxChars must be a non-negative safe integer");
+    }
+    const marker = options.marker ?? "\n[truncated]";
+    const truncated = value.length > options.maxChars;
+    const boundedMarker = marker.slice(0, options.maxChars);
+    const sourceChars = truncated
+        ? Math.max(options.maxChars - boundedMarker.length, 0)
+        : value.length;
+    const text = truncated ? value.slice(0, sourceChars) + boundedMarker : value;
+    return Object.freeze({
+        text,
+        metadata: Object.freeze({
+            truncated,
+            originalChars: value.length,
+            returnedChars: text.length,
+            omittedChars: Math.max(value.length - sourceChars, 0),
+        }),
+    });
+}
+export function boundCollection(values, options) {
+    if (!Number.isSafeInteger(options.maxItems) || options.maxItems < 0) {
+        throw new RangeError("maxItems must be a non-negative safe integer");
+    }
+    const items = Object.freeze(values.slice(0, options.maxItems));
+    return Object.freeze({
+        items,
+        metadata: Object.freeze({
+            truncated: values.length > items.length,
+            totalItems: values.length,
+            returnedItems: items.length,
+            omittedItems: values.length - items.length,
+        }),
+    });
+}
+export function sanitizeJsonText(value) {
+    return [...value]
+        .map((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        const preservedWhitespace = codePoint === 0x09 || codePoint === 0x0a || codePoint === 0x0d;
+        const unsafeControl = (codePoint < 0x20 && !preservedWhitespace) ||
+            (codePoint >= 0x7f && codePoint <= 0x9f);
+        const unpairedSurrogate = codePoint >= 0xd800 && codePoint <= 0xdfff;
+        return unsafeControl || unpairedSurrogate ? "�" : character;
+    })
+        .join("");
+}

package/dist/src/plugin-sdk/files.d.ts

@@ -0,0 +1,16 @@
+export type BoundedRegularFileReadFailure = Readonly<{
+    ok: false;
+    reason: "not_regular_file" | "too_large" | "changed_during_read" | "outside_root" | "safe_open_unsupported";
+    byteCount?: number;
+}>;
+export type BoundedRegularFileReadSuccess = Readonly<{
+    ok: true;
+    bytes: Buffer;
+    byteCount: number;
+}>;
+export type BoundedRegularFileReadResult = BoundedRegularFileReadSuccess | BoundedRegularFileReadFailure;
+export declare function readBoundedRegularFile(absolutePath: string, options: Readonly<{
+    maxBytes: number;
+    rootPath: string;
+    signal?: AbortSignal;
+}>): Promise<BoundedRegularFileReadResult>;

package/dist/src/plugin-sdk/files.js

@@ -0,0 +1,95 @@
+import { constants } from "node:fs";
+import { open, realpath, stat } from "node:fs/promises";
+import { relative, sep } from "node:path";
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    const error = new Error("The file read was cancelled.");
+    error.name = "AbortError";
+    throw error;
+}
+async function readExact(handle, buffer, signal) {
+    let offset = 0;
+    while (offset < buffer.length) {
+        throwIfAborted(signal);
+        const result = await handle.read(buffer, offset, buffer.length - offset, offset);
+        if (result.bytesRead === 0)
+            return false;
+        offset += result.bytesRead;
+    }
+    return true;
+}
+export async function readBoundedRegularFile(absolutePath, options) {
+    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) {
+        throw new RangeError("maxBytes must be a non-negative safe integer");
+    }
+    throwIfAborted(options.signal);
+    if (typeof constants.O_NOFOLLOW !== "number") {
+        return Object.freeze({ ok: false, reason: "safe_open_unsupported" });
+    }
+    let handle;
+    try {
+        handle = await open(absolutePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const before = await handle.stat({ bigint: true });
+        if (!before.isFile()) {
+            return Object.freeze({ ok: false, reason: "not_regular_file" });
+        }
+        const [canonicalRoot, canonicalTarget] = await Promise.all([
+            realpath(options.rootPath),
+            realpath(absolutePath),
+        ]);
+        const rootRelative = relative(canonicalRoot, canonicalTarget);
+        if (rootRelative === ".." ||
+            rootRelative.startsWith(`..${sep}`) ||
+            rootRelative.startsWith(sep)) {
+            return Object.freeze({ ok: false, reason: "outside_root" });
+        }
+        const pathIdentity = await stat(canonicalTarget, { bigint: true });
+        if (pathIdentity.dev !== before.dev ||
+            pathIdentity.ino !== before.ino ||
+            !pathIdentity.isFile()) {
+            return Object.freeze({ ok: false, reason: "changed_during_read" });
+        }
+        const byteCount = Number(before.size);
+        if (!Number.isSafeInteger(byteCount) || byteCount < 0) {
+            return Object.freeze({
+                ok: false,
+                reason: "too_large",
+                byteCount,
+            });
+        }
+        if (byteCount > options.maxBytes) {
+            return Object.freeze({
+                ok: false,
+                reason: "too_large",
+                byteCount,
+            });
+        }
+        const bytes = Buffer.alloc(byteCount);
+        if (!(await readExact(handle, bytes, options.signal))) {
+            return Object.freeze({
+                ok: false,
+                reason: "changed_during_read",
+                byteCount,
+            });
+        }
+        throwIfAborted(options.signal);
+        const after = await handle.stat({ bigint: true });
+        if (!after.isFile() ||
+            Number(after.size) !== byteCount ||
+            after.dev !== before.dev ||
+            after.ino !== before.ino ||
+            after.mtimeNs !== before.mtimeNs ||
+            after.ctimeNs !== before.ctimeNs) {
+            return Object.freeze({
+                ok: false,
+                reason: "changed_during_read",
+                byteCount: Number(after.size),
+            });
+        }
+        return Object.freeze({ ok: true, bytes, byteCount });
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}

package/dist/src/plugin-sdk/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./bounds.js";
+export * from "./files.js";
+export * from "./parameters.js";
+export * from "./paths.js";
+export * from "./plugin.js";
+export * from "./results.js";
+export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/index.js

@@ -0,0 +1,7 @@
+export * from "./bounds.js";
+export * from "./files.js";
+export * from "./parameters.js";
+export * from "./paths.js";
+export * from "./plugin.js";
+export * from "./results.js";
+export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/parameters.d.ts

@@ -0,0 +1,44 @@
+export type PluginParameterErrorCode = "plugin_parameter_required" | "plugin_parameter_invalid";
+export declare class PluginParameterError extends TypeError {
+    readonly code: PluginParameterErrorCode;
+    readonly parameter: string;
+    constructor(params: {
+        code: PluginParameterErrorCode;
+        parameter: string;
+        message?: string;
+    });
+}
+export declare function isPluginParameterError(error: unknown): error is PluginParameterError;
+export type StringParameterOptions = Readonly<{
+    name?: string;
+    parameter?: string;
+    trim?: boolean;
+    minLength?: number;
+    maxLength?: number;
+}>;
+type StringParameterInput = string | StringParameterOptions;
+export declare function readOptionalString(value: unknown, input?: StringParameterInput): string | undefined;
+export declare function readRequiredString(value: unknown, input?: StringParameterInput): string;
+export declare function readBoundedInteger(value: unknown, options: Readonly<{
+    name?: string;
+    parameter?: string;
+    minimum: number;
+    maximum: number;
+    defaultValue?: number;
+}>): number;
+export declare function readBoolean(value: unknown, options?: Readonly<{
+    name?: string;
+    parameter?: string;
+    defaultValue?: boolean;
+}>): boolean;
+export declare function readStringArray(value: unknown, options?: Readonly<{
+    name?: string;
+    parameter?: string;
+    defaultValue?: readonly string[];
+    minItems?: number;
+    maxItems?: number;
+    maxItemLength?: number;
+    trim?: boolean;
+    unique?: boolean;
+}>): readonly string[];
+export {};

package/dist/src/plugin-sdk/parameters.js

@@ -0,0 +1,123 @@
+export class PluginParameterError extends TypeError {
+    code;
+    parameter;
+    constructor(params) {
+        super(params.message ?? `${params.parameter}: ${params.code}`);
+        this.name = "PluginParameterError";
+        this.code = params.code;
+        this.parameter = params.parameter;
+    }
+}
+export function isPluginParameterError(error) {
+    return error instanceof PluginParameterError;
+}
+function stringOptions(input) {
+    return typeof input === "string" ? { name: input } : input;
+}
+function parameterName(options) {
+    return options.name ?? options.parameter ?? "value";
+}
+function parseString(value, options) {
+    if (value === undefined || value === null)
+        return undefined;
+    const parameter = parameterName(options);
+    if (typeof value !== "string") {
+        throw new PluginParameterError({
+            code: "plugin_parameter_invalid",
+            parameter,
+        });
+    }
+    const parsed = options.trim === false ? value : value.trim();
+    if ((options.minLength !== undefined && parsed.length < options.minLength) ||
+        (options.maxLength !== undefined && parsed.length > options.maxLength)) {
+        throw new PluginParameterError({
+            code: "plugin_parameter_invalid",
+            parameter,
+        });
+    }
+    return parsed;
+}
+export function readOptionalString(value, input = {}) {
+    return parseString(value, stringOptions(input));
+}
+export function readRequiredString(value, input = {}) {
+    const options = stringOptions(input);
+    const parameter = parameterName(options);
+    const parsed = parseString(value, {
+        ...options,
+        minLength: Math.max(options.minLength ?? 1, 1),
+    });
+    if (parsed === undefined) {
+        throw new PluginParameterError({
+            code: "plugin_parameter_required",
+            parameter,
+        });
+    }
+    return parsed;
+}
+export function readBoundedInteger(value, options) {
+    const parameter = parameterName(options);
+    const candidate = value === undefined ? options.defaultValue : value;
+    if (!Number.isSafeInteger(candidate) ||
+        candidate < options.minimum ||
+        candidate > options.maximum) {
+        throw new PluginParameterError({
+            code: candidate === undefined
+                ? "plugin_parameter_required"
+                : "plugin_parameter_invalid",
+            parameter,
+        });
+    }
+    return candidate;
+}
+export function readBoolean(value, options = {}) {
+    const parameter = parameterName(options);
+    const candidate = value === undefined ? options.defaultValue : value;
+    if (typeof candidate !== "boolean") {
+        throw new PluginParameterError({
+            code: candidate === undefined
+                ? "plugin_parameter_required"
+                : "plugin_parameter_invalid",
+            parameter,
+        });
+    }
+    return candidate;
+}
+export function readStringArray(value, options = {}) {
+    const parameter = parameterName(options);
+    const candidate = value === undefined ? options.defaultValue : value;
+    if (!Array.isArray(candidate)) {
+        throw new PluginParameterError({
+            code: candidate === undefined
+                ? "plugin_parameter_required"
+                : "plugin_parameter_invalid",
+            parameter,
+        });
+    }
+    if ((options.minItems !== undefined && candidate.length < options.minItems) ||
+        (options.maxItems !== undefined && candidate.length > options.maxItems)) {
+        throw new PluginParameterError({
+            code: "plugin_parameter_invalid",
+            parameter,
+        });
+    }
+    const parsed = candidate.map((entry) => {
+        if (typeof entry !== "string") {
+            throw new PluginParameterError({
+                code: "plugin_parameter_invalid",
+                parameter,
+            });
+        }
+        const item = options.trim === false ? entry : entry.trim();
+        if (item.length === 0 ||
+            (options.maxItemLength !== undefined &&
+                item.length > options.maxItemLength)) {
+            throw new PluginParameterError({
+                code: "plugin_parameter_invalid",
+                parameter,
+            });
+        }
+        return item;
+    });
+    return Object.freeze(options.unique === false ? parsed : [...new Set(parsed)]);
+}

package/dist/src/plugin-sdk/paths.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedRuntimeToolPath, RuntimePluginLoadContext, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation } from "../plugin-contract/entrypoint.js";
+export type ResolvePluginPathOptions = Readonly<{
+    defaultPath?: string;
+    requirePath?: boolean;
+    allowedLocations?: readonly RuntimeToolPathLocation[];
+}>;
+export declare function resolvePluginPath(context: Pick<RuntimePluginLoadContext, "runtimePathResolver">, rawPath: unknown, options?: ResolvePluginPathOptions): ResolvedRuntimeToolPath;
+export declare function runtimeToolPathErrorCode(error: unknown): RuntimeToolPathErrorCode | undefined;
+export declare function isRuntimeToolPathError(error: unknown): error is RuntimeToolPathError;

package/dist/src/plugin-sdk/paths.js

@@ -0,0 +1,15 @@
+export function resolvePluginPath(context, rawPath, options = {}) {
+    return context.runtimePathResolver.resolve(rawPath, options);
+}
+export function runtimeToolPathErrorCode(error) {
+    if (!(error instanceof Error) ||
+        !("code" in error) ||
+        typeof error.code !== "string" ||
+        !error.code.startsWith("runtime_tool_path_")) {
+        return undefined;
+    }
+    return error.code;
+}
+export function isRuntimeToolPathError(error) {
+    return runtimeToolPathErrorCode(error) !== undefined;
+}

package/dist/src/plugin-sdk/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimePluginEntrypoint, RuntimePluginEntrypointFactory } from "../plugin-contract/entrypoint.js";
+export type RuntimePluginDefinition = RuntimePluginEntrypoint | RuntimePluginEntrypointFactory;
+/**
+ * Declares a runtime plugin while preserving its exact factory or entrypoint
+ * type. Runtime validation remains owned by the manifest loader.
+ */
+export declare function defineRuntimePlugin<const T extends RuntimePluginDefinition>(definition: T): T;

package/dist/src/plugin-sdk/plugin.js

@@ -0,0 +1,7 @@
+/**
+ * Declares a runtime plugin while preserving its exact factory or entrypoint
+ * type. Runtime validation remains owned by the manifest loader.
+ */
+export function defineRuntimePlugin(definition) {
+    return definition;
+}

package/dist/src/plugin-sdk/results.d.ts

@@ -0,0 +1,21 @@
+import type { ToolImplementationOutput } from "../plugin-contract/entrypoint.js";
+type ResultCommon = Pick<ToolImplementationOutput, "actions" | "data" | "exitCode" | "progress" | "stderr" | "stdout">;
+export declare const PLUGIN_RESULT_SERIALIZED_MAX_BYTES: number;
+export declare function enforcePluginResultByteBudget(result: ToolImplementationOutput): ToolImplementationOutput;
+export type SuccessResultInput = ResultCommon & Readonly<{
+    output: string;
+    producedNewInformation?: boolean;
+}>;
+export declare function successResult(input: SuccessResultInput): ToolImplementationOutput;
+export type FailureResultInput = ResultCommon & Readonly<{
+    errorCode: string;
+    message: string;
+    output?: string;
+}>;
+export declare function failureResult(input: FailureResultInput): ToolImplementationOutput;
+export declare function failureFromError(error: unknown, options: Readonly<{
+    fallbackCode: string;
+    fallbackMessage: string;
+    operation?: string;
+}>): ToolImplementationOutput;
+export {};

package/dist/src/plugin-sdk/results.js

@@ -0,0 +1,70 @@
+import { isPluginParameterError, } from "./parameters.js";
+import { runtimeToolPathErrorCode } from "./paths.js";
+export const PLUGIN_RESULT_SERIALIZED_MAX_BYTES = 128 * 1024;
+function resultBoundsFailure(code, message) {
+    return {
+        ok: false,
+        output: message,
+        producedNewInformation: false,
+        error: message,
+        errorCode: code,
+    };
+}
+export function enforcePluginResultByteBudget(result) {
+    let serialized;
+    try {
+        const candidate = JSON.stringify(result);
+        if (candidate === undefined) {
+            return resultBoundsFailure("plugin_result_not_json_safe", "The plugin produced a result that is not JSON-safe.");
+        }
+        serialized = candidate;
+    }
+    catch {
+        return resultBoundsFailure("plugin_result_not_json_safe", "The plugin produced a result that is not JSON-safe.");
+    }
+    if (Buffer.byteLength(serialized, "utf8") > PLUGIN_RESULT_SERIALIZED_MAX_BYTES) {
+        return resultBoundsFailure("plugin_result_too_large", `The plugin result exceeds the ${PLUGIN_RESULT_SERIALIZED_MAX_BYTES}-byte safety limit.`);
+    }
+    return result;
+}
+export function successResult(input) {
+    return enforcePluginResultByteBudget({
+        ok: true,
+        output: input.output,
+        producedNewInformation: input.producedNewInformation ?? true,
+        ...(input.progress !== undefined ? { progress: input.progress } : {}),
+        ...(input.actions !== undefined ? { actions: input.actions } : {}),
+        ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
+        ...(input.stdout !== undefined ? { stdout: input.stdout } : {}),
+        ...(input.stderr !== undefined ? { stderr: input.stderr } : {}),
+        ...(input.data !== undefined ? { data: input.data } : {}),
+    });
+}
+export function failureResult(input) {
+    return enforcePluginResultByteBudget({
+        ok: false,
+        output: input.output ?? input.message,
+        producedNewInformation: false,
+        ...(input.progress !== undefined ? { progress: input.progress } : {}),
+        ...(input.actions !== undefined ? { actions: input.actions } : {}),
+        ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
+        ...(input.stdout !== undefined ? { stdout: input.stdout } : {}),
+        ...(input.stderr !== undefined ? { stderr: input.stderr } : {}),
+        ...(input.data !== undefined ? { data: input.data } : {}),
+        error: input.message,
+        errorCode: input.errorCode,
+    });
+}
+export function failureFromError(error, options) {
+    const pathCode = runtimeToolPathErrorCode(error);
+    const parameterCode = isPluginParameterError(error) ? error.code : undefined;
+    const errorCode = pathCode ?? parameterCode ?? options.fallbackCode;
+    const message = pathCode ?? parameterCode ?? options.fallbackMessage;
+    return failureResult({
+        errorCode,
+        message,
+        output: options.operation
+            ? `${options.operation} failed: ${message}`
+            : message,
+    });
+}

package/dist/src/runtime/adapters/compiled-workspace-provider.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceProvider } from "../ports.js";
+export type CompiledWorkspaceProviderOptions = {
+    compiledPath?: string;
+};
+export declare function createCompiledWorkspaceProvider(options?: CompiledWorkspaceProviderOptions): WorkspaceProvider;

package/dist/src/runtime/adapters/compiled-workspace-provider.js

@@ -0,0 +1,7 @@
+import { createWorkspaceContextProvider } from "../context/workspace-context.js";
+export function createCompiledWorkspaceProvider(options = {}) {
+    const provider = createWorkspaceContextProvider(options);
+    return {
+        getSystemSummary: provider.getWorkspaceSystemSummary,
+    };
+}

package/dist/src/runtime/adapters/configured-skill-provider.d.ts

@@ -0,0 +1,16 @@
+import type { CompiledRuntimePlugin } from "../plugins/compiled-catalog.js";
+import type { RuntimeConfig, SkillProvider, ToolRegistry } from "../ports.js";
+export type ConfiguredSkillProviderOptions = {
+    config: RuntimeConfig;
+    listToolDefinitions?: Pick<ToolRegistry, "listDefinitions">["listDefinitions"];
+};
+export type RuntimePluginSkillProviderOptions = {
+    plugins: readonly CompiledRuntimePlugin[];
+    listToolDefinitions?: Pick<ToolRegistry, "listDefinitions">["listDefinitions"];
+};
+/** Creates the skill projection from one already-compiled plugin catalog. */
+export declare function createRuntimePluginSkillProvider(options: RuntimePluginSkillProviderOptions): SkillProvider;
+/** Loads the config-selected plugin catalog and projects only its skills. */
+export declare function createConfiguredSkillProvider(options: ConfiguredSkillProviderOptions): SkillProvider;
+/** Uses the same bundled plugin manifests as the unconfigured tool registry. */
+export declare function createBundledPluginSkillProvider(options?: Pick<RuntimePluginSkillProviderOptions, "listToolDefinitions">): SkillProvider;

package/dist/src/runtime/adapters/configured-skill-provider.js

@@ -0,0 +1,59 @@
+import { createSkillsContextProvider, } from "../context/skills-context.js";
+import { loadBundledRuntimePlugins, loadConfiguredRuntimePlugins, } from "../plugins/loader.js";
+function unique(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function buildPluginSkillCatalog(plugins, activeToolNames) {
+    const skills = {};
+    const actionSkills = {};
+    for (const plugin of plugins) {
+        for (const [action, skillNames] of Object.entries(plugin.capabilitySkills)) {
+            if (activeToolNames && !activeToolNames.has(action)) {
+                continue;
+            }
+            for (const skillName of skillNames) {
+                const content = plugin.skills[skillName];
+                if (content === undefined) {
+                    throw new Error(`Runtime plugin ${plugin.id} references unknown skill ${skillName}`);
+                }
+                const existing = skills[skillName];
+                if (existing !== undefined && existing !== content) {
+                    throw new Error(`Duplicate runtime plugin skill: ${skillName}`);
+                }
+                skills[skillName] = content;
+            }
+            actionSkills[action] = unique([
+                ...(actionSkills[action] ?? []),
+                ...skillNames,
+            ]);
+        }
+    }
+    return Object.freeze({
+        skills: Object.freeze(skills),
+        actionSkills: Object.freeze(actionSkills),
+    });
+}
+function createProviderFromPlugins(options) {
+    const activeToolNames = options.listToolDefinitions
+        ? new Set(options.listToolDefinitions().map((definition) => definition.name))
+        : undefined;
+    return createSkillsContextProvider(buildPluginSkillCatalog(options.plugins, activeToolNames));
+}
+/** Creates the skill projection from one already-compiled plugin catalog. */
+export function createRuntimePluginSkillProvider(options) {
+    return createProviderFromPlugins(options);
+}
+/** Loads the config-selected plugin catalog and projects only its skills. */
+export function createConfiguredSkillProvider(options) {
+    return createProviderFromPlugins({
+        plugins: loadConfiguredRuntimePlugins(options.config),
+        listToolDefinitions: options.listToolDefinitions,
+    });
+}
+/** Uses the same bundled plugin manifests as the unconfigured tool registry. */
+export function createBundledPluginSkillProvider(options = {}) {
+    return createProviderFromPlugins({
+        plugins: loadBundledRuntimePlugins(),
+        listToolDefinitions: options.listToolDefinitions,
+    });
+}

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

@@ -0,0 +1,3 @@
+import type { ConversationContextProvider, SessionStore } from "../ports.js";
+export declare const defaultRuntimeSessionStore: Pick<SessionStore, "appendMessage" | "appendContextEntry" | "appendRequestEvent" | "compareAndSwapSessionMemoryCheckpoint" | "getAllSessions" | "getOrCreateSession" | "startRequestStream" | "upsertArtifactPaths" | "updateSessionRuntimeMode" | "updateSessionTitle">;
+export declare const defaultRuntimeConversationContextProvider: Pick<ConversationContextProvider, "buildContextBuckets">;

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

@@ -0,0 +1,16 @@
+import { appendContextEntry, appendMessage, appendRequestEvent, buildContextBuckets, getAllSessions, getOrCreateSession, startRequestStream, upsertArtifactPaths, updateSessionRuntimeMode, updateSessionTitle, compareAndSwapSessionMemoryCheckpoint, } from "../../sessions/index.js";
+export const defaultRuntimeSessionStore = {
+    appendMessage,
+    appendContextEntry,
+    appendRequestEvent,
+    compareAndSwapSessionMemoryCheckpoint,
+    getAllSessions,
+    getOrCreateSession,
+    startRequestStream,
+    upsertArtifactPaths,
+    updateSessionRuntimeMode,
+    updateSessionTitle,
+};
+export const defaultRuntimeConversationContextProvider = {
+    buildContextBuckets,
+};

package/dist/src/runtime/adapters/file-session-store.d.ts

@@ -0,0 +1,8 @@
+import type { SessionRecord } from "../../sessions/types.js";
+import type { SessionStore } from "../ports.js";
+export type FileSessionStoreOptions = {
+    sessionsDir?: string;
+    now?: () => Date;
+    createMessageId?: (session: SessionRecord) => string;
+};
+export declare function createFileSessionStore(options?: FileSessionStoreOptions): SessionStore;

package/dist/src/runtime/adapters/file-session-store.js

@@ -0,0 +1,26 @@
+import { SessionService } from "../../sessions/session-service.js";
+export function createFileSessionStore(options = {}) {
+    const service = new SessionService(options);
+    return {
+        getOrCreateSession: service.getOrCreateSession.bind(service),
+        getAllSessions: service.getAllSessions.bind(service),
+        listSessions: service.listSessions.bind(service),
+        getSessionById: service.getSessionById.bind(service),
+        getSessionSnapshot: service.getSessionSnapshot.bind(service),
+        getRequestReplayById: service.getRequestReplayById.bind(service),
+        updateSessionTitle: service.updateSessionTitle.bind(service),
+        updateSessionRuntimeMode: service.updateSessionRuntimeMode.bind(service),
+        appendMessage: service.appendMessage.bind(service),
+        appendContextEntry: service.appendContextEntry.bind(service),
+        upsertArtifactPaths: service.upsertArtifactPaths.bind(service),
+        startRequestStream: service.startRequestStream.bind(service),
+        appendRequestEvent: service.appendRequestEvent.bind(service),
+        compareAndSwapSessionMemoryCheckpoint: service.compareAndSwapSessionMemoryCheckpoint.bind(service),
+        deleteSession: service.deleteSession.bind(service),
+        deleteSessionWithStats: service.deleteSessionWithStats.bind(service),
+        resetSession: service.resetSession.bind(service),
+        clearSessionMessages: service.clearSessionMessages.bind(service),
+        deleteMessage: service.deleteMessage.bind(service),
+        deleteMessageWithStats: service.deleteMessageWithStats.bind(service),
+    };
+}

package/dist/src/runtime/adapters/in-memory-session-store.d.ts

@@ -0,0 +1,8 @@
+import type { SessionRecord } from "../../sessions/types.js";
+import type { SessionStore } from "../ports.js";
+export type InMemorySessionStoreOptions = {
+    initialSessions?: SessionRecord[];
+    now?: () => Date;
+    createMessageId?: (session: SessionRecord) => string;
+};
+export declare function createInMemorySessionStore(options?: InMemorySessionStoreOptions): SessionStore;