@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/runtime/runtime.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Event-Sourced Runtime
+ *
+ * Top-level runtime that assembles EventStore + SessionManager + Reactor.
+ * Provides unified interface for UI layers.
+ */
+import type { EventBase, ImageContent } from "../event-store/types.js";
+import type { EventStore, SubscribeOptions } from "../event-store/store.js";
+import type { SessionDescriptor } from "../projection/types.js";
+import type { ToolRegistry, ApprovalHandler } from "../intent/types.js";
+import type { LLMClient, ModelConfig, ToolDefinition } from "./llm-types.js";
+import { SessionManager } from "../projection/session-manager.js";
+import { SessionProjection } from "../projection/session-projection.js";
+import { type TimelineQueryOptions } from "../projection/timeline-projection.js";
+import { IntentClassifier, type ClassifierConfig } from "../intent/classifier.js";
+import type { CheckpointRef, RuntimeAdapter, RuntimeStatus } from "./types.js";
+import { type CompactionEngineSettings } from "../compaction/compaction-engine.js";
+export interface EventSourcedRuntimeConfig {
+    /** Working directory (used to derive workspace_id) */
+    cwd: string;
+    /** Agent directory for storage */
+    agentDir?: string;
+    /** SQLite database path for events (overrides default) */
+    storagePath?: string;
+    /** Session index path (overrides default) */
+    sessionIndexPath?: string;
+    /** Pre-configured EventStore (optional, will create if not provided) */
+    store?: EventStore;
+    /** Thread ID for event isolation. When set, the runtime wraps its store so every appended event carries thread_id = threadId. */
+    threadId?: string;
+    /** Pre-configured SessionManager (optional, will create if not provided) */
+    sessionManager?: SessionManager;
+    /** Classifier configuration */
+    classifierConfig?: ClassifierConfig;
+    /** Tool registry */
+    toolRegistry: ToolRegistry;
+    /** Runtime adapter for deterministic tool execution and checkpoints */
+    runtimeAdapter?: RuntimeAdapter;
+    /** Approval handler for UI */
+    approvalHandler?: ApprovalHandler;
+    /** LLM client */
+    llmClient: LLMClient;
+    /** System prompt */
+    systemPrompt: string;
+    /** Model configuration */
+    model: ModelConfig;
+    /** Tools available to the agent */
+    tools: ToolDefinition[];
+    /** Context token budget */
+    contextBudget?: number;
+    /** Retry policy (default: DefaultRetryPolicy). */
+    retryPolicy?: import("./policies.js").RetryPolicy;
+    /** Whether assistant messages that complete with stop_reason=error should be retried by the reactor. */
+    retryAssistantErrorCompletions?: boolean;
+    /** Compaction policy (default: NoopCompactionPolicy). */
+    compactionPolicy?: import("./policies.js").CompactionPolicy;
+    /** Settings for the default event-sourced compaction engine. Ignored when compactionPolicy is provided. */
+    compactionEngineSettings?: CompactionEngineSettings;
+}
+export interface RuntimeCompactOptions {
+    reason?: "manual" | "threshold" | "overflow";
+    token_count?: number;
+}
+/**
+ * EventSourcedRuntime - the primary LLM execution engine.
+ *
+ * Assembles EventStore + SessionManager + Reactor.
+ * Provides unified interface for UI layers.
+ */
+export declare class EventSourcedRuntime {
+    readonly store: EventStore;
+    readonly sessionManager: SessionManager | undefined;
+    readonly runtimeAdapter: RuntimeAdapter;
+    readonly classifier: IntentClassifier;
+    private reactor;
+    private config;
+    private readonly ownsStore;
+    /** Working directory for this runtime */
+    get cwd(): string;
+    /** Agent data directory */
+    get agentDir(): string;
+    private _isProcessing;
+    private _turnCompletionWaiters;
+    private _turnSubscription;
+    private _resolveSettled;
+    constructor(config: EventSourcedRuntimeConfig);
+    /**
+     * Process user input. Drives the reactor to completion (one turn cycle).
+     */
+    prompt(text: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Check if runtime is currently processing.
+     */
+    get isRunning(): boolean;
+    get signal(): AbortSignal | undefined;
+    /**
+     * Resolve when the current prompt cycle is fully settled.
+     */
+    waitForIdle(): Promise<void>;
+    private _resolveIdleWaiters;
+    /**
+     * Interrupt current execution.
+     *
+     * Sets _abortedByUser on the reactor, which causes _onAgentTurnCompleted to discard
+     * queued follow-ups and let the reactor settle. The settled promise resolves naturally
+     * when the current turn finishes (via _waitUntilSettled).
+     *
+     * Edge case: if no turn is running (no AGENT_TURN_COMPLETED will fire), also resolve
+     * the settled promise immediately so the caller doesn't hang.
+     */
+    abort(): void;
+    /**
+     * Inject a steer message — interrupts the current turn and delivers the message
+     * as a follow-up after the current turn settles.
+     */
+    steer(text: string, images?: ImageContent[]): void;
+    /**
+     * Queue a follow-up message — delivered after the current turn naturally completes.
+     * If the runtime is not processing, queues it for the next prompt.
+     */
+    followUp(text: string, images?: ImageContent[]): void;
+    /**
+     * Request context compaction. The active reactor handles this immediately when
+     * running; otherwise the request is recorded for the event stream.
+     */
+    compact(options?: RuntimeCompactOptions): void;
+    setModel(provider: string, modelId: string): void;
+    getModel(): ModelConfig;
+    setThinkingLevel(level: string): void;
+    getThinkingLevel(): string | undefined;
+    getProjection(): SessionProjection;
+    getTools(): ToolDefinition[];
+    setTools(tools: ToolDefinition[]): void;
+    getSystemPrompt(): string;
+    setSystemPrompt(prompt: string): void;
+    private _createDefaultProjection;
+    /**
+     * Wait until the reactor has settled — i.e. an AGENT_TURN_COMPLETED fires AND
+     * no further USER_MESSAGE has been appended in the same tick (e.g. by follow-up draining).
+     */
+    private _waitUntilSettled;
+    /**
+     * Approve a pending intent.
+     */
+    approve(intentEventId: string): void;
+    /**
+     * Reject a pending intent.
+     */
+    reject(intentEventId: string): void;
+    /**
+     * Subscribe to real-time events (for UI).
+     */
+    subscribe(handler: (event: EventBase) => void, options?: SubscribeOptions): () => void;
+    /**
+     * Query the activity timeline (for UI rendering).
+     */
+    getTimeline(options?: TimelineQueryOptions): import("../projection/timeline-projection.js").TimelineEntry[];
+    /**
+     * Fork session at a specific event.
+     */
+    fork(eventId: string): SessionDescriptor;
+    /**
+     * Switch to a different session.
+     */
+    switchSession(sessionId: string): void;
+    /**
+     * Create a new session.
+     */
+    createSession(name?: string): SessionDescriptor;
+    /**
+     * Get current session descriptor.
+     */
+    getCurrentSession(): SessionDescriptor | undefined;
+    createCheckpoint(label?: string): Promise<CheckpointRef>;
+    restoreCheckpoint(checkpoint: CheckpointRef): Promise<void>;
+    getRuntimeStatus(): Promise<RuntimeStatus>;
+    /**
+     * Dispose the runtime.
+     */
+    dispose(): void;
+}
+/**
+ * Create an EventSourcedRuntime from existing components.
+ */
+/**
+ * Create an EventSourcedRuntime from existing components.
+ *
+ * Note: This factory bypasses the constructor to allow injection of
+ * pre-configured EventStore and SessionManager instances.
+ */
+export declare function createEventSourcedRuntime(store: EventStore, sessionManager: SessionManager, config: Omit<EventSourcedRuntimeConfig, "cwd" | "storagePath" | "sessionIndexPath">): EventSourcedRuntime;

package/dist/core/runtime/runtime.js

@@ -0,0 +1,449 @@
+/**
+ * Event-Sourced Runtime
+ *
+ * Top-level runtime that assembles EventStore + SessionManager + Reactor.
+ * Provides unified interface for UI layers.
+ */
+import { SqliteEventStore } from "../event-store/sqlite-store.js";
+import { ThreadScopedStore } from "../event-store/thread-scoped-store.js";
+import { deriveWorkspaceId, getEventDatabasePath, getSessionIndexPath } from "../event-store/workspace.js";
+import { SessionManager } from "../projection/session-manager.js";
+import { SessionProjection } from "../projection/session-projection.js";
+import { TimelineProjection } from "../projection/timeline-projection.js";
+import { IntentClassifier } from "../intent/classifier.js";
+import { Reactor } from "./reactor.js";
+import { LocalRuntimeAdapter } from "./local-runtime.js";
+import { CompactionEngine } from "../compaction/compaction-engine.js";
+import { getAgentDir } from "../../config.js";
+// ============================================================================
+// Event-Sourced Runtime
+// ============================================================================
+/**
+ * EventSourcedRuntime - the primary LLM execution engine.
+ *
+ * Assembles EventStore + SessionManager + Reactor.
+ * Provides unified interface for UI layers.
+ */
+export class EventSourcedRuntime {
+    /** Working directory for this runtime */
+    get cwd() { return this.config.cwd; }
+    /** Agent data directory */
+    get agentDir() { return this.config.agentDir ?? getAgentDir(); }
+    constructor(config) {
+        this.reactor = null;
+        this._isProcessing = false;
+        this._turnCompletionWaiters = [];
+        this.config = config;
+        this.ownsStore = !config.store;
+        // 1. Create or use provided EventStore
+        const workspaceId = deriveWorkspaceId(config.cwd);
+        const rawStore = config.store ?? new SqliteEventStore(workspaceId, config.storagePath ?? getEventDatabasePath(workspaceId, config.agentDir));
+        this.store = config.threadId ? new ThreadScopedStore(rawStore, config.threadId) : rawStore;
+        this.runtimeAdapter = config.runtimeAdapter ?? new LocalRuntimeAdapter({
+            workspace_id: this.store.workspace_id,
+            cwd: config.cwd,
+            agentDir: config.agentDir,
+            toolRegistry: config.toolRegistry,
+        });
+        // 2. Create or use provided SessionManager (optional for migration)
+        this.sessionManager = config.sessionManager ?? (config.sessionManager !== undefined ? new SessionManager(this.store, config.sessionIndexPath ?? getSessionIndexPath(this.store.workspace_id, config.agentDir)) : undefined);
+        // 3. Create IntentClassifier
+        this.classifier = new IntentClassifier(config.classifierConfig);
+        this.store.append({
+            actor_id: "runtime",
+            type: "RUNTIME_STARTED",
+            payload: { runtime_id: this.runtimeAdapter.runtime_id, kind: this.runtimeAdapter.kind, cwd: config.cwd },
+        });
+    }
+    /**
+     * Process user input. Drives the reactor to completion (one turn cycle).
+     */
+    async prompt(text, images) {
+        if (this._isProcessing) {
+            throw new Error("EventSourcedRuntime is already processing a prompt. Use steer() or followUp() to queue messages, or wait for completion.");
+        }
+        this._isProcessing = true;
+        try {
+            // Lazy-create the reactor and start it. Reactor lives only as long as the prompt cycle.
+            const projection = this.getProjection();
+            this.reactor = new Reactor({
+                store: this.store,
+                projection,
+                llmClient: this.config.llmClient,
+                classifier: this.classifier,
+                toolRegistry: this.config.toolRegistry,
+                approvalHandler: this.config.approvalHandler,
+                runtimeAdapter: this.runtimeAdapter,
+                systemPrompt: this.config.systemPrompt,
+                model: this.config.model,
+                contextBudget: this.config.contextBudget ?? 128000,
+                tools: this.config.tools,
+                retryPolicy: this.config.retryPolicy,
+                retryAssistantErrorCompletions: this.config.retryAssistantErrorCompletions,
+                compactionPolicy: this.config.compactionPolicy ?? new CompactionEngine({
+                    store: this.store,
+                    projection,
+                    llmClient: this.config.llmClient,
+                    model: this.config.model,
+                    settings: {
+                        contextWindow: this.config.contextBudget ?? 128000,
+                        ...this.config.compactionEngineSettings,
+                    },
+                }),
+                sessionManager: this.sessionManager,
+            });
+            await this.reactor.start();
+            // Wait until the reactor reaches a fully idle state. The reactor may chain
+            // multiple turns (e.g. follow-up queue draining), so we keep waiting until settled.
+            const settledPromise = this._waitUntilSettled();
+            // Append the user message — the reactor will pick it up
+            this.store.append({
+                actor_id: "user",
+                type: "USER_MESSAGE",
+                payload: { content: text, images },
+            });
+            await settledPromise;
+        }
+        finally {
+            this._turnSubscription?.();
+            this._turnSubscription = undefined;
+            this.reactor?.stop();
+            this.reactor = null;
+            this._isProcessing = false;
+            this._resolveIdleWaiters();
+        }
+    }
+    /**
+     * Check if runtime is currently processing.
+     */
+    get isRunning() {
+        return this._isProcessing;
+    }
+    get signal() {
+        return this.reactor?.signal;
+    }
+    /**
+     * Resolve when the current prompt cycle is fully settled.
+     */
+    waitForIdle() {
+        if (!this._isProcessing)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this._turnCompletionWaiters.push(resolve);
+        });
+    }
+    _resolveIdleWaiters() {
+        const waiters = this._turnCompletionWaiters.splice(0);
+        for (const resolve of waiters)
+            resolve();
+    }
+    /**
+     * Interrupt current execution.
+     *
+     * Sets _abortedByUser on the reactor, which causes _onAgentTurnCompleted to discard
+     * queued follow-ups and let the reactor settle. The settled promise resolves naturally
+     * when the current turn finishes (via _waitUntilSettled).
+     *
+     * Edge case: if no turn is running (no AGENT_TURN_COMPLETED will fire), also resolve
+     * the settled promise immediately so the caller doesn't hang.
+     */
+    abort() {
+        this.store.append({
+            actor_id: "user",
+            type: "USER_INTERRUPT",
+            payload: {},
+        });
+        this.reactor?.interrupt();
+        // The _waitUntilSettled subscription will resolve when AGENT_TURN_COMPLETED fires.
+        // But if no turn is running (or the turn fails before starting), we resolve immediately.
+        if (!this._isProcessing && this._resolveSettled) {
+            this._resolveSettled();
+        }
+    }
+    /**
+     * Inject a steer message — interrupts the current turn and delivers the message
+     * as a follow-up after the current turn settles.
+     */
+    steer(text, images) {
+        if (!this._isProcessing) {
+            this.store.append({
+                actor_id: "user",
+                type: "USER_MESSAGE",
+                payload: { content: text, images },
+            });
+            return;
+        }
+        this.store.append({
+            actor_id: "user",
+            type: "USER_INTERRUPT",
+            payload: { content: text, images, reason: "steer" },
+        });
+    }
+    /**
+     * Queue a follow-up message — delivered after the current turn naturally completes.
+     * If the runtime is not processing, queues it for the next prompt.
+     */
+    followUp(text, images) {
+        this.store.append({
+            actor_id: "user",
+            type: "USER_FOLLOWUP_QUEUED",
+            payload: { content: text, images },
+        });
+    }
+    /**
+     * Request context compaction. The active reactor handles this immediately when
+     * running; otherwise the request is recorded for the event stream.
+     */
+    compact(options) {
+        this.store.append({
+            actor_id: "user",
+            type: "COMPACTION_REQUESTED",
+            payload: {
+                reason: options?.reason ?? "manual",
+                token_count: options?.token_count ?? 0,
+            },
+        });
+    }
+    setModel(provider, modelId) {
+        const previous_provider = this.config.model.provider;
+        const previous_model_id = this.config.model.model_id;
+        this.config.model.provider = provider;
+        this.config.model.model_id = modelId;
+        this.store.append({
+            actor_id: "user",
+            type: "MODEL_CHANGED",
+            payload: {
+                provider,
+                model_id: modelId,
+                previous_provider,
+                previous_model_id,
+            },
+        });
+    }
+    getModel() {
+        return { ...this.config.model };
+    }
+    setThinkingLevel(level) {
+        const previous_level = this.config.model.thinking_level;
+        this.config.model.thinking_level = level;
+        this.store.append({
+            actor_id: "user",
+            type: "THINKING_LEVEL_CHANGED",
+            payload: { level, previous_level },
+        });
+    }
+    getThinkingLevel() {
+        return this.config.model.thinking_level;
+    }
+    getProjection() {
+        return this.sessionManager?.getActiveSession() ?? this._createDefaultProjection();
+    }
+    getTools() {
+        return [...this.config.tools];
+    }
+    setTools(tools) {
+        this.config.tools.splice(0, this.config.tools.length, ...tools);
+        this.store.append({
+            actor_id: "user",
+            type: "USER_CONFIG_CHANGE",
+            payload: { key: "tools", old_value: undefined, new_value: tools.map((tool) => tool.name) },
+        });
+    }
+    getSystemPrompt() {
+        return this.config.systemPrompt;
+    }
+    setSystemPrompt(prompt) {
+        const old_value = this.config.systemPrompt;
+        this.config.systemPrompt = prompt;
+        this.store.append({
+            actor_id: "user",
+            type: "USER_CONFIG_CHANGE",
+            payload: { key: "systemPrompt", old_value, new_value: prompt },
+        });
+    }
+    _createDefaultProjection() {
+        const desc = {
+            session_id: "default",
+            thread_id: "default",
+            workspace_id: this.store.workspace_id,
+            event_range: { start_event_id: "ORIGIN", end_event_id: "HEAD" },
+            created_by: "user_explicit",
+            created_at: Date.now(),
+        };
+        return new SessionProjection(this.store, desc);
+    }
+    /**
+     * Wait until the reactor has settled — i.e. an AGENT_TURN_COMPLETED fires AND
+     * no further USER_MESSAGE has been appended in the same tick (e.g. by follow-up draining).
+     */
+    _waitUntilSettled() {
+        return new Promise((resolve) => {
+            this._resolveSettled = resolve;
+            let pendingCheck = false;
+            const unsub = this.store.subscribe(() => {
+                if (pendingCheck)
+                    return;
+                pendingCheck = true;
+                queueMicrotask(() => {
+                    pendingCheck = false;
+                    const followUpsRemaining = this.reactor?.pendingFollowUpCount ?? 0;
+                    if (followUpsRemaining > 0)
+                        return;
+                    const retriesRemaining = this.reactor?.pendingRetryCount ?? 0;
+                    if (retriesRemaining > 0)
+                        return;
+                    const lastMsg = this.store.query({ types: ["USER_MESSAGE"], reverse: true, limit: 1 })[0];
+                    const lastCompleted = this.store.query({
+                        types: ["AGENT_TURN_COMPLETED"],
+                        reverse: true,
+                        limit: 1,
+                    })[0];
+                    if (lastMsg && lastCompleted && lastMsg.sequence > lastCompleted.sequence)
+                        return;
+                    unsub();
+                    resolve();
+                });
+            }, { types: ["AGENT_TURN_COMPLETED"] });
+            this._turnSubscription = unsub;
+        });
+    }
+    /**
+     * Approve a pending intent.
+     */
+    approve(intentEventId) {
+        this.store.append({
+            actor_id: "user",
+            type: "USER_APPROVAL",
+            payload: { intent_event_id: intentEventId },
+        });
+    }
+    /**
+     * Reject a pending intent.
+     */
+    reject(intentEventId) {
+        this.store.append({
+            actor_id: "user",
+            type: "USER_REJECTION",
+            payload: { intent_event_id: intentEventId },
+        });
+    }
+    /**
+     * Subscribe to real-time events (for UI).
+     */
+    subscribe(handler, options) {
+        return this.store.subscribe(handler, options);
+    }
+    /**
+     * Query the activity timeline (for UI rendering).
+     */
+    getTimeline(options) {
+        const projection = new TimelineProjection(this.store);
+        return projection.query(options);
+    }
+    /**
+     * Fork session at a specific event.
+     */
+    fork(eventId) {
+        return this.sessionManager?.forkAt(eventId);
+    }
+    /**
+     * Switch to a different session.
+     */
+    switchSession(sessionId) {
+        this.sessionManager?.switchTo(sessionId);
+    }
+    /**
+     * Create a new session.
+     */
+    createSession(name) {
+        return this.sessionManager?.createSession("user_explicit", name);
+    }
+    /**
+     * Get current session descriptor.
+     */
+    getCurrentSession() {
+        const sessionId = this.sessionManager?.getActiveSessionId();
+        return sessionId ? this.sessionManager?.getSession(sessionId) : undefined;
+    }
+    async createCheckpoint(label) {
+        const checkpoint = await this.runtimeAdapter.createCheckpoint({
+            cwd: this.config.cwd,
+            event_head: this.store.head,
+            event_head_sequence: this.store.head_sequence,
+            label,
+        });
+        this.store.append({
+            actor_id: "runtime",
+            type: "CHECKPOINT_CREATED",
+            payload: checkpoint,
+            caused_by: this.store.head,
+        });
+        return checkpoint;
+    }
+    async restoreCheckpoint(checkpoint) {
+        try {
+            await this.runtimeAdapter.restoreCheckpoint(checkpoint);
+            this.store.append({
+                actor_id: "runtime",
+                type: "CHECKPOINT_RESTORED",
+                payload: checkpoint,
+                caused_by: checkpoint.event_head,
+            });
+        }
+        catch (error) {
+            this.store.append({
+                actor_id: "runtime",
+                type: "CHECKPOINT_FAILED",
+                payload: {
+                    checkpoint,
+                    error_message: error instanceof Error ? error.message : String(error),
+                },
+                caused_by: checkpoint.event_head,
+            });
+            throw error;
+        }
+    }
+    async getRuntimeStatus() {
+        return this.runtimeAdapter.getStatus();
+    }
+    /**
+     * Dispose the runtime.
+     */
+    dispose() {
+        this.sessionManager?.dispose();
+        if (this.ownsStore) {
+            this.store.close?.();
+        }
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create an EventSourcedRuntime from existing components.
+ */
+/**
+ * Create an EventSourcedRuntime from existing components.
+ *
+ * Note: This factory bypasses the constructor to allow injection of
+ * pre-configured EventStore and SessionManager instances.
+ */
+export function createEventSourcedRuntime(store, sessionManager, config) {
+    return new EventSourcedRuntime({
+        cwd: store.workspace_id, // workspace_id is used as cwd proxy
+        store,
+        sessionManager,
+        toolRegistry: config.toolRegistry,
+        classifierConfig: config.classifierConfig,
+        runtimeAdapter: config.runtimeAdapter,
+        approvalHandler: config.approvalHandler,
+        llmClient: config.llmClient,
+        systemPrompt: config.systemPrompt,
+        model: config.model,
+        tools: config.tools,
+        contextBudget: config.contextBudget,
+        retryPolicy: config.retryPolicy,
+        compactionPolicy: config.compactionPolicy,
+        compactionEngineSettings: config.compactionEngineSettings,
+    });
+}

package/dist/core/runtime/types.d.ts

@@ -0,0 +1,42 @@
+import type { EventBase } from "../event-store/types.js";
+import type { ToolExecutionResult, ToolExecutionUpdate } from "../intent/types.js";
+export type RuntimeKind = "local" | "cloud" | "container";
+export interface ToolExecutionRequest {
+    tool_call_id: string;
+    tool_name: string;
+    arguments: Record<string, unknown>;
+    caused_by?: string;
+    signal?: AbortSignal;
+    onUpdate?: (partial: ToolExecutionUpdate) => void;
+}
+export interface CheckpointRequest {
+    cwd: string;
+    event_head?: string;
+    event_head_sequence?: number;
+    label?: string;
+}
+export interface CheckpointRef {
+    checkpoint_id: string;
+    path: string;
+    created_at: number;
+    event_head?: string;
+    event_head_sequence?: number;
+    label?: string;
+}
+export interface RuntimeStatus {
+    runtime_id: string;
+    workspace_id: string;
+    kind: RuntimeKind;
+    cwd: string;
+    status: "idle" | "running" | "paused" | "error";
+}
+export interface RuntimeAdapter {
+    readonly runtime_id: string;
+    readonly workspace_id: string;
+    readonly kind: RuntimeKind;
+    executeTool(request: ToolExecutionRequest): Promise<ToolExecutionResult>;
+    createCheckpoint(request: CheckpointRequest): Promise<CheckpointRef>;
+    restoreCheckpoint(ref: CheckpointRef): Promise<void>;
+    getStatus(): Promise<RuntimeStatus>;
+    subscribeEvents?(after?: string): AsyncIterable<EventBase>;
+}

package/dist/core/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/sdk.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public SDK entry point.
+ *
+ * Exposes `createSessionFacade()` as the primary session creation API,
+ * plus tool factories and type exports for extension development.
+ */
+export { createSessionFacade, type CreateSessionFacadeOptions, type CreateSessionFacadeResult, } from "./session-facade-factory.js";
+export type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ExtensionFactory, SlashCommandInfo, SlashCommandSource, ToolDefinition, } from "./extensions/index.js";
+export type { PromptTemplate } from "./prompt-templates.js";
+export type { Skill } from "./skills.js";
+export type { Tool } from "./tools/index.js";
+export { withFileMutationQueue, createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, } from "./tools/index.js";