@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,38 @@
+import type WebSocket from "ws";
+import type { EventSinkFactory, ModelGatewayClient, RuntimeConfig, RuntimeHost, SessionStore, ToolRegistry } from "./ports.js";
+import type { RuntimeAttachmentStore } from "./attachments/store.js";
+import type { RequestHandlerOptions, RunRequestMessage } from "./request/contracts.js";
+import { type SessionMemoryCompactor } from "./context/session-memory/index.js";
+export type RuntimeEnvironmentServices = Readonly<{
+    config: RuntimeConfig;
+    sessions: SessionStore;
+    attachments: RuntimeAttachmentStore;
+    tools: ToolRegistry;
+    models: ModelGatewayClient;
+    events: EventSinkFactory;
+    sessionMemoryCompactor: SessionMemoryCompactor;
+}>;
+export type RuntimeRequestOptions = Pick<RequestHandlerOptions, "toolApprovalController" | "requestSteering">;
+export type RuntimeRequestHandler = Readonly<{
+    handle: (ws: WebSocket, message: RunRequestMessage, options?: RuntimeRequestOptions) => Promise<void>;
+}>;
+export type RuntimeApplication = Readonly<{
+    services: RuntimeEnvironmentServices;
+    host: RuntimeHost;
+    requests: RuntimeRequestHandler;
+}>;
+export type RuntimeDependencies = {
+    config: RuntimeConfig;
+    host: RuntimeHost;
+    sessions: SessionStore;
+    attachments: RuntimeAttachmentStore;
+    tools: ToolRegistry;
+    models: ModelGatewayClient;
+    events: EventSinkFactory;
+    sessionMemoryCompactor: SessionMemoryCompactor;
+};
+export type RuntimeDependencyOverrides = Partial<Omit<RuntimeDependencies, "config">>;
+export type RuntimeApplicationOverrides = RuntimeDependencyOverrides;
+export declare function createRuntimeApplication(config?: RuntimeConfig, overrides?: RuntimeApplicationOverrides): RuntimeApplication;
+export declare function createRuntimeRequestHandler(services: RuntimeEnvironmentServices): RuntimeRequestHandler;
+export declare function createDefaultRuntimeDependencies(config?: RuntimeConfig, overrides?: RuntimeDependencyOverrides): RuntimeDependencies;

package/dist/src/runtime/composition.js

@@ -0,0 +1,36 @@
+import { createBoundRuntimeRequestHandler, createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, 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 services = Object.freeze({
+        config,
+        sessions: overrides.sessions ?? createDefaultSessionStore(config),
+        attachments: overrides.attachments ?? createDefaultAttachmentStore(config),
+        tools,
+        models: overrides.models ?? createDefaultModelGatewayClient(config),
+        events: overrides.events ?? createDefaultEventSinkFactory(config),
+        sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
+    });
+    const requests = createRuntimeRequestHandler(services);
+    const host = overrides.host ??
+        createDefaultRuntimeHost(config, {
+            runtimeId: config.runtimeId,
+            agentBridgeUrl: config.agentBridgeUrl,
+            agentBridgeToken: config.agentBridgeToken,
+            services,
+            requestHandler: requests,
+            requestHandlerFactory: createRuntimeRequestHandler,
+        });
+    return Object.freeze({ services, host, requests });
+}
+export function createRuntimeRequestHandler(services) {
+    return createBoundRuntimeRequestHandler(services);
+}
+export function createDefaultRuntimeDependencies(config = loadRuntimeConfig(), overrides = {}) {
+    const application = createRuntimeApplication(config, overrides);
+    return {
+        ...application.services,
+        host: application.host,
+    };
+}

package/dist/src/runtime/config/builders.d.ts

