@corbat-tech/coco 2.37.0 → 2.39.0

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

@@ -0,0 +1,969 @@
+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.graph.started" | "agent.graph.completed" | "agent.graph.failed" | "agent.tool.called" | "agent.handoff.created" | "agent.artifact.created" | "agent.completed" | "agent.failed" | "guardrail.input" | "guardrail.output" | "guardrail.tool" | "workflow.planned" | "workflow.started" | "workflow.completed" | "workflow.failed" | "workflow.gate.passed" | "workflow.gate.failed" | "shared_state.updated" | "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 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 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;
+    maxConcurrentRuns?: number;
+}
+interface AgentCapability {
+    role: AgentRole;
+    allowedTools: string[];
+    risk: WorkflowRisk;
+    model?: string;
+    temperature?: number;
+    budget?: AgentBudget;
+    guardrails?: AgentGuardrailPolicy;
+}
+interface AgentGuardrailPolicy {
+    input?: boolean;
+    output?: boolean;
+    toolUse?: boolean;
+    redactSecrets?: boolean;
+    blockPromptInjection?: boolean;
+}
+interface AgentDefinition {
+    id: string;
+    role: AgentRole;
+    name: string;
+    instructions: string;
+    capability: AgentCapability;
+    outputSchema?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface LegacyAgentRoleMapping {
+    legacy: string;
+    role: AgentRole;
+    reason: string;
+}
+declare function mapLegacyAgentRole(legacyRole: string, fallback?: AgentRole): AgentRole;
+declare function listLegacyAgentRoleMappings(): LegacyAgentRoleMapping[];
+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 AgentMessageRole = "user" | "agent" | "system" | "tool";
+interface AgentMessage {
+    id: string;
+    role: AgentMessageRole;
+    content: string;
+    taskId?: string;
+    agentRunId?: string;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface AgentHandoff {
+    id: string;
+    fromAgentRunId: string;
+    toRole: AgentRole;
+    task: AgentTask;
+    artifacts: AgentArtifact[];
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface AgentCard {
+    id: string;
+    role: AgentRole;
+    name: string;
+    description: string;
+    skills: string[];
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    capability: AgentCapability;
+}
+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[];
+}
+type SharedWorkspaceRecordKind = "fact" | "decision" | "risk" | "file" | "testResult" | "artifact";
+interface SharedWorkspaceProvenance {
+    workflowRunId: string;
+    agentRunId?: string;
+    nodeId?: string;
+    taskId?: string;
+    eventId?: string;
+    confidence?: number;
+    risk?: WorkflowRisk;
+}
+interface SharedWorkspaceRecord {
+    id: string;
+    kind: SharedWorkspaceRecordKind;
+    key: string;
+    value: unknown;
+    provenance: SharedWorkspaceProvenance;
+    createdAt: string;
+}
+interface SharedWorkspaceWriteInput {
+    kind: SharedWorkspaceRecordKind;
+    key: string;
+    value: unknown;
+    provenance: SharedWorkspaceProvenance;
+    createdAt?: string;
+}
+interface SharedWorkspaceStore {
+    write(input: SharedWorkspaceWriteInput): SharedWorkspaceRecord;
+    list(): SharedWorkspaceRecord[];
+    snapshot(): SharedWorkspaceStateSnapshot;
+    readForRole(role: AgentRole): SharedWorkspaceStateSnapshot;
+    clear(): void;
+}
+declare class InMemorySharedWorkspaceStore implements SharedWorkspaceStore {
+    private records;
+    write(input: SharedWorkspaceWriteInput): SharedWorkspaceRecord;
+    list(): SharedWorkspaceRecord[];
+    snapshot(): SharedWorkspaceStateSnapshot;
+    readForRole(role: AgentRole): SharedWorkspaceStateSnapshot;
+    clear(): void;
+}
+declare class FileSharedWorkspaceStore implements SharedWorkspaceStore {
+    private readonly filePath;
+    private readonly memory;
+    private writable;
+    constructor(filePath: string);
+    write(input: SharedWorkspaceWriteInput): SharedWorkspaceRecord;
+    list(): SharedWorkspaceRecord[];
+    snapshot(): SharedWorkspaceStateSnapshot;
+    readForRole(role: AgentRole): SharedWorkspaceStateSnapshot;
+    clear(): void;
+    private readRecordsFromDisk;
+}
+declare class SharedWorkspaceState {
+    private readonly workflowRunId;
+    private readonly store;
+    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;
+    records(): SharedWorkspaceRecord[];
+}
+type ToolRiskLevel = "low" | "medium" | "high" | "critical";
+interface ToolRiskManifestEntry {
+    toolName: string;
+    risk: WorkflowRisk;
+    level: ToolRiskLevel;
+    requiredCapability?: AgentRole | AgentRole[];
+    requiresConsent?: boolean;
+    destructive?: boolean;
+    secretsSensitive?: boolean;
+    network?: boolean;
+    filesystem?: boolean;
+}
+type ToolRiskManifest = Record<string, ToolRiskManifestEntry>;
+interface AgentToolPolicyDecision {
+    allowed: boolean;
+    risk: WorkflowRisk;
+    reason?: string;
+    requiresConsent?: boolean;
+}
+declare function evaluateAgentToolPolicy(input: {
+    capability: AgentCapability;
+    toolName: string;
+    manifest?: ToolRiskManifest;
+}): AgentToolPolicyDecision;
+interface AgentTraceContext {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    workflowRunId?: string;
+    agentRunId?: string;
+    taskId?: string;
+    toolCallId?: string;
+}
+declare function createAgentTraceContext(input?: Partial<AgentTraceContext>): AgentTraceContext;
+interface AgentGraphNodeExecution {
+    node: AgentGraphNode;
+    task: AgentTask;
+    attempt: number;
+    workflowRunId: string;
+    trace: AgentTraceContext;
+    dependencyResults: Map<string, AgentRunResult>;
+    sharedState: SharedWorkspaceStore;
+    eventLog: EventLog;
+}
+type AgentGraphNodeExecutor = (execution: AgentGraphNodeExecution) => Promise<AgentRunResult>;
+type AgentGateEvaluator = (input: {
+    gate: AgentGateDefinition;
+    node: AgentGraphNode;
+    result: AgentRunResult;
+    workflowRunId: string;
+    trace: AgentTraceContext;
+    sharedState: SharedWorkspaceStore;
+    eventLog: EventLog;
+}) => Promise<{
+    passed: boolean;
+    reason?: string;
+}>;
+interface AgentGraphEngineOptions {
+    eventLog?: EventLog;
+    sharedState?: SharedWorkspaceStore;
+    nodeExecutor?: AgentGraphNodeExecutor;
+    gateEvaluator?: AgentGateEvaluator;
+    trace?: AgentTraceContext;
+}
+interface AgentGraphRunInput {
+    workflowRunId: string;
+    graph: AgentGraphDefinition;
+    input: Record<string, unknown>;
+}
+type AgentGraphRunStatus = "completed" | "failed";
+interface AgentGraphRunResult {
+    id: string;
+    status: AgentGraphRunStatus;
+    nodeResults: Record<string, AgentRunResult>;
+    artifacts: AgentArtifact[];
+    stateSnapshot: SharedWorkspaceStateSnapshot;
+    trace: AgentTraceContext;
+    startedAt: string;
+    completedAt: string;
+    error?: string;
+}
+declare class AgentGraphEngine {
+    private readonly eventLog?;
+    private readonly sharedState;
+    private readonly nodeExecutor;
+    private readonly gateEvaluator;
+    private readonly trace;
+    constructor(options?: AgentGraphEngineOptions);
+    run(input: AgentGraphRunInput): Promise<AgentGraphRunResult>;
+    private executeNode;
+    private evaluateNodeGates;
+}
+declare function createAgentGraphEngine(options?: AgentGraphEngineOptions): AgentGraphEngine;
+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 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;
+    graphResult?: AgentGraphRunResult;
+    trace?: AgentTraceContext;
+}
+interface WorkflowRunContext {
+    workflow: WorkflowDefinition;
+    plan: WorkflowPlan;
+    eventLog: EventLog;
+}
+type WorkflowHandler = (input: Record<string, unknown>, context: WorkflowRunContext) => Promise<unknown>;
+interface WorkflowEngineOptions {
+    catalog?: WorkflowCatalog;
+    eventLog?: EventLog;
+    sharedState?: SharedWorkspaceStore;
+    nodeExecutor?: AgentGraphNodeExecutor;
+}
+declare class WorkflowEngine {
+    private readonly catalog;
+    private readonly eventLog;
+    private handlers;
+    private readonly sharedState;
+    private nodeExecutor?;
+    constructor(catalog?: WorkflowCatalog, eventLog?: EventLog, options?: Omit<WorkflowEngineOptions, "catalog" | "eventLog">);
+    registerHandler(workflowId: string, handler: WorkflowHandler): void;
+    registerNodeExecutor(executor: AgentGraphNodeExecutor): void;
+    createPlan(workflowId: string, input: Record<string, unknown>): WorkflowPlan;
+    run(request: WorkflowRunInput): Promise<WorkflowRunResult>;
+}
+declare function createWorkflowEngine(catalog?: WorkflowCatalog, eventLog?: EventLog, options?: Omit<WorkflowEngineOptions, "catalog" | "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 { type AgentTask as $, AGENT_MODES as A, type AgentMessageRole as B, type ChatOptions as C, type AgentModeDefinition as D, type AgentModeId as E, type AgentRole as F, type AgentRunResult as G, type AgentRunStatus as H, AgentRuntime as I, type AgentRuntimeOptions as J, type AgentRuntimeSnapshot as K, type LLMProvider as L, type Message as M, type AgentToolPolicyDecision as N, type AgentTraceContext as O, type ProviderConfig as P, DEFAULT_WORKFLOWS as Q, type EventLog as R, type StreamChunk as S, FileSharedWorkspaceStore as T, InMemorySharedWorkspaceStore as U, type LegacyAgentRoleMapping as V, type PermissionDecision as W, type PermissionPolicy as X, ProviderRegistry as Y, type ProviderRuntimeSelection as Z, type ReasoningEffort as _, type ChatResponse as a, type RuntimeEvent as a0, type RuntimeEventType as a1, type RuntimeMode as a2, type RuntimeSession as a3, type RuntimeSessionCreateOptions as a4, type RuntimeSessionStore as a5, type RuntimeToolExecutionInput as a6, type RuntimeToolExecutionResult as a7, type RuntimeTurnContext as a8, type RuntimeTurnInput as a9, createAgentArtifact as aA, createAgentGraphEngine as aB, createAgentRuntime as aC, createAgentTraceContext as aD, createProvider as aE, createProviderRegistry as aF, createSummaryArtifact as aG, createWorkflowCatalog as aH, createWorkflowEngine as aI, createWorkflowRegistry as aJ, evaluateAgentToolPolicy as aK, getAgentMode as aL, isAgentMode as aM, listAgentModes as aN, listLegacyAgentRoleMappings as aO, mapLegacyAgentRole as aP, normalizeAgentRunResult as aQ, validateAgentCapabilities as aR, validateAgentGraph as aS, workflowToAgentGraph as aT, type ProviderType as aU, type RuntimeTurnResult as aa, type RuntimeTurnRunner as ab, type RuntimeTurnStreamEvent as ac, type SharedWorkspaceProvenance as ad, type SharedWorkspaceRecord as ae, type SharedWorkspaceRecordKind as af, SharedWorkspaceState as ag, type SharedWorkspaceStateSnapshot as ah, type SharedWorkspaceStore as ai, type SharedWorkspaceWriteInput as aj, type ToolRiskLevel as ak, type ToolRiskManifest as al, type ToolRiskManifestEntry as am, WorkflowCatalog as an, type WorkflowDefinition as ao, WorkflowEngine as ap, type WorkflowHandler as aq, type WorkflowPlan as ar, WorkflowRegistry as as, type WorkflowRetryPolicy as at, type WorkflowRisk as au, type WorkflowRunContext as av, type WorkflowRunInput as aw, type WorkflowRunResult as ax, type WorkflowRunStatus as ay, type WorkflowStepDefinition as az, 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 AgentCard as h, type AgentDefinition as i, type AgentGateDefinition as j, type AgentGateKind as k, type AgentGraphDefinition as l, type AgentGraphEdge as m, AgentGraphEngine as n, type AgentGraphEngineOptions as o, type AgentGraphNode as p, type AgentGraphNodeExecution as q, type AgentGraphNodeExecutor as r, type AgentGraphRunInput as s, type AgentGraphRunResult as t, type AgentGraphRunStatus as u, type AgentGraphValidationIssue as v, type AgentGraphValidationResult as w, type AgentGuardrailPolicy as x, type AgentHandoff as y, type AgentMessage as z };