agor-live 0.3.7

package/dist/core/dist/tools/index.d.cts

@@ -0,0 +1,967 @@
+import { d as Message, M as MessageRole } from '../message-BoxZISHg.cjs';
+import { M as MessageID, a as SessionID, T as TaskID } from '../id-DMqyogFB.cjs';
+import { PermissionMode } from '@anthropic-ai/claude-agent-sdk';
+import { f as MessagesRepository, g as SessionRepository, S as SessionMCPServerRepository, M as MCPServerRepository, W as WorktreeRepository } from '../worktrees-BzIxB1U6.cjs';
+import { PermissionService } from '../permissions/index.cjs';
+import { TokenUsage } from '../utils/pricing.cjs';
+import { T as TaskStatus, e as Task } from '../task-BIEgT1DK.cjs';
+export { AVAILABLE_CLAUDE_MODEL_ALIASES, ClaudeModel, DEFAULT_CLAUDE_MODEL } from './claude/models.cjs';
+import { P as PermissionMode$1 } from '../session-BPjJlVdZ.cjs';
+export { CODEX_MINI_MODEL, CODEX_MODELS, DEFAULT_CODEX_MODEL, DEFAULT_GEMINI_MODEL, GEMINI_MODELS, GeminiModel } from './models.cjs';
+import '../repo-3CUrCRbq.cjs';
+import 'drizzle-orm/libsql';
+import 'drizzle-orm/sqlite-core';
+import '../agentic-tool-DsyX8diw.cjs';
+
+/**
+ * Tool Types - Base types for agentic coding tools
+ *
+ * Tools: External agentic coding products (Claude Code, Cursor, Codex, Gemini)
+ * Not to be confused with AI agents (internal personas)
+ */
+
+/**
+ * Supported tool types
+ */
+type ToolType = 'claude-code' | 'cursor' | 'codex' | 'gemini';
+/**
+ * Streaming callback interface for agents that support real-time streaming
+ *
+ * Agents call these callbacks during message generation to provide progressive updates.
+ * If agent doesn't support streaming, it simply calls messagesService.create() at end.
+ *
+ * Example usage:
+ * ```typescript
+ * streamingCallbacks.onStreamStart(messageId, { session_id, task_id, role, timestamp });
+ * // ... stream chunks ...
+ * streamingCallbacks.onStreamChunk(messageId, "Hello world");
+ * streamingCallbacks.onStreamEnd(messageId);
+ * // Then MANDATORY: messagesService.create() with full message
+ * ```
+ */
+interface StreamingCallbacks {
+    /**
+     * Called when message streaming starts
+     *
+     * @param messageId - Unique ID for this message (agent generates via uuidv7)
+     * @param metadata - Initial metadata (role, timestamp, etc.)
+     */
+    onStreamStart(messageId: MessageID, metadata: {
+        session_id: SessionID;
+        task_id?: TaskID;
+        role: MessageRole.ASSISTANT;
+        timestamp: string;
+    }): void;
+    /**
+     * Called for each chunk of streamed content
+     *
+     * Recommended chunk size: 3-10 words for optimal UX/performance balance.
+     * Buffer tokens and flush at sentence boundaries (., !, ?, \n\n) or word count threshold.
+     *
+     * @param messageId - Message being streamed
+     * @param chunk - Text chunk (3-10 words recommended)
+     */
+    onStreamChunk(messageId: MessageID, chunk: string): void;
+    /**
+     * Called when streaming completes successfully
+     *
+     * IMPORTANT: Agent must still call messagesService.create() with full message after this!
+     * This is just a signal to clean up streaming UI state.
+     *
+     * @param messageId - Message that finished streaming
+     */
+    onStreamEnd(messageId: MessageID): void;
+    /**
+     * Called if streaming encounters an error
+     *
+     * @param messageId - Message that failed
+     * @param error - Error that occurred
+     */
+    onStreamError(messageId: MessageID, error: Error): void;
+}
+/**
+ * Tool capabilities - feature flags for what each tool supports
+ */
+interface ToolCapabilities {
+    /** Can import historical sessions from tool's storage */
+    supportsSessionImport: boolean;
+    /** Can create new sessions via SDK/API */
+    supportsSessionCreate: boolean;
+    /** Can send prompts and receive responses */
+    supportsLiveExecution: boolean;
+    /** Can fork sessions at specific points */
+    supportsSessionFork: boolean;
+    /** Can spawn child sessions for subsessions */
+    supportsChildSpawn: boolean;
+    /** Tracks git state natively */
+    supportsGitState: boolean;
+    /**
+     * Streams responses in real-time (optional UX enhancement)
+     *
+     * If true, tool will use StreamingCallbacks during executeTask() to provide
+     * progressive updates. If false, tool will execute synchronously and return
+     * complete message.
+     *
+     * All tools MUST call messagesService.create() with complete message regardless
+     * of streaming support - streaming is purely optional progressive UX.
+     */
+    supportsStreaming: boolean;
+}
+/**
+ * Options for importing sessions
+ */
+interface ImportOptions {
+    /** Project directory (for tools that organize by project) */
+    projectDir?: string;
+    /** Additional tool-specific options */
+    [key: string]: unknown;
+}
+/**
+ * Configuration for creating new sessions
+ */
+interface CreateSessionConfig {
+    /** Initial prompt to send */
+    initialPrompt?: string;
+    /** Working directory for the session */
+    workingDirectory?: string;
+    /** Git reference (branch/commit) to start from */
+    gitRef?: string;
+    /** Concepts to inject as context */
+    concepts?: string[];
+    /** Additional tool-specific config */
+    [key: string]: unknown;
+}
+/**
+ * Session handle - minimal identifier returned after creation/import
+ */
+interface SessionHandle {
+    sessionId: string;
+    toolType: ToolType;
+}
+/**
+ * Session data - rich data from import
+ */
+interface SessionData extends SessionHandle {
+    messages: Message[];
+    metadata: SessionMetadata;
+    workingDirectory?: string;
+}
+/**
+ * Session metadata
+ */
+interface SessionMetadata {
+    sessionId: string;
+    toolType: ToolType;
+    status: 'active' | 'idle' | 'completed' | 'failed';
+    createdAt: Date;
+    lastUpdatedAt: Date;
+    workingDirectory?: string;
+    gitState?: {
+        ref: string;
+        baseSha: string;
+        currentSha: string;
+    };
+    messageCount?: number;
+    taskCount?: number;
+}
+/**
+ * Task execution result
+ */
+interface TaskResult {
+    taskId: string;
+    status: 'completed' | 'failed' | 'cancelled';
+    messages: Message[];
+    error?: Error;
+    completedAt: Date;
+}
+/**
+ * Message range for querying messages
+ */
+interface MessageRange {
+    startIndex?: number;
+    endIndex?: number;
+    limit?: number;
+}
+
+/**
+ * ITool - Base interface for agentic coding tool integrations
+ *
+ * Single unified interface for all tool interactions.
+ * Methods are optional based on tool capabilities.
+ *
+ * Design philosophy:
+ * - Functionality-oriented (what you can DO)
+ * - Optional methods based on capabilities
+ * - Start simple, expand as we learn from multiple tools
+ * - Don't split into Client/Session unless runtime separation is clear
+ */
+
+interface ITool {
+    /** Tool type identifier */
+    readonly toolType: ToolType;
+    /** Human-readable tool name */
+    readonly name: string;
+    /**
+     * Get tool capabilities (feature flags)
+     */
+    getCapabilities(): ToolCapabilities;
+    /**
+     * Check if tool is installed and accessible
+     */
+    checkInstalled(): Promise<boolean>;
+    /**
+     * Import existing session from tool's storage
+     *
+     * Example: Load Claude Code session from ~/.claude/projects/
+     *
+     * @param sessionId - Tool's session identifier
+     * @param options - Import options (e.g., project directory)
+     * @returns Rich session data with messages and metadata
+     */
+    importSession?(sessionId: string, options?: ImportOptions): Promise<SessionData>;
+    /**
+     * Create new session via SDK/API
+     *
+     * @param config - Session configuration
+     * @returns Session handle (minimal identifier)
+     */
+    createSession?(config: CreateSessionConfig): Promise<SessionHandle>;
+    /**
+     * Execute task (send prompt) in existing session
+     *
+     * CONTRACT:
+     * - MANDATORY: Must call messagesService.create() with complete message when done
+     * - MANDATORY: Complete message automatically broadcasts via FeathersJS
+     * - OPTIONAL: If supportsStreaming=true, may call streamingCallbacks during execution
+     *
+     * STREAMING:
+     * - If streamingCallbacks provided AND supportsStreaming=true:
+     *   - Call onStreamStart() before generating
+     *   - Call onStreamChunk() for each 3-10 word chunk
+     *   - Call onStreamEnd() after generating
+     *   - Then create complete message in DB
+     * - If streamingCallbacks not provided OR supportsStreaming=false:
+     *   - Execute synchronously
+     *   - Create complete message in DB
+     *   - User sees loading spinner, then full message
+     *
+     * @param sessionId - Session identifier
+     * @param prompt - User prompt
+     * @param taskId - Task identifier (for linking messages)
+     * @param streamingCallbacks - Optional callbacks for real-time streaming (ignored if !supportsStreaming)
+     * @returns Task result with message IDs
+     */
+    executeTask?(sessionId: string, prompt: string, taskId?: string, streamingCallbacks?: StreamingCallbacks): Promise<TaskResult>;
+    /**
+     * Get session metadata
+     */
+    getSessionMetadata?(sessionId: string): Promise<SessionMetadata>;
+    /**
+     * Get messages from session
+     */
+    getSessionMessages?(sessionId: string, range?: MessageRange): Promise<Message[]>;
+    /**
+     * List all available sessions
+     */
+    listSessions?(): Promise<SessionMetadata[]>;
+    /**
+     * Fork session at specific message index
+     *
+     * Creates divergent exploration path
+     */
+    forkSession?(sessionId: string, atMessageIndex?: number): Promise<SessionHandle>;
+    /**
+     * Spawn child session for subsession
+     *
+     * Creates focused subsession session with minimal context
+     */
+    spawnChildSession?(parentSessionId: string, prompt: string): Promise<SessionHandle>;
+    /**
+     * Stop currently executing task in session
+     *
+     * Gracefully terminates the agent's current execution.
+     * Implementation varies by SDK:
+     * - Claude Agent SDK: Call interrupt() on Query object
+     * - Gemini SDK: Call abort() on AbortController
+     * - Codex SDK: Set stop flag and break event loop
+     *
+     * @param sessionId - Session identifier
+     * @param taskId - Optional task ID to stop (if multiple tasks running)
+     * @returns Success status and partial results if available
+     */
+    stopTask?(sessionId: string, taskId?: string): Promise<{
+        success: boolean;
+        partialResult?: Partial<TaskResult>;
+        reason?: string;
+    }>;
+}
+
+/**
+ * Service interface for creating messages via FeathersJS
+ * This ensures WebSocket events are emitted when messages are created
+ */
+interface MessagesService {
+    create(data: Partial<Message>): Promise<Message>;
+}
+/**
+ * Service interface for updating tasks via FeathersJS
+ * This ensures WebSocket events are emitted when tasks are updated
+ */
+interface TasksService {
+    get(id: string): Promise<any>;
+    patch(id: string, data: Partial<any>): Promise<any>;
+    emit(event: string, data: any): void;
+}
+/**
+ * Service interface for updating sessions via FeathersJS
+ * This ensures WebSocket events are emitted when sessions are updated (e.g., permission config)
+ */
+interface SessionsService {
+    patch(id: string, data: Partial<any>): Promise<any>;
+}
+declare class ClaudeTool implements ITool {
+    private messagesRepo?;
+    private sessionsRepo?;
+    private messagesService?;
+    private tasksService?;
+    readonly toolType: "claude-code";
+    readonly name = "Claude Code";
+    private promptService?;
+    constructor(messagesRepo?: MessagesRepository | undefined, sessionsRepo?: SessionRepository | undefined, apiKey?: string, messagesService?: MessagesService | undefined, sessionMCPRepo?: SessionMCPServerRepository, mcpServerRepo?: MCPServerRepository, permissionService?: PermissionService, tasksService?: TasksService | undefined, sessionsService?: SessionsService, worktreesRepo?: WorktreeRepository);
+    getCapabilities(): ToolCapabilities;
+    checkInstalled(): Promise<boolean>;
+    importSession(sessionId: string, options?: ImportOptions): Promise<SessionData>;
+    /**
+     * Execute a prompt against a session WITH real-time streaming
+     *
+     * Creates user message, streams response chunks from Claude, then creates complete assistant messages.
+     * Calls streamingCallbacks during message generation for real-time UI updates.
+     * Agent SDK may return multiple assistant messages (e.g., tool invocation, then response).
+     *
+     * @param sessionId - Session to execute prompt in
+     * @param prompt - User prompt text
+     * @param taskId - Optional task ID for linking messages
+     * @param permissionMode - Optional permission mode for SDK
+     * @param streamingCallbacks - Optional callbacks for real-time streaming (enables typewriter effect)
+     * @returns User message ID and array of assistant message IDs
+     */
+    executePromptWithStreaming(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode, streamingCallbacks?: StreamingCallbacks): Promise<{
+        userMessageId: MessageID;
+        assistantMessageIds: MessageID[];
+        tokenUsage?: TokenUsage;
+        durationMs?: number;
+        agentSessionId?: string;
+        contextWindow?: number;
+        contextWindowLimit?: number;
+    }>;
+    /**
+     * Create user message in database (from text prompt)
+     * @private
+     */
+    private createUserMessage;
+    /**
+     * Create user message from SDK content (tool results, etc.)
+     * @private
+     */
+    private createUserMessageFromContent;
+    /**
+     * Capture and store Agent SDK session_id for conversation continuity
+     * @private
+     */
+    private captureAgentSessionId;
+    /**
+     * Create complete assistant message in database
+     * @private
+     */
+    private createAssistantMessage;
+    /**
+     * Execute a prompt against a session (non-streaming version)
+     *
+     * Creates user message, streams response from Claude, creates assistant messages.
+     * Agent SDK may return multiple assistant messages (e.g., tool invocation, then response).
+     * Returns user message ID and array of assistant message IDs.
+     *
+     * Also captures and stores the Agent SDK session_id for conversation continuity.
+     */
+    executePrompt(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode): Promise<{
+        userMessageId: MessageID;
+        assistantMessageIds: MessageID[];
+        tokenUsage?: TokenUsage;
+        durationMs?: number;
+        agentSessionId?: string;
+        contextWindow?: number;
+        contextWindowLimit?: number;
+    }>;
+    /**
+     * Stop currently executing task in session
+     *
+     * Uses Claude Agent SDK's native interrupt() method to gracefully stop execution.
+     *
+     * @param sessionId - Session identifier
+     * @param taskId - Optional task ID (not used for Claude, session-level stop)
+     * @returns Success status and reason if failed
+     */
+    stopTask(sessionId: string, taskId?: string): Promise<{
+        success: boolean;
+        partialResult?: Partial<{
+            taskId: string;
+            status: 'completed' | 'failed' | 'cancelled';
+        }>;
+        reason?: string;
+    }>;
+}
+
+/**
+ * Claude Code transcript parser
+ *
+ * Parses JSONL transcript files from ~/.claude/projects/
+ */
+interface TranscriptMessage {
+    type: 'user' | 'assistant' | 'system' | 'file-history-snapshot';
+    uuid?: string;
+    sessionId?: string;
+    timestamp?: string;
+    parentUuid?: string | null;
+    cwd?: string;
+    gitBranch?: string;
+    version?: string;
+    message?: {
+        role: string;
+        content: string | Array<{
+            type: string;
+            [key: string]: unknown;
+        }>;
+    };
+    isMeta?: boolean;
+    isSidechain?: boolean;
+    messageId?: string;
+    snapshot?: unknown;
+    isSnapshotUpdate?: boolean;
+}
+/**
+ * Get transcript file path for a session ID
+ */
+declare function getTranscriptPath(sessionId: string, projectDir?: string): string;
+/**
+ * Parse JSONL transcript file
+ */
+declare function parseTranscript(transcriptPath: string): Promise<TranscriptMessage[]>;
+/**
+ * Load transcript for a session ID
+ */
+declare function loadSessionTranscript(sessionId: string, projectDir?: string): Promise<TranscriptMessage[]>;
+/**
+ * Filter transcript messages (exclude meta messages, snapshots, etc.)
+ */
+declare function filterConversationMessages(messages: TranscriptMessage[]): TranscriptMessage[];
+/**
+ * Build conversation tree from transcript messages
+ */
+interface ConversationNode {
+    message: TranscriptMessage;
+    children: ConversationNode[];
+}
+declare function buildConversationTree(messages: TranscriptMessage[]): ConversationNode[];
+
+/**
+ * Load Claude Code session by parsing transcript file
+ *
+ * Strategy:
+ * 1. Locate transcript file in ~/.claude/projects/{project-slug}/{session-id}.jsonl
+ * 2. Parse the JSONL file to get full message history
+ */
+
+interface ClaudeSession {
+    sessionId: string;
+    transcriptPath: string;
+    cwd: string | null;
+    messages: TranscriptMessage[];
+}
+/**
+ * Load a Claude Code session by ID
+ *
+ * Parses the JSONL transcript file from ~/.claude/projects/
+ */
+declare function loadClaudeSession(sessionId: string, projectDir?: string): Promise<ClaudeSession>;
+
+/**
+ * Convert Claude transcript messages to Agor Message format
+ */
+
+/**
+ * Convert a transcript message to an Agor Message
+ */
+declare function transcriptToMessage(transcript: TranscriptMessage, sessionId: SessionID, index: number): Message;
+/**
+ * Convert array of transcript messages to Agor Messages
+ */
+declare function transcriptsToMessages(transcripts: TranscriptMessage[], sessionId: SessionID): Message[];
+
+/**
+ * Extract Tasks from Claude Code conversation messages
+ *
+ * Converts user messages into Task records with message ranges.
+ */
+
+interface ExtractedTask {
+    task_id: string;
+    session_id: SessionID;
+    full_prompt: string;
+    description: string;
+    status: typeof TaskStatus.COMPLETED;
+    message_range: {
+        start_index: number;
+        end_index: number;
+        start_timestamp: string;
+        end_timestamp?: string;
+    };
+    git_state: {
+        sha_at_start: string;
+    };
+    model: string;
+    tool_use_count: number;
+    created_at: string;
+    completed_at?: string;
+}
+/**
+ * Extract tasks from conversation messages
+ * Each user message becomes a task with its associated assistant responses
+ */
+declare function extractTasksFromMessages(messages: Message[], sessionId: SessionID): Partial<Task>[];
+
+/**
+ * Session Context Injection
+ *
+ * Appends Agor-specific context to CLAUDE.md for session awareness.
+ * IMPORTANT: Appends to existing CLAUDE.md, does not replace it.
+ */
+
+/**
+ * Generate Agor session context block to append to CLAUDE.md
+ */
+declare function generateSessionContext(sessionId: SessionID): string;
+/**
+ * Append session context to CLAUDE.md in a worktree
+ *
+ * CRITICAL: This APPENDS to existing CLAUDE.md, never replaces it!
+ * This ensures we don't overwrite the Claude Code system prompt.
+ */
+declare function appendSessionContextToCLAUDEmd(worktreePath: string, sessionId: SessionID): Promise<void>;
+/**
+ * Remove session context from CLAUDE.md (cleanup)
+ */
+declare function removeSessionContextFromCLAUDEmd(worktreePath: string): Promise<void>;
+
+/**
+ * Codex Tool Implementation
+ *
+ * Current capabilities:
+ * - ✅ Live execution via OpenAI Codex SDK
+ * - ❌ Import sessions (deferred - need real session JSONL format)
+ * - ❌ Session creation (handled via live execution)
+ */
+
+declare class CodexTool implements ITool {
+    private messagesRepo?;
+    private sessionsRepo?;
+    private messagesService?;
+    private tasksService?;
+    readonly toolType: "codex";
+    readonly name = "OpenAI Codex";
+    private promptService?;
+    constructor(messagesRepo?: MessagesRepository | undefined, sessionsRepo?: SessionRepository | undefined, apiKey?: string, messagesService?: MessagesService | undefined, tasksService?: TasksService | undefined);
+    getCapabilities(): ToolCapabilities;
+    checkInstalled(): Promise<boolean>;
+    /**
+     * Execute a prompt against a session WITH real-time streaming
+     *
+     * Creates user message, streams response chunks from Codex, then creates complete assistant messages.
+     * Calls streamingCallbacks during message generation for real-time UI updates.
+     *
+     * @param sessionId - Session to execute prompt in
+     * @param prompt - User prompt text
+     * @param taskId - Optional task ID for linking messages
+     * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+     * @param streamingCallbacks - Optional callbacks for real-time streaming (enables typewriter effect)
+     * @returns User message ID and array of assistant message IDs
+     */
+    executePromptWithStreaming(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode$1, streamingCallbacks?: StreamingCallbacks): Promise<{
+        userMessageId: MessageID;
+        assistantMessageIds: MessageID[];
+    }>;
+    /**
+     * Create user message in database
+     * @private
+     */
+    private createUserMessage;
+    /**
+     * Capture and store Codex thread ID for conversation continuity
+     * @private
+     */
+    private captureThreadId;
+    /**
+     * Create complete assistant message in database
+     * @private
+     */
+    private createAssistantMessage;
+    /**
+     * Execute a prompt against a session (non-streaming version)
+     *
+     * Creates user message, collects response from Codex, creates assistant messages.
+     * Returns user message ID and array of assistant message IDs.
+     *
+     * @param sessionId - Session to execute prompt in
+     * @param prompt - User prompt text
+     * @param taskId - Optional task ID for linking messages
+     * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+     */
+    executePrompt(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode$1): Promise<{
+        userMessageId: MessageID;
+        assistantMessageIds: MessageID[];
+    }>;
+    /**
+     * Stop currently executing task in session
+     *
+     * Uses a flag-based approach to break the event loop on the next iteration.
+     *
+     * @param sessionId - Session identifier
+     * @param taskId - Optional task ID (not used for Codex, session-level stop)
+     * @returns Success status and reason if failed
+     */
+    stopTask(sessionId: string, taskId?: string): Promise<{
+        success: boolean;
+        partialResult?: Partial<{
+            taskId: string;
+            status: 'completed' | 'failed' | 'cancelled';
+        }>;
+        reason?: string;
+    }>;
+}
+
+/**
+ * Codex Prompt Service
+ *
+ * Handles live execution of prompts against Codex sessions using OpenAI Codex SDK.
+ * Wraps the @openai/codex-sdk for thread management and execution.
+ */
+
+interface CodexPromptResult {
+    /** Complete assistant response from Codex */
+    messages: Array<{
+        content: Array<{
+            type: string;
+            text?: string;
+            id?: string;
+            name?: string;
+            input?: Record<string, unknown>;
+        }>;
+        toolUses?: Array<{
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        }>;
+    }>;
+    /** Number of input tokens */
+    inputTokens: number;
+    /** Number of output tokens */
+    outputTokens: number;
+    /** Agent SDK thread ID for conversation continuity */
+    threadId: string;
+}
+/**
+ * Streaming event types for Codex execution
+ */
+type CodexStreamEvent = {
+    type: 'partial';
+    textChunk: string;
+    threadId?: string;
+    resolvedModel?: string;
+} | {
+    type: 'tool_start';
+    toolUse: {
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    };
+    threadId?: string;
+} | {
+    type: 'tool_complete';
+    toolUse: {
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+        output?: string;
+        status?: string;
+    };
+    threadId?: string;
+} | {
+    type: 'complete';
+    content: Array<{
+        type: string;
+        text?: string;
+        id?: string;
+        name?: string;
+        input?: Record<string, unknown>;
+    }>;
+    toolUses?: Array<{
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }>;
+    threadId: string;
+    resolvedModel?: string;
+};
+declare class CodexPromptService {
+    private sessionsRepo;
+    private codex;
+    private lastApprovalPolicy;
+    private stopRequested;
+    constructor(_messagesRepo: MessagesRepository, sessionsRepo: SessionRepository, apiKey?: string);
+    /**
+     * Generate ~/.codex/config.toml for approval_policy setting
+     *
+     * NOTE: approval_policy cannot be passed via ThreadOptions, so we must use config.toml.
+     * We minimize file writes by tracking the last set value and only updating when it changes.
+     */
+    private ensureApprovalPolicy;
+    /**
+     * Convert Codex item to ToolUse format
+     * Maps different Codex item types to Agor tool use schema
+     */
+    private itemToToolUse;
+    /**
+     * Execute prompt with streaming support
+     *
+     * Uses Codex SDK's runStreamed() method for real-time event streaming.
+     * Yields partial text chunks and complete messages.
+     *
+     * @param sessionId - Agor session ID
+     * @param prompt - User prompt
+     * @param taskId - Optional task ID
+     * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+     * @returns Async generator of streaming events
+     */
+    promptSessionStreaming(sessionId: SessionID, prompt: string, _taskId?: TaskID, permissionMode?: PermissionMode$1): AsyncGenerator<CodexStreamEvent>;
+    /**
+     * Execute prompt (non-streaming version)
+     *
+     * Collects all streaming events and returns complete result.
+     *
+     * @param sessionId - Agor session ID
+     * @param prompt - User prompt
+     * @param taskId - Optional task ID
+     * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+     * @returns Complete prompt result
+     */
+    promptSession(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode$1): Promise<CodexPromptResult>;
+    /**
+     * Stop currently executing task
+     *
+     * Sets a stop flag that is checked in the event loop.
+     * The loop will break on the next iteration, stopping execution gracefully.
+     *
+     * @param sessionId - Session identifier
+     * @returns Success status
+     */
+    stopTask(sessionId: SessionID): {
+        success: boolean;
+        reason?: string;
+    };
+}
+
+/**
+ * Gemini Tool Implementation
+ *
+ * Current capabilities:
+ * - ✅ Live execution via @google/gemini-cli-core SDK
+ * - ✅ Token-level streaming with AsyncGenerator
+ * - ✅ Permission modes (ask, auto, allow-all)
+ * - ✅ Session continuity via setHistory()
+ * - ❌ Import sessions (deferred - need checkpoint format)
+ * - ❌ Session creation (handled via live execution)
+ */
+
+declare class GeminiTool implements ITool {
+    private messagesRepo?;
+    private messagesService?;
+    private tasksService?;
+    readonly toolType: "gemini";
+    readonly name = "Google Gemini";
+    private promptService?;
+    constructor(messagesRepo?: MessagesRepository | undefined, sessionsRepo?: SessionRepository, apiKey?: string, messagesService?: MessagesService | undefined, tasksService?: TasksService | undefined);
+    getCapabilities(): ToolCapabilities;
+    checkInstalled(): Promise<boolean>;
+    /**
+     * Execute a prompt against a session WITH real-time streaming
+     *
+     * Creates user message, streams response chunks from Gemini, then creates complete assistant messages.
+     * Calls streamingCallbacks during message generation for real-time UI updates.
+     *
+     * @param sessionId - Session to execute prompt in
+     * @param prompt - User prompt text
+     * @param taskId - Optional task ID for linking messages
+     * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+     * @param streamingCallbacks - Optional callbacks for real-time streaming (enables typewriter effect)
+     * @returns User message ID and array of assistant message IDs
+     */
+    executePromptWithStreaming(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode$1, streamingCallbacks?: StreamingCallbacks): Promise<{
+        userMessageId: MessageID;
+        assistantMessageIds: MessageID[];
+    }>;
+    /**
+     * Create user message in database
+     * @private
+     */
+    private createUserMessage;
+    /**
+     * Create complete assistant message in database
+     * @private
+     */
+    private createAssistantMessage;
+    /**
+     * Execute a prompt against a session (non-streaming version)
+     *
+     * Creates user message, collects response from Gemini, creates assistant messages.
+     * Returns user message ID and array of assistant message IDs.
+     *
+     * @param sessionId - Session to execute prompt in
+     * @param prompt - User prompt text
+     * @param taskId - Optional task ID for linking messages
+     * @param permissionMode - Permission mode for tool execution ('ask' | 'auto' | 'allow-all')
+     */
+    executePrompt(sessionId: SessionID, prompt: string, taskId?: TaskID, permissionMode?: PermissionMode$1): Promise<{
+        userMessageId: MessageID;
+        assistantMessageIds: MessageID[];
+    }>;
+    /**
+     * Stop currently executing task in session
+     *
+     * Uses AbortController to gracefully cancel the streaming request.
+     *
+     * @param sessionId - Session identifier
+     * @param taskId - Optional task ID (not used for Gemini, session-level stop)
+     * @returns Success status and reason if failed
+     */
+    stopTask(sessionId: string, taskId?: string): Promise<{
+        success: boolean;
+        partialResult?: Partial<{
+            taskId: string;
+            status: 'completed' | 'failed' | 'cancelled';
+        }>;
+        reason?: string;
+    }>;
+}
+
+/**
+ * Gemini Prompt Service - Handles live execution via @google/gemini-cli-core SDK
+ *
+ * Features:
+ * - Token-level streaming via AsyncGenerator
+ * - Session continuity via setHistory()
+ * - Permission modes (DEFAULT, AUTO_EDIT, YOLO)
+ * - Event-driven architecture (13 event types)
+ * - CLAUDE.md auto-loading
+ */
+
+/**
+ * Streaming event types for prompt service consumers
+ */
+type GeminiStreamEvent = {
+    type: 'partial';
+    textChunk: string;
+    resolvedModel?: string;
+    sessionId?: string;
+} | {
+    type: 'complete';
+    content: Array<{
+        type: string;
+        text?: string;
+        id?: string;
+        name?: string;
+        input?: Record<string, unknown>;
+    }>;
+    toolUses?: Array<{
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }>;
+    resolvedModel?: string;
+    sessionId?: string;
+} | {
+    type: 'tool_start';
+    toolName: string;
+    toolInput: Record<string, unknown>;
+} | {
+    type: 'tool_complete';
+    toolName: string;
+    result: unknown;
+};
+declare class GeminiPromptService {
+    private sessionsRepo;
+    private sessionClients;
+    private activeControllers;
+    constructor(_messagesRepo: MessagesRepository, sessionsRepo: SessionRepository, _apiKey?: string);
+    /**
+     * Execute prompt with streaming via @google/gemini-cli-core SDK
+     *
+     * @param sessionId - Agor session ID
+     * @param prompt - User prompt text
+     * @param taskId - Optional task ID for message linking
+     * @param permissionMode - Agor permission mode ('ask' | 'auto' | 'allow-all')
+     * @yields Streaming events (partial chunks and complete messages)
+     */
+    promptSessionStreaming(sessionId: SessionID, prompt: string, _taskId?: TaskID, permissionMode?: PermissionMode$1): AsyncGenerator<GeminiStreamEvent>;
+    /**
+     * Load session file from SDK's filesystem storage
+     *
+     * Searches for session file in ~/.gemini/tmp/{projectHash}/chats/
+     * matching pattern: session-*-{sessionId-first8}.json
+     */
+    private loadSessionFile;
+    /**
+     * Get or create GeminiClient for a session
+     *
+     * Manages client lifecycle and session continuity via history restoration.
+     */
+    private getOrCreateClient;
+    /**
+     * Map Agor permission mode to Gemini ApprovalMode
+     *
+     * Gemini SDK supports 3 modes:
+     * - DEFAULT: Prompt for each tool use
+     * - AUTO_EDIT: Auto-approve file edits, prompt for shell/web commands
+     * - YOLO: Auto-approve all operations
+     */
+    private mapPermissionMode;
+    /**
+     * Convert SDK's ConversationRecord to Gemini Content[] format
+     *
+     * This converts the SDK's session file format into the API format needed for setHistory()
+     */
+    private convertConversationToHistory;
+    /**
+     * Update session history after turn completion
+     *
+     * The SDK's ChatRecordingService automatically persists to filesystem,
+     * so we just log for debugging purposes.
+     */
+    private updateSessionHistory;
+    /**
+     * Stop currently executing task
+     *
+     * Calls abort() on the AbortController to gracefully stop streaming.
+     *
+     * @param sessionId - Session identifier
+     * @returns Success status
+     */
+    stopTask(sessionId: SessionID): {
+        success: boolean;
+        reason?: string;
+    };
+    /**
+     * Clean up client for a session (e.g., on session close)
+     */
+    closeSession(sessionId: SessionID): Promise<void>;
+}
+
+export { type ClaudeSession, ClaudeTool, type CodexPromptResult, CodexPromptService, type CodexStreamEvent, CodexTool, type ConversationNode, type CreateSessionConfig, type ExtractedTask, GeminiPromptService, type GeminiStreamEvent, GeminiTool, type ITool, type ImportOptions, type MessageRange, type MessagesService, type SessionData, type SessionHandle, type SessionMetadata, type SessionsService, type StreamingCallbacks, type TaskResult, type TasksService, type ToolCapabilities, type ToolType, type TranscriptMessage, appendSessionContextToCLAUDEmd, buildConversationTree, extractTasksFromMessages, filterConversationMessages, generateSessionContext, getTranscriptPath, loadClaudeSession, loadSessionTranscript, parseTranscript, removeSessionContextFromCLAUDEmd, transcriptToMessage, transcriptsToMessages };