@@ -0,0 +1,23 @@
+import type { RuntimeConfig, RuntimeLoggingConfig, RuntimeModelConfig, RuntimePluginConfig, RuntimeTimeouts } from "../ports.js";
+import type { ModelContextConfig, ModelGenerationConfig } from "../../model-gateway/types.js";
+import type { RuntimeConfigFile, RuntimeEnv } from "./types.js";
+import type { RuntimeModelExecutionPolicies } from "./model-execution-policy.js";
+export declare function compactTimeouts(timeouts: RuntimeTimeouts): RuntimeTimeouts | undefined;
+export declare function buildFeatureFlags(config: RuntimeConfigFile): RuntimeConfig["featureFlags"];
+export declare function buildLoggingConfig(config: RuntimeConfigFile, env?: RuntimeEnv): RuntimeLoggingConfig;
+export declare function buildPluginConfig(config: RuntimeConfigFile): RuntimePluginConfig | undefined;
+export declare function buildModelGatewayFormat(value: unknown): "json" | Record<string, unknown> | undefined;
+export declare function buildModelGenerationConfig(value: unknown): ModelGenerationConfig | undefined;
+export declare function buildModelContextConfig(value: unknown): ModelContextConfig | undefined;
+export declare function buildModelInvocationProfiles(profiles: unknown): RuntimeModelConfig["invocationProfiles"] | undefined;
+export declare function buildModelDefaults(defaults: unknown): RuntimeModelConfig["defaults"] | undefined;
+export type BuiltRuntimeModelConfiguration = Readonly<{
+    modelPolicy?: RuntimeModelConfig;
+    executionPolicies?: RuntimeModelExecutionPolicies;
+}>;
+export declare function buildRuntimeModelConfiguration(config: RuntimeConfigFile, options?: {
+    mainConfigPath?: string;
+}): BuiltRuntimeModelConfiguration;
+export declare function buildModelConfig(config: RuntimeConfigFile, options?: {
+    mainConfigPath?: string;
+}): RuntimeModelConfig | undefined;

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

