@abot-ai/runtime 1.0.0

package/dist/src/shared/agent.js

@@ -0,0 +1,18 @@
+import { createHash } from "node:crypto";
+import { DEFAULT_RUNTIME_ID } from "./constants.js";
+export function normalizeRuntimeId(value) {
+    return value.trim().toLowerCase() || DEFAULT_RUNTIME_ID;
+}
+export function resolveAgentMode(value) {
+    const mode = String(value || "")
+        .trim()
+        .toLowerCase();
+    if (mode === "fast")
+        return "fast";
+    if (mode === "deep")
+        return "deep";
+    return "reasoning";
+}
+export function stableBridgeToken(value) {
+    return createHash("sha1").update(value).digest("hex").slice(0, 12);
+}

package/dist/src/shared/attachments.d.ts

@@ -0,0 +1,64 @@
+export type RuntimeAttachmentKind = "image" | "file";
+export declare const RUNTIME_ATTACHMENT_MIME_TYPES: Readonly<{
+    "image/png": Readonly<{
+        kind: "image";
+        extension: ".png";
+    }>;
+    "image/jpeg": Readonly<{
+        kind: "image";
+        extension: ".jpg";
+    }>;
+    "image/webp": Readonly<{
+        kind: "image";
+        extension: ".webp";
+    }>;
+    "application/pdf": Readonly<{
+        kind: "file";
+        extension: ".pdf";
+    }>;
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": Readonly<{
+        kind: "file";
+        extension: ".docx";
+    }>;
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": Readonly<{
+        kind: "file";
+        extension: ".xlsx";
+    }>;
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": Readonly<{
+        kind: "file";
+        extension: ".pptx";
+    }>;
+    "text/plain": Readonly<{
+        kind: "file";
+        extension: ".txt";
+    }>;
+    "text/csv": Readonly<{
+        kind: "file";
+        extension: ".csv";
+    }>;
+    "text/markdown": Readonly<{
+        kind: "file";
+        extension: ".md";
+    }>;
+    "application/json": Readonly<{
+        kind: "file";
+        extension: ".json";
+    }>;
+    "application/rtf": Readonly<{
+        kind: "file";
+        extension: ".rtf";
+    }>;
+}>;
+export declare function normalizeRuntimeAttachmentMimeType(value: string): string;
+export declare function resolveRuntimeAttachmentMimeType(value: string): Readonly<{
+    kind: RuntimeAttachmentKind;
+    extension: string;
+}> | undefined;
+export type RuntimeAttachmentReference = {
+    id: string;
+    kind: RuntimeAttachmentKind;
+    mimeType: string;
+    storageRef: string;
+    name?: string;
+    size?: number;
+};

package/dist/src/shared/attachments.js

@@ -0,0 +1,26 @@
+export const RUNTIME_ATTACHMENT_MIME_TYPES = Object.freeze({
+    "image/png": Object.freeze({ kind: "image", extension: ".png" }),
+    "image/jpeg": Object.freeze({ kind: "image", extension: ".jpg" }),
+    "image/webp": Object.freeze({ kind: "image", extension: ".webp" }),
+    "application/pdf": Object.freeze({
+        kind: "file",
+        extension: ".pdf",
+    }),
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": Object.freeze({ kind: "file", extension: ".docx" }),
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": Object.freeze({ kind: "file", extension: ".xlsx" }),
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": Object.freeze({ kind: "file", extension: ".pptx" }),
+    "text/plain": Object.freeze({ kind: "file", extension: ".txt" }),
+    "text/csv": Object.freeze({ kind: "file", extension: ".csv" }),
+    "text/markdown": Object.freeze({ kind: "file", extension: ".md" }),
+    "application/json": Object.freeze({
+        kind: "file",
+        extension: ".json",
+    }),
+    "application/rtf": Object.freeze({ kind: "file", extension: ".rtf" }),
+});
+export function normalizeRuntimeAttachmentMimeType(value) {
+    return value.split(";", 1)[0].trim().toLowerCase();
+}
+export function resolveRuntimeAttachmentMimeType(value) {
+    return RUNTIME_ATTACHMENT_MIME_TYPES[normalizeRuntimeAttachmentMimeType(value)];
+}

package/dist/src/shared/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_AGENT_BRIDGE_URL = "ws://127.0.0.1:8787/agent-bridge";
+export declare const DEFAULT_RUNTIME_ID = "prod";
+export declare const DEFAULT_MODEL_GATEWAY_URL = "http://127.0.0.1:3000";
+export declare const DEFAULT_OLLAMA_URL = "http://127.0.0.1:11434";

