@corbat-tech/coco 2.37.0 → 2.38.0

package/dist/agent-runtime-DeLcB0Ie.d.ts

@@ -0,0 +1,756 @@
+import { T as ToolRegistry, a as ToolDefinition$1 } from './registry-CEpl9Jq0.js';
+
+/**
+ * Unified thinking/reasoning mode support for all LLM providers.
+ *
+ * Normalizes three distinct API surfaces:
+ *   - Anthropic: thinking.budget_tokens
+ *   - OpenAI Chat Completions: reasoning_effort
+ *   - OpenAI Responses API: reasoning.effort
+ *   - Gemini: thinkingConfig.thinkingBudget
+ *   - Kimi: thinking.type enabled/disabled
+ */
+/**
+ * Provider-agnostic thinking mode.
+ * "off"    — disable thinking entirely (or keep disabled for models like Kimi)
+ * "auto"   — provider default / dynamic budget
+ * "low"    — minimal reasoning
+ * "medium" — balanced reasoning
+ * "high"   — maximum reasoning
+ * { budget: N } — explicit token budget (Anthropic / Gemini only; rejected for effort-only providers)
+ */
+type ThinkingMode = "off" | "auto" | "low" | "medium" | "high" | {
+    budget: number;
+};
+/**
+ * Whether this provider/model uses effort buckets (OpenAI) or token budgets (Anthropic, Gemini).
+ */
+type ThinkingKind = "effort" | "budget";
+
+/**
+ * LLM Provider types for Corbat-Coco
+ */
+
+/**
+ * Message role
+ */
+type MessageRole = "system" | "user" | "assistant";
+/**
+ * Message content types
+ */
+type MessageContent = string | Array<TextContent | ImageContent | ToolUseContent | ToolResultContent>;
+/**
+ * Text content block
+ */
+interface TextContent {
+    type: "text";
+    text: string;
+}
+/**
+ * Image content block
+ */
+interface ImageContent {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}
+/**
+ * Tool use content block
+ */
+interface ToolUseContent {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    /** Gemini-specific: preserve function-call thought signature across tool turns */
+    geminiThoughtSignature?: string;
+}
+/**
+ * Tool result content block
+ */
+interface ToolResultContent {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+}
+/**
+ * Chat message
+ */
+interface Message {
+    role: MessageRole;
+    content: MessageContent;
+}
+/**
+ * Tool definition for LLM
+ */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Tool call from LLM
+ */
+interface ToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    /** Gemini-specific: preserve function-call thought signature across tool turns */
+    geminiThoughtSignature?: string;
+}
+/**
+ * Chat options
+ */
+interface ChatOptions {
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    stopSequences?: string[];
+    system?: string;
+    timeout?: number;
+    /** Abort signal to cancel in-flight requests */
+    signal?: AbortSignal;
+    /** Thinking/reasoning mode to pass to the model (if supported) */
+    thinking?: ThinkingMode;
+}
+/**
+ * Chat response
+ */
+interface ChatResponse {
+    id: string;
+    content: string;
+    stopReason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    model: string;
+}
+/**
+ * Chat with tools options
+ */
+interface ChatWithToolsOptions extends ChatOptions {
+    tools: ToolDefinition[];
+    toolChoice?: "auto" | "any" | {
+        type: "tool";
+        name: string;
+    };
+}
+/**
+ * Chat with tools response
+ */
+interface ChatWithToolsResponse extends ChatResponse {
+    toolCalls: ToolCall[];
+}
+/**
+ * Stream chunk
+ */
+interface StreamChunk {
+    type: "text" | "tool_use_start" | "tool_use_delta" | "tool_use_end" | "done";
+    text?: string;
+    toolCall?: Partial<ToolCall>;
+    stopReason?: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use";
+}
+/**
+ * LLM Provider interface
+ */
+interface LLMProvider {
+    /**
+     * Provider identifier
+     */
+    id: string;
+    /**
+     * Provider display name
+     */
+    name: string;
+    /**
+     * Initialize the provider
+     */
+    initialize(config: ProviderConfig): Promise<void>;
+    /**
+     * Send a chat message
+     */
+    chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
+    /**
+     * Send a chat message with tool use
+     */
+    chatWithTools(messages: Message[], options: ChatWithToolsOptions): Promise<ChatWithToolsResponse>;
+    /**
+     * Stream a chat response
+     */
+    stream(messages: Message[], options?: ChatOptions): AsyncIterable<StreamChunk>;
+    /**
+     * Stream a chat response with tool use
+     */
+    streamWithTools(messages: Message[], options: ChatWithToolsOptions): AsyncIterable<StreamChunk>;
+    /**
+     * Count tokens in text
+     */
+    countTokens(text: string): number;
+    /**
+     * Get context window size
+     */
+    getContextWindow(): number;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Provider configuration
+ */
+interface ProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    timeout?: number;
+    project?: string;
+    location?: string;
+    /** Internal: flag to indicate using Google Cloud ADC */
+    useADC?: boolean;
+}
+
+/**
+ * Provider and model catalog.
+ *
+ * This is the source of truth for model IDs, defaults, context windows,
+ * pricing metadata, and provider capabilities. Endpoint adapters still own
+ * request/response conversion, but they should read model metadata from here.
+ */
+
+type ModelStatus = "current" | "legacy" | "deprecated" | "experimental";
+type ModelCapability = "streaming" | "tool-use" | "vision" | "reasoning-effort" | "adaptive-thinking" | "thinking-budget" | "openai-responses" | "openai-chat" | "anthropic-messages" | "gemini-generate-content";
+interface ProviderSource {
+    name: string;
+    url: string;
+    verifiedAt: string;
+}
+interface ModelPricing {
+    inputPerMillion: number;
+    outputPerMillion: number;
+}
+interface ModelCatalogEntry {
+    id: string;
+    name: string;
+    description?: string;
+    contextWindow: number;
+    maxOutputTokens?: number;
+    recommended?: boolean;
+    status: ModelStatus;
+    capabilities: ModelCapability[];
+    pricing?: ModelPricing;
+    source: ProviderSource;
+}
+interface ProviderCatalogEntry {
+    id: ProviderType;
+    defaultModel: string;
+    models: ModelCatalogEntry[];
+}
+
+/**
+ * Runtime compatibility view derived from the static provider catalog.
+ *
+ * The catalog records what a model is; this module records how Coco should use it
+ * safely at runtime, including endpoint selection and reasoning/tooling limits.
+ */
+
+type ProviderEndpointStrategy = "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+type ModelCompatibilityStatus = ModelStatus | "unverified";
+interface ProviderRuntimeCapability {
+    provider: ProviderType;
+    model: string;
+    catalogModel?: ModelCatalogEntry;
+    status: ModelCompatibilityStatus;
+    endpoint: ProviderEndpointStrategy;
+    supportsStreaming: boolean;
+    supportsToolUse: boolean;
+    supportsVision: boolean;
+    supportsReasoning: boolean;
+    reasoningKinds: ThinkingKind[];
+    defaultReasoning: ThinkingMode;
+    contextWindow: number;
+    maxOutputTokens?: number;
+    sourceUrl?: string;
+    restrictions: string[];
+}
+interface ProviderProbeResult extends ProviderRuntimeCapability {
+    available: boolean | "not-checked";
+    checkedAt: string;
+    error?: string;
+}
+
+/**
+ * Provider exports for Corbat-Coco
+ */
+
+/**
+ * Supported provider types
+ */
+type ProviderType = "anthropic" | "openai" | "codex" | "copilot" | "gemini" | "vertex" | "kimi" | "kimi-code" | "lmstudio" | "ollama" | "groq" | "openrouter" | "mistral" | "deepseek" | "together" | "huggingface" | "qwen";
+/**
+ * Create a provider by type
+ */
+declare function createProvider(type: ProviderType, config?: ProviderConfig): Promise<LLMProvider>;
+
+/** Catalog-backed provider/model registry used by runtime consumers. */
+declare class ProviderRegistry {
+    listProviders(): ProviderCatalogEntry[];
+    getProvider(provider: ProviderType): ProviderCatalogEntry;
+    listModels(provider: ProviderType): ModelCatalogEntry[];
+    getModel(provider: ProviderType, model: string): ModelCatalogEntry | undefined;
+    getDefaultModel(provider: ProviderType): string;
+    getRecommendedModel(provider: ProviderType): ModelCatalogEntry;
+    getCapability(provider: ProviderType, model?: string): ProviderRuntimeCapability;
+    createProvider(provider: ProviderType, config?: ProviderConfig): Promise<LLMProvider>;
+    probe(provider: ProviderType, model: string | undefined, checkAvailability?: () => Promise<boolean>): Promise<ProviderProbeResult>;
+}
+declare function createProviderRegistry(): ProviderRegistry;
+
+/**
+ * Agent mode registry.
+ *
+ * Modes describe the intended control flow for a runtime turn without changing
+ * the provider interface. CLI, headless, and embedders share this registry.
+ */
+type AgentModeId = "ask" | "plan" | "build" | "debug" | "review" | "architect";
+interface AgentModeDefinition {
+    id: AgentModeId;
+    label: string;
+    description: string;
+    readOnly: boolean;
+    preferredTools: string[];
+    requiresVerification: boolean;
+}
+declare const AGENT_MODES: Record<AgentModeId, AgentModeDefinition>;
+declare function getAgentMode(mode: AgentModeId): AgentModeDefinition;
+declare function listAgentModes(): AgentModeDefinition[];
+declare function isAgentMode(value: string): value is AgentModeId;
+
+type ReasoningEffort = "auto" | "low" | "medium" | "high" | "max";
+type RuntimeMode = AgentModeId;
+interface AgentRuntimeOptions {
+    providerType: ProviderType;
+    model?: string;
+    providerConfig?: ProviderConfig;
+    provider?: LLMProvider;
+    toolRegistry?: ToolRegistry;
+    /** Legacy CLI session store passthrough. Runtime APIs use runtimeSessionStore. */
+    sessionStore?: unknown;
+    runtimeSessionStore?: RuntimeSessionStore;
+    workflowEngine?: WorkflowEngine;
+    permissionPolicy?: PermissionPolicy;
+    eventLog?: EventLog;
+    eventLogPath?: string;
+    turnRunner?: RuntimeTurnRunner;
+    /**
+     * Publish provider/tools into Coco's legacy process-global subagent bridge.
+     * CLI/headless use this for compatibility; embedders should leave it false.
+     */
+    publishToGlobalBridge?: boolean;
+}
+interface AgentRuntimeSnapshot {
+    provider: {
+        type: ProviderType;
+        model: string;
+        capability: ProviderRuntimeCapability;
+    };
+    tools: {
+        count: number;
+        names: string[];
+    };
+    modes: AgentModeDefinition[];
+}
+type RuntimeEventType = "runtime.initialized" | "provider.attached" | "provider.created" | "provider.updated" | "turn.started" | "turn.completed" | "turn.cancelled" | "turn.failed" | "tool.started" | "tool.completed" | "tool.allowed" | "tool.blocked" | "tool.skipped" | "agent.started" | "agent.tool.called" | "agent.artifact.created" | "agent.completed" | "agent.failed" | "guardrail.input" | "guardrail.output" | "guardrail.tool" | "workflow.planned" | "workflow.started" | "workflow.completed" | "workflow.failed" | "workflow.gate.failed" | "session.created" | "session.updated" | "checkpoint.created" | "error";
+interface RuntimeEvent {
+    id: string;
+    type: RuntimeEventType;
+    timestamp: string;
+    data: Record<string, unknown>;
+}
+interface EventLog {
+    record(type: RuntimeEventType, data?: Record<string, unknown>): RuntimeEvent;
+    list(): RuntimeEvent[];
+    count(): number;
+    clear(): void;
+}
+interface PermissionDecision {
+    allowed: boolean;
+    reason?: string;
+    requiresConfirmation?: boolean;
+    risk: "read-only" | "write" | "network" | "destructive" | "secrets-sensitive";
+}
+interface PermissionPolicy {
+    canExecuteTool(mode: RuntimeMode, tool: ToolDefinition$1): PermissionDecision;
+    canExecuteToolInput?(mode: RuntimeMode, tool: ToolDefinition$1, input: Record<string, unknown>): PermissionDecision;
+}
+interface ProviderRuntimeSelection {
+    provider: ProviderType;
+    model: string;
+    thinking?: ThinkingMode;
+}
+interface RuntimeSession {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    mode: RuntimeMode;
+    messages: Message[];
+    instructions?: string;
+    metadata: Record<string, unknown>;
+}
+interface RuntimeSessionCreateOptions {
+    id?: string;
+    mode?: RuntimeMode;
+    instructions?: string;
+    metadata?: Record<string, unknown>;
+    messages?: Message[];
+}
+interface RuntimeSessionStore {
+    create(options?: RuntimeSessionCreateOptions): RuntimeSession;
+    get(id: string): RuntimeSession | undefined;
+    update(session: RuntimeSession): RuntimeSession;
+    list(): RuntimeSession[];
+    delete(id: string): boolean;
+}
+interface RuntimeTurnInput {
+    content: string;
+    sessionId?: string;
+    mode?: RuntimeMode;
+    options?: ChatOptions;
+    metadata?: Record<string, unknown>;
+    /**
+     * Tool names that the embedding product has explicitly confirmed for this
+     * turn. Destructive tools are still blocked unless listed here.
+     */
+    confirmedTools?: string[];
+}
+interface RuntimeTurnResult {
+    sessionId: string;
+    content: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        estimated?: boolean;
+    };
+    model: string;
+    mode: RuntimeMode;
+}
+type RuntimeTurnStreamEvent = {
+    type: "text";
+    sessionId: string;
+    text: string;
+} | {
+    type: "done";
+    sessionId: string;
+    result: RuntimeTurnResult;
+} | {
+    type: "error";
+    sessionId: string;
+    error: string;
+};
+interface RuntimeTurnContext {
+    runtime: unknown;
+    session: RuntimeSession;
+    provider: LLMProvider;
+    toolRegistry: ToolRegistry;
+    permissionPolicy: PermissionPolicy;
+    eventLog: EventLog;
+}
+interface RuntimeTurnRunner {
+    run(input: RuntimeTurnInput, context: RuntimeTurnContext): Promise<RuntimeTurnResult>;
+}
+interface RuntimeToolExecutionInput {
+    sessionId?: string;
+    mode?: RuntimeMode;
+    toolName: string;
+    input: Record<string, unknown>;
+    confirmed?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface RuntimeToolExecutionResult {
+    toolName: string;
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    duration: number;
+    decision: PermissionDecision;
+}
+
+type AgentRole = "researcher" | "planner" | "architect" | "editor" | "coder" | "tester" | "reviewer" | "optimizer" | "security" | "qa" | "integrator" | "pm" | "docs" | "database";
+interface AgentBudget {
+    maxTurns?: number;
+    timeoutMs?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxEstimatedCostUsd?: number;
+}
+interface AgentCapability {
+    role: AgentRole;
+    allowedTools: string[];
+    risk: WorkflowRisk;
+    model?: string;
+    temperature?: number;
+    budget?: AgentBudget;
+}
+interface AgentTask {
+    id: string;
+    role: AgentRole;
+    objective: string;
+    context?: Record<string, unknown>;
+    dependencies?: string[];
+    expectedOutput?: AgentArtifactKind[];
+    constraints?: string[];
+}
+type AgentArtifactKind = "plan" | "findings" | "patchProposal" | "testReport" | "riskReport" | "summary";
+interface AgentArtifact<T = unknown> {
+    id: string;
+    kind: AgentArtifactKind;
+    agentRunId?: string;
+    taskId?: string;
+    title?: string;
+    content: T;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+type AgentRunStatus = "completed" | "failed" | "cancelled" | "timeout";
+interface AgentRunResult {
+    id: string;
+    taskId: string;
+    role: AgentRole;
+    status: AgentRunStatus;
+    success: boolean;
+    output: string;
+    artifacts: AgentArtifact[];
+    toolsUsed: string[];
+    turns: number;
+    durationMs: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        estimated?: boolean;
+    };
+    error?: string;
+    startedAt: string;
+    completedAt: string;
+    metadata?: Record<string, unknown>;
+}
+type AgentGateKind = "tests" | "coverage" | "review" | "security" | "quality-score" | "human-approval";
+interface AgentGateDefinition {
+    id: string;
+    kind: AgentGateKind;
+    description: string;
+    required: boolean;
+    threshold?: number;
+}
+interface AgentGraphNode {
+    id: string;
+    agentRole?: AgentRole;
+    description: string;
+    dependsOn?: string[];
+    requiredTools?: string[];
+    risk: WorkflowRisk;
+    gates?: string[];
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMs?: number;
+    };
+    condition?: string;
+}
+interface AgentGraphEdge {
+    from: string;
+    to: string;
+    condition?: string;
+}
+interface AgentGraphDefinition {
+    nodes: AgentGraphNode[];
+    edges?: AgentGraphEdge[];
+    gates?: AgentGateDefinition[];
+    parallelism?: number;
+}
+interface AgentGraphValidationIssue {
+    code: "duplicate-node" | "missing-dependency" | "missing-edge-node" | "missing-gate" | "cycle" | "invalid-parallelism" | "invalid-retry-policy";
+    message: string;
+    nodeId?: string;
+    gateId?: string;
+}
+interface AgentGraphValidationResult {
+    valid: boolean;
+    issues: AgentGraphValidationIssue[];
+    levels: string[][];
+}
+interface SharedWorkspaceStateSnapshot {
+    facts: Record<string, unknown>;
+    decisions: Record<string, unknown>;
+    risks: Record<string, unknown>;
+    files: Record<string, unknown>;
+    testResults: Record<string, unknown>;
+    artifacts: AgentArtifact[];
+}
+declare class SharedWorkspaceState {
+    private facts;
+    private decisions;
+    private risks;
+    private files;
+    private testResults;
+    private artifacts;
+    writeFact(key: string, value: unknown): void;
+    recordDecision(key: string, value: unknown): void;
+    recordRisk(key: string, value: unknown): void;
+    recordFile(path: string, value: unknown): void;
+    recordTestResult(key: string, value: unknown): void;
+    addArtifact(artifact: AgentArtifact): void;
+    readForRole(role: AgentRole): SharedWorkspaceStateSnapshot;
+    snapshot(): SharedWorkspaceStateSnapshot;
+}
+declare function createAgentArtifact<T>(input: Omit<AgentArtifact<T>, "id" | "createdAt"> & {
+    id?: string;
+    createdAt?: string;
+}): AgentArtifact<T>;
+declare function createSummaryArtifact(output: string, metadata?: Pick<AgentArtifact, "agentRunId" | "taskId"> & {
+    title?: string;
+}): AgentArtifact<string>;
+declare function normalizeAgentRunResult(input: {
+    id: string;
+    taskId: string;
+    role: AgentRole;
+    success: boolean;
+    output: string;
+    startedAt?: string;
+    completedAt?: string;
+    durationMs?: number;
+    turns?: number;
+    toolsUsed?: string[];
+    usage?: AgentRunResult["usage"];
+    error?: string;
+    artifacts?: AgentArtifact[];
+    status?: AgentRunStatus;
+    metadata?: Record<string, unknown>;
+}): AgentRunResult;
+declare function validateAgentCapabilities(capability: AgentCapability, requiredTools?: string[]): AgentGraphValidationIssue[];
+declare function validateAgentGraph(graph: AgentGraphDefinition): AgentGraphValidationResult;
+
+type WorkflowRisk = "read-only" | "write" | "network" | "destructive" | "secrets-sensitive";
+interface WorkflowStepDefinition {
+    id: string;
+    description: string;
+    requiredTools: string[];
+    risk: WorkflowRisk;
+}
+interface WorkflowRetryPolicy {
+    maxAttempts: number;
+    backoffMs?: number;
+}
+interface WorkflowDefinition {
+    id: string;
+    name: string;
+    description: string;
+    inputSchema: string;
+    /** Legacy linear workflow steps. Prefer nodes for new multi-agent workflows. */
+    steps: WorkflowStepDefinition[];
+    nodes?: AgentGraphNode[];
+    edges?: AgentGraphDefinition["edges"];
+    gates?: AgentGateDefinition[];
+    retryPolicy?: WorkflowRetryPolicy;
+    parallelism?: number;
+    checks: string[];
+    outputKind: "markdown" | "json" | "patch" | "pull-request" | "release";
+    replayable: boolean;
+}
+interface WorkflowPlan {
+    id: string;
+    workflowId: string;
+    input: Record<string, unknown>;
+    status: "planned";
+    createdAt: string;
+}
+declare function workflowToAgentGraph(workflow: WorkflowDefinition): AgentGraphDefinition;
+/** Descriptive catalog of reusable workflow definitions; it does not execute workflows. */
+declare class WorkflowCatalog {
+    private workflows;
+    constructor(workflows?: WorkflowDefinition[]);
+    register(workflow: WorkflowDefinition): void;
+    get(id: string): WorkflowDefinition | undefined;
+    list(): WorkflowDefinition[];
+    createPlan(workflowId: string, input: Record<string, unknown>, eventLog?: EventLog): WorkflowPlan;
+}
+declare const DEFAULT_WORKFLOWS: WorkflowDefinition[];
+declare const WorkflowRegistry: typeof WorkflowCatalog;
+declare function createWorkflowCatalog(workflows?: WorkflowDefinition[]): WorkflowCatalog;
+declare function createWorkflowRegistry(workflows?: WorkflowDefinition[]): WorkflowCatalog;
+
+type WorkflowRunStatus = "completed" | "failed";
+interface WorkflowRunInput {
+    workflowId: string;
+    input: Record<string, unknown>;
+    plan?: WorkflowPlan;
+}
+interface WorkflowRunResult {
+    id: string;
+    workflowId: string;
+    status: WorkflowRunStatus;
+    output: unknown;
+    startedAt: string;
+    completedAt: string;
+    error?: string;
+}
+interface WorkflowRunContext {
+    workflow: WorkflowDefinition;
+    plan: WorkflowPlan;
+    eventLog: EventLog;
+}
+type WorkflowHandler = (input: Record<string, unknown>, context: WorkflowRunContext) => Promise<unknown>;
+declare class WorkflowEngine {
+    private readonly catalog;
+    private readonly eventLog;
+    private handlers;
+    constructor(catalog?: WorkflowCatalog, eventLog?: EventLog);
+    registerHandler(workflowId: string, handler: WorkflowHandler): void;
+    createPlan(workflowId: string, input: Record<string, unknown>): WorkflowPlan;
+    run(request: WorkflowRunInput): Promise<WorkflowRunResult>;
+}
+declare function createWorkflowEngine(catalog?: WorkflowCatalog, eventLog?: EventLog): WorkflowEngine;
+
+/**
+ * Reusable runtime facade for wiring providers, tools, permissions, sessions,
+ * and observability. It does not own the CLI loop; CLI/headless are adapters on
+ * top of this boundary.
+ */
+declare class AgentRuntime {
+    private readonly options;
+    readonly providerRegistry: ProviderRegistry;
+    readonly toolRegistry: ToolRegistry;
+    readonly sessionStore: unknown;
+    readonly runtimeSessionStore: RuntimeSessionStore;
+    readonly workflowEngine: WorkflowEngine;
+    readonly permissionPolicy: PermissionPolicy;
+    readonly eventLog: EventLog;
+    readonly turnRunner: RuntimeTurnRunner;
+    private providerType;
+    private model;
+    private provider?;
+    constructor(options: AgentRuntimeOptions);
+    initialize(): Promise<void>;
+    getModel(): string;
+    updateProvider(providerType: ProviderType, model: string | undefined, provider: LLMProvider): void;
+    private publishToGlobalBridge;
+    snapshot(): AgentRuntimeSnapshot;
+    createSession(options?: RuntimeSessionCreateOptions): RuntimeSession;
+    getSession(sessionId: string): RuntimeSession | undefined;
+    listSessions(): RuntimeSession[];
+    runTurn(input: RuntimeTurnInput): Promise<RuntimeTurnResult>;
+    streamTurn(input: RuntimeTurnInput): AsyncIterable<RuntimeTurnStreamEvent>;
+    executeTool(input: RuntimeToolExecutionInput): Promise<RuntimeToolExecutionResult>;
+    assertToolAllowed(mode: RuntimeMode, toolName: string, input?: Record<string, unknown>): boolean;
+}
+declare function createAgentRuntime(options: AgentRuntimeOptions): Promise<AgentRuntime>;
+
+export { WorkflowEngine as $, AGENT_MODES as A, type AgentTask as B, type ChatOptions as C, DEFAULT_WORKFLOWS as D, type EventLog as E, type RuntimeEvent as F, type RuntimeEventType as G, type RuntimeMode as H, type RuntimeSession as I, type RuntimeSessionCreateOptions as J, type RuntimeSessionStore as K, type LLMProvider as L, type Message as M, type RuntimeToolExecutionInput as N, type RuntimeToolExecutionResult as O, type ProviderConfig as P, type RuntimeTurnContext as Q, type ReasoningEffort as R, type StreamChunk as S, type RuntimeTurnInput as T, type RuntimeTurnResult as U, type RuntimeTurnRunner as V, type RuntimeTurnStreamEvent as W, SharedWorkspaceState as X, type SharedWorkspaceStateSnapshot as Y, WorkflowCatalog as Z, type WorkflowDefinition as _, type ChatResponse as a, type WorkflowHandler as a0, type WorkflowPlan as a1, WorkflowRegistry as a2, type WorkflowRetryPolicy as a3, type WorkflowRisk as a4, type WorkflowRunContext as a5, type WorkflowRunInput as a6, type WorkflowRunResult as a7, type WorkflowRunStatus as a8, type WorkflowStepDefinition as a9, createAgentArtifact as aa, createAgentRuntime as ab, createProvider as ac, createProviderRegistry as ad, createSummaryArtifact as ae, createWorkflowCatalog as af, createWorkflowEngine as ag, createWorkflowRegistry as ah, getAgentMode as ai, isAgentMode as aj, listAgentModes as ak, normalizeAgentRunResult as al, validateAgentCapabilities as am, validateAgentGraph as an, workflowToAgentGraph as ao, type ProviderType as ap, type ChatWithToolsOptions as b, type ChatWithToolsResponse as c, type AgentArtifact as d, type AgentArtifactKind as e, type AgentBudget as f, type AgentCapability as g, type AgentGateDefinition as h, type AgentGateKind as i, type AgentGraphDefinition as j, type AgentGraphEdge as k, type AgentGraphNode as l, type AgentGraphValidationIssue as m, type AgentGraphValidationResult as n, type AgentModeDefinition as o, type AgentModeId as p, type AgentRole as q, type AgentRunResult as r, type AgentRunStatus as s, AgentRuntime as t, type AgentRuntimeOptions as u, type AgentRuntimeSnapshot as v, type PermissionDecision as w, type PermissionPolicy as x, ProviderRegistry as y, type ProviderRuntimeSelection as z };