@@ -0,0 +1,485 @@
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "./constants.js";
+import { isRequestExecutionPolicyId } from "./model-execution-policy.js";
+import { RuntimeConfigValidationError, validateModelProfileConfig, } from "./validation.js";
+import { readConfigPositiveInt, isRecord, readNestedConfigString, readNestedConfigStringArray, readOptionalBoolean, readOptionalStringMap, } from "./utils.js";
+export function compactTimeouts(timeouts) {
+    const entries = Object.entries(timeouts).filter(([, value]) => typeof value === "number");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+export function buildFeatureFlags(config) {
+    const raw = isRecord(config.featureFlags)
+        ? config.featureFlags
+        : isRecord(config.features)
+            ? config.features
+            : undefined;
+    if (!raw) {
+        return undefined;
+    }
+    const entries = Object.entries(raw).filter((entry) => {
+        const value = entry[1];
+        return (typeof value === "boolean" ||
+            typeof value === "number" ||
+            typeof value === "string");
+    });
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function readTraceEnabledOverride(env) {
+    const value = env?.LLM_RUNTIME_TRACE?.trim().toLowerCase();
+    if (!value) {
+        return undefined;
+    }
+    return !(value === "0" || value === "false" || value === "off");
+}
+export function buildLoggingConfig(config, env) {
+    const logging = isRecord(config.logging) ? config.logging : undefined;
+    const rotation = isRecord(logging?.rotation) ? logging.rotation : undefined;
+    return {
+        enabled: readTraceEnabledOverride(env) ??
+            readOptionalBoolean(logging, "enabled") ??
+            DEFAULT_RUNTIME_LOGGING_ENABLED,
+        rotation: {
+            maxFileSizeMb: readConfigPositiveInt(rotation, "maxFileSizeMb") ??
+                DEFAULT_RUNTIME_LOG_ROTATION_CONFIG.maxFileSizeMb,
+            maxFiles: readConfigPositiveInt(rotation, "maxFiles") ??
+                DEFAULT_RUNTIME_LOG_ROTATION_CONFIG.maxFiles,
+            maxAgeDays: readConfigPositiveInt(rotation, "maxAgeDays") ??
+                DEFAULT_RUNTIME_LOG_ROTATION_CONFIG.maxAgeDays,
+        },
+    };
+}
+export function buildPluginConfig(config) {
+    if (!isRecord(config.plugins)) {
+        return undefined;
+    }
+    const enabled = readOptionalBoolean(config.plugins, "enabled");
+    const allow = readNestedConfigStringArray(config.plugins, "allow");
+    const deny = readNestedConfigStringArray(config.plugins, "deny");
+    const pluginConfig = {
+        ...(enabled !== undefined ? { enabled } : {}),
+        ...(allow ? { allow } : {}),
+        ...(deny ? { deny } : {}),
+    };
+    return Object.keys(pluginConfig).length > 0 ? pluginConfig : undefined;
+}
+function buildModelProfile(profile) {
+    const model = readNestedConfigString(profile, "model");
+    if (!model) {
+        return undefined;
+    }
+    const label = readNestedConfigString(profile, "label");
+    const provider = readNestedConfigString(profile, "provider");
+    const contextWindowTokens = readOptionalPositiveInteger(profile, "contextWindowTokens");
+    const supportsThinking = readOptionalBoolean(profile, "supportsThinking");
+    const generation = buildModelGenerationConfig(profile.generation);
+    const context = buildModelContextConfig(profile.context);
+    const capabilities = buildModelCapabilities(profile.capabilities);
+    const calibration = buildModelStepCalibrations(profile.calibration);
+    const configRef = readNestedConfigString(profile, "configRef");
+    return {
+        ...(configRef ? { configRef } : {}),
+        ...(label ? { label } : {}),
+        ...(provider ? { provider } : {}),
+        model,
+        ...(contextWindowTokens !== undefined ? { contextWindowTokens } : {}),
+        ...(supportsThinking !== undefined ? { supportsThinking } : {}),
+        ...(isRecord(profile.options) ? { options: profile.options } : {}),
+        ...(generation ? { generation } : {}),
+        ...(context ? { context } : {}),
+        ...(capabilities ? { capabilities } : {}),
+        ...(calibration ? { calibration } : {}),
+    };
+}
+function mergeRawCalibration(base, override) {
+    return Object.fromEntries(Array.from(new Set([...Object.keys(base), ...Object.keys(override)])).map((slotId) => {
+        const baseSlot = base[slotId];
+        const overrideSlot = override[slotId];
+        return [
+            slotId,
+            isRecord(baseSlot) && isRecord(overrideSlot)
+                ? mergeModelProfileSources(baseSlot, overrideSlot)
+                : (overrideSlot ?? baseSlot),
+        ];
+    }));
+}
+function mergeModelProfileSources(referenced, inline) {
+    return {
+        ...referenced,
+        ...inline,
+        ...(isRecord(referenced.options) || isRecord(inline.options)
+            ? {
+                options: {
+                    ...(isRecord(referenced.options) ? referenced.options : {}),
+                    ...(isRecord(inline.options) ? inline.options : {}),
+                },
+            }
+            : {}),
+        ...(isRecord(referenced.generation) || isRecord(inline.generation)
+            ? {
+                generation: {
+                    ...(isRecord(referenced.generation) ? referenced.generation : {}),
+                    ...(isRecord(inline.generation) ? inline.generation : {}),
+                },
+            }
+            : {}),
+        ...(isRecord(referenced.context) || isRecord(inline.context)
+            ? {
+                context: {
+                    ...(isRecord(referenced.context) ? referenced.context : {}),
+                    ...(isRecord(inline.context) ? inline.context : {}),
+                },
+            }
+            : {}),
+        ...(isRecord(referenced.capabilities) || isRecord(inline.capabilities)
+            ? {
+                capabilities: {
+                    ...(isRecord(referenced.capabilities)
+                        ? referenced.capabilities
+                        : {}),
+                    ...(isRecord(inline.capabilities) ? inline.capabilities : {}),
+                },
+            }
+            : {}),
+        ...(isRecord(referenced.calibration) || isRecord(inline.calibration)
+            ? {
+                calibration: mergeRawCalibration(isRecord(referenced.calibration) ? referenced.calibration : {}, isRecord(inline.calibration) ? inline.calibration : {}),
+            }
+            : {}),
+    };
+}
+function buildModelStepCalibrations(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const entries = [];
+    for (const [slotId, calibration] of Object.entries(value)) {
+        if (!isRecord(calibration)) {
+            continue;
+        }
+        const profileId = readNestedConfigString(calibration, "profileId");
+        const timeoutMs = readConfigPositiveInt(calibration, "timeoutMs");
+        const generation = buildModelGenerationConfig(calibration.generation);
+        const context = buildModelContextConfig(calibration.context);
+        const format = buildModelGatewayFormat(calibration.format);
+        const instructions = readNestedConfigStringArray(calibration, "instructions");
+        const config = {
+            ...(profileId ? { profileId } : {}),
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            ...(generation ? { generation } : {}),
+            ...(context ? { context } : {}),
+            ...(format ? { format } : {}),
+            ...(instructions ? { instructions } : {}),
+        };
+        if (Object.keys(config).length > 0) {
+            entries.push([slotId, config]);
+        }
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function resolveModelProfileRefPath(params) {
+    return isAbsolute(params.configRef)
+        ? params.configRef
+        : resolve(dirname(params.mainConfigPath), params.configRef);
+}
+function readReferencedModelProfileConfig(params) {
+    const referencedPath = resolveModelProfileRefPath(params);
+    let raw = "";
+    try {
+        raw = readFileSync(referencedPath, "utf-8");
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            throw new RuntimeConfigValidationError(referencedPath, [
+                "model profile configRef file was not found",
+            ]);
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid model profile config JSON at ${referencedPath}: ${message}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new RuntimeConfigValidationError(referencedPath, [
+            "root must be an object",
+        ]);
+    }
+    const issues = [];
+    validateModelProfileConfig(issues, parsed, "model profile", {
+        allowConfigRef: false,
+    });
+    if (issues.length > 0) {
+        throw new RuntimeConfigValidationError(referencedPath, issues);
+    }
+    return parsed;
+}
+export function buildModelGatewayFormat(value) {
+    if (value === "json") {
+        return "json";
+    }
+    return isRecord(value) ? value : undefined;
+}
+function buildModelInvocationProfile(profile) {
+    const profileId = readNestedConfigString(profile, "profileId");
+    if (!profileId) {
+        return undefined;
+    }
+    const generation = buildModelGenerationConfig(profile.generation);
+    const context = buildModelContextConfig(profile.context);
+    const format = buildModelGatewayFormat(profile.format);
+    return {
+        profileId,
+        ...(generation ? { generation } : {}),
+        ...(context ? { context } : {}),
+        ...(format ? { format } : {}),
+    };
+}
+function readModelModalities(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const modalities = value.filter((entry) => entry === "text" || entry === "image" || entry === "audio");
+    return modalities.length > 0 ? [...new Set(modalities)] : undefined;
+}
+function buildModelCapabilities(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const inputModalities = readModelModalities(value.inputModalities);
+    const outputModalities = readModelModalities(value.outputModalities);
+    const capabilities = {
+        ...(inputModalities ? { inputModalities } : {}),
+        ...(outputModalities ? { outputModalities } : {}),
+    };
+    return Object.keys(capabilities).length > 0 ? capabilities : undefined;
+}
+function readOptionalNumber(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function readOptionalPositiveInteger(record, key) {
+    const value = readOptionalNumber(record, key);
+    return value !== undefined && value > 0 && Number.isSafeInteger(value)
+        ? value
+        : undefined;
+}
+function readOptionalNonNegativeInteger(record, key) {
+    const value = readOptionalNumber(record, key);
+    return value !== undefined && value >= 0 && Number.isInteger(value)
+        ? value
+        : undefined;
+}
+function readOptionalPositiveNumber(record, key) {
+    const value = readOptionalNumber(record, key);
+    return value !== undefined && value > 0 ? value : undefined;
+}
+function buildModelTokenEstimationConfig(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const asciiCharactersPerToken = readOptionalPositiveNumber(value, "asciiCharactersPerToken");
+    const nonAsciiBytesPerToken = readOptionalPositiveNumber(value, "nonAsciiBytesPerToken");
+    const messageOverheadTokens = readOptionalPositiveNumber(value, "messageOverheadTokens");
+    const config = {
+        ...(asciiCharactersPerToken !== undefined
+            ? { asciiCharactersPerToken }
+            : {}),
+        ...(nonAsciiBytesPerToken !== undefined ? { nonAsciiBytesPerToken } : {}),
+        ...(messageOverheadTokens !== undefined ? { messageOverheadTokens } : {}),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+function buildModelFormatTokenAccountingConfig(value) {
+    if (!isRecord(value) ||
+        (value.mode !== "none" && value.mode !== "estimate")) {
+        return undefined;
+    }
+    const fixedOverheadTokens = readOptionalNonNegativeInteger(value, "fixedOverheadTokens");
+    return {
+        mode: value.mode,
+        ...(fixedOverheadTokens !== undefined ? { fixedOverheadTokens } : {}),
+    };
+}
+export function buildModelGenerationConfig(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const temperature = readOptionalNumber(value, "temperature");
+    const topP = readOptionalNumber(value, "topP");
+    const reasoningEffort = value.reasoningEffort === "none" ||
+        value.reasoningEffort === "minimal" ||
+        value.reasoningEffort === "low" ||
+        value.reasoningEffort === "medium" ||
+        value.reasoningEffort === "high" ||
+        value.reasoningEffort === "xhigh"
+        ? value.reasoningEffort
+        : undefined;
+    const config = {
+        ...(temperature !== undefined ? { temperature } : {}),
+        ...(topP !== undefined ? { topP } : {}),
+        ...(reasoningEffort ? { reasoningEffort } : {}),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+export function buildModelContextConfig(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const formatTokenAccounting = buildModelFormatTokenAccountingConfig(value.formatTokenAccounting);
+    const tokenEstimation = buildModelTokenEstimationConfig(value.tokenEstimation);
+    const config = {
+        ...(formatTokenAccounting ? { formatTokenAccounting } : {}),
+        ...(tokenEstimation ? { tokenEstimation } : {}),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+function buildModelProvider(provider) {
+    const type = readNestedConfigString(provider, "type");
+    if (!type) {
+        return undefined;
+    }
+    const baseUrl = readNestedConfigString(provider, "baseUrl");
+    const apiKeyEnv = readNestedConfigString(provider, "apiKeyEnv");
+    const keepAlive = readNestedConfigString(provider, "keepAlive");
+    const settings = isRecord(provider.settings)
+        ? { ...provider.settings }
+        : undefined;
+    return {
+        type,
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(apiKeyEnv ? { apiKeyEnv } : {}),
+        ...(keepAlive ? { keepAlive } : {}),
+        ...(settings ? { settings } : {}),
+    };
+}
+function buildModelProviders(providers) {
+    if (!isRecord(providers)) {
+        return undefined;
+    }
+    const entries = [];
+    for (const [providerId, provider] of Object.entries(providers)) {
+        if (!isRecord(provider)) {
+            continue;
+        }
+        const modelProvider = buildModelProvider(provider);
+        if (modelProvider) {
+            entries.push([providerId, modelProvider]);
+        }
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function buildModelProfiles(profiles, options) {
+    if (!isRecord(profiles)) {
+        return {};
+    }
+    const gatewayEntries = [];
+    const executionEntries = [];
+    for (const [profileId, profile] of Object.entries(profiles)) {
+        if (!isRecord(profile)) {
+            continue;
+        }
+        const configRef = readNestedConfigString(profile, "configRef");
+        const referenced = configRef && options?.mainConfigPath
+            ? readReferencedModelProfileConfig({
+                mainConfigPath: options.mainConfigPath,
+                configRef,
+            })
+            : undefined;
+        const source = referenced
+            ? mergeModelProfileSources(referenced, profile)
+            : profile;
+        const modelProfile = buildModelProfile(source);
+        if (!modelProfile && configRef) {
+            throw new RuntimeConfigValidationError(options?.mainConfigPath ?? "runtime config", [`models.profiles.${profileId}.model must be a non-empty string`]);
+        }
+        if (modelProfile) {
+            gatewayEntries.push([profileId, modelProfile]);
+        }
+        const execution = isRecord(source.execution) ? source.execution : undefined;
+        if (execution && isRequestExecutionPolicyId(execution.policy)) {
+            executionEntries.push([profileId, { policy: execution.policy }]);
+        }
+    }
+    return {
+        ...(gatewayEntries.length > 0
+            ? { gatewayProfiles: Object.fromEntries(gatewayEntries) }
+            : {}),
+        ...(executionEntries.length > 0
+            ? { executionPolicies: Object.fromEntries(executionEntries) }
+            : {}),
+    };
+}
+export function buildModelInvocationProfiles(profiles) {
+    if (!isRecord(profiles)) {
+        return undefined;
+    }
+    const entries = [];
+    for (const [profileId, profile] of Object.entries(profiles)) {
+        if (!isRecord(profile)) {
+            continue;
+        }
+        const invocationProfile = buildModelInvocationProfile(profile);
+        if (invocationProfile) {
+            entries.push([profileId, invocationProfile]);
+        }
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+export function buildModelDefaults(defaults) {
+    if (!isRecord(defaults)) {
+        return undefined;
+    }
+    const overrideClientPreference = readOptionalBoolean(defaults, "overrideClientPreference");
+    const profileId = readNestedConfigString(defaults, "profileId");
+    const roles = readOptionalStringMap(defaults, "roles");
+    const steps = readOptionalStringMap(defaults, "steps");
+    const context = buildModelContextConfig(defaults.context);
+    const config = {
+        ...(overrideClientPreference !== undefined
+            ? { overrideClientPreference }
+            : {}),
+        ...(profileId ? { profileId } : {}),
+        ...(roles ? { roles } : {}),
+        ...(steps ? { steps } : {}),
+        ...(context ? { context } : {}),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+export function buildRuntimeModelConfiguration(config, options) {
+    if (!isRecord(config.models)) {
+        return {};
+    }
+    const providers = buildModelProviders(config.models.providers);
+    const builtProfiles = buildModelProfiles(config.models.profiles, options);
+    const invocationProfiles = buildModelInvocationProfiles(config.models.invocationProfiles);
+    const defaults = buildModelDefaults(config.models.defaults);
+    const modelPolicy = providers || builtProfiles.gatewayProfiles || invocationProfiles || defaults
+        ? {
+            ...(providers ? { providers } : {}),
+            ...(builtProfiles.gatewayProfiles
+                ? { profiles: builtProfiles.gatewayProfiles }
+                : {}),
+            ...(invocationProfiles ? { invocationProfiles } : {}),
+            ...(defaults ? { defaults } : {}),
+        }
+        : undefined;
+    return {
+        ...(modelPolicy ? { modelPolicy } : {}),
+        ...(builtProfiles.executionPolicies
+            ? { executionPolicies: builtProfiles.executionPolicies }
+            : {}),
+    };
+}
+export function buildModelConfig(config, options) {
+    return buildRuntimeModelConfiguration(config, options).modelPolicy;
+}

package/dist/src/runtime/config/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_RUNTIME_AGENT_BRIDGE_URL = "ws://127.0.0.1:8787/abot/agent-bridge";
+export declare const DEFAULT_RUNTIME_CONFIG_FILE = "runtime.config.json";
+export declare const DEFAULT_RUNTIME_LOGGING_ENABLED = true;
+export declare const DEFAULT_RUNTIME_LOG_ROTATION_CONFIG: {
+    readonly maxFileSizeMb: 20;
+    readonly maxFiles: 10;
+    readonly maxAgeDays: 7;
+};

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

@@ -0,0 +1,8 @@
+export const DEFAULT_RUNTIME_AGENT_BRIDGE_URL = "ws://127.0.0.1:8787/abot/agent-bridge";
+export const DEFAULT_RUNTIME_CONFIG_FILE = "runtime.config.json";
+export const DEFAULT_RUNTIME_LOGGING_ENABLED = true;
+export const DEFAULT_RUNTIME_LOG_ROTATION_CONFIG = {
+    maxFileSizeMb: 20,
+    maxFiles: 10,
+    maxAgeDays: 7,
+};

package/dist/src/runtime/config/effective-model-config-validation.d.ts

@@ -0,0 +1,11 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+import type { RequestRunnerConfig } from "./runner/contracts.js";
+/**
+ * Validates the fully materialized model policy against the strict runner
+ * authority before the Runtime starts accepting requests.
+ */
+export declare function validateEffectiveRuntimeModelConfig(params: {
+    configPath: string;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    runnerConfig: RequestRunnerConfig;
+}): void;