@abot-ai/runtime 1.0.0

package/dist/src/runtime/context/session-memory/projection.js

@@ -0,0 +1,26 @@
+export function buildSessionMemoryCheckpointMessage(sessionId, checkpoint) {
+    const lastCoveredMessage = checkpoint.coveredMessages.at(-1);
+    return Object.freeze({
+        role: "system",
+        content: JSON.stringify({
+            kind: checkpoint.kind,
+            authority: "prior_conversation",
+            purpose: "preserve_settled_current_session_continuity",
+            sessionId,
+            checkpointRevision: checkpoint.revision,
+            sourceRevision: checkpoint.sourceRevision,
+            coverage: {
+                messageCount: checkpoint.coveredMessages.length,
+                throughMessageId: lastCoveredMessage?.messageId ?? null,
+            },
+            summary: checkpoint.summary,
+            presenceEffect: "passive_prior_conversation_not_current_user_intent_work_routing_or_completion_evidence",
+        }),
+    });
+}
+export function projectSessionMemoryMessages(projection) {
+    return Object.freeze([
+        ...projection.priorConversationMessages,
+        ...projection.historyMessages.map(({ role, content }) => Object.freeze({ role, content })),
+    ]);
+}

package/dist/src/runtime/context/session-memory/root-projection.d.ts

@@ -0,0 +1,9 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { RequestExecutionSeed } from "../../request/contracts.js";
+import type { RequestHistoryMessage } from "../request-context-contracts.js";
+export type RootSessionMemoryProjection = Readonly<{
+    historyMessages: readonly RequestHistoryMessage[];
+    priorConversationMessages: readonly ChatMessage[];
+    historyRetention?: "compaction_managed";
+}>;
+export declare function projectRootSessionMemory(request: Pick<RequestExecutionSeed, "historyMessages" | "sessionMemory">): RootSessionMemoryProjection;

package/dist/src/runtime/context/session-memory/root-projection.js

@@ -0,0 +1,14 @@
+export function projectRootSessionMemory(request) {
+    if (!request.sessionMemory) {
+        return Object.freeze({
+            historyMessages: request.historyMessages,
+            priorConversationMessages: Object.freeze([]),
+        });
+    }
+    const projection = request.sessionMemory.project();
+    return Object.freeze({
+        historyMessages: projection.historyMessages,
+        priorConversationMessages: projection.priorConversationMessages,
+        historyRetention: "compaction_managed",
+    });
+}

package/dist/src/runtime/context/session-memory/selection.d.ts

@@ -0,0 +1,8 @@
+import type { SessionMemoryCheckpoint } from "../../../sessions/memory/contracts.js";
+import { type SessionMemorySourceSnapshot } from "../../../sessions/memory/source.js";
+import { type SessionMemoryRequestProjection } from "./contracts.js";
+export declare function selectSessionMemoryProjection(params: {
+    sessionId: string;
+    source: SessionMemorySourceSnapshot;
+    checkpoint?: SessionMemoryCheckpoint;
+}): SessionMemoryRequestProjection;

package/dist/src/runtime/context/session-memory/selection.js

