@corbat-tech/coco 2.38.0 → 2.40.0

package/dist/{agent-runtime-DeLcB0Ie.d.ts → workflow-engine-DleSoUhy.d.ts}

@@ -1,4 +1,4 @@
-import { T as ToolRegistry, a as ToolDefinition$1 } from './registry-CEpl9Jq0.js';
+import { z } from 'zod';
 
 /**
  * Unified thinking/reasoning mode support for all LLM providers.
@@ -87,7 +87,7 @@ interface Message {
 /**
  * Tool definition for LLM
  */
-interface ToolDefinition {
+interface ToolDefinition$1 {
     name: string;
     description: string;
     input_schema: {
@@ -138,7 +138,7 @@ interface ChatResponse {
  * Chat with tools options
  */
 interface ChatWithToolsOptions extends ChatOptions {
-    tools: ToolDefinition[];
+    tools: ToolDefinition$1[];
     toolChoice?: "auto" | "any" | {
         type: "tool";
         name: string;
@@ -302,19 +302,117 @@ type ProviderType = "anthropic" | "openai" | "codex" | "copilot" | "gemini" | "v
  */
 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;
+/**
+ * Tool Registry for Corbat-Coco
+ * Central management of all available tools
+ */
+
+/**
+ * Tool definition
+ */
+interface ToolDefinition<TInput = unknown, TOutput = unknown> {
+    name: string;
+    description: string;
+    category: ToolCategory;
+    parameters: z.ZodType<TInput, any, any>;
+    execute: (params: TInput) => Promise<TOutput>;
+}
+/**
+ * Tool categories
+ */
+type ToolCategory = "file" | "bash" | "git" | "test" | "quality" | "build" | "deploy" | "config" | "web" | "search" | "memory" | "document";
+/**
+ * Tool execution result
+ */
+interface ToolResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    duration: number;
+}
+/**
+ * Progress callback for long-running operations
+ */
+type ProgressCallback = (progress: ProgressInfo) => void;
+/**
+ * Progress information
+ */
+interface ProgressInfo {
+    /** Current step or phase name */
+    phase: string;
+    /** Progress percentage (0-100), null if indeterminate */
+    percent: number | null;
+    /** Human-readable message */
+    message?: string;
+    /** Estimated time remaining in ms, null if unknown */
+    estimatedTimeRemaining?: number | null;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for tool execution
+ */
+interface ExecuteOptions {
+    /** Progress callback for long operations */
+    onProgress?: ProgressCallback;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Tool registry
+ */
+declare class ToolRegistry {
+    private tools;
+    private logger;
+    /**
+     * Register a tool
+     */
+    register<TInput, TOutput>(tool: ToolDefinition<TInput, TOutput>): void;
+    /**
+     * Unregister a tool
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a tool by name
+     */
+    get<TInput = unknown, TOutput = unknown>(name: string): ToolDefinition<TInput, TOutput> | undefined;
+    /**
+     * Check if a tool exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get all tools
+     */
+    getAll(): ToolDefinition[];
+    /**
+     * Get tools by category
+     */
+    getByCategory(category: ToolCategory): ToolDefinition[];
+    /**
+     * Execute a tool
+     */
+    execute<TInput, TOutput>(name: string, params: TInput, options?: ExecuteOptions): Promise<ToolResult<TOutput>>;
+    /**
+     * Get tool definitions for LLM (simplified format)
+     */
+    getToolDefinitionsForLLM(): Array<{
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }>;
+}
+/**
+ * Get the global tool registry
+ */
+declare function getToolRegistry(): ToolRegistry;
+/**
+ * Create a new tool registry
+ */
+declare function createToolRegistry(): ToolRegistry;
+/**
+ * Helper to create a tool definition with type safety
+ */
+declare function defineTool<TInput, TOutput>(definition: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
 
 /**
  * Agent mode registry.
@@ -336,155 +434,6 @@ 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;
@@ -492,6 +441,7 @@ interface AgentBudget {
     maxInputTokens?: number;
     maxOutputTokens?: number;
     maxEstimatedCostUsd?: number;
+    maxConcurrentRuns?: number;
 }
 interface AgentCapability {
     role: AgentRole;
@@ -500,7 +450,31 @@ interface AgentCapability {
     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;
@@ -543,6 +517,35 @@ interface AgentRunResult {
     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;
@@ -563,6 +566,7 @@ interface AgentGraphNode {
         maxAttempts: number;
         backoffMs?: number;
     };
+    timeoutMs?: number;
     condition?: string;
 }
 interface AgentGraphEdge {
@@ -595,7 +599,62 @@ interface SharedWorkspaceStateSnapshot {
     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 {
+    id?: string;
+    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;
@@ -610,7 +669,102 @@ declare class SharedWorkspaceState {
     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;
+    allowSimulated?: boolean;
+}
+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;
@@ -637,6 +791,7 @@ declare function normalizeAgentRunResult(input: {
 }): AgentRunResult;
 declare function validateAgentCapabilities(capability: AgentCapability, requiredTools?: string[]): AgentGraphValidationIssue[];
 declare function validateAgentGraph(graph: AgentGraphDefinition): AgentGraphValidationResult;
+declare function dryRunAgentGraphNodeExecutor(execution: AgentGraphNodeExecution): Promise<AgentRunResult>;
 
 type WorkflowRisk = "read-only" | "write" | "network" | "destructive" | "secrets-sensitive";
 interface WorkflowStepDefinition {
@@ -687,6 +842,219 @@ declare const WorkflowRegistry: typeof WorkflowCatalog;
 declare function createWorkflowCatalog(workflows?: WorkflowDefinition[]): WorkflowCatalog;
 declare function createWorkflowRegistry(workflows?: WorkflowDefinition[]): WorkflowCatalog;
 
+type RuntimeSurface = "cli" | "api" | "web" | "whatsapp" | "slack" | "teams" | "internal" | "mcp" | "worker";
+interface TenantContext {
+    id: string;
+    name?: string;
+    environment?: "development" | "staging" | "production";
+    metadata?: Record<string, unknown>;
+}
+interface UserContext {
+    id?: string;
+    displayName?: string;
+    roles?: string[];
+    groups?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface DataBoundary {
+    region?: string;
+    classification?: "public" | "internal" | "confidential" | "restricted";
+    allowCrossTenantMemory?: boolean;
+    redactSensitiveData?: boolean;
+}
+interface CostBudget {
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxEstimatedCostUsd?: number;
+    maxTurns?: number;
+}
+interface RetentionPolicy {
+    conversationDays?: number;
+    eventDays?: number;
+    artifactDays?: number;
+}
+interface RuntimePolicy {
+    allowedTools?: string[];
+    maxToolRisk?: WorkflowRisk;
+    requireHumanApprovalFor?: WorkflowRisk[];
+    dataBoundary?: DataBoundary;
+    costBudget?: CostBudget;
+    retention?: RetentionPolicy;
+    rateLimit?: {
+        maxRequestsPerMinute?: number;
+        maxConcurrentRuns?: number;
+    };
+}
+interface RuntimeRequestContext {
+    tenant?: TenantContext;
+    user?: UserContext;
+    surface: RuntimeSurface;
+    channel?: string;
+    correlationId?: string;
+    policy?: RuntimePolicy;
+    metadata?: Record<string, unknown>;
+}
+declare function createRuntimeRequestContext(input?: Partial<RuntimeRequestContext>): RuntimeRequestContext;
+declare function mergeRuntimePolicy(base: RuntimePolicy | undefined, override: RuntimePolicy | undefined): RuntimePolicy | undefined;
+declare function runtimeContextToMetadata(context: RuntimeRequestContext | undefined): Record<string, unknown>;
+
+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;
+    legacyAgentBridge?: {
+        setAgentProvider(provider: LLMProvider): void;
+        setAgentToolRegistry(registry: ToolRegistry): void;
+    };
+    runtimeContext?: RuntimeRequestContext;
+    runtimePolicy?: RuntimePolicy;
+}
+interface AgentRuntimeSnapshot {
+    provider: {
+        type: ProviderType;
+        model: string;
+        capability: ProviderRuntimeCapability;
+    };
+    tools: {
+        count: number;
+        names: string[];
+    };
+    modes: AgentModeDefinition[];
+    context?: RuntimeRequestContext;
+    policy?: RuntimePolicy;
+}
+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): PermissionDecision;
+    canExecuteToolInput?(mode: RuntimeMode, tool: ToolDefinition, 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 WorkflowRunStatus = "completed" | "failed";
 interface WorkflowRunInput {
     workflowId: string;
@@ -701,6 +1069,8 @@ interface WorkflowRunResult {
     startedAt: string;
     completedAt: string;
     error?: string;
+    graphResult?: AgentGraphRunResult;
+    trace?: AgentTraceContext;
 }
 interface WorkflowRunContext {
     workflow: WorkflowDefinition;
@@ -708,49 +1078,26 @@ interface WorkflowRunContext {
     eventLog: EventLog;
 }
 type WorkflowHandler = (input: Record<string, unknown>, context: WorkflowRunContext) => Promise<unknown>;
+interface WorkflowEngineOptions {
+    catalog?: WorkflowCatalog;
+    eventLog?: EventLog;
+    sharedState?: SharedWorkspaceStore;
+    nodeExecutor?: AgentGraphNodeExecutor;
+    runtimePolicy?: RuntimePolicy;
+}
 declare class WorkflowEngine {
     private readonly catalog;
     private readonly eventLog;
     private handlers;
-    constructor(catalog?: WorkflowCatalog, eventLog?: EventLog);
+    private readonly sharedState;
+    private readonly runtimePolicy?;
+    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): 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>;
+declare function createWorkflowEngine(catalog?: WorkflowCatalog, eventLog?: EventLog, options?: Omit<WorkflowEngineOptions, "catalog" | "eventLog">): WorkflowEngine;
 
-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 };
+export { type RetentionPolicy 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, type AgentRuntimeOptions as I, type AgentRuntimeSnapshot as J, type AgentToolPolicyDecision as K, type LLMProvider as L, type Message as M, type AgentTraceContext as N, type CostBudget as O, type ProviderConfig as P, DEFAULT_WORKFLOWS as Q, type DataBoundary as R, type StreamChunk as S, type EventLog as T, FileSharedWorkspaceStore as U, InMemorySharedWorkspaceStore as V, type LegacyAgentRoleMapping as W, type PermissionDecision as X, type PermissionPolicy as Y, type ProviderRuntimeSelection as Z, type ReasoningEffort as _, type ChatResponse as a, validateAgentCapabilities as a$, type AgentTask as a0, type RuntimeEvent as a1, type RuntimeEventType as a2, type RuntimeMode as a3, type RuntimePolicy as a4, type RuntimeRequestContext as a5, type RuntimeSession as a6, type RuntimeSessionCreateOptions as a7, type RuntimeSessionStore as a8, type RuntimeSurface as a9, type WorkflowRetryPolicy as aA, type WorkflowRisk as aB, type WorkflowRunContext as aC, type WorkflowRunInput as aD, type WorkflowRunResult as aE, type WorkflowRunStatus as aF, type WorkflowStepDefinition as aG, createAgentArtifact as aH, createAgentGraphEngine as aI, createAgentTraceContext as aJ, createProvider as aK, createRuntimeRequestContext as aL, createSummaryArtifact as aM, createToolRegistry as aN, createWorkflowCatalog as aO, createWorkflowEngine as aP, createWorkflowRegistry as aQ, dryRunAgentGraphNodeExecutor as aR, evaluateAgentToolPolicy as aS, getAgentMode as aT, isAgentMode as aU, listAgentModes as aV, listLegacyAgentRoleMappings as aW, mapLegacyAgentRole as aX, mergeRuntimePolicy as aY, normalizeAgentRunResult as aZ, runtimeContextToMetadata as a_, type RuntimeToolExecutionInput as aa, type RuntimeToolExecutionResult as ab, type RuntimeTurnContext as ac, type RuntimeTurnInput as ad, type RuntimeTurnResult as ae, type RuntimeTurnRunner as af, type RuntimeTurnStreamEvent as ag, type SharedWorkspaceProvenance as ah, type SharedWorkspaceRecord as ai, type SharedWorkspaceRecordKind as aj, SharedWorkspaceState as ak, type SharedWorkspaceStateSnapshot as al, type SharedWorkspaceStore as am, type SharedWorkspaceWriteInput as an, type TenantContext as ao, ToolRegistry as ap, type ToolRiskLevel as aq, type ToolRiskManifest as ar, type ToolRiskManifestEntry as as, type UserContext as at, WorkflowCatalog as au, type WorkflowDefinition as av, WorkflowEngine as aw, type WorkflowHandler as ax, type WorkflowPlan as ay, WorkflowRegistry as az, type ChatWithToolsOptions as b, validateAgentGraph as b0, workflowToAgentGraph as b1, type ToolDefinition as b2, type ToolCategory as b3, type ToolResult as b4, defineTool as b5, getToolRegistry as b6, type ProviderType as b7, type ProviderCatalogEntry as b8, type ModelCatalogEntry as b9, type ProviderRuntimeCapability as ba, type ProviderProbeResult as bb, 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 };