@appsforgood/agent-kit-runtime 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,585 @@
+import { z } from 'zod';
+import * as _langchain_langgraph from '@langchain/langgraph';
+import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
+
+type ModelCapability = "text" | "tools" | "parallel-tools" | "structured-output" | "streaming" | "vision" | "reasoning" | "usage";
+interface ModelMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    name?: string;
+    toolCallId?: string;
+}
+interface ModelToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    risk: "read" | "write" | "network" | "secret" | "destructive";
+}
+interface ModelToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+interface ModelUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+interface ModelRequest {
+    model: string;
+    messages: ModelMessage[];
+    tools?: ModelToolDefinition[];
+    temperature?: number;
+    maxOutputTokens?: number;
+    signal?: AbortSignal;
+}
+interface ModelResponse {
+    text: string;
+    toolCalls: ModelToolCall[];
+    finishReason?: string;
+    usage?: ModelUsage;
+    providerResponseId?: string;
+}
+interface ProviderProbeResult {
+    providerId: string;
+    available: boolean;
+    capabilities: ModelCapability[];
+    models?: string[];
+    latencyMs: number;
+    error?: string;
+}
+interface ModelProviderAdapter {
+    readonly id: string;
+    readonly capabilities: ReadonlySet<ModelCapability>;
+    probe(signal?: AbortSignal): Promise<ProviderProbeResult>;
+    invoke(request: ModelRequest): Promise<ModelResponse>;
+}
+interface RoutedModelResult {
+    providerId: string;
+    model: string;
+    response: ModelResponse;
+    attempts: Array<{
+        providerId: string;
+        model: string;
+        outcome: "selected" | "capability-mismatch" | "error";
+        detail?: string;
+    }>;
+}
+interface AgentNodeInput {
+    runId: string;
+    workflowId: string;
+    agentId: string;
+    goal: string;
+    instructions: string;
+    requiredOutputs: string[];
+    allowedHandoffs: string[];
+    mutationAllowed: boolean;
+    priorResults: AgentNodeResult[];
+    worktreePath?: string;
+}
+interface AgentNodeResult {
+    agentId: string;
+    summary: string;
+    decision: string;
+    risk: string;
+    artifacts: string[];
+    verification: string[];
+    requestedHandoff?: string;
+}
+interface AgentNodeExecutor {
+    execute(input: AgentNodeInput, signal?: AbortSignal): Promise<AgentNodeResult>;
+}
+interface RuntimeApprovalHandler {
+    (request: Omit<ApprovalRequest, "approvalId" | "requestedAt">): Promise<boolean>;
+}
+type ApprovalRisk = "plan" | "write" | "network" | "secret" | "destructive" | "host-mutation" | "final-commit";
+interface ApprovalRequest {
+    approvalId: string;
+    runId: string;
+    risk: ApprovalRisk;
+    title: string;
+    detail: string;
+    requestedAt: string;
+}
+interface ApprovalDecision {
+    approvalId: string;
+    decision: "approve" | "reject";
+    decidedAt: string;
+    actor?: string;
+    note?: string;
+}
+type RunStatus = "planned" | "running" | "awaiting-approval" | "blocked" | "cancelled" | "failed" | "complete";
+interface RunEvent {
+    schemaVersion: 1;
+    eventId: string;
+    sequence: number;
+    runId: string;
+    createdAt: string;
+    type: "run_started" | "run_status_changed" | "agent_started" | "agent_completed" | "handoff" | "approval_requested" | "approval_decided" | "tool_started" | "tool_completed" | "provider_selected" | "artifact" | "verification" | "run_error" | "run_completed";
+    agentId?: string;
+    text?: string;
+    status?: RunStatus;
+    approval?: ApprovalRequest | ApprovalDecision;
+    data?: Record<string, unknown>;
+}
+interface RunRecord {
+    schemaVersion: 1;
+    runId: string;
+    workflowId: string;
+    goal: string;
+    status: RunStatus;
+    createdAt: string;
+    updatedAt: string;
+    sourceRoot: string;
+    baseCommit: string;
+    worktreePath?: string;
+    branchName?: string;
+    activeAgentId?: string | undefined;
+    pendingApproval?: ApprovalRequest | undefined;
+    commit?: string;
+    changed?: string;
+    results: AgentNodeResult[];
+    error?: string;
+}
+interface RuntimeCommandResult {
+    ok: boolean;
+    command: string;
+    run?: RunRecord;
+    runs?: RunRecord[];
+    data?: unknown;
+    message?: string;
+}
+
+declare const LocalMcpContract: z.ZodObject<{
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    envRefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    allowHostExecution: z.ZodDefault<z.ZodBoolean>;
+    allowedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const RemoteMcpContract: z.ZodObject<{
+    transport: z.ZodLiteral<"streamable-http">;
+    url: z.ZodString;
+    authRef: z.ZodOptional<z.ZodString>;
+    allowedHosts: z.ZodArray<z.ZodString>;
+    allowPrivateNetwork: z.ZodDefault<z.ZodBoolean>;
+    allowedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const RuntimeConfigContract: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    defaultWorkflow: z.ZodDefault<z.ZodString>;
+    defaultAlias: z.ZodDefault<z.ZodString>;
+    databasePath: z.ZodDefault<z.ZodString>;
+    providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodEnum<{
+            openai: "openai";
+            anthropic: "anthropic";
+            gemini: "gemini";
+            xai: "xai";
+            deepseek: "deepseek";
+            kimi: "kimi";
+            glm: "glm";
+            openrouter: "openrouter";
+            ollama: "ollama";
+            "lm-studio": "lm-studio";
+            vllm: "vllm";
+            "openai-compatible": "openai-compatible";
+        }>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        credentialRef: z.ZodOptional<z.ZodString>;
+        allowPrivateNetwork: z.ZodDefault<z.ZodBoolean>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            reasoning: "reasoning";
+            tools: "tools";
+            text: "text";
+            "parallel-tools": "parallel-tools";
+            "structured-output": "structured-output";
+            streaming: "streaming";
+            vision: "vision";
+            usage: "usage";
+        }>>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    modelAliases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        candidates: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        requiredCapabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            reasoning: "reasoning";
+            tools: "tools";
+            text: "text";
+            "parallel-tools": "parallel-tools";
+            "structured-output": "structured-output";
+            streaming: "streaming";
+            vision: "vision";
+            usage: "usage";
+        }>>>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    agentRoutes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    agentExecutors: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        model: "model";
+        cursor: "cursor";
+    }>>>;
+    mutationAgents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cursor: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        command: z.ZodDefault<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        transport: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        envRefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowHostExecution: z.ZodDefault<z.ZodBoolean>;
+        allowedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        transport: z.ZodLiteral<"streamable-http">;
+        url: z.ZodString;
+        authRef: z.ZodOptional<z.ZodString>;
+        allowedHosts: z.ZodArray<z.ZodString>;
+        allowPrivateNetwork: z.ZodDefault<z.ZodBoolean>;
+        allowedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>], "transport">>>;
+    sandbox: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            docker: "docker";
+            "host-readonly": "host-readonly";
+        }>>;
+        image: z.ZodDefault<z.ZodString>;
+        network: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            approved: "approved";
+        }>>;
+        allowHostMutations: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        memoryMb: z.ZodDefault<z.ZodNumber>;
+        cpus: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    approvals: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodLiteral<"risk-tiered">>;
+        requirePlan: z.ZodDefault<z.ZodBoolean>;
+        requireFinalCommit: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    limits: z.ZodDefault<z.ZodObject<{
+        maxSteps: z.ZodDefault<z.ZodNumber>;
+        maxAgentVisits: z.ZodDefault<z.ZodNumber>;
+        maxRetriesPerNode: z.ZodDefault<z.ZodNumber>;
+        maxToolCallsPerAgent: z.ZodDefault<z.ZodNumber>;
+        runTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type RuntimeConfig = z.infer<typeof RuntimeConfigContract>;
+type McpServerConfig = z.infer<typeof LocalMcpContract> | z.infer<typeof RemoteMcpContract>;
+declare function loadRuntimeConfig(cwd: string): RuntimeConfig;
+
+interface CredentialStore {
+    resolve(reference: string): Promise<string>;
+    set(reference: string, value: string): Promise<void>;
+    delete(reference: string): Promise<boolean>;
+}
+
+interface RunEventStore {
+    create(record: RunRecord): RunRecord;
+    read(runId: string): RunRecord;
+    list(): RunRecord[];
+    update(runId: string, patch: Partial<RunRecord>): RunRecord;
+    append(runId: string, event: Omit<RunEvent, "schemaVersion" | "eventId" | "sequence" | "runId" | "createdAt">): RunEvent;
+    events(runId: string): RunEvent[];
+}
+declare class FileRunEventStore implements RunEventStore {
+    readonly root: string;
+    constructor(cwd: string);
+    create(record: RunRecord): RunRecord;
+    read(runId: string): RunRecord;
+    list(): RunRecord[];
+    update(runId: string, patch: Partial<RunRecord>): RunRecord;
+    append(runId: string, event: Omit<RunEvent, "schemaVersion" | "eventId" | "sequence" | "runId" | "createdAt">): RunEvent;
+    events(runId: string): RunEvent[];
+    setStatus(runId: string, status: RunStatus, text?: string): RunRecord;
+    private recordPath;
+    private eventsPath;
+    private runDir;
+    private lockPath;
+    private writeRecord;
+    private ensureRoot;
+}
+
+declare class ProviderRegistry {
+    private readonly providers;
+    constructor(config: RuntimeConfig, credentials: CredentialStore);
+    register(adapter: ModelProviderAdapter): void;
+    get(id: string): ModelProviderAdapter;
+    list(): ModelProviderAdapter[];
+}
+declare class ModelRouter {
+    private readonly config;
+    private readonly registry;
+    constructor(config: RuntimeConfig, registry: ProviderRegistry);
+    invoke(alias: string, request: Omit<ModelRequest, "model">): Promise<RoutedModelResult>;
+}
+
+declare const AgentContract: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    defaultFor: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skills: z.ZodArray<z.ZodString>;
+    handsOffTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const WorkflowContract: z.ZodObject<{
+    id: z.ZodString;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sequence: z.ZodArray<z.ZodString>;
+    council: z.ZodArray<z.ZodString>;
+    requiredOutputs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const RosterContract: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    stack: z.ZodString;
+    required: z.ZodBoolean;
+    defaultWorkflow: z.ZodString;
+    principle: z.ZodOptional<z.ZodString>;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        defaultFor: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skills: z.ZodArray<z.ZodString>;
+        handsOffTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    workflows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        triggers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sequence: z.ZodArray<z.ZodString>;
+        council: z.ZodArray<z.ZodString>;
+        requiredOutputs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    handoffRules: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type AgentRoster = z.infer<typeof RosterContract>;
+type RosterAgent = z.infer<typeof AgentContract>;
+type RosterWorkflow = z.infer<typeof WorkflowContract>;
+
+interface WorktreeRecord {
+    sourceRoot: string;
+    path: string;
+    branchName: string;
+    baseCommit: string;
+    excludedDirtyChanges: boolean;
+}
+declare class WorktreeManager {
+    readonly sourceRoot: string;
+    constructor(sourceRoot: string);
+    inspect(): Promise<{
+        baseCommit: string;
+        dirty: boolean;
+        status: string;
+        sensitivePaths: string[];
+    }>;
+    create(runId: string, options?: {
+        acknowledgeDirtyBase?: boolean;
+    }): Promise<WorktreeRecord>;
+    changes(path: string): Promise<string>;
+    head(path: string): Promise<string>;
+    commit(path: string, runId: string, title: string): Promise<{
+        commit: string;
+        changed: string;
+    }>;
+    remove(path: string, options?: {
+        deleteBranch?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+}
+
+interface RuntimePlan {
+    rosterId: string;
+    workflowId: string;
+    sequence: string[];
+    council: string[];
+    requiredOutputs: string[];
+    mutationAgents: string[];
+    cursorAgents: string[];
+    modelAliases: string[];
+    mcpServers: string[];
+    approvals: Array<"plan" | "network" | "write" | "host-mutation" | "final-commit">;
+}
+interface RuntimeValidation {
+    valid: boolean;
+    enabled: boolean;
+    rosterId: string;
+    workflows: string[];
+    providers: string[];
+    aliases: string[];
+    warnings: string[];
+}
+interface RuntimeServiceOptions {
+    credentials?: CredentialStore;
+    providerRegistry?: ProviderRegistry;
+}
+declare class AgentKitRuntimeService {
+    readonly cwd: string;
+    readonly config: RuntimeConfig;
+    readonly roster: AgentRoster;
+    readonly events: FileRunEventStore;
+    readonly credentials: CredentialStore;
+    readonly providers: ProviderRegistry;
+    readonly router: ModelRouter;
+    readonly worktrees: WorktreeManager;
+    constructor(cwd: string, options?: RuntimeServiceOptions);
+    validate(): RuntimeValidation;
+    plan(goal: string, requestedWorkflow?: string): RuntimePlan;
+    run(goal: string, options?: {
+        workflowId?: string;
+        acknowledgeDirtyBase?: boolean;
+        signal?: AbortSignal;
+    }): Promise<RunRecord>;
+    resume(runId: string, input: Omit<ApprovalDecision, "decidedAt">, options?: {
+        signal?: AbortSignal;
+    }): Promise<RunRecord>;
+    status(runId?: string): RunRecord | RunRecord[];
+    cancel(runId: string): RunRecord;
+    probeProvider(providerId?: string): Promise<ProviderProbeResult[]>;
+    probeMcp(server: string): Promise<unknown>;
+    setCredential(reference: string, value: string): Promise<void>;
+    deleteCredential(reference: string): Promise<boolean>;
+    exportEvidence(runId: string): string;
+    private invoke;
+}
+
+interface McpToolResult {
+    output: string;
+    data?: Record<string, unknown>;
+    isError: boolean;
+}
+declare function assertSafeMcpUrl(url: URL, config: Extract<McpServerConfig, {
+    transport: "streamable-http";
+}>): Promise<void>;
+declare class McpClientBroker {
+    private readonly servers;
+    private readonly credentials;
+    private readonly cwd;
+    private readonly connections;
+    private readonly toolNames;
+    constructor(servers: Record<string, McpServerConfig>, credentials: CredentialStore, cwd: string);
+    definitions(): Promise<ModelToolDefinition[]>;
+    call(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<McpToolResult>;
+    probe(server: string): Promise<{
+        server: string;
+        tools: string[];
+        transport: McpServerConfig["transport"];
+    }>;
+    close(): Promise<void>;
+    private connect;
+}
+
+declare const CouncilState: _langchain_langgraph.AnnotationRoot<{
+    runId: _langchain_langgraph.LastValue<string>;
+    workflowId: _langchain_langgraph.LastValue<string>;
+    goal: _langchain_langgraph.LastValue<string>;
+    sourceRoot: _langchain_langgraph.LastValue<string>;
+    baseCommit: _langchain_langgraph.LastValue<string>;
+    worktreePath: _langchain_langgraph.LastValue<string>;
+    results: _langchain_langgraph.LastValue<AgentNodeResult[]>;
+    visits: _langchain_langgraph.LastValue<Record<string, number>>;
+    steps: _langchain_langgraph.LastValue<number>;
+    planApproved: _langchain_langgraph.LastValue<boolean>;
+    externalApproved: _langchain_langgraph.LastValue<boolean>;
+    mutationApproved: _langchain_langgraph.LastValue<boolean>;
+    hostMutationApproved: _langchain_langgraph.LastValue<boolean>;
+    finalCommitApproved: _langchain_langgraph.LastValue<boolean>;
+    commit: _langchain_langgraph.LastValue<string | null>;
+}>;
+type CouncilGraphState = typeof CouncilState.State;
+interface CouncilGraphDependencies {
+    cwd: string;
+    config: RuntimeConfig;
+    roster: AgentRoster;
+    workflow: RosterWorkflow;
+    events: FileRunEventStore;
+    worktrees: WorktreeManager;
+    checkpointer: SqliteSaver;
+    executorFor(agent: RosterAgent, state: CouncilGraphState): AgentNodeExecutor;
+    signal?: AbortSignal;
+}
+declare function initialCouncilState(input: {
+    runId: string;
+    workflowId: string;
+    goal: string;
+    sourceRoot: string;
+    baseCommit: string;
+    worktreePath: string;
+}): CouncilGraphState;
+declare function compileCouncilGraph(dependencies: CouncilGraphDependencies): _langchain_langgraph.CompiledStateGraph<{
+    runId: string;
+    workflowId: string;
+    goal: string;
+    sourceRoot: string;
+    baseCommit: string;
+    worktreePath: string;
+    results: AgentNodeResult[];
+    visits: Record<string, number>;
+    steps: number;
+    planApproved: boolean;
+    externalApproved: boolean;
+    mutationApproved: boolean;
+    hostMutationApproved: boolean;
+    finalCommitApproved: boolean;
+    commit: string | null;
+}, {
+    runId?: string;
+    workflowId?: string;
+    goal?: string;
+    sourceRoot?: string;
+    baseCommit?: string;
+    worktreePath?: string;
+    results?: AgentNodeResult[];
+    visits?: Record<string, number>;
+    steps?: number;
+    planApproved?: boolean;
+    externalApproved?: boolean;
+    mutationApproved?: boolean;
+    hostMutationApproved?: boolean;
+    finalCommitApproved?: boolean;
+    commit?: string | null;
+}, string, {
+    runId: _langchain_langgraph.LastValue<string>;
+    workflowId: _langchain_langgraph.LastValue<string>;
+    goal: _langchain_langgraph.LastValue<string>;
+    sourceRoot: _langchain_langgraph.LastValue<string>;
+    baseCommit: _langchain_langgraph.LastValue<string>;
+    worktreePath: _langchain_langgraph.LastValue<string>;
+    results: _langchain_langgraph.LastValue<AgentNodeResult[]>;
+    visits: _langchain_langgraph.LastValue<Record<string, number>>;
+    steps: _langchain_langgraph.LastValue<number>;
+    planApproved: _langchain_langgraph.LastValue<boolean>;
+    externalApproved: _langchain_langgraph.LastValue<boolean>;
+    mutationApproved: _langchain_langgraph.LastValue<boolean>;
+    hostMutationApproved: _langchain_langgraph.LastValue<boolean>;
+    finalCommitApproved: _langchain_langgraph.LastValue<boolean>;
+    commit: _langchain_langgraph.LastValue<string | null>;
+}, {
+    runId: _langchain_langgraph.LastValue<string>;
+    workflowId: _langchain_langgraph.LastValue<string>;
+    goal: _langchain_langgraph.LastValue<string>;
+    sourceRoot: _langchain_langgraph.LastValue<string>;
+    baseCommit: _langchain_langgraph.LastValue<string>;
+    worktreePath: _langchain_langgraph.LastValue<string>;
+    results: _langchain_langgraph.LastValue<AgentNodeResult[]>;
+    visits: _langchain_langgraph.LastValue<Record<string, number>>;
+    steps: _langchain_langgraph.LastValue<number>;
+    planApproved: _langchain_langgraph.LastValue<boolean>;
+    externalApproved: _langchain_langgraph.LastValue<boolean>;
+    mutationApproved: _langchain_langgraph.LastValue<boolean>;
+    hostMutationApproved: _langchain_langgraph.LastValue<boolean>;
+    finalCommitApproved: _langchain_langgraph.LastValue<boolean>;
+    commit: _langchain_langgraph.LastValue<string | null>;
+}, _langchain_langgraph.StateDefinition, unknown, unknown, unknown, []>;
+
+export { AgentKitRuntimeService, type AgentNodeExecutor, type AgentNodeInput, type AgentNodeResult, type ApprovalDecision, type ApprovalRequest, type ApprovalRisk, FileRunEventStore, McpClientBroker, type ModelCapability, type ModelMessage, type ModelProviderAdapter, type ModelRequest, type ModelResponse, ModelRouter, type ModelToolCall, type ModelToolDefinition, type ModelUsage, type ProviderProbeResult, ProviderRegistry, type RoutedModelResult, type RunEvent, type RunRecord, type RunStatus, type RuntimeApprovalHandler, type RuntimeCommandResult, type RuntimeConfig, RuntimeConfigContract, type RuntimePlan, type RuntimeServiceOptions, type RuntimeValidation, WorktreeManager, assertSafeMcpUrl, compileCouncilGraph, initialCouncilState, loadRuntimeConfig };