@@ -0,0 +1,35 @@
+import { resolveCoveredTurnCount, } from "../../../sessions/memory/source.js";
+import { SESSION_MEMORY_PROTECTED_TURN_COUNT, } from "./contracts.js";
+import { buildSessionMemoryCheckpointMessage } from "./projection.js";
+export function selectSessionMemoryProjection(params) {
+    const coveredTurnCount = resolveCoveredTurnCount(params.source, params.checkpoint);
+    if (coveredTurnCount === undefined) {
+        throw new Error("session_memory_checkpoint_coverage_invalid");
+    }
+    const uncoveredTurns = params.source.turns.slice(coveredTurnCount);
+    const compactableTurnCount = Math.max(0, uncoveredTurns.length - SESSION_MEMORY_PROTECTED_TURN_COUNT);
+    const priorConversationMessages = params.checkpoint
+        ? Object.freeze([
+            buildSessionMemoryCheckpointMessage(params.sessionId, params.checkpoint),
+        ])
+        : Object.freeze([]);
+    return Object.freeze({
+        priorConversationMessages,
+        historyMessages: Object.freeze(uncoveredTurns.flatMap(({ userMessages, assistant }) => [
+            ...userMessages.map(toRequestHistoryMessage),
+            toRequestHistoryMessage(assistant),
+        ])),
+        compactableTurnCount,
+        checkpointRevision: params.checkpoint?.revision ?? 0,
+        sourceRevision: params.source.sourceRevision,
+    });
+}
+function toRequestHistoryMessage(message) {
+    return Object.freeze({
+        id: message.id,
+        role: message.role,
+        content: message.content,
+        createdAt: message.createdAt,
+        ...(message.requestId ? { requestId: message.requestId } : {}),
+    });
+}

package/dist/src/runtime/context/skills-context.d.ts

@@ -0,0 +1,12 @@
+export type RuntimeSkillCatalog = Readonly<{
+    skills: Readonly<Record<string, string>>;
+    actionSkills: Readonly<Record<string, readonly string[]>>;
+}>;
+export type SkillsContextProvider = {
+    getActionContext: (action: string) => Promise<string>;
+};
+/**
+ * Projects plugin-authored action mappings into model context. This layer
+ * classifies no capability and carries no tool-specific policy.
+ */
+export declare function createSkillsContextProvider(catalog?: RuntimeSkillCatalog): SkillsContextProvider;

package/dist/src/runtime/context/skills-context.js

