@mono-agent/agent-runtime 0.3.0 → 0.4.1

package/types/ai/runtime/model-refs.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function canonicalizeLegacyModelReference(value: string): string;
+/**
+ * @param {string} value
+ * @returns {RuntimeModelRef}
+ */
+export function normalizeRuntimeModelReference(value: string): RuntimeModelRef;
+/**
+ * @param {string} value
+ * @returns {RuntimeModelRef["sdk"]}
+ */
+export function sdkFromModelReference(value: string): RuntimeModelRef["sdk"];
+/**
+ * @param {string} value
+ * @returns {RuntimeModelRef}
+ */
+export function parseRuntimeModelReference(value: string): RuntimeModelRef;
+/**
+ * @param {string|RuntimeModelRef} modelRefOrParsed
+ * @param {string} executionMode
+ * @returns {string|null}
+ */
+export function executionModeIncompatibilityReason(modelRefOrParsed: string | RuntimeModelRef, executionMode: string): string | null;
+/**
+ * @param {string|RuntimeModelRef} modelRefOrParsed
+ * @param {string} executionMode
+ * @returns {boolean}
+ */
+export function isModelCompatibleWithExecutionMode(modelRefOrParsed: string | RuntimeModelRef, executionMode: string): boolean;
+export const ACTIVE_RUNTIME_KINDS: string[];
+export const RESERVED_RUNTIME_KINDS: string[];
+export type RuntimeModelRef = import("../types.js").RuntimeModelRef;

package/types/ai/runtime/registry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @returns {Array<RuntimeBridgeDescriptor>}
+ */
+export function listRuntimeBridges(): Array<RuntimeBridgeDescriptor>;
+/**
+ * @param {import('../types.js').RuntimeModelRef} modelRef
+ * @param {Object} [options]
+ * @returns {Promise<RuntimeBridge>}
+ */
+export function resolveRuntimeBridge(modelRef: import("../types.js").RuntimeModelRef, options?: any): Promise<RuntimeBridge>;
+/**
+ * `RuntimeModelRef` is referenced inline (not aliased with a top-level
+ * `@typedef`) so this barrel does not re-export a second `RuntimeModelRef`
+ * type alongside model-refs.js's — that duplicate `export *` re-export is a
+ * TS2308 ambiguity. The canonical export stays in model-refs.js/types.js.
+ */
+export type RuntimeBridge = import("../types.js").RuntimeBridge;
+/**
+ * `RuntimeModelRef` is referenced inline (not aliased with a top-level
+ * `@typedef`) so this barrel does not re-export a second `RuntimeModelRef`
+ * type alongside model-refs.js's — that duplicate `export *` re-export is a
+ * TS2308 ambiguity. The canonical export stays in model-refs.js/types.js.
+ */
+export type RuntimeBridgeDescriptor = import("../types.js").RuntimeBridgeDescriptor;
+/**
+ * `RuntimeModelRef` is referenced inline (not aliased with a top-level
+ * `@typedef`) so this barrel does not re-export a second `RuntimeModelRef`
+ * type alongside model-refs.js's — that duplicate `export *` re-export is a
+ * TS2308 ambiguity. The canonical export stays in model-refs.js/types.js.
+ */
+export type RuntimeBridgeId = import("../types.js").RuntimeBridgeId;
+export type BridgeSpec = {
+    id: RuntimeBridgeId;
+    supports: (ref: (import("../types.js").RuntimeModelRef | undefined), options?: any) => boolean;
+    capabilities: (ref?: import("../types.js").RuntimeModelRef) => any;
+    load: (options?: any) => Promise<RuntimeBridge>;
+};
+export { RUNTIME_CAPABILITIES, runtimeCapabilities } from "./capabilities.js";

package/types/ai/runtime/router.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @typedef {import('../types.js').RuntimeModelRef} RuntimeModelRef
+ * @typedef {import('../types.js').AgentRuntimeHostOptions} AgentRuntimeHostOptions
+ * @typedef {import('../types.js').AgentRuntimeInstance} AgentRuntimeInstance
+ * @typedef {import('../types.js').RuntimeRunOptions} RuntimeRunOptions
+ * @typedef {import('../types.js').RuntimeResult} RuntimeResult
+ */
+/**
+ * @typedef {Object} RouterChainEntryInput
+ * A chain entry as accepted by createRouterRuntime: either the shorthand bare
+ * RuntimeModelRef, or the full `{model, executionMode?, requires?}` form.
+ * @property {RuntimeModelRef} model
+ * @property {string} [executionMode]
+ * @property {Object<string, *>} [requires]
+ */
+/**
+ * @typedef {Object} RouterChainEntry
+ * @property {RuntimeModelRef} model
+ * @property {string|null} executionMode
+ * @property {Object<string, *>|null} requires
+ */
+/**
+ * @param {Object} [options]
+ * @param {AgentRuntimeHostOptions} [options.host]
+ * @param {ReadonlyArray<RuntimeModelRef|RouterChainEntryInput>} [options.chain]
+ * @returns {AgentRuntimeInstance & {chain: () => Array<RouterChainEntry>}}
+ */
+export function createRouterRuntime({ host, chain }?: {
+    host?: AgentRuntimeHostOptions;
+    chain?: ReadonlyArray<RuntimeModelRef | RouterChainEntryInput>;
+}): AgentRuntimeInstance & {
+    chain: () => Array<RouterChainEntry>;
+};
+export type RuntimeModelRef = import("../types.js").RuntimeModelRef;
+export type AgentRuntimeHostOptions = import("../types.js").AgentRuntimeHostOptions;
+export type AgentRuntimeInstance = import("../types.js").AgentRuntimeInstance;
+export type RuntimeRunOptions = import("../types.js").RuntimeRunOptions;
+export type RuntimeResult = import("../types.js").RuntimeResult;
+/**
+ * A chain entry as accepted by createRouterRuntime: either the shorthand bare
+ * RuntimeModelRef, or the full `{model, executionMode?, requires?}` form.
+ */
+export type RouterChainEntryInput = {
+    model: RuntimeModelRef;
+    executionMode?: string;
+    requires?: {
+        [x: string]: any;
+    };
+};
+export type RouterChainEntry = {
+    model: RuntimeModelRef;
+    executionMode: string | null;
+    requires: {
+        [x: string]: any;
+    } | null;
+};