package/dist/src/shared/constants.js

@@ -0,0 +1,4 @@
+export const DEFAULT_AGENT_BRIDGE_URL = "ws://127.0.0.1:8787/agent-bridge";
+export const DEFAULT_RUNTIME_ID = "prod";
+export const DEFAULT_MODEL_GATEWAY_URL = "http://127.0.0.1:3000";
+export const DEFAULT_OLLAMA_URL = "http://127.0.0.1:11434";

package/dist/src/shared/invocation-profile-selection.d.ts

@@ -0,0 +1,42 @@
+import type { ModelGatewayPolicyConfig, ModelInvocationProfileConfig, ModelPreference } from "../model-gateway/types.js";
+import type { ModelStep } from "./types.js";
+export type InvocationProfileSource = "clientPreference" | "default" | "modelStep" | "role";
+export type InvocationProfileCandidate<TProfile> = {
+    profileId: string;
+    profile: TProfile;
+    source: InvocationProfileSource;
+    invocationProfileId?: string;
+    invocationProfile?: ModelInvocationProfileConfig;
+};
+export type ProfileResolver<TProfile> = (profileId: string, policy?: ModelGatewayPolicyConfig) => TProfile | undefined;
+export declare function normalizeProfileId(value: unknown): string | undefined;
+export declare function normalizeModelPreference<TProfile>(value: unknown, policy: ModelGatewayPolicyConfig | undefined, resolveProfile: ProfileResolver<TProfile>): ModelPreference | undefined;
+export declare function resolveProfileCandidate<TProfile>(params: {
+    profileId: unknown;
+    policy?: ModelGatewayPolicyConfig;
+    source: InvocationProfileSource;
+    resolveProfile: ProfileResolver<TProfile>;
+}): InvocationProfileCandidate<TProfile> | undefined;
+export declare function resolveClientPreferenceProfile<TProfile>(params: {
+    modelPreference?: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    modelStep?: ModelStep | string;
+    resolveProfile: ProfileResolver<TProfile>;
+}): InvocationProfileCandidate<TProfile> | undefined;
+export declare function resolveConfiguredInvocationProfile<TProfile>(params: {
+    taskType?: string;
+    modelStep?: ModelStep | string;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    includeStepFallback?: boolean;
+    fallbackStepProfileId?: string;
+    resolveProfile: ProfileResolver<TProfile>;
+}): InvocationProfileCandidate<TProfile> | undefined;
+export declare function resolveEffectiveInvocationProfile<TProfile>(params: {
+    taskType?: string;
+    modelStep?: ModelStep | string;
+    modelPreference?: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    includeStepFallback?: boolean;
+    fallbackStepProfileId?: string;
+    resolveProfile: ProfileResolver<TProfile>;
+}): InvocationProfileCandidate<TProfile> | undefined;

package/dist/src/shared/invocation-profile-selection.js