@@ -0,0 +1,27 @@
+const EMPTY_CATALOG = Object.freeze({
+    skills: Object.freeze({}),
+    actionSkills: Object.freeze({}),
+});
+function unique(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function buildActionContext(skillNames, skills) {
+    const parts = [];
+    for (const skillName of unique(skillNames)) {
+        const content = skills[skillName]?.trim();
+        if (!content) {
+            continue;
+        }
+        parts.push(`### SKILL: ${skillName}`, content, "");
+    }
+    return parts.join("\n").trim();
+}
+/**
+ * Projects plugin-authored action mappings into model context. This layer
+ * classifies no capability and carries no tool-specific policy.
+ */
+export function createSkillsContextProvider(catalog = EMPTY_CATALOG) {
+    return {
+        getActionContext: (action) => Promise.resolve(buildActionContext(catalog.actionSkills[action] ?? [], catalog.skills)),
+    };
+}

package/dist/src/runtime/context/token-estimator.d.ts

@@ -0,0 +1,6 @@
+import type { ChatMessage, ModelTokenEstimationConfig } from "../../model-gateway/types.js";
+export declare function estimateTextTokens(text: string, config?: ModelTokenEstimationConfig): number;
+export declare function estimateAsciiCharacterTokens(characterCount: number, config?: ModelTokenEstimationConfig): number;
+export declare function estimateNonAsciiByteTokens(byteCount: number, config?: ModelTokenEstimationConfig): number;
+export declare function estimateMessageTokens(message: ChatMessage, config?: ModelTokenEstimationConfig): number;
+export declare function estimateMessagesTokens(messages: readonly ChatMessage[], config?: ModelTokenEstimationConfig): number;

package/dist/src/runtime/context/token-estimator.js

@@ -0,0 +1,53 @@
+const DEFAULT_ASCII_CHARACTERS_PER_TOKEN = 2;
+const DEFAULT_NON_ASCII_BYTES_PER_TOKEN = 2;
+const DEFAULT_MESSAGE_OVERHEAD_TOKENS = 6;
+export function estimateTextTokens(text, config = {}) {
+    let asciiCharacters = 0;
+    let nonAsciiBytes = 0;
+    for (const character of text) {
+        if (character.codePointAt(0) <= 0x7f) {
+            asciiCharacters += 1;
+        }
+        else {
+            nonAsciiBytes += Buffer.byteLength(character, "utf8");
+        }
+    }
+    return (estimateAsciiCharacterTokens(asciiCharacters, config) +
+        estimateNonAsciiByteTokens(nonAsciiBytes, config));
+}
+export function estimateAsciiCharacterTokens(characterCount, config = {}) {
+    return Math.ceil(nonNegativeFiniteOrZero(characterCount) /
+        positiveOrDefault(config.asciiCharactersPerToken, DEFAULT_ASCII_CHARACTERS_PER_TOKEN));
+}
+export function estimateNonAsciiByteTokens(byteCount, config = {}) {
+    return Math.ceil(nonNegativeFiniteOrZero(byteCount) /
+        positiveOrDefault(config.nonAsciiBytesPerToken, DEFAULT_NON_ASCII_BYTES_PER_TOKEN));
+}
+export function estimateMessageTokens(message, config = {}) {
+    const messageOverheadTokens = positiveOrDefault(config.messageOverheadTokens, DEFAULT_MESSAGE_OVERHEAD_TOKENS);
+    if (message.toolCalls !== undefined) {
+        return message.toolCalls.reduce((total, call) => total +
+            messageOverheadTokens +
+            estimateTextTokens(call.callId, config) +
+            estimateTextTokens(call.name, config) +
+            estimateTextTokens(call.arguments, config), 0);
+    }
+    if (message.role === "tool") {
+        return (messageOverheadTokens +
+            estimateTextTokens(message.toolCallId, config) +
+            estimateTextTokens(message.toolName, config) +
+            estimateTextTokens(message.content, config));
+    }
+    return messageOverheadTokens + estimateTextTokens(message.content, config);
+}
+export function estimateMessagesTokens(messages, config = {}) {
+    return messages.reduce((total, message) => total + estimateMessageTokens(message, config), 0);
+}
+function positiveOrDefault(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? value
+        : fallback;
+}
+function nonNegativeFiniteOrZero(value) {
+    return Number.isFinite(value) && value > 0 ? value : 0;
+}

package/dist/src/runtime/context/workspace-context.d.ts

@@ -0,0 +1,8 @@
+export type WorkspaceContextProviderOptions = {
+    compiledPath?: string;
+};
+export type WorkspaceContextProvider = {
+    getWorkspaceSystemSummary: () => Promise<string>;
+};
+export declare function createWorkspaceContextProvider(options?: WorkspaceContextProviderOptions): WorkspaceContextProvider;
+export declare function getWorkspaceSystemSummary(): Promise<string>;

package/dist/src/runtime/context/workspace-context.js

@@ -0,0 +1,49 @@
+import { readFile, stat } from "node:fs/promises";
+import { getDefaultWorkspaceSummaryPath } from "../config/layout.js";
+export function createWorkspaceContextProvider(options = {}) {
+    const compiledPath = options.compiledPath ?? getDefaultWorkspaceSummaryPath(process.cwd());
+    let cachedSummary = null;
+    async function loadWorkspaceSystemSummary() {
+        try {
+            const fileStat = await stat(compiledPath);
+            if (cachedSummary &&
+                cachedSummary.mtimeMs === fileStat.mtimeMs &&
+                cachedSummary.size === fileStat.size) {
+                return cachedSummary.summary;
+            }
+            const raw = await readFile(compiledPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed.summary === "string") {
+                const summary = parsed.summary.trim();
+                cachedSummary = {
+                    mtimeMs: fileStat.mtimeMs,
+                    size: fileStat.size,
+                    summary,
+                };
+                return summary;
+            }
+            cachedSummary = {
+                mtimeMs: fileStat.mtimeMs,
+                size: fileStat.size,
+                summary: "",
+            };
+            return "";
+        }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                cachedSummary = null;
+                return "";
+            }
+            throw error;
+        }
+    }
+    return {
+        getWorkspaceSystemSummary() {
+            return loadWorkspaceSystemSummary();
+        },
+    };
+}
+const defaultWorkspaceContextProvider = createWorkspaceContextProvider();
+export function getWorkspaceSystemSummary() {
+    return defaultWorkspaceContextProvider.getWorkspaceSystemSummary();
+}

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

