@kodax-ai/kodax 0.7.63 → 0.7.67

package/dist/sdk-runtime.d.ts

@@ -0,0 +1,1070 @@
+import { E as KodaXReasoningMode, d as KodaXCustomProviderConfig } from './types-chunks/types.d-Bp4Lm1jv.js';
+export { j as KodaXMessage } from './types-chunks/types.d-Bp4Lm1jv.js';
+import { X as KodaXOptions, L as KodaXEvents, a5 as KodaXResult, b0 as RuntimeContextBudgetSnapshot, b7 as RuntimeToolExposurePlan } from './types-chunks/bash-prefix-extractor.d-D57Gt6n8.js';
+import { x as AgentExecutorFactory, p as AgentDispatchPolicy, n as AgentCredentialBroker, g as AgentArtifactPolicy, o as AgentDispatchContext, aP as KodaXImageInputArtifact, aS as KodaXInputArtifactSource, bj as KodaXVideoInputArtifact, dc as WorkflowProcessSnapshot, d6 as WorkflowProcessEvent, N as AgentRegistrationService, am as DispatchableAgentQuery, ak as DispatchableAgentListing, K as AgentPreflightInput, L as AgentPreflightResult, V as AgentTaskService } from './types-chunks/types.d-DG9B4SMm.js';
+import { i as SkillMetadata } from './types-chunks/types.d-vJExiRje.js';
+import { a as McpServerConfig } from './types-chunks/config.d-CJy1WENT.js';
+import { s as McpServerStatus, t as McpServerToolList } from './types-chunks/manager.d-Zum9cGHU.js';
+import { c as ManagedWorkflowSnapshot } from './types-chunks/run-manager.d-lnwnfyNC.js';
+import { L as LoadedExtensionDiagnostic, u as ExtensionRuntimeDiagnostics } from './types-chunks/types.d-DYv3a1ka.js';
+import { D as saveConfig, c as CommandInfo } from './types-chunks/utils.d-DMI-9GTR.js';
+import { d as FullTranscriptSessionData, j as SessionTranscriptEntry, a as CompactSessionResult } from './types-chunks/public-api.d-CPBMPDiU.js';
+import 'vscode-languageserver-protocol';
+import './types-chunks/cost-tracker.d-CBLk1fiD.js';
+import './types-chunks/capability.d-3C62G8Eq.js';
+import './types-chunks/base.d-DalIRhbb.js';
+import './types-chunks/guardrail.d-vSaBe64I.js';
+import './types-chunks/guardrail.d-Ds7JHxR1.js';
+import 'readline';
+import 'child_process';
+
+declare const KODAX_DAEMON_PROTOCOL = "kodax-runtime-daemon";
+declare const KODAX_DAEMON_PROTOCOL_VERSION = 1;
+type RuntimeDaemonMethod = 'initialize' | 'runtime.initialize' | 'ping' | 'runtime.identity' | 'runtime.status' | 'runtime.shutdown' | 'runtime.capabilities' | 'daemon.status' | 'daemon.stop' | 'daemon.logs' | 'session.create' | 'session.load' | 'session.list' | 'session.transcript' | 'session.fork' | 'session.notice.append' | 'session.rewind' | 'session.active_entry.set' | 'session.activeEntry.set' | 'session.compact' | 'session.archive' | 'session.unarchive' | 'session.delete' | 'session.settings.get' | 'session.settings.update' | 'run.start' | 'run.get' | 'run.list' | 'run.await' | 'run.abort' | 'run.model.set' | 'run.provider.set' | 'run.reasoning.set' | 'run.setModel' | 'run.setProvider' | 'run.setReasoning' | 'event.subscribe' | 'event.unsubscribe' | 'event.replay' | 'permission.list' | 'permission.listPending' | 'permission.request' | 'permission.respond' | 'workflow.list' | 'workflow.get' | 'workflow.subscribe' | 'workflow.unsubscribe' | 'workflow.pause' | 'workflow.resume' | 'workflow.stop' | 'config.read' | 'config.patch' | 'config.reload' | 'model.list' | 'provider.list' | 'provider.custom.list' | 'provider.custom.upsert' | 'provider.custom.remove' | 'mcp.server.list' | 'mcp.server.get' | 'mcp.server.validate' | 'mcp.server.upsert' | 'mcp.server.delete' | 'mcp.server.remove' | 'mcp.server.reload' | 'mcp.tool.list' | 'extension.list' | 'extension.reload' | 'command.list' | 'command.resolve' | 'skill.list' | 'skill.describe' | 'skill.read' | 'artifact.create' | 'artifact.get' | 'artifact.delete' | 'agentRegistrations.list' | 'agentRegistrations.upsert' | 'agentRegistrations.remove' | 'agents.listDispatchable' | 'agents.describe' | 'agents.preflight' | 'agentTasks.list' | 'agentTasks.start' | 'agentTasks.get' | 'agentTasks.events' | 'agentTasks.wait' | 'agentTasks.sendInput' | 'agentTasks.cancel' | 'agentTasks.reconcile' | 'context.budget.get' | 'tool.exposure.preview';
+type RuntimeDaemonNotificationMethod = 'event' | 'runtime.warning';
+interface RuntimeDaemonError {
+    readonly code: RuntimeDaemonErrorCode;
+    readonly message: string;
+    readonly data?: unknown;
+}
+type RuntimeDaemonErrorCode = 'invalid_frame' | 'invalid_request' | 'invalid_params' | 'not_initialized' | 'method_not_found' | 'unauthorized' | 'permission_denied' | 'conflict' | 'not_found' | 'cancelled' | 'overloaded' | 'internal_error';
+interface RuntimeDaemonFrameBase {
+    readonly protocol: typeof KODAX_DAEMON_PROTOCOL;
+    readonly version: typeof KODAX_DAEMON_PROTOCOL_VERSION;
+}
+interface RuntimeDaemonRequest extends RuntimeDaemonFrameBase {
+    readonly kind: 'request';
+    readonly id: string;
+    readonly method: RuntimeDaemonMethod;
+    readonly params?: unknown;
+}
+interface RuntimeDaemonSuccessResponse extends RuntimeDaemonFrameBase {
+    readonly kind: 'response';
+    readonly id: string;
+    readonly result: unknown;
+}
+interface RuntimeDaemonErrorResponse extends RuntimeDaemonFrameBase {
+    readonly kind: 'error';
+    readonly id?: string;
+    readonly error: RuntimeDaemonError;
+}
+interface RuntimeDaemonNotification extends RuntimeDaemonFrameBase {
+    readonly kind: 'notification';
+    readonly method: RuntimeDaemonNotificationMethod;
+    readonly params?: unknown;
+}
+type RuntimeDaemonFrame = RuntimeDaemonRequest | RuntimeDaemonSuccessResponse | RuntimeDaemonErrorResponse | RuntimeDaemonNotification;
+declare const RUNTIME_DAEMON_METHODS: readonly RuntimeDaemonMethod[];
+
+interface RuntimeDaemonClientTransport {
+    request(method: RuntimeDaemonMethod, params?: unknown): Promise<unknown>;
+    subscribe(listener: (notification: RuntimeDaemonNotification) => void): RuntimeSubscription;
+    close?(): Promise<void> | void;
+}
+
+interface RuntimeWorkerResourceLimits {
+    readonly maxOldGenerationSizeMb?: number;
+    readonly maxYoungGenerationSizeMb?: number;
+    readonly stackSizeMb?: number;
+}
+interface RuntimeWorkerOptions {
+    readonly resourceLimits?: RuntimeWorkerResourceLimits;
+    readonly shutdownTimeoutMs?: number;
+}
+
+interface RuntimeDaemonEndpoint {
+    readonly kind: 'pipe' | 'unix';
+    readonly path: string;
+}
+
+type RuntimeDaemonJsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+interface RuntimeDaemonJsonSchema {
+    readonly type?: RuntimeDaemonJsonSchemaType | readonly RuntimeDaemonJsonSchemaType[];
+    readonly description?: string;
+    readonly enum?: readonly (string | number | boolean | null)[];
+    readonly properties?: Record<string, RuntimeDaemonJsonSchema>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean | RuntimeDaemonJsonSchema;
+    readonly items?: RuntimeDaemonJsonSchema;
+    readonly oneOf?: readonly RuntimeDaemonJsonSchema[];
+}
+interface RuntimeDaemonMethodSchema {
+    readonly params: RuntimeDaemonJsonSchema;
+    readonly result: RuntimeDaemonJsonSchema;
+}
+interface RuntimeDaemonProtocolSchema {
+    readonly protocol: typeof KODAX_DAEMON_PROTOCOL;
+    readonly version: typeof KODAX_DAEMON_PROTOCOL_VERSION;
+    readonly methods: Record<RuntimeDaemonMethod, RuntimeDaemonMethodSchema>;
+    readonly notifications: Record<RuntimeDaemonNotificationMethod, RuntimeDaemonJsonSchema>;
+}
+declare const RUNTIME_DAEMON_METHOD_SCHEMAS: {
+    initialize: {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'runtime.initialize': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    ping: {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'runtime.identity': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'runtime.status': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'runtime.shutdown': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'runtime.capabilities': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'daemon.status': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'daemon.stop': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'daemon.logs': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.create': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.load': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.transcript': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.fork': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.notice.append': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.rewind': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.active_entry.set': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.activeEntry.set': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.compact': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.archive': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.unarchive': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.delete': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.settings.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'session.settings.update': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.start': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.await': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.abort': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.model.set': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.provider.set': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.reasoning.set': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.setModel': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.setProvider': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'run.setReasoning': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'event.subscribe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'event.unsubscribe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'event.replay': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'permission.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'permission.listPending': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'permission.request': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'permission.respond': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'workflow.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'workflow.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'workflow.subscribe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'workflow.unsubscribe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'workflow.pause': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'workflow.resume': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'workflow.stop': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'config.read': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'config.patch': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'config.reload': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'model.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'provider.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'provider.custom.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'provider.custom.upsert': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'provider.custom.remove': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'mcp.server.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'mcp.server.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'mcp.server.validate': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'mcp.server.upsert': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'mcp.server.delete': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'mcp.server.remove': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'mcp.server.reload': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'mcp.tool.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'extension.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'extension.reload': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'command.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'command.resolve': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'skill.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'skill.describe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'skill.read': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'artifact.create': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'artifact.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'artifact.delete': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentRegistrations.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentRegistrations.upsert': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentRegistrations.remove': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agents.listDispatchable': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agents.describe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agents.preflight': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.start': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.events': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.wait': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.sendInput': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.cancel': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'agentTasks.reconcile': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'context.budget.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'tool.exposure.preview': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+};
+declare const RUNTIME_DAEMON_NOTIFICATION_SCHEMAS: {
+    event: RuntimeDaemonJsonSchema;
+    'runtime.warning': RuntimeDaemonJsonSchema;
+};
+declare const RUNTIME_DAEMON_PROTOCOL_SCHEMA: RuntimeDaemonProtocolSchema;
+declare const RUNTIME_DAEMON_PROTOCOL_SCHEMA_JSON: string;
+declare function listRuntimeDaemonSchemaMethods(): readonly RuntimeDaemonMethod[];
+
+/**
+ * SDK subpath entry - `@kodax-ai/kodax/runtime`.
+ *
+ * FEATURE_253 (v0.7.64): embedded runtime contract. This module composes the
+ * existing coding run loop, REPL-backed session storage, and agent workflow
+ * process manager without introducing a daemon or a fifth workspace package.
+ */
+
+type KodaXRuntimeMode = 'embedded' | 'daemon';
+type KodaXRuntimeIsolation = 'inline' | 'worker' | 'process';
+
+type ReplRuntimeConfigPatch = Parameters<typeof saveConfig>[0];
+declare const RUNTIME_CONFIG_PATCH_KEYS: readonly ["provider", "model", "effort", "planModeEffort", "thinking", "reasoningMode", "agentMode", "permissionMode", "locale", "providerModels", "extensions", "repoIntelligenceMode", "repoIntelligenceTrace", "verifierLog", "stallLog", "fallbackProviders", "fastProvider", "fastModel", "deepProvider", "deepModel", "maxOutputTokens", "disablePromptCache", "lsp", "lspAutoDownload", "acpLogLevel", "sessionRetentionDays", "repoIntelligence", "workflow"];
+type RuntimeConfigPatchKey = typeof RUNTIME_CONFIG_PATCH_KEYS[number];
+interface RuntimeIdentity {
+    readonly runtimeId: string;
+    readonly mode: KodaXRuntimeMode;
+    readonly profile: string;
+    readonly startedAt: string;
+    readonly version: string;
+    readonly isolation?: KodaXRuntimeIsolation;
+    readonly workerThreadId?: number;
+}
+interface RuntimeClientInfo {
+    readonly name: string;
+    readonly title?: string;
+    readonly version?: string;
+}
+interface RuntimeClientCapabilities {
+    readonly richEvents?: boolean;
+    readonly permissionPrompts?: boolean;
+    readonly configAdmin?: boolean;
+    readonly commandCatalog?: boolean;
+    readonly skillCatalog?: boolean;
+    readonly artifactUpload?: boolean;
+    readonly contextDiagnostics?: boolean;
+}
+interface RuntimeExternalAgentsOptions {
+    readonly factories: readonly AgentExecutorFactory[];
+    readonly policy: AgentDispatchPolicy;
+    readonly credentialBroker?: AgentCredentialBroker;
+    /** Authorizes an executor before it materializes any remote artifact. Defaults to deny. */
+    readonly artifactPolicy?: AgentArtifactPolicy;
+    /** Default host-derived context for Worker tools; run.start may override it. */
+    readonly defaultContext?: AgentDispatchContext;
+}
+interface CreateKodaXRuntimeOptions {
+    /** Runtime ownership form. Defaults to a caller-owned embedded Runtime. */
+    readonly mode?: KodaXRuntimeMode;
+    /** Embedded-only execution location. Daemon mode selects host isolation internally. */
+    readonly isolation?: 'inline' | 'worker';
+    /** Requires `isolation: 'worker'`; rejected instead of being silently ignored. */
+    readonly worker?: RuntimeWorkerOptions;
+    readonly homeDir?: string;
+    readonly profile?: string;
+    readonly sessionsDir?: string;
+    readonly defaultProvider?: string;
+    readonly defaultModel?: string;
+    readonly permissionTimeoutMs?: number;
+    readonly daemonStartupTimeoutMs?: number;
+    readonly daemonConnectTimeoutMs?: number;
+    readonly daemonTransport?: RuntimeDaemonClientTransport;
+    readonly daemonEndpoint?: string | RuntimeDaemonEndpoint;
+    /** Defaults to true for daemon mode unless a transport or endpoint is supplied. */
+    readonly autoStartDaemon?: boolean;
+    readonly daemonToken?: string;
+    readonly clientInfo?: RuntimeClientInfo;
+    readonly capabilities?: RuntimeClientCapabilities;
+    readonly requirements?: RuntimeCapabilityRequirements;
+    /** Inline host injection. Functions never cross daemon or Worker transport. */
+    readonly externalAgents?: RuntimeExternalAgentsOptions;
+}
+interface ConnectKodaXRuntimeOptions {
+    readonly profile?: string;
+    /** Attach-only by default; set true to start or reuse the local profile daemon. */
+    readonly autoStart?: boolean;
+    readonly endpoint?: string | RuntimeDaemonEndpoint;
+    readonly transport?: RuntimeDaemonClientTransport;
+    readonly homeDir?: string;
+    readonly sessionsDir?: string;
+    readonly defaultProvider?: string;
+    readonly defaultModel?: string;
+    readonly permissionTimeoutMs?: number;
+    readonly daemonStartupTimeoutMs?: number;
+    readonly daemonConnectTimeoutMs?: number;
+    readonly daemonToken?: string;
+    readonly clientInfo?: RuntimeClientInfo;
+    readonly capabilities?: RuntimeClientCapabilities;
+    readonly requirements?: RuntimeCapabilityRequirements;
+}
+interface RuntimeCapabilityRequirements {
+    /** Reject inline and shared daemon hosts; only a Worker-hosted Runtime satisfies this. */
+    readonly hardDispose?: boolean;
+    /** Reject hosts that do not advertise an installed external Agent executor plane. */
+    readonly externalAgents?: boolean;
+}
+interface RuntimeDiagnosticFilter {
+    readonly sessionId?: string;
+    readonly runId?: string;
+}
+interface RuntimeDiagnosticsService {
+    latestContextBudget(filter?: RuntimeDiagnosticFilter): Promise<RuntimeContextBudgetSnapshot | null>;
+    latestToolExposure(filter?: RuntimeDiagnosticFilter): Promise<RuntimeToolExposurePlan | null>;
+}
+interface KodaXRuntime {
+    readonly identity: RuntimeIdentity;
+    readonly sessions: RuntimeSessionService;
+    readonly runs: RuntimeRunService;
+    readonly events: RuntimeEventService;
+    readonly permissions: RuntimePermissionService;
+    readonly workflows: RuntimeWorkflowService;
+    readonly config: RuntimeConfigService;
+    readonly catalog: RuntimeCatalogService;
+    readonly mcp: RuntimeMcpService;
+    readonly artifacts: RuntimeArtifactService;
+    readonly status: RuntimeStatusService;
+    readonly diagnostics: RuntimeDiagnosticsService;
+    readonly admin: RuntimeAdminService;
+    readonly agents: RuntimeAgentService;
+    readonly agentTasks: RuntimeAgentTaskService;
+    /**
+     * Release this facade. Inline closes its private Runtime, Worker mode shuts
+     * down and terminates its Worker, and daemon mode only detaches this client.
+     */
+    close(): Promise<void>;
+}
+interface RuntimeAdminService {
+    readonly agentRegistrations: AgentRegistrationService;
+}
+interface RuntimeAgentService {
+    readonly enabled: boolean;
+    listDispatchable(query: DispatchableAgentQuery): Promise<readonly DispatchableAgentListing[]>;
+    describe(agentId: string, query: DispatchableAgentQuery): Promise<DispatchableAgentListing | undefined>;
+    preflight(input: AgentPreflightInput): Promise<AgentPreflightResult>;
+}
+type RuntimeAgentTaskService = Pick<AgentTaskService, 'start' | 'list' | 'get' | 'events' | 'wait' | 'sendInput' | 'cancel' | 'reconcile'>;
+type RuntimeConfigPatch = Partial<Pick<ReplRuntimeConfigPatch, RuntimeConfigPatchKey>>;
+interface RuntimeConfigReloadResult {
+    readonly ok: true;
+    readonly config: unknown;
+}
+interface RuntimeConfigService {
+    read(): Promise<unknown>;
+    patch(patch: RuntimeConfigPatch): Promise<unknown>;
+    reload(): Promise<RuntimeConfigReloadResult>;
+}
+interface RuntimeModelListFilter {
+    readonly provider?: string;
+}
+interface RuntimeCommandResolveInput {
+    readonly name: string;
+    readonly projectRoot?: string;
+}
+interface RuntimeCommandInfo {
+    readonly name: string;
+    readonly aliases?: readonly string[];
+    readonly description: string;
+    readonly source: CommandInfo['source'];
+    readonly usage?: string;
+    readonly argumentHint?: string;
+    readonly location?: CommandInfo['location'];
+    readonly path?: string;
+    readonly userInvocable?: boolean;
+    readonly disableModelInvocation?: boolean;
+    readonly allowedTools?: string;
+    readonly context?: 'fork';
+    readonly agent?: string;
+    readonly model?: string;
+}
+interface RuntimeSkillListFilter {
+    readonly projectRoot?: string;
+    readonly userInvocableOnly?: boolean;
+}
+interface RuntimeSkillDescribeInput {
+    readonly name: string;
+    readonly projectRoot?: string;
+}
+interface RuntimeSkillFileSummary {
+    readonly name: string;
+    readonly path: string;
+    readonly relativePath: string;
+}
+interface RuntimeSkillSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly userInvocable: boolean;
+    readonly argumentHint?: string;
+    readonly path: string;
+    readonly source: SkillMetadata['source'];
+    readonly disableModelInvocation: boolean;
+}
+interface RuntimeSkillDescription extends RuntimeSkillSummary {
+    readonly content: string;
+    readonly skillFilePath: string;
+    readonly scripts?: readonly RuntimeSkillFileSummary[];
+    readonly references?: readonly RuntimeSkillFileSummary[];
+    readonly assets?: readonly RuntimeSkillFileSummary[];
+    readonly templates?: readonly RuntimeSkillFileSummary[];
+    readonly resources?: readonly RuntimeSkillFileSummary[];
+}
+interface RuntimeExtensionReloadResult {
+    readonly ok: true;
+    readonly active: boolean;
+    readonly diagnostics?: ExtensionRuntimeDiagnostics;
+}
+interface RuntimeExtensionListResult {
+    readonly active: boolean;
+    readonly extensions: readonly LoadedExtensionDiagnostic[];
+    readonly diagnostics?: ExtensionRuntimeDiagnostics;
+}
+interface RuntimeCatalogService {
+    providers(): Promise<unknown>;
+    models(filter?: RuntimeModelListFilter): Promise<unknown>;
+    commands(projectRoot?: string): Promise<readonly RuntimeCommandInfo[]>;
+    resolveCommand(input: RuntimeCommandResolveInput): Promise<RuntimeCommandInfo | null>;
+    skills(filter?: RuntimeSkillListFilter): Promise<readonly RuntimeSkillSummary[]>;
+    describeSkill(input: RuntimeSkillDescribeInput): Promise<RuntimeSkillDescription | null>;
+    customProviders(): Promise<readonly KodaXCustomProviderConfig[]>;
+    upsertCustomProvider(config: KodaXCustomProviderConfig): Promise<KodaXCustomProviderConfig>;
+    deleteCustomProvider(name: string): Promise<boolean>;
+    extensions(): Promise<RuntimeExtensionListResult>;
+    reloadExtensions(): Promise<RuntimeExtensionReloadResult>;
+}
+interface RuntimeMcpToolListFilter {
+    readonly server?: string;
+    readonly forceRefresh?: boolean;
+}
+interface RuntimeMcpReloadResult {
+    readonly ok: true;
+    readonly servers: readonly McpServerStatus[];
+}
+type RuntimeMcpValidateResult = {
+    readonly ok: true;
+    readonly config: McpServerConfig;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+interface RuntimeMcpService {
+    listServers(): Promise<Record<string, McpServerConfig>>;
+    getServer(name: string): Promise<McpServerConfig | undefined>;
+    validateServer(name: string, config: unknown): Promise<RuntimeMcpValidateResult>;
+    upsertServer(name: string, config: McpServerConfig): Promise<McpServerConfig>;
+    deleteServer(name: string): Promise<boolean>;
+    reloadServers(): Promise<RuntimeMcpReloadResult>;
+    listTools(filter?: RuntimeMcpToolListFilter): Promise<readonly McpServerToolList[]>;
+}
+type RuntimeArtifactKind = 'image' | 'file' | 'video';
+interface RuntimeCreateArtifactInput {
+    readonly kind: RuntimeArtifactKind;
+    readonly path: string;
+    readonly mediaType?: string;
+    readonly mimeType?: string;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface RuntimeArtifact {
+    readonly id: string;
+    readonly kind: RuntimeArtifactKind;
+    readonly path: string;
+    readonly sizeBytes: number;
+    readonly mediaType?: string;
+    readonly mimeType?: string;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+    readonly createdAt: string;
+}
+interface RuntimeArtifactService {
+    create(input: RuntimeCreateArtifactInput): Promise<RuntimeArtifact>;
+    get(artifactId: string): Promise<RuntimeArtifact | undefined>;
+    delete(artifactId: string): Promise<boolean>;
+}
+interface RuntimeCreateSessionInput {
+    readonly sessionId?: string;
+    readonly title?: string;
+    readonly projectPath?: string;
+    readonly gitRoot?: string;
+    readonly surface?: string;
+    readonly profileId?: string;
+    readonly tag?: string;
+}
+interface RuntimeSession {
+    readonly id: string;
+    readonly title: string;
+    readonly gitRoot?: string;
+    readonly workspaceRoot?: string;
+    readonly surface?: string;
+    readonly profileId?: string;
+    readonly createdAt?: string;
+}
+interface RuntimeSessionSummary extends RuntimeSession {
+    /** Opaque continuation token accepted by RuntimeSessionFilter.cursor. */
+    readonly cursor?: string;
+    readonly msgCount: number;
+    readonly tag?: string;
+    readonly projectKey?: string;
+    readonly archived?: boolean;
+}
+type RuntimeTranscript = FullTranscriptSessionData;
+interface RuntimeSessionFilter {
+    readonly projectRoot?: string;
+    readonly scope?: 'user' | 'managed-task-worker' | 'all';
+    readonly includeArchived?: boolean;
+    readonly limit?: number;
+    readonly before?: string;
+    readonly tag?: string;
+    readonly surface?: string;
+    readonly cursor?: string;
+}
+interface RuntimeForkSessionInput {
+    readonly sessionId: string;
+    readonly selector?: string;
+    readonly newSessionId?: string;
+    readonly title?: string;
+}
+interface RuntimeSessionSettings {
+    readonly provider?: string;
+    readonly model?: string;
+    readonly effort?: KodaXOptions['effort'];
+    readonly thinking?: boolean;
+    readonly reasoningMode?: KodaXReasoningMode;
+    readonly permissionMode?: string;
+    readonly executionCwd?: string;
+}
+interface RuntimeSessionSettingsPatch {
+    readonly provider?: string | null;
+    readonly model?: string | null;
+    readonly effort?: KodaXOptions['effort'] | null;
+    readonly thinking?: boolean | null;
+    readonly reasoningMode?: KodaXReasoningMode | null;
+    readonly permissionMode?: string | null;
+    readonly executionCwd?: string | null;
+}
+interface RuntimeAppendNoticeInput {
+    readonly sessionId: string;
+    readonly content: string;
+    readonly source?: string;
+}
+interface RuntimeRewindSessionInput {
+    readonly sessionId: string;
+    readonly selector?: string;
+}
+interface RuntimeSetActiveEntryInput {
+    readonly sessionId: string;
+    readonly entryId: string;
+}
+interface RuntimeCompactSessionInput {
+    readonly sessionId: string;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly customInstructions?: string;
+    readonly contextWindow?: number;
+}
+interface RuntimeCompactSessionResult extends CompactSessionResult {
+    readonly session?: RuntimeSession;
+}
+interface RuntimeSessionService {
+    create(input?: RuntimeCreateSessionInput): Promise<RuntimeSession>;
+    load(sessionId: string): Promise<RuntimeSession>;
+    list(filter?: RuntimeSessionFilter): Promise<readonly RuntimeSessionSummary[]>;
+    transcript(sessionId: string): Promise<RuntimeTranscript | null>;
+    fork(input: RuntimeForkSessionInput): Promise<RuntimeSession | null>;
+    getSettings(sessionId: string): Promise<RuntimeSessionSettings>;
+    updateSettings(sessionId: string, patch: RuntimeSessionSettingsPatch): Promise<RuntimeSessionSettings>;
+    appendNotice(input: RuntimeAppendNoticeInput): Promise<SessionTranscriptEntry | null>;
+    rewind(input: RuntimeRewindSessionInput): Promise<RuntimeSession | null>;
+    setActiveEntry(input: RuntimeSetActiveEntryInput): Promise<RuntimeSession | null>;
+    compact(input: RuntimeCompactSessionInput): Promise<RuntimeCompactSessionResult>;
+    archive(sessionId: string): Promise<void>;
+    unarchive(sessionId: string): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+}
+type RuntimeRunPhase = 'queued' | 'running' | 'waiting_permission' | 'waiting_user_input' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+type RuntimeRunMode = 'coding' | 'managed_task';
+interface RuntimeTextInput {
+    readonly type: 'text';
+    readonly text: string;
+}
+interface RuntimeImageInput {
+    readonly type: 'image';
+    readonly path: string;
+    readonly mediaType?: KodaXImageInputArtifact['mediaType'];
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface RuntimeFileInput {
+    readonly type: 'file';
+    readonly path: string;
+    readonly mediaType?: string;
+    readonly mimeType?: string;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface RuntimeVideoInput {
+    readonly type: 'video';
+    readonly path: string;
+    readonly mediaType: KodaXVideoInputArtifact['mediaType'];
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface RuntimeArtifactRefInput {
+    readonly type: 'artifact_ref';
+    readonly artifactId: string;
+    readonly description?: string;
+}
+type RuntimeInput = RuntimeTextInput | RuntimeImageInput | RuntimeFileInput | RuntimeVideoInput | RuntimeArtifactRefInput;
+type RuntimePermissionBroker = 'runtime' | 'client';
+interface RuntimeStartRunInput {
+    readonly sessionId: string;
+    readonly prompt?: string;
+    readonly input?: RuntimeInput | readonly RuntimeInput[];
+    readonly mode?: RuntimeRunMode;
+    readonly permissionBroker?: RuntimePermissionBroker;
+    readonly options?: RuntimeKodaXOptions;
+    /** Host-derived dispatch identity; never accepted from an LLM tool payload. */
+    readonly agentContext?: AgentDispatchContext;
+}
+type RuntimeKodaXOptions = Omit<KodaXOptions, 'provider' | 'session' | 'events'> & {
+    readonly provider?: string;
+    readonly session?: KodaXOptions['session'];
+    readonly events?: KodaXEvents;
+};
+interface RuntimeRunStatus {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly turnId?: string;
+    readonly phase: RuntimeRunPhase;
+    readonly startedAt: string;
+    readonly endedAt?: string;
+    readonly provider: string;
+    readonly model?: string;
+    readonly reasoning?: KodaXReasoningMode;
+    readonly error?: string;
+}
+interface RuntimeRunResult {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly phase: RuntimeRunPhase;
+    readonly result?: KodaXResult;
+    readonly error?: Error;
+}
+interface RuntimeRunHandle {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly turnId?: string;
+    readonly result: Promise<RuntimeRunResult>;
+}
+interface RuntimeRunFilter {
+    readonly sessionId?: string;
+    readonly phase?: RuntimeRunPhase | readonly RuntimeRunPhase[];
+}
+interface RuntimeRunService {
+    start(input: RuntimeStartRunInput): Promise<RuntimeRunHandle>;
+    await(runId: string): Promise<RuntimeRunResult>;
+    get(runId: string): Promise<RuntimeRunStatus>;
+    list(filter?: RuntimeRunFilter): Promise<readonly RuntimeRunStatus[]>;
+    abort(runId: string): Promise<void>;
+    setModel(runId: string, model: string | undefined): Promise<void>;
+    setProvider(runId: string, provider: string): Promise<void>;
+    setReasoning(runId: string, reasoning: KodaXReasoningMode | undefined): Promise<void>;
+}
+type RuntimeEventType = 'session.created' | 'session.loaded' | 'session.settings.updated' | 'session.notice.appended' | 'session.rewound' | 'session.active_entry.updated' | 'session.compacted' | 'run.queued' | 'run.started' | 'run.progress' | 'turn.started' | 'turn.completed' | 'turn.failed' | 'assistant.delta' | 'thinking.delta' | 'thinking.finished' | 'tool.started' | 'tool.progress' | 'tool.finished' | 'user_input.requested' | 'user_input.resolved' | 'permission.requested' | 'permission.resolved' | 'workflow.started' | 'workflow.updated' | 'workflow.finished' | 'context.compaction.started' | 'context.compaction.stats' | 'context.compaction.finished' | 'context.compaction.messages' | 'context.compaction.ended' | 'context.compaction.skipped' | 'context.budget.snapshot' | 'tool.exposure.planned' | 'child_activity.finished' | 'provider.retry' | 'provider.recovery' | 'repo_intelligence.trace' | 'todo.updated' | 'todo.warning' | 'sidecar.message' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'run.interrupted' | 'artifact.created' | 'config.effective' | 'runtime.warning';
+interface RuntimeEventEnvelope<TPayload = unknown> {
+    readonly id: string;
+    readonly seq: number;
+    readonly time: string;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly type: RuntimeEventType;
+    readonly payload: TPayload;
+}
+type RuntimeEvent = RuntimeEventEnvelope;
+interface RuntimeEventFilter {
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly type?: RuntimeEventType | readonly RuntimeEventType[];
+}
+interface RuntimeEventReplayFilter extends RuntimeEventFilter {
+    readonly sinceSeq?: number;
+    readonly limit?: number;
+}
+type RuntimeEventListener = (event: RuntimeEvent) => void;
+interface RuntimeSubscription {
+    close(): void;
+}
+interface RuntimeEventService {
+    subscribe(filter: RuntimeEventFilter, listener: RuntimeEventListener): RuntimeSubscription;
+    replay(filter?: RuntimeEventReplayFilter): Promise<readonly RuntimeEvent[]>;
+}
+type RuntimePermissionRisk = 'low' | 'medium' | 'high';
+interface RuntimePermissionScope {
+    readonly toolName?: string;
+    readonly sessionId?: string;
+}
+interface RuntimePermissionRequest {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly toolCallId?: string;
+    readonly toolName: string;
+    readonly reason?: string;
+    readonly risk?: RuntimePermissionRisk;
+    readonly inputPreview?: string;
+    readonly createdAt: string;
+    readonly expiresAt?: string;
+}
+interface RuntimePermissionRequestInput {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly toolCallId?: string;
+    readonly toolName: string;
+    readonly reason?: string;
+    readonly risk?: RuntimePermissionRisk;
+    readonly inputPreview?: string;
+    readonly expiresAt?: string;
+    readonly timeoutMs?: number;
+}
+type RuntimePermissionDecision = {
+    readonly type: 'allow_once';
+} | {
+    readonly type: 'allow_always';
+    readonly scope: RuntimePermissionScope;
+} | {
+    readonly type: 'reject';
+    readonly reason?: string;
+};
+interface RuntimePermissionFilter {
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly toolName?: string;
+}
+interface RuntimePermissionRespondOptions {
+    readonly runId?: string;
+}
+interface RuntimePermissionService {
+    request(input: RuntimePermissionRequestInput): Promise<RuntimePermissionDecision>;
+    listPending(filter?: RuntimePermissionFilter): Promise<readonly RuntimePermissionRequest[]>;
+    respond(requestId: string, decision: RuntimePermissionDecision, options?: RuntimePermissionRespondOptions): Promise<boolean>;
+}
+interface RuntimeWorkflowFilter {
+    readonly runId?: string;
+    readonly activeOnly?: boolean;
+    readonly limit?: number;
+}
+type RuntimeWorkflowSummary = ManagedWorkflowSnapshot;
+type RuntimeWorkflowSnapshot = WorkflowProcessSnapshot;
+type RuntimeWorkflowListener = (event: WorkflowProcessEvent) => void;
+interface RuntimeWorkflowService {
+    list(filter?: RuntimeWorkflowFilter): Promise<readonly RuntimeWorkflowSummary[]>;
+    get(runId: string): Promise<RuntimeWorkflowSnapshot | undefined>;
+    subscribe(filter: RuntimeWorkflowFilter, listener: RuntimeWorkflowListener): RuntimeSubscription;
+    pause(runId: string): Promise<boolean>;
+    resume(runId: string): Promise<boolean>;
+    stop(runId: string): Promise<boolean>;
+}
+interface RuntimeStatusSnapshot {
+    readonly runtimeId: string;
+    readonly mode: KodaXRuntimeMode;
+    readonly profile: string;
+    readonly startedAt: string;
+    readonly sessions: readonly RuntimeSessionSummary[];
+    readonly runs: readonly RuntimeRunStatus[];
+    readonly pendingPermissions: readonly RuntimePermissionRequest[];
+    readonly workflows: readonly RuntimeWorkflowSummary[];
+}
+interface RuntimeStatusService {
+    snapshot(): Promise<RuntimeStatusSnapshot>;
+}
+declare function createKodaXRuntime(options?: CreateKodaXRuntimeOptions): Promise<KodaXRuntime>;
+declare function connectKodaXRuntime(options?: ConnectKodaXRuntimeOptions): Promise<KodaXRuntime>;
+
+export { KODAX_DAEMON_PROTOCOL, KODAX_DAEMON_PROTOCOL_VERSION, KodaXEvents, KodaXResult, RUNTIME_DAEMON_METHODS, RUNTIME_DAEMON_METHOD_SCHEMAS, RUNTIME_DAEMON_NOTIFICATION_SCHEMAS, RUNTIME_DAEMON_PROTOCOL_SCHEMA, RUNTIME_DAEMON_PROTOCOL_SCHEMA_JSON, RuntimeContextBudgetSnapshot, RuntimeToolExposurePlan, SessionTranscriptEntry, connectKodaXRuntime, createKodaXRuntime, listRuntimeDaemonSchemaMethods };
+export type { ConnectKodaXRuntimeOptions, CreateKodaXRuntimeOptions, KodaXRuntime, KodaXRuntimeIsolation, KodaXRuntimeMode, RuntimeAdminService, RuntimeAgentService, RuntimeAgentTaskService, RuntimeAppendNoticeInput, RuntimeArtifact, RuntimeArtifactKind, RuntimeArtifactRefInput, RuntimeArtifactService, RuntimeCapabilityRequirements, RuntimeCatalogService, RuntimeClientCapabilities, RuntimeClientInfo, RuntimeCommandInfo, RuntimeCommandResolveInput, RuntimeCompactSessionInput, RuntimeCompactSessionResult, RuntimeConfigPatch, RuntimeConfigReloadResult, RuntimeConfigService, RuntimeCreateArtifactInput, RuntimeCreateSessionInput, RuntimeDaemonClientTransport, RuntimeDaemonEndpoint, RuntimeDaemonError, RuntimeDaemonErrorCode, RuntimeDaemonFrame, RuntimeDaemonJsonSchema, RuntimeDaemonMethod, RuntimeDaemonMethodSchema, RuntimeDaemonNotification, RuntimeDaemonNotificationMethod, RuntimeDaemonProtocolSchema, RuntimeDaemonRequest, RuntimeDiagnosticFilter, RuntimeDiagnosticsService, RuntimeEvent, RuntimeEventEnvelope, RuntimeEventFilter, RuntimeEventListener, RuntimeEventReplayFilter, RuntimeEventService, RuntimeEventType, RuntimeExtensionListResult, RuntimeExtensionReloadResult, RuntimeExternalAgentsOptions, RuntimeFileInput, RuntimeForkSessionInput, RuntimeIdentity, RuntimeImageInput, RuntimeInput, RuntimeKodaXOptions, RuntimeMcpReloadResult, RuntimeMcpService, RuntimeMcpToolListFilter, RuntimeMcpValidateResult, RuntimeModelListFilter, RuntimePermissionBroker, RuntimePermissionDecision, RuntimePermissionFilter, RuntimePermissionRequest, RuntimePermissionRequestInput, RuntimePermissionRespondOptions, RuntimePermissionRisk, RuntimePermissionScope, RuntimePermissionService, RuntimeRewindSessionInput, RuntimeRunFilter, RuntimeRunHandle, RuntimeRunMode, RuntimeRunPhase, RuntimeRunResult, RuntimeRunService, RuntimeRunStatus, RuntimeSession, RuntimeSessionFilter, RuntimeSessionService, RuntimeSessionSettings, RuntimeSessionSettingsPatch, RuntimeSessionSummary, RuntimeSetActiveEntryInput, RuntimeSkillDescribeInput, RuntimeSkillDescription, RuntimeSkillFileSummary, RuntimeSkillListFilter, RuntimeSkillSummary, RuntimeStartRunInput, RuntimeStatusService, RuntimeStatusSnapshot, RuntimeSubscription, RuntimeTextInput, RuntimeTranscript, RuntimeVideoInput, RuntimeWorkerOptions, RuntimeWorkerResourceLimits, RuntimeWorkflowFilter, RuntimeWorkflowListener, RuntimeWorkflowService, RuntimeWorkflowSnapshot, RuntimeWorkflowSummary };