@@ -0,0 +1,125 @@
+import { resolveRuntimeModelRole } from "./model-role-policy.js";
+import { isFastModelStep, isMainModelStep } from "./model-steps.js";
+export function normalizeProfileId(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+export function normalizeModelPreference(value, policy, resolveProfile) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const profileId = normalizeProfileId(value.profileId);
+    if (!profileId ||
+        !resolveProfileCandidate({
+            profileId,
+            policy,
+            source: "clientPreference",
+            resolveProfile,
+        })) {
+        return undefined;
+    }
+    const scope = value.scope;
+    return {
+        profileId,
+        scope: scope === "main" ? "main" : "all",
+    };
+}
+export function resolveProfileCandidate(params) {
+    const profileId = normalizeProfileId(params.profileId);
+    if (!profileId) {
+        return undefined;
+    }
+    const invocationProfile = params.policy?.invocationProfiles?.[profileId];
+    if (invocationProfile) {
+        const baseProfileId = normalizeProfileId(invocationProfile.profileId);
+        const profile = baseProfileId
+            ? params.resolveProfile(baseProfileId, params.policy)
+            : undefined;
+        return profile && baseProfileId
+            ? {
+                profileId: baseProfileId,
+                profile,
+                source: params.source,
+                invocationProfileId: profileId,
+                invocationProfile,
+            }
+            : undefined;
+    }
+    const profile = params.resolveProfile(profileId, params.policy);
+    return profile
+        ? {
+            profileId,
+            profile,
+            source: params.source,
+        }
+        : undefined;
+}
+export function resolveClientPreferenceProfile(params) {
+    const preference = normalizeModelPreference(params.modelPreference, params.modelPolicy, params.resolveProfile);
+    if (!preference) {
+        return undefined;
+    }
+    if (preference.scope !== "all" && !isMainModelStep(params.modelStep)) {
+        return undefined;
+    }
+    return resolveProfileCandidate({
+        profileId: preference.profileId,
+        policy: params.modelPolicy,
+        source: "clientPreference",
+        resolveProfile: params.resolveProfile,
+    });
+}
+export function resolveConfiguredInvocationProfile(params) {
+    const step = typeof params.modelStep === "string" ? params.modelStep.trim() : "";
+    const configuredStepProfileId = params.modelPolicy?.defaults?.steps?.[step];
+    const stepProfile = resolveProfileCandidate({
+        profileId: configuredStepProfileId,
+        policy: params.modelPolicy,
+        source: "modelStep",
+        resolveProfile: params.resolveProfile,
+    });
+    if (stepProfile) {
+        return stepProfile;
+    }
+    if (!configuredStepProfileId &&
+        params.includeStepFallback &&
+        isFastModelStep(step)) {
+        const profileId = normalizeProfileId(params.fallbackStepProfileId);
+        const profile = profileId
+            ? params.resolveProfile(profileId, params.modelPolicy)
+            : undefined;
+        if (profile && profileId) {
+            return {
+                profileId,
+                profile,
+                source: "modelStep",
+            };
+        }
+    }
+    const role = resolveRuntimeModelRole({
+        modelStep: step,
+    });
+    const roleProfile = resolveProfileCandidate({
+        profileId: role ? params.modelPolicy?.defaults?.roles?.[role] : undefined,
+        policy: params.modelPolicy,
+        source: "role",
+        resolveProfile: params.resolveProfile,
+    });
+    if (roleProfile) {
+        return roleProfile;
+    }
+    return resolveProfileCandidate({
+        profileId: params.modelPolicy?.defaults?.profileId,
+        policy: params.modelPolicy,
+        source: "default",
+        resolveProfile: params.resolveProfile,
+    });
+}
+export function resolveEffectiveInvocationProfile(params) {
+    const configuredProfile = resolveConfiguredInvocationProfile(params);
+    const clientPreferenceProfile = resolveClientPreferenceProfile(params);
+    return params.modelPolicy?.defaults?.overrideClientPreference === true
+        ? (configuredProfile ?? clientPreferenceProfile)
+        : (clientPreferenceProfile ?? configuredProfile);
+}

package/dist/src/shared/load-dotenv.d.ts

@@ -0,0 +1 @@
+export declare function loadDotEnvFile(envPath?: string): void;

package/dist/src/shared/load-dotenv.js

@@ -0,0 +1,40 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let loaded = false;
+function parseEnvLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+        return null;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0)
+        return null;
+    const key = trimmed.slice(0, eq).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+        return null;
+    let value = trimmed.slice(eq + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+    }
+    return { key, value };
+}
+export function loadDotEnvFile(envPath = join(process.cwd(), ".env")) {
+    if (loaded)
+        return;
+    loaded = true;
+    let raw = "";
+    try {
+        raw = readFileSync(envPath, "utf-8");
+    }
+    catch {
+        return;
+    }
+    for (const line of raw.split(/\r?\n/)) {
+        const parsed = parseEnvLine(line);
+        if (!parsed)
+            continue;
+        if (process.env[parsed.key] === undefined) {
+            process.env[parsed.key] = parsed.value;
+        }
+    }
+}

package/dist/src/shared/model-role-policy.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveRuntimeModelRole(params: {
+    modelStep?: string;
+}): string | undefined;

package/dist/src/shared/model-role-policy.js

@@ -0,0 +1,12 @@
+import { normalizeModelStepId, resolveModelInvocationStep, } from "./model-step-registry.js";
+export function resolveRuntimeModelRole(params) {
+    const step = normalizeModelStepId(params.modelStep);
+    const definition = resolveModelInvocationStep(step);
+    if (definition) {
+        return definition.role;
+    }
+    if (step.length === 0) {
+        return "chat";
+    }
+    return undefined;
+}

package/dist/src/shared/model-step-registry-data.json

@@ -0,0 +1,125 @@
+{
+  "steps": {
+    "SUPERVISOR_DECISION": {
+      "id": "supervisor.decision",
+      "owner": "runtime-core",
+      "role": "supervisor",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "supervisor_decision",
+      "outputTokenPolicy": "core_decision",
+      "attachmentPolicy": "conversation"
+    },
+    "SUPERVISOR_RESPONSE": {
+      "id": "supervisor.response",
+      "owner": "runtime-core",
+      "role": "supervisor",
+      "lane": "main",
+      "defaultFormat": "raw",
+      "outputContract": "supervisor_response",
+      "attachmentPolicy": "conversation"
+    },
+    "WORKER_DECISION": {
+      "id": "worker.decision",
+      "owner": "runtime-core",
+      "role": "worker",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "worker_decision",
+      "outputTokenPolicy": "core_decision",
+      "attachmentPolicy": "none"
+    },
+    "WORKER_RESULT": {
+      "id": "worker.result",
+      "owner": "runtime-core",
+      "role": "worker",
+      "lane": "main",
+      "defaultFormat": "raw",
+      "outputContract": "worker_result",
+      "attachmentPolicy": "none"
+    },
+    "PLANNER_DECISION": {
+      "id": "planner.decision",
+      "owner": "runtime-core",
+      "role": "planner",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "planner_decision",
+      "outputTokenPolicy": "core_decision",
+      "attachmentPolicy": "none"
+    },
+    "PLANNER_GRAPH": {
+      "id": "planner.graph",
+      "owner": "runtime-core",
+      "role": "planner",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "planner_graph_proposal",
+      "attachmentPolicy": "none"
+    },
+    "REVIEWER_DECISION": {
+      "id": "reviewer.decision",
+      "owner": "runtime-core",
+      "role": "reviewer",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "reviewer_decision",
+      "outputTokenPolicy": "core_decision",
+      "attachmentPolicy": "none"
+    },
+    "DEGRADED_FINALIZATION": {
+      "id": "degraded.finalization",
+      "owner": "runtime-core",
+      "role": "chatFinalization",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "degraded_finalization"
+    },
+    "EXECUTION_DECISION": {
+      "id": "execution.decision",
+      "owner": "runtime-core",
+      "role": "executor",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "execution_agent_decision",
+      "outputTokenPolicy": "core_decision",
+      "attachmentPolicy": "conversation"
+    },
+    "EXECUTION_RESPONSE": {
+      "id": "execution.response",
+      "owner": "runtime-core",
+      "role": "utility",
+      "lane": "main",
+      "defaultFormat": "raw",
+      "outputContract": "execution_response_text",
+      "attachmentPolicy": "conversation"
+    },
+    "AUDITOR_DECISION": {
+      "id": "auditor.decision",
+      "owner": "runtime-core",
+      "role": "auditor",
+      "lane": "main",
+      "defaultFormat": "json",
+      "outputContract": "auditor_decision",
+      "outputTokenPolicy": "core_decision",
+      "attachmentPolicy": "none"
+    },
+    "CONTEXT_COMPACTION": {
+      "id": "context.compact",
+      "owner": "runtime-core",
+      "role": "utility",
+      "lane": "utility",
+      "defaultFormat": "json",
+      "outputContract": "context_compaction",
+      "attachmentPolicy": "none"
+    },
+    "TOOL_PAYLOAD_RAW": {
+      "id": "tool_payload.raw",
+      "owner": "runtime-core",
+      "role": "utility",
+      "lane": "utility",
+      "defaultFormat": "raw",
+      "outputContract": "tool_payload_text"
+    }
+  }
+}

package/dist/src/shared/model-step-registry.d.ts

@@ -0,0 +1,133 @@
+import type { ModelInvocationLane, ModelInvocationStepDefinition } from "./model-step-registry.types.js";
+export type { ModelInvocationFormat, ModelInvocationAttachmentPolicy, ModelInvocationLane, ModelInvocationOutputTokenPolicy, ModelInvocationRole, ModelInvocationStepDefinition, ModelInvocationStepOwner, RegisteredModelInvocationStepDefinition, } from "./model-step-registry.types.js";
+export declare const CORE_DECISION_OUTPUT_TOKEN_LIMIT = 2048;
+export declare const MODEL_INVOCATION_STEP_REGISTRY: {
+    readonly SUPERVISOR_DECISION: {
+        readonly id: "supervisor.decision";
+        readonly owner: "runtime-core";
+        readonly role: "supervisor";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "supervisor_decision";
+        readonly outputTokenPolicy: "core_decision";
+        readonly attachmentPolicy: "conversation";
+    };
+    readonly SUPERVISOR_RESPONSE: {
+        readonly id: "supervisor.response";
+        readonly owner: "runtime-core";
+        readonly role: "supervisor";
+        readonly lane: "main";
+        readonly defaultFormat: "raw";
+        readonly outputContract: "supervisor_response";
+        readonly attachmentPolicy: "conversation";
+    };
+    readonly WORKER_DECISION: {
+        readonly id: "worker.decision";
+        readonly owner: "runtime-core";
+        readonly role: "worker";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "worker_decision";
+        readonly outputTokenPolicy: "core_decision";
+        readonly attachmentPolicy: "none";
+    };
+    readonly WORKER_RESULT: {
+        readonly id: "worker.result";
+        readonly owner: "runtime-core";
+        readonly role: "worker";
+        readonly lane: "main";
+        readonly defaultFormat: "raw";
+        readonly outputContract: "worker_result";
+        readonly attachmentPolicy: "none";
+    };
+    readonly PLANNER_DECISION: {
+        readonly id: "planner.decision";
+        readonly owner: "runtime-core";
+        readonly role: "planner";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "planner_decision";
+        readonly outputTokenPolicy: "core_decision";
+        readonly attachmentPolicy: "none";
+    };
+    readonly PLANNER_GRAPH: {
+        readonly id: "planner.graph";
+        readonly owner: "runtime-core";
+        readonly role: "planner";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "planner_graph_proposal";
+        readonly attachmentPolicy: "none";
+    };
+    readonly REVIEWER_DECISION: {
+        readonly id: "reviewer.decision";
+        readonly owner: "runtime-core";
+        readonly role: "reviewer";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "reviewer_decision";
+        readonly outputTokenPolicy: "core_decision";
+        readonly attachmentPolicy: "none";
+    };
+    readonly DEGRADED_FINALIZATION: {
+        readonly id: "degraded.finalization";
+        readonly owner: "runtime-core";
+        readonly role: "chatFinalization";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "degraded_finalization";
+    };
+    readonly EXECUTION_DECISION: {
+        readonly id: "execution.decision";
+        readonly owner: "runtime-core";
+        readonly role: "executor";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "execution_agent_decision";
+        readonly outputTokenPolicy: "core_decision";
+        readonly attachmentPolicy: "conversation";
+    };
+    readonly EXECUTION_RESPONSE: {
+        readonly id: "execution.response";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "main";
+        readonly defaultFormat: "raw";
+        readonly outputContract: "execution_response_text";
+        readonly attachmentPolicy: "conversation";
+    };
+    readonly AUDITOR_DECISION: {
+        readonly id: "auditor.decision";
+        readonly owner: "runtime-core";
+        readonly role: "auditor";
+        readonly lane: "main";
+        readonly defaultFormat: "json";
+        readonly outputContract: "auditor_decision";
+        readonly outputTokenPolicy: "core_decision";
+        readonly attachmentPolicy: "none";
+    };
+    readonly CONTEXT_COMPACTION: {
+        readonly id: "context.compact";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "utility";
+        readonly defaultFormat: "json";
+        readonly outputContract: "context_compaction";
+        readonly attachmentPolicy: "none";
+    };
+    readonly TOOL_PAYLOAD_RAW: {
+        readonly id: "tool_payload.raw";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "utility";
+        readonly defaultFormat: "raw";
+        readonly outputContract: "tool_payload_text";
+    };
+};
+export type ModelInvocationStepKey = keyof typeof MODEL_INVOCATION_STEP_REGISTRY;
+export type ModelStep = (typeof MODEL_INVOCATION_STEP_REGISTRY)[ModelInvocationStepKey]["id"];
+export declare const MODEL_INVOCATION_STEP_DEFINITIONS: readonly ModelInvocationStepDefinition[];
+export declare function normalizeModelStepId(modelStep: unknown): string;
+export declare function resolveModelInvocationStep(modelStep: unknown): ModelInvocationStepDefinition | undefined;
+export declare function resolveModelStepOutputTokenLimit(modelStep: unknown): number | undefined;
+export declare function isRegisteredModelStepInLane(modelStep: unknown, lane: ModelInvocationLane): boolean;