@@ -0,0 +1,29 @@
+import { type RuntimeAttachmentStore } from "./attachments/store.js";
+import type { ConversationContextProvider, EventSink, EventSinkFactory, ModelGatewayClient, RuntimeConfig, RuntimeHost, SessionStore, SkillProvider, ToolRegistry, WorkspaceProvider } from "./ports.js";
+import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "./composition.js";
+export declare function createDefaultRuntimeHost(config?: RuntimeConfig, defaults?: DefaultRuntimeHostBindings): RuntimeHost;
+export type DefaultRuntimeHostBindings = Readonly<{
+    runtimeId?: string;
+    agentBridgeUrl?: string;
+    agentBridgeToken?: string;
+    eventSinkFactory?: EventSinkFactory;
+    modelGatewayClient?: ModelGatewayClient;
+    sessionStore?: SessionStore;
+    attachmentStore?: RuntimeAttachmentStore;
+    toolRegistry?: ToolRegistry;
+    services?: RuntimeEnvironmentServices;
+    requestHandler?: RuntimeRequestHandler;
+    requestHandlerFactory?: (services: RuntimeEnvironmentServices) => RuntimeRequestHandler;
+}>;
+export declare function createBoundRuntimeRequestHandler(services: RuntimeEnvironmentServices): RuntimeRequestHandler;
+export declare function createDefaultAttachmentStore(config: RuntimeConfig): RuntimeAttachmentStore;
+export declare function createDefaultSessionStore(config?: RuntimeConfig): SessionStore;
+export declare function createDefaultConversationContextProvider(): ConversationContextProvider;
+export declare function createDefaultToolRegistry(config?: RuntimeConfig): ToolRegistry;
+export declare function createDefaultSkillProvider(config?: RuntimeConfig, options?: {
+    toolRegistry?: Pick<ToolRegistry, "listDefinitions">;
+}): SkillProvider;
+export declare function createDefaultWorkspaceProvider(config?: RuntimeConfig): WorkspaceProvider;
+export declare function createDefaultModelGatewayClient(config?: RuntimeConfig): ModelGatewayClient;
+export declare function createDefaultEventSinkFactory(config?: RuntimeConfig): EventSinkFactory;
+export declare function createNoopEventSink(): EventSink;

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

