@sudocode-ai/local-server 0.1.0

package/dist/execution/engine/engine.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Execution Engine Interface
+ *
+ * Core abstraction for task execution engines. Provides methods for
+ * submitting, controlling, monitoring, and waiting for task execution.
+ *
+ * @module execution/engine/engine
+ */
+import type { ExecutionTask, ExecutionResult, TaskStatus, EngineMetrics, TaskCompleteHandler, TaskFailedHandler } from './types.js';
+/**
+ * IExecutionEngine - Interface for task execution engines
+ *
+ * Defines the contract for engines that manage Claude Code agent execution.
+ * Implementations may use different strategies (queue-based, pool-based, etc.)
+ * but must provide these core capabilities.
+ */
+export interface IExecutionEngine {
+    /**
+     * Submit a single task for execution
+     *
+     * @param task - The task to execute
+     * @returns Promise resolving to the task ID
+     */
+    submitTask(task: ExecutionTask): Promise<string>;
+    /**
+     * Submit multiple tasks for execution
+     *
+     * @param tasks - Array of tasks to execute
+     * @returns Promise resolving to array of task IDs
+     */
+    submitTasks(tasks: ExecutionTask[]): Promise<string[]>;
+    /**
+     * Cancel a queued or running task
+     *
+     * For queued tasks, removes from queue without execution.
+     * For running tasks, terminates the process.
+     *
+     * @param taskId - ID of task to cancel
+     * @returns Promise that resolves when cancellation complete
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Get current status of a task
+     *
+     * @param taskId - ID of task to query
+     * @returns Current task status or null if task not found
+     */
+    getTaskStatus(taskId: string): TaskStatus | null;
+    /**
+     * Wait for a task to complete
+     *
+     * Returns immediately if task already completed, otherwise
+     * waits for completion and returns result.
+     *
+     * @param taskId - ID of task to wait for
+     * @returns Promise resolving to execution result
+     * @throws Error if task fails
+     */
+    waitForTask(taskId: string): Promise<ExecutionResult>;
+    /**
+     * Wait for multiple tasks to complete
+     *
+     * @param taskIds - IDs of tasks to wait for
+     * @returns Promise resolving to array of execution results
+     * @throws Error if any task fails
+     */
+    waitForTasks(taskIds: string[]): Promise<ExecutionResult[]>;
+    /**
+     * Get current engine metrics
+     *
+     * Returns real-time statistics about engine performance
+     * and resource utilization.
+     *
+     * @returns Current engine metrics (defensive copy)
+     */
+    getMetrics(): EngineMetrics;
+    /**
+     * Register handler for task completion events
+     *
+     * Called when any task completes successfully.
+     *
+     * @param handler - Callback function to invoke on completion
+     */
+    onTaskComplete(handler: TaskCompleteHandler): void;
+    /**
+     * Register handler for task failure events
+     *
+     * Called when any task fails after all retries exhausted.
+     *
+     * @param handler - Callback function to invoke on failure
+     */
+    onTaskFailed(handler: TaskFailedHandler): void;
+    /**
+     * Gracefully shutdown the engine
+     *
+     * Stops accepting new tasks, cancels queued tasks,
+     * terminates running tasks, and releases all resources.
+     *
+     * @returns Promise that resolves when shutdown complete
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/execution/engine/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/execution/engine/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEjD;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEvD;;;;;;;;OAQG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1C;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAEjD;;;;;;;;;OASG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAEtD;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAE5D;;;;;;;OAOG;IACH,UAAU,IAAI,aAAa,CAAC;IAE5B;;;;;;OAMG;IACH,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEnD;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAE/C;;;;;;;OAOG;IACH,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/dist/execution/engine/simple-engine.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Simple Execution Engine
+ *
+ * Queue-based execution engine that spawns a process per task
+ * with concurrency limits. Implements the "simple first" approach.
+ *
+ * @module execution/engine/simple-engine
+ */
+import type { IExecutionEngine } from "./engine.js";
+import type { ExecutionTask, ExecutionResult, TaskStatus, EngineMetrics, TaskCompleteHandler, TaskFailedHandler, EngineConfig } from "./types.js";
+import type { IProcessManager } from "../process/manager.js";
+/**
+ * SimpleExecutionEngine - Queue-based task execution with concurrency control
+ *
+ * Key features:
+ * - FIFO queue for task ordering
+ * - Configurable concurrency limit (default: 3)
+ * - Automatic retry on failure
+ * - Event emission for task lifecycle
+ * - Promise-based waiting
+ * - Graceful shutdown
+ */
+export declare class SimpleExecutionEngine implements IExecutionEngine {
+    private _processManager;
+    private _config;
+    private taskQueue;
+    private runningTasks;
+    private completedResults;
+    private taskResolvers;
+    private metrics;
+    private completeHandlers;
+    private failedHandlers;
+    private pollingIntervals;
+    /**
+     * Create a new SimpleExecutionEngine
+     *
+     * @param processManager - Process manager for spawning Claude processes
+     * @param config - Engine configuration options
+     */
+    constructor(_processManager: IProcessManager, _config?: EngineConfig);
+    /**
+     * Submit a single task for execution
+     *
+     * Adds task to queue and attempts to start execution if capacity available.
+     *
+     * @param task - The task to execute
+     * @returns Promise resolving to the task ID
+     */
+    submitTask(task: ExecutionTask): Promise<string>;
+    /**
+     * Submit multiple tasks for execution
+     *
+     * @param tasks - Array of tasks to execute
+     * @returns Promise resolving to array of task IDs
+     */
+    submitTasks(tasks: ExecutionTask[]): Promise<string[]>;
+    /**
+     * Process the task queue
+     *
+     * Dequeues tasks and starts execution while capacity is available.
+     * Checks dependencies before execution and re-queues if not met.
+     *
+     * @private
+     */
+    private processQueue;
+    /**
+     * Check if all task dependencies are met
+     *
+     * @param task - Task to check
+     * @returns True if all dependencies completed successfully
+     * @private
+     */
+    private areDependenciesMet;
+    /**
+     * Check if any task dependency has failed
+     *
+     * @param task - Task to check
+     * @returns True if any dependency failed
+     * @private
+     */
+    private hasFailedDependency;
+    /**
+     * Track task as running and update capacity metrics
+     *
+     * @param task - Task to start tracking
+     * @private
+     */
+    private trackTaskStart;
+    /**
+     * Track task completion and release capacity
+     *
+     * @param taskId - ID of completed task
+     * @private
+     */
+    private trackTaskComplete;
+    /**
+     * Execute a task
+     *
+     * Acquires a process, sends the prompt, collects output, and builds the result.
+     *
+     * @param task - Task to execute
+     * @private
+     */
+    private executeTask;
+    /**
+     * Wait for a process to exit
+     *
+     * @param process - The managed process to wait for
+     * @param timeoutMs - Optional timeout in milliseconds
+     * @private
+     */
+    private waitForProcessExit;
+    /**
+     * Parse metadata from stream-json output
+     *
+     * Extracts tools used, files changed, tokens, etc. from the output.
+     *
+     * @param output - Raw output from Claude Code
+     * @returns Parsed metadata
+     * @private
+     */
+    private parseMetadata;
+    /**
+     * Handle task failure
+     *
+     * Implements automatic retry logic if maxRetries is configured.
+     * Re-queues failed tasks at front of queue for priority retry.
+     *
+     * @param taskId - ID of failed task
+     * @param error - Error that occurred
+     * @private
+     */
+    private handleTaskFailure;
+    /**
+     * Cancel a queued or running task
+     *
+     * Removes task from queue if still queued, or terminates process if running.
+     * Idempotent - safe to call multiple times or for non-existent tasks.
+     *
+     * @param taskId - ID of task to cancel
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Get current status of a task
+     */
+    getTaskStatus(taskId: string): TaskStatus | null;
+    /**
+     * Wait for a task to complete
+     *
+     * Returns a promise that resolves with the task result when complete.
+     * Supports multiple concurrent waiters for the same task.
+     *
+     * @param taskId - ID of the task to wait for
+     * @returns Promise resolving to the execution result
+     */
+    waitForTask(taskId: string): Promise<ExecutionResult>;
+    /**
+     * Wait for multiple tasks to complete
+     *
+     * Returns a promise that resolves when all tasks complete.
+     *
+     * @param taskIds - Array of task IDs to wait for
+     * @returns Promise resolving to array of execution results
+     */
+    waitForTasks(taskIds: string[]): Promise<ExecutionResult[]>;
+    /**
+     * Get current engine metrics
+     *
+     * Returns defensive copy of current metrics.
+     *
+     * @returns Current engine metrics
+     */
+    getMetrics(): EngineMetrics;
+    /**
+     * Register handler for task completion events
+     */
+    onTaskComplete(handler: TaskCompleteHandler): void;
+    /**
+     * Register handler for task failure events
+     */
+    onTaskFailed(handler: TaskFailedHandler): void;
+    /**
+     * Gracefully shutdown the engine
+     *
+     * Cancels all running tasks, clears the queue, and shuts down the process manager.
+     * Idempotent - safe to call multiple times.
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=simple-engine.d.ts.map

package/dist/execution/engine/simple-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-engine.d.ts","sourceRoot":"","sources":["../../../src/execution/engine/simple-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EAGb,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IA8B1D,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,OAAO;IA7BjB,OAAO,CAAC,SAAS,CAAuB;IAGxC,OAAO,CAAC,YAAY,CAAkC;IAGtD,OAAO,CAAC,gBAAgB,CAAsC;IAG9D,OAAO,CAAC,aAAa,CAAqC;IAG1D,OAAO,CAAC,OAAO,CAAgB;IAG/B,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,cAAc,CAA2B;IAGjD,OAAO,CAAC,gBAAgB,CAAqC;IAE7D;;;;;OAKG;gBAEO,eAAe,EAAE,eAAe,EAChC,OAAO,GAAE,YAAiB;IAkBpC;;;;;;;OAOG;IACG,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAWtD;;;;;OAKG;IACG,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAW5D;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IA2CpB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAyB1B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAazB;;;;;;;OAOG;YACW,WAAW;IAyGzB;;;;;;OAMG;YACW,kBAAkB;IA+ChC;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAWrB;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IA6EzB;;;;;;;OAOG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6C/C;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IA0BhD;;;;;;;;OAQG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAa3D;;;;;;;OAOG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAIjE;;;;;;OAMG;IACH,UAAU,IAAI,aAAa;IAK3B;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAIlD;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAI9C;;;;;OAKG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CA6BhC"}

package/dist/execution/engine/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Engine Layer Types
+ *
+ * Core types for the Execution Engine (Layer 2) that manages
+ * task queueing, concurrency, and multi-agent execution.
+ *
+ * @module execution/engine/types
+ */
+/**
+ * ExecutionTask - Represents a unit of work to be executed by a Claude Code agent
+ */
+export interface ExecutionTask {
+    id: string;
+    type: 'issue' | 'spec' | 'custom';
+    entityId?: string;
+    prompt: string;
+    workDir: string;
+    priority: number;
+    dependencies: string[];
+    createdAt: Date;
+    config: {
+        timeout?: number;
+        maxRetries?: number;
+        env?: Record<string, string>;
+    };
+    metadata?: Record<string, any>;
+}
+/**
+ * ExecutionResult - The outcome of executing a task
+ */
+export interface ExecutionResult {
+    taskId: string;
+    executionId: string;
+    success: boolean;
+    exitCode: number;
+    output: string;
+    error?: string;
+    startedAt: Date;
+    completedAt: Date;
+    duration: number;
+    metadata?: {
+        toolsUsed?: string[];
+        filesChanged?: string[];
+        tokensUsed?: number;
+        cost?: number;
+    };
+}
+/**
+ * EngineMetrics - Real-time engine performance statistics
+ */
+export interface EngineMetrics {
+    maxConcurrent: number;
+    currentlyRunning: number;
+    availableSlots: number;
+    queuedTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    averageDuration: number;
+    successRate: number;
+    throughput: number;
+    totalProcessesSpawned: number;
+    activeProcesses: number;
+}
+/**
+ * TaskStatus - Discriminated union for task state tracking
+ */
+export type TaskStatus = {
+    state: 'queued';
+    position: number;
+} | {
+    state: 'running';
+    processId: string;
+    startedAt: Date;
+} | {
+    state: 'completed';
+    result: ExecutionResult;
+} | {
+    state: 'failed';
+    error: string;
+} | {
+    state: 'cancelled';
+    cancelledAt: Date;
+};
+/**
+ * TaskCompleteHandler - Callback for task completion events
+ */
+export type TaskCompleteHandler = (result: ExecutionResult) => void;
+/**
+ * TaskFailedHandler - Callback for task failure events
+ */
+export type TaskFailedHandler = (taskId: string, error: Error) => void;
+/**
+ * EngineConfig - Configuration options for execution engines
+ */
+export interface EngineConfig {
+    maxConcurrent?: number;
+    claudePath?: string;
+    onOutput?: (data: Buffer, type: 'stdout' | 'stderr') => void;
+}
+/**
+ * RunningTask - Internal tracking for currently executing tasks
+ */
+export interface RunningTask {
+    task: ExecutionTask;
+    process: any;
+    startedAt: Date;
+    attempt: number;
+}
+/**
+ * TaskResolver - Promise resolver for async task waiting
+ */
+export interface TaskResolver {
+    resolve: (result: ExecutionResult) => void;
+    reject: (error: Error) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/execution/engine/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/execution/engine/types.ts"],"names":[],"mappings":"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"}

package/dist/execution/output/ag-ui-adapter.d.ts

@@ -0,0 +1,176 @@
+/**
+ * AG-UI Event Adapter
+ *
+ * Transforms SPEC-007 output processing events into AG-UI protocol events.
+ * This adapter subscribes to events from IOutputProcessor and emits standardized
+ * AG-UI events that can be consumed by frontends via SSE or WebSocket transports.
+ *
+ * @module execution/output/ag-ui-adapter
+ */
+import { type RunStartedEvent, type RunFinishedEvent, type RunErrorEvent, type StepStartedEvent, type StepFinishedEvent, type ToolCallStartEvent, type ToolCallArgsEvent, type ToolCallEndEvent, type ToolCallResultEvent, type TextMessageStartEvent, type TextMessageContentEvent, type TextMessageEndEvent, type StateDeltaEvent, type StateSnapshotEvent, type CustomEvent, type State } from "@ag-ui/core";
+import { IOutputProcessor } from "./types.js";
+/**
+ * Event listener callback type
+ *
+ * Accepts any AG-UI event type from @ag-ui/core
+ */
+export type AgUiEventListener = (event: RunStartedEvent | RunFinishedEvent | RunErrorEvent | StepStartedEvent | StepFinishedEvent | ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent | ToolCallResultEvent | TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent | StateDeltaEvent | StateSnapshotEvent | CustomEvent) => void;
+/**
+ * AgUiEventAdapter - Transforms SPEC-007 events to AG-UI events
+ *
+ * This adapter bridges the gap between the Output Processing Layer (SPEC-007)
+ * and the AG-UI protocol (SPEC-009). It subscribes to output processor events
+ * and emits corresponding AG-UI protocol events.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new AgUiEventAdapter('run-123');
+ * adapter.onEvent((event) => {
+ *   console.log('AG-UI event:', event);
+ *   // Send to SSE transport or WebSocket
+ * });
+ *
+ * const processor = new ClaudeCodeOutputProcessor();
+ * adapter.connectToProcessor(processor);
+ * adapter.emitRunStarted({ model: 'claude-sonnet-4' });
+ * ```
+ */
+export declare class AgUiEventAdapter {
+    private runId;
+    private threadId;
+    private listeners;
+    private processor;
+    private currentState;
+    private activeToolCalls;
+    private messageCounter;
+    /**
+     * Create a new AG-UI event adapter
+     *
+     * @param runId - Unique identifier for this execution run
+     * @param threadId - Thread identifier (defaults to runId if not provided)
+     */
+    constructor(runId: string, threadId?: string);
+    /**
+     * Connect to an output processor and subscribe to its events
+     *
+     * @param processor - The output processor to subscribe to
+     */
+    connectToProcessor(processor: IOutputProcessor): void;
+    /**
+     * Register an event listener
+     *
+     * @param listener - Callback to invoke when AG-UI events are emitted
+     */
+    onEvent(listener: AgUiEventListener): void;
+    /**
+     * Remove an event listener
+     *
+     * @param listener - Callback to remove
+     */
+    offEvent(listener: AgUiEventListener): void;
+    /**
+     * Emit RUN_STARTED event
+     *
+     * @param metadata - Optional run metadata (model, config, etc.)
+     */
+    emitRunStarted(metadata?: Record<string, any>): void;
+    /**
+     * Emit RUN_FINISHED event
+     *
+     * @param result - Optional result data
+     */
+    emitRunFinished(result?: any): void;
+    /**
+     * Emit a state snapshot with current execution state
+     */
+    emitStateSnapshot(): void;
+    /**
+     * Handle tool call events from SPEC-007
+     *
+     * Transforms a single ToolCall into a sequence of AG-UI events:
+     * - TOOL_CALL_START (when tool is invoked)
+     * - TOOL_CALL_ARGS (with input parameters)
+     * - TOOL_CALL_END (when tool completes)
+     * - TOOL_CALL_RESULT (with result/error)
+     */
+    private handleToolCall;
+    /**
+     * Handle file change events from SPEC-007
+     *
+     * Transforms FileChange into a CUSTOM event with file operation details
+     */
+    private handleFileChange;
+    /**
+     * Handle progress updates from SPEC-007
+     *
+     * Transforms ProcessingMetrics into STATE_DELTA events
+     */
+    private handleProgress;
+    /**
+     * Handle error events from SPEC-007
+     *
+     * Transforms errors into RUN_ERROR events
+     */
+    private handleError;
+    /**
+     * Handle message events
+     *
+     * Transforms text messages into TEXT_MESSAGE_* AG-UI events.
+     * For now, we emit the full message content in a single event.
+     */
+    private handleMessage;
+    /**
+     * Handle usage metric updates
+     *
+     * Transforms usage metrics into CUSTOM usage events and updates state.
+     */
+    private handleUsage;
+    /**
+     * Emit a state delta with partial state updates
+     *
+     * @param updates - Partial state updates to apply
+     */
+    private emitStateDelta;
+    /**
+     * Emit an AG-UI event to all registered listeners
+     *
+     * @param event - The event to emit
+     */
+    private emit;
+    /**
+     * Emit STEP_STARTED event for workflow step execution
+     *
+     * @param stepId - Unique identifier for the step (stored in rawEvent)
+     * @param stepName - Human-readable name of the step
+     */
+    emitStepStarted(stepId: string, stepName: string): void;
+    /**
+     * Emit STEP_FINISHED event for workflow step completion
+     *
+     * @param stepId - Unique identifier for the step (stored in rawEvent)
+     * @param status - Status of the step ('success' or 'error', stored in rawEvent)
+     * @param output - Optional output data from the step (stored in rawEvent)
+     */
+    emitStepFinished(stepId: string, status: "success" | "error", output?: any): void;
+    /**
+     * Emit RUN_ERROR event when workflow execution fails
+     *
+     * @param message - Error message
+     * @param stack - Optional error stack trace
+     * @param code - Optional error code
+     */
+    emitRunError(message: string, stack?: string, code?: string): void;
+    /**
+     * Get current adapter state
+     *
+     * @returns Current state object
+     */
+    getState(): State;
+    /**
+     * Get the run ID
+     *
+     * @returns The run ID this adapter is tracking
+     */
+    getRunId(): string;
+}
+//# sourceMappingURL=ag-ui-adapter.d.ts.map

package/dist/execution/output/ag-ui-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ag-ui-adapter.d.ts","sourceRoot":"","sources":["../../../src/execution/output/ag-ui-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,EAQjB,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,KAAK,EACD,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,gBAAgB,GAChB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,qBAAqB,GACrB,uBAAuB,GACvB,mBAAmB,GACnB,eAAe,GACf,kBAAkB,GAClB,WAAW,KACZ,IAAI,CAAC;AAEV;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,eAAe,CAGT;IACd,OAAO,CAAC,cAAc,CAAa;IAEnC;;;;;OAKG;gBACS,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAK5C;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IAYrD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAI1C;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAI3C;;;;OAIG;IACH,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAYpD;;;;OAIG;IACH,eAAe,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,IAAI;IAWnC;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAwBzB;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc,CAkEpB;IAEF;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAkBtB;IAEF;;;;OAIG;IACH,OAAO,CAAC,cAAc,CAYpB;IAEF;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAiBjB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,aAAa,CAiCnB;IAEF;;;;OAIG;IACH,OAAO,CAAC,WAAW,CA8BjB;IAEF;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;;OAIG;IACH,OAAO,CAAC,IAAI;IA2BZ;;;;;OAKG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAavD;;;;;;OAMG;IACH,gBAAgB,CACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,GAAG,OAAO,EAC3B,MAAM,CAAC,EAAE,GAAG,GACX,IAAI;IAeP;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAWlE;;;;OAIG;IACH,QAAQ,IAAI,KAAK;IAIjB;;;;OAIG;IACH,QAAQ,IAAI,MAAM;CAGnB"}