package/types/ai/runtime/session-liveness.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @typedef {object} SessionRegistryLike
+ * @property {(id: string) => any} get
+ * @property {(id: string, value: any, opts?: {idleTimeoutMs?: number}) => void} set
+ * @property {(id: string) => boolean} delete
+ */
+/**
+ * @typedef {{ok: true, entry: any} | {ok: false, reason: "busy" | "missing"}} ClaimResult
+ * @typedef {{ok: true, id: string, release: () => void, commit: (entry: any) => void} | {ok: false, entry: any}} ReserveResult
+ */
+/**
+ * @typedef {object} SessionLiveness
+ * @property {(id: string) => ClaimResult} claim
+ * @property {(id: string) => any} adoptIfPresent
+ * @property {(id: string, seed: any, ttl: number|undefined) => ReserveResult} reserve
+ * @property {(id: string) => void} release
+ */
+/**
+ * Wrap a session registry with the synchronous liveness primitives. The
+ * explicit return typedef pins the claim/reserve discriminated unions so
+ * callers narrow on `ok` (object-literal inference would otherwise widen `ok`
+ * to boolean and break narrowing).
+ * @param {SessionRegistryLike} registry
+ * @returns {SessionLiveness}
+ */
+export function createSessionLiveness(registry: SessionRegistryLike): SessionLiveness;
+export type SessionRegistryLike = {
+    get: (id: string) => any;
+    set: (id: string, value: any, opts?: {
+        idleTimeoutMs?: number;
+    }) => void;
+    delete: (id: string) => boolean;
+};
+export type ClaimResult = {
+    ok: true;
+    entry: any;
+} | {
+    ok: false;
+    reason: "busy" | "missing";
+};
+export type ReserveResult = {
+    ok: true;
+    id: string;
+    release: () => void;
+    commit: (entry: any) => void;
+} | {
+    ok: false;
+    entry: any;
+};
+export type SessionLiveness = {
+    claim: (id: string) => ClaimResult;
+    adoptIfPresent: (id: string) => any;
+    reserve: (id: string, seed: any, ttl: number | undefined) => ReserveResult;
+    release: (id: string) => void;
+};

package/types/ai/runtime/sessions.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @param {object} [options]
+ * @param {number} [options.idleTimeoutMs]
+ * @param {(value: any, reason: string) => (void | Promise<void>)} [options.onEvict]
+ * @param {() => number} [options.now]
+ * @param {(value: any) => boolean} [options.isBusy]
+ */
+export function createSessionRegistry({ idleTimeoutMs, onEvict, now, isBusy }?: {
+    idleTimeoutMs?: number;
+    onEvict?: (value: any, reason: string) => (void | Promise<void>);
+    now?: () => number;
+    isBusy?: (value: any) => boolean;
+}): {
+    get(id: any): any;
+    /**
+     * @param {any} id
+     * @param {any} value
+     * @param {{idleTimeoutMs?: number}} [options]
+     */
+    set(id: any, value: any, { idleTimeoutMs: entryTtl }?: {
+        idleTimeoutMs?: number;
+    }): void;
+    /**
+     * @param {any} id
+     * @param {{idleTimeoutMs?: number}} [options]
+     */
+    touch(id: any, { idleTimeoutMs: entryTtl }?: {
+        idleTimeoutMs?: number;
+    }): void;
+    has(id: any): boolean;
+    /** Remove without running onEvict — for callers that already cleaned up. */
+    delete(id: any): boolean;
+    dispose(id: any): Promise<boolean>;
+    disposeAll(): Promise<void>;
+    size(): number;
+};
+export function disposeProviderSession(providerSessionId: any): Promise<boolean>;
+export function disposeAllProviderSessions(): Promise<void>;

package/types/ai/streaming/codex-events.d.ts

@@ -0,0 +1,30 @@
+export function normalizeCodexItemType(type: any): any;
+export function normalizeCodexItemEvent(raw: any, context?: {}): {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            tool_use_id: any;
+            content: any;
+            is_error: boolean;
+        }[];
+    };
+} | {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            id: any;
+            name: any;
+            input: any;
+        }[];
+    };
+} | {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            text: any;
+        }[];
+    };
+};

package/types/ai/streaming/opencode-events.d.ts

@@ -0,0 +1,41 @@
+export function toolUseEvent(part: any): {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            id: any;
+            name: any;
+            input: any;
+        }[];
+    };
+};
+export function toolResultEvent(part: any): {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            tool_use_id: any;
+            content: any;
+            is_error: boolean;
+        }[];
+    };
+};
+export function thinkingEvent(part: any): {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            text: any;
+        }[];
+    };
+};
+export function assistantTextEvent(text: any): {
+    type: string;
+    message: {
+        content: {
+            type: string;
+            text: any;
+        }[];
+    };
+};
+export function toolPartSettled(part: any): boolean;