@@ -0,0 +1,209 @@
+import { startAgentBridge } from "../bridge/start-agent-bridge.js";
+import { buildContextBuckets, buildContextWindow } from "../sessions/index.js";
+import { createModelGatewayClient, invokeModelGateway, invokeRawModelGateway, } from "../model-gateway/client.js";
+import { createBundledPluginSkillProvider, createConfiguredSkillProvider, } from "./adapters/configured-skill-provider.js";
+import { createFileSessionStore } from "./adapters/file-session-store.js";
+import { createFileAttachmentStore, } from "./attachments/store.js";
+import { createSourceWorkspaceProvider } from "./adapters/source-workspace-provider.js";
+import { createRuntimeEventBus } from "./events/runtime-emitter.js";
+import { configureDebugLogger } from "./observability/debug-logger.js";
+import { createConfiguredToolRegistry } from "./capabilities/configured-tool-registry.js";
+import { loadBundledRuntimePlugins, loadConfiguredRuntimePlugins, runtimePluginsToToolModules, } from "./plugins/loader.js";
+import { handleRunRequest } from "./request/handler.js";
+import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
+export function createDefaultRuntimeHost(config, defaults = {}) {
+    return {
+        start(options = {}) {
+            const services = resolveRuntimeHostEnvironmentServices({
+                config,
+                defaults,
+                options,
+            });
+            const runtimeConfig = services?.config ?? options.runtimeConfig ?? config;
+            const defaultRuntimeConfig = defaults.services?.config ?? config;
+            const runtimeConfigIdentityChanged = runtimeConfig !== undefined && runtimeConfig !== defaultRuntimeConfig;
+            const requestHandler = services
+                ? resolveRuntimeHostRequestHandler(services, defaults)
+                : defaults.requestHandler;
+            return startAgentBridge({
+                runtimeConfig,
+                runtimeId: options.runtimeId ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.runtimeId
+                        : defaults.runtimeId),
+                token: options.agentBridgeToken ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.agentBridgeToken
+                        : defaults.agentBridgeToken),
+                url: options.agentBridgeUrl ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.agentBridgeUrl
+                        : defaults.agentBridgeUrl),
+                eventSinkFactory: services?.events ??
+                    options.eventSinkFactory ??
+                    defaults.eventSinkFactory,
+                modelGatewayClient: services?.models ??
+                    options.modelGatewayClient ??
+                    defaults.modelGatewayClient,
+                sessionStore: services?.sessions ?? options.sessionStore ?? defaults.sessionStore,
+                attachmentStore: services?.attachments ??
+                    options.attachmentStore ??
+                    defaults.attachmentStore ??
+                    (runtimeConfig
+                        ? createDefaultAttachmentStore(runtimeConfig)
+                        : undefined),
+                toolRegistry: services?.tools ??
+                    options.toolRegistry ??
+                    defaults.toolRegistry ??
+                    createDefaultToolRegistry(runtimeConfig),
+                requestHandler,
+            });
+        },
+    };
+}
+function resolveRuntimeHostEnvironmentServices(params) {
+    const bound = params.defaults.services;
+    const runtimeConfig = params.options.runtimeConfig ?? bound?.config ?? params.config;
+    if (!runtimeConfig) {
+        return undefined;
+    }
+    const mayReuseBound = bound?.config === runtimeConfig;
+    const mayUseLegacyDefaults = !bound && params.config === runtimeConfig;
+    const sessions = params.options.sessionStore ??
+        (mayReuseBound ? bound.sessions : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.sessionStore : undefined) ??
+        createDefaultSessionStore(runtimeConfig);
+    const attachments = params.options.attachmentStore ??
+        (mayReuseBound ? bound.attachments : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.attachmentStore : undefined) ??
+        createDefaultAttachmentStore(runtimeConfig);
+    const tools = params.options.toolRegistry ??
+        (mayReuseBound ? bound.tools : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.toolRegistry : undefined) ??
+        createDefaultToolRegistry(runtimeConfig);
+    const models = params.options.modelGatewayClient ??
+        (mayReuseBound ? bound.models : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.modelGatewayClient : undefined) ??
+        createDefaultModelGatewayClient(runtimeConfig);
+    const events = params.options.eventSinkFactory ??
+        (mayReuseBound ? bound.events : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.eventSinkFactory : undefined) ??
+        createDefaultEventSinkFactory(runtimeConfig);
+    const sessionMemoryCompactor = bound?.sessionMemoryCompactor ?? createModelSessionMemoryCompactor();
+    if (mayReuseBound &&
+        sessions === bound.sessions &&
+        attachments === bound.attachments &&
+        tools === bound.tools &&
+        models === bound.models &&
+        events === bound.events &&
+        sessionMemoryCompactor === bound.sessionMemoryCompactor) {
+        return bound;
+    }
+    return Object.freeze({
+        config: runtimeConfig,
+        sessions,
+        attachments,
+        tools,
+        models,
+        events,
+        sessionMemoryCompactor,
+    });
+}
+function resolveRuntimeHostRequestHandler(services, defaults) {
+    if (services === defaults.services && defaults.requestHandler) {
+        return defaults.requestHandler;
+    }
+    return (defaults.requestHandlerFactory ?? createBoundRuntimeRequestHandler)(services);
+}
+export function createBoundRuntimeRequestHandler(services) {
+    const environmentOptions = {
+        runtimeConfig: services.config,
+        eventSinkFactory: services.events,
+        modelGatewayClient: services.models,
+        sessionStore: services.sessions,
+        attachmentStore: services.attachments,
+        toolRegistry: services.tools,
+        sessionMemoryCompactor: services.sessionMemoryCompactor,
+    };
+    return Object.freeze({
+        handle(ws, message, requestOptions = {}) {
+            return handleRunRequest(ws, message, {
+                ...environmentOptions,
+                ...requestOptions,
+            });
+        },
+    });
+}
+export function createDefaultAttachmentStore(config) {
+    return createFileAttachmentStore({
+        attachmentsDir: config.paths.attachmentsDir,
+    });
+}
+export function createDefaultSessionStore(config) {
+    return createFileSessionStore(config ? { sessionsDir: config.paths.sessionsDir } : {});
+}
+export function createDefaultConversationContextProvider() {
+    return {
+        buildContextBuckets,
+        buildContextWindow,
+    };
+}
+export function createDefaultToolRegistry(config) {
+    const plugins = config
+        ? loadConfiguredRuntimePlugins(config)
+        : loadBundledRuntimePlugins();
+    return createConfiguredToolRegistry(config, runtimePluginsToToolModules(plugins));
+}
+export function createDefaultSkillProvider(config, options = {}) {
+    const toolRegistry = options.toolRegistry ??
+        (config ? createDefaultToolRegistry(config) : undefined);
+    const listToolDefinitions = toolRegistry?.listDefinitions;
+    if (config) {
+        return createConfiguredSkillProvider({ config, listToolDefinitions });
+    }
+    return createBundledPluginSkillProvider({ listToolDefinitions });
+}
+export function createDefaultWorkspaceProvider(config) {
+    return createSourceWorkspaceProvider(config ? { workspaceDir: config.paths.workspaceDir } : {});
+}
+export function createDefaultModelGatewayClient(config) {
+    if (!config) {
+        return {
+            invoke: invokeModelGateway,
+            invokeRaw: invokeRawModelGateway,
+        };
+    }
+    return createModelGatewayClient({
+        baseUrl: config.modelGatewayUrl,
+        streamInactivityTimeoutMs: config.timeouts?.streamInactivityTimeoutMs,
+        ...(config.models ? { modelPolicy: config.models } : {}),
+    });
+}
+export function createDefaultEventSinkFactory(config) {
+    if (config) {
+        configureDebugLogger({
+            traceFile: config.paths.traceFile,
+            enabled: config.logging?.enabled,
+            rotation: config.logging?.rotation,
+        });
+    }
+    return {
+        create(options) {
+            return createRuntimeEventBus(options);
+        },
+    };
+}
+export function createNoopEventSink() {
+    return {
+        publish: () => { },
+        event: () => { },
+        runtimeState: () => { },
+        token: () => { },
+        legacyToken: () => { },
+        thinkingDelta: () => { },
+        completed: () => { },
+        failed: () => { },
+        drain: async () => { },
+        dispose: () => { },
+    };
+}

package/dist/src/runtime/events/event-status.d.ts

@@ -0,0 +1,20 @@
+type BridgeEventPayload = {
+    type?: string;
+    name?: string;
+    tool?: string;
+    stage?: string;
+    phase?: string;
+    reason?: string;
+    ok?: boolean;
+    actions?: Array<{
+        type?: string;
+        target?: string;
+        details?: string;
+    }>;
+    status?: string;
+    message?: string;
+    [key: string]: unknown;
+};
+export declare function formatToolDisplayName(tool: string): string;
+export declare function enrichEventPayload(payload: BridgeEventPayload): BridgeEventPayload;
+export {};