@qodo/sdk 0.13.4 → 2.0.0-next.1

package/dist/sdk/QodoSDK.js

@@ -1,1115 +0,0 @@
-import { ConfigManager } from '../config/index.js';
-import { v4 as uuid } from 'uuid';
-import { findNearestAgentConfig } from './discovery.js';
-import { buildDefaultSdkAgentConfig } from './defaults.js';
-import { mcpInitialization, ServerRegistry, ToolProcessorManager } from '../mcp/index.js';
-import { runWithEnvironment, ServerData, SessionContext } from '../session/index.js';
-import { MessageManager } from '../context/index.js';
-import { AgentAPI } from '../api/agent.js';
-import { AgentRunnerCore } from './runner/index.js';
-import { BackendBootstrap } from './bootstrap.js';
-import { AuthProvider } from '../auth/index.js';
-import { QodoInfoClient, QodoSessionsClient, QodoToolsClient } from '../clients/index.js';
-import { canonicalizePathSync, extractSetFlags } from '../utils/index.js';
-import { extractProgress } from './runner/progress.js';
-import { toLangChainDict, toOpenAIChat } from './runner/formats.js';
-import { buildFinalResult, isZodSchema, validateStructuredOutput, QodoOutputValidationError } from './runner/finalize.js';
-import { createSdkEvent, getSdkVersion, SdkEventType, } from './events.js';
-export class QodoSDK {
-    options;
-    /** Backend info (get-things) facade */
-    info;
-    /** Session history facade */
-    sessions;
-    /** Tool discovery facade */
-    tools;
-    initialized = false;
-    // Environment for AsyncLocalStorage-scoped singletons.
-    // Mark as sdkMode to avoid process.exit in SDK code paths.
-    env = {
-        sdkMode: true,
-        sdkDebug: false,
-    };
-    // SDK is headless by default. We avoid writing to stdout/stderr unless
-    // explicitly enabled via options.debug or a provided logger.
-    logger;
-    // Per-run envelope metadata
-    runId = '';
-    seq = 0;
-    runStartMs = 0;
-    sessionContext;
-    lastInitMeta = null;
-    messageManager;
-    agent;
-    core;
-    eventQueue = [];
-    pendingResolvers = [];
-    done = false;
-    activeRuns = 0;
-    // When true, this instance shares MCP with a parent and
-    // dispose() will not tear down MCP servers.
-    isFork = false;
-    _forkParent;
-    _activeForkCount = 0;
-    _listenerCleanups = [];
-    // For `sdk.message.delta`
-    lastAiText = '';
-    lastAiMessageId = '';
-    // Deduplication for tool lifecycle
-    toolRequestedEmitted = new Set();
-    toolApprovalEmitted = new Set();
-    toolApprovalInFlight = new Set();
-    toolExecutedEmitted = new Set();
-    // Track tool names by call id so sdk.tool.executed can include tool_name
-    toolRegistry = new Map();
-    // Per-run Zod schema for runtime validation of structured_output
-    runOutputZodSchema = undefined;
-    constructor(options = {}) {
-        this.options = options;
-        this.info = QodoInfoClient.fromSdkOptions(options);
-        this.sessions = QodoSessionsClient.fromSdkOptions(options);
-        this.tools = QodoToolsClient.fromSdkOptions(options);
-        // If debug is enabled, allow verbose logs in this SDK environment.
-        if (this.options.debug === true) {
-            this.env.sdkDebug = true;
-        }
-        const noop = () => { };
-        const fallback = this.options.debug
-            ? {
-                debug: console.debug.bind(console),
-                info: console.info.bind(console),
-                warn: console.warn.bind(console),
-                error: console.error.bind(console),
-            }
-            : { debug: noop, info: noop, warn: noop, error: noop };
-        this.logger = {
-            debug: this.options.logger?.debug ?? fallback.debug,
-            info: this.options.logger?.info ?? fallback.info,
-            warn: this.options.logger?.warn ?? fallback.warn,
-            error: this.options.logger?.error ?? fallback.error,
-        };
-    }
-    static fromAgent(agentObject, options = {}) {
-        return new QodoSDK({ ...options, agentObject });
-    }
-    /**
-     * Create a new SDK instance that will run using a specific backend session id.
-     *
-     * This is useful for:
-     * - resuming or continuing a known session
-     * - binding a run to a session id created via `sdk.sessions.createSessionId()`
-     *
-     * Note: this returns a NEW SDK instance (does not mutate the current one).
-     */
-    withSession(sessionId) {
-        const nextFlags = { ...(this.options.flags || {}), sid: sessionId };
-        return new QodoSDK({ ...this.options, flags: nextFlags });
-    }
-    /**
-     * Replace the backend session ID on this initialized instance without
-     * reinitializing MCP servers or other resources.
-     *
-     * Intended for long-lived SDK instances (e.g., Slack bots, multi-tenant
-     * servers) that need per-request session isolation while keeping MCP
-     * connections warm.
-     *
-     * If no sessionId is provided, a fresh one is fetched from the backend.
-     * Returns the effective session ID.
-     */
-    async replaceSession(sessionId) {
-        if (!this.initialized) {
-            throw new Error('Cannot replaceSession before SDK is initialized. Call stream/prompt first, or use withSession().');
-        }
-        if (this.isFork) {
-            throw new Error('Cannot replaceSession on a fork. Create a new fork instead.');
-        }
-        if (this.activeRuns > 0) {
-            throw new Error('Cannot replaceSession while a run is in progress. Wait for the current run to complete.');
-        }
-        const newId = sessionId ?? await this.sessions.createSessionId();
-        this.sessionContext.replaceSessionId(newId);
-        return newId;
-    }
-    /**
-     * Create a lightweight SDK clone that shares this instance's MCP servers
-     * but gets its own session, WebSocket, and message state.
-     *
-     * Use this for concurrent request handling (e.g., Slack bots, multi-tenant
-     * servers) where each request needs session isolation but MCP connections
-     * should stay warm.
-     *
-     * The returned fork MUST be disposed after use via `fork.dispose()`.
-     * Disposing a fork tears down its session and WebSocket but leaves the
-     * parent's MCP servers running.
-     *
-     * @param sessionId Optional backend session ID. If omitted, a fresh one is created.
-     */
-    async fork(sessionId) {
-        if (!this.initialized) {
-            throw new Error('Cannot fork before SDK is initialized. Call stream/prompt first.');
-        }
-        if (this.isFork) {
-            throw new Error('Cannot fork a forked instance. Call fork() on the parent SDK instead.');
-        }
-        const child = new QodoSDK({ ...this.options });
-        child.isFork = true;
-        child._forkParent = this;
-        this._activeForkCount++;
-        try {
-            await runWithEnvironment(child.env, async () => {
-                // Share parent's expensive resources (read-only after init)
-                child.env.authProvider = this.env.authProvider;
-                child.env.serverRegistry = this.env.serverRegistry;
-                child.env.mcpManager = this.env.mcpManager;
-                child.env.serverData = this.env.serverData;
-                // Fresh per-request middleware
-                const tpm = new ToolProcessorManager();
-                for (const mw of this.options.toolMiddleware ?? []) {
-                    tpm.addMiddleware(mw);
-                }
-                child.env.toolProcessorManager = tpm;
-                // Fresh session context with a new session ID
-                const newId = sessionId ?? await child.sessions.createSessionId();
-                child.sessionContext = await SessionContext.newSessionContext({ ...this.sessionContext.getFlags() }, { ...this.sessionContext.getCommand() }, this.sessionContext.getGeneralInstructions(), this.sessionContext.getSystemPrompt(), undefined, // forks always start fresh
-                newId);
-                // Replicate parent's path configuration
-                const paths = this.sessionContext.getAccessiblePaths();
-                if (paths.length > 0) {
-                    await child.sessionContext.setAccessiblePaths(paths);
-                }
-                const execCwd = this.sessionContext.getExecutionCwd();
-                if (execCwd) {
-                    child.sessionContext.setExecutionCwd(execCwd);
-                }
-                // Fresh message manager, agent, and core
-                child.messageManager = new MessageManager();
-                child.agent = new AgentAPI(child.sessionContext);
-                child.setupEventListeners();
-                child.core = new AgentRunnerCore(child.sessionContext, child.messageManager, child.agent, () => { }, child.options.autoApproveTools !== false);
-            });
-            child.initialized = true;
-            child.lastInitMeta = this.lastInitMeta;
-            return child;
-        }
-        catch (error) {
-            // Clean up partially constructed fork to avoid resource leaks.
-            // child.dispose() may return early (child not yet initialized),
-            // so always decrement the parent's fork count explicitly.
-            // Clear _forkParent first to prevent double-decrement in dispose().
-            child._forkParent = undefined;
-            this._activeForkCount--;
-            try {
-                await child.dispose();
-            }
-            catch { /* cleanup must not throw */ }
-            throw error;
-        }
-    }
-    /**
-     * Register message, loading, and error listeners on the message manager.
-     * Called during both full initialization and fork setup.
-     */
-    setupEventListeners() {
-        // Clear any previous listener cleanups before registering new ones
-        this._listenerCleanups = [];
-        // Observe message list changes to emit:
-        // - sdk.message.full
-        // - sdk.message.delta (best effort from last AI message)
-        this._listenerCleanups.push(this.messageManager.addMessageListener((messages) => {
-            const lc = toLangChainDict(messages);
-            const openai = toOpenAIChat(messages);
-            const sid = this.sessionContext.getSessionId();
-            this.pushEvent(SdkEventType.MessageFull, sid, {
-                messages: { langchain: lc, openai },
-            });
-            // progress extraction
-            try {
-                const progress = extractProgress(messages);
-                if (progress) {
-                    this.pushEvent(SdkEventType.Progress, sid, { ...progress });
-                }
-            }
-            catch { /* non-fatal: progress extraction is best-effort */ }
-            // tool lifecycle extraction from LangChain dict (AIMessage tool_calls + ToolMessage results)
-            try {
-                this.extractToolLifecycleFromLangChain(lc, sid);
-            }
-            catch { /* non-fatal: tool lifecycle extraction is best-effort */ }
-            // delta: compare last AI message string
-            try {
-                const lastAi = messages
-                    .slice()
-                    .reverse()
-                    .find((m) => m?.constructor?.name === 'AIMessage');
-                const content = lastAi?.content;
-                const text = typeof content === 'string' ? content : '';
-                const messageId = lastAi?.additional_kwargs?.id || lastAi?.id || 'ai';
-                if (messageId !== this.lastAiMessageId) {
-                    this.lastAiMessageId = messageId;
-                    this.lastAiText = '';
-                }
-                if (text.length > this.lastAiText.length && text.startsWith(this.lastAiText)) {
-                    const delta = text.slice(this.lastAiText.length);
-                    if (delta && delta.length > 0) {
-                        this.pushEvent(SdkEventType.MessageDelta, sid, {
-                            message_id: String(messageId),
-                            role: 'assistant',
-                            delta,
-                        });
-                    }
-                }
-                this.lastAiText = text;
-            }
-            catch { /* non-fatal: delta extraction is best-effort */ }
-        }));
-        // Finalization
-        this._listenerCleanups.push(this.messageManager.addLoadingListener(async (isLoading) => {
-            const sid = this.sessionContext.getSessionId();
-            if (!isLoading) {
-                try {
-                    await this.agent.finishCurrentTask(false);
-                }
-                catch { /* best-effort: must not block finalization */ }
-                // AgentRunnerCore already emits final for old SDK, but we produce our own terminal sdk.final here
-                // by reading the message manager state.
-                try {
-                    const finalized = buildFinalResult(this.messageManager);
-                    // Check if there's an error - if so, mark as failure
-                    const currentError = this.messageManager.getError();
-                    const success = !currentError;
-                    // Runtime Zod validation of structured_output when a schema is available
-                    let validatedOutput = finalized.structured_output;
-                    let validationError;
-                    if (validatedOutput !== undefined && isZodSchema(this.runOutputZodSchema)) {
-                        try {
-                            validatedOutput = validateStructuredOutput(this.runOutputZodSchema, validatedOutput);
-                        }
-                        catch (ve) {
-                            if (ve instanceof QodoOutputValidationError) {
-                                validationError = ve.message;
-                            }
-                            else {
-                                validationError = ve instanceof Error ? ve.message : String(ve);
-                            }
-                        }
-                    }
-                    this.pushEvent(SdkEventType.Final, sid, {
-                        success: success && !validationError,
-                        ...(currentError ? { error: currentError } : {}),
-                        ...(validationError ? { error: validationError } : {}),
-                        model: this.sessionContext.getModel(),
-                        result: {
-                            ...(validatedOutput !== undefined ? { structured_output: validatedOutput } : {}),
-                            ...(finalized.final_output ? { final_output: finalized.final_output } : {}),
-                        },
-                        messages: { langchain: finalized.messagesLC, openai: finalized.messagesOpenAI },
-                        meta: {
-                            tools_auto_approved: this.options.autoApproveTools !== false,
-                            subagents_used: finalized.subagentsUsed,
-                            ...(this.sessionContext.isDryRun() ? { dry_run: true } : {}),
-                            ...(() => { const _ee = this.sessionContext?.getCommand?.()?.exit_expression; return _ee ? { exit_expression: _ee } : {}; })(),
-                        },
-                    });
-                    this.done = true;
-                }
-                catch (e) {
-                    this.pushEvent(SdkEventType.Error, sid, { message: e?.message || 'Failed to finalize' });
-                    this.pushEvent(SdkEventType.Final, sid, {
-                        success: false,
-                        error: e?.message || 'Failed to finalize',
-                        model: this.sessionContext.getModel(),
-                        result: {},
-                        messages: { langchain: [], openai: [] },
-                        meta: { tools_auto_approved: this.options.autoApproveTools !== false, subagents_used: false, ...(this.sessionContext.isDryRun() ? { dry_run: true } : {}), ...(() => { const _ee = this.sessionContext?.getCommand?.()?.exit_expression; return _ee ? { exit_expression: _ee } : {}; })() },
-                    });
-                    this.done = true;
-                }
-            }
-        }));
-        this._listenerCleanups.push(this.messageManager.addErrorListener(async (error) => {
-            if (!error)
-                return;
-            const sid = this.sessionContext.getSessionId();
-            this.pushEvent(SdkEventType.Error, sid, { message: error });
-            try {
-                await this.agent.finishCurrentTask(true);
-            }
-            catch { /* best-effort: must not block error handling */ }
-        }));
-        // Protocol-v2 transport lifecycle: surface reconnect, reconcile, and stall
-        // events through the SDK envelope stream. Consumers that only read these
-        // envelopes (no direct WebSocketClient access) can still distinguish a
-        // transient reconnect from a hard stall and respond appropriately.
-        const unsubscribeTransport = this.agent.onTransportEvent({
-            reconnecting: ({ attempt }) => {
-                const sid = this.sessionContext.getSessionId();
-                this.pushEvent(SdkEventType.Reconnecting, sid, { attempt });
-            },
-            reconnected: ({ downtime_ms }) => {
-                const sid = this.sessionContext.getSessionId();
-                this.pushEvent(SdkEventType.Reconnected, sid, { ...(typeof downtime_ms === 'number' ? { downtime_ms } : {}) });
-            },
-            resumeAck: ({ current_checkpoint, last_consumed_turn_id, awaiting, outbox_size }) => {
-                const sid = this.sessionContext.getSessionId();
-                this.pushEvent(SdkEventType.ResumeReconciled, sid, {
-                    ...(current_checkpoint ? { current_checkpoint } : {}),
-                    ...(last_consumed_turn_id ? { last_consumed_turn_id } : {}),
-                    awaiting,
-                    outbox_size,
-                });
-            },
-            reconcileFailed: ({ reason, awaiting }) => {
-                const sid = this.sessionContext.getSessionId();
-                this.pushEvent(SdkEventType.ReconcileFailed, sid, {
-                    reason,
-                    ...(awaiting ? { awaiting } : {}),
-                });
-            },
-            stallDetected: ({ stage, outboxSize }) => {
-                const sid = this.sessionContext.getSessionId();
-                this.pushEvent(SdkEventType.StallDetected, sid, {
-                    stage,
-                    outbox_size: outboxSize,
-                });
-            },
-        });
-        this._listenerCleanups.push(unsubscribeTransport);
-    }
-    pushEvent(type, sessionId, data, opts) {
-        const evt = createSdkEvent({
-            type,
-            run_id: this.runId,
-            seq: ++this.seq,
-            session_id: sessionId,
-            data,
-            ...(opts?.request_id ? { request_id: opts.request_id } : {}),
-            elapsed_ms: this.runStartMs ? Date.now() - this.runStartMs : undefined,
-        });
-        if (this.pendingResolvers.length > 0) {
-            const resolve = this.pendingResolvers.shift();
-            resolve({ value: evt, done: false });
-        }
-        else {
-            this.eventQueue.push(evt);
-        }
-    }
-    async ensureInitialized(desiredCommandName) {
-        if (this.initialized) {
-            // Return previously computed summary; best-effort fallback.
-            if (this.lastInitMeta)
-                return this.lastInitMeta;
-            return { commandName: '', promptMode: false, projectPath: this.options.projectPath ? canonicalizePathSync(this.options.projectPath) : canonicalizePathSync(process.cwd()), agentSource: { source: 'default' } };
-        }
-        // Create environment-scoped auth provider
-        const authProvider = new AuthProvider(this.options.apiKey);
-        this.env.authProvider = authProvider;
-        // Create environment-scoped ToolProcessorManager and register user middleware
-        const tpm = new ToolProcessorManager();
-        if (this.options.toolMiddleware) {
-            for (const mw of this.options.toolMiddleware) {
-                tpm.addMiddleware(mw);
-            }
-        }
-        this.env.toolProcessorManager = tpm;
-        // Init backend get-things (supports baseUrl override)
-        const bootstrap = new BackendBootstrap({ baseUrlOverride: this.options?.backend?.baseUrl });
-        await bootstrap.init();
-        const flags = {
-            ...(this.options.flags || {}),
-            sdk: true,
-            ...(this.options.debug ? { debug: true } : {}),
-            ...(this.options.interactiveMode !== undefined ? { interactiveMode: this.options.interactiveMode } : {}),
-        };
-        if (this.options.model)
-            flags.model = this.options.model;
-        // Resolve effective cwd first (used for agent discovery and tool defaults)
-        const explicitProjectPath = this.options.projectPath ? canonicalizePathSync(this.options.projectPath) : undefined;
-        // Only fallback to process.cwd() here - the single source of truth
-        const effectiveCwd = explicitProjectPath || canonicalizePathSync(process.cwd());
-        // SDK-first agent resolution:
-        // 1) agentObject / agentContent / explicit agentFile
-        // 2) auto-discover agent.toml|yaml|yml from cwd
-        // 3) fallback to built-in minimal config
-        let configInput = this.options.agentObject ?? this.options.agentContent ?? this.options.agentFile;
-        let isFileContent = !!this.options.agentContent || !!this.options.agentObject;
-        let agentSource = { source: 'file' };
-        if (this.options.agentObject)
-            agentSource = { source: 'object' };
-        else if (this.options.agentContent)
-            agentSource = { source: 'content' };
-        else if (this.options.agentFile)
-            agentSource = { source: 'file', path: String(this.options.agentFile) };
-        if (!configInput) {
-            const discovered = await findNearestAgentConfig(effectiveCwd);
-            if (discovered) {
-                configInput = discovered;
-                isFileContent = false;
-                agentSource = { source: 'discovered', path: discovered };
-            }
-            else {
-                configInput = buildDefaultSdkAgentConfig();
-                isFileContent = true;
-                agentSource = { source: 'default' };
-            }
-        }
-        const configManager = await ConfigManager.init(configInput, isFileContent);
-        // Resolve command or mode
-        let modeCommand;
-        if (flags.mode) {
-            modeCommand = configManager.resolveModeAsCommand(flags.mode);
-        }
-        // Determine whether the caller passed a command name or a free-form prompt.
-        // SDK should be "prompt-first": if the provided string is not a known command,
-        // we still build a command config via getCommandConfig(prompt) (which returns
-        // a default config inheriting top-level model/tools) and treat the string as
-        // user prompt.
-        const allCommands = configManager.listCommands();
-        const desiredIsCommand = !!(desiredCommandName && allCommands.includes(desiredCommandName));
-        // If the user provided a command name but there are no commands configured,
-        // we treat it as a prompt (prompt-first behavior). We also synthesize an
-        // internal default command config so execution can proceed.
-        const hasAnyCommands = allCommands.length > 0;
-        // Choose command:
-        // 1) mode (explicit)
-        // 2) if desired name is a known command -> use that command
-        // 3) else if a non-empty prompt was provided -> treat as prompt and build a default command config
-        // 4) else if commands exist -> fallback to flags.command or a single command
-        // 5) else (no commands) -> synthesize default command
-        let command;
-        let cmdName = typeof flags.command === 'string' ? flags.command : configManager.getSingleCommand() || '';
-        let promptMode = false;
-        if (flags.mode) {
-            command = modeCommand;
-            cmdName = flags.mode;
-        }
-        else if (desiredIsCommand) {
-            cmdName = desiredCommandName;
-            command = configManager.getCommandConfig(cmdName);
-        }
-        else if (desiredCommandName && String(desiredCommandName).trim().length > 0) {
-            cmdName = ''; // prompt flow
-            promptMode = true;
-            command = configManager.getCommandConfig(desiredCommandName);
-        }
-        else if (hasAnyCommands) {
-            command = configManager.getCommandConfig(cmdName);
-        }
-        else {
-            // No commands exist: synthesize a default command that inherits top-level
-            // model/tools/mcpServers/etc. Prompt() uses this path.
-            cmdName = '';
-            promptMode = true;
-            command = configManager.getCommandConfig('');
-        }
-        // Tool allow/deny flags
-        if (flags.tools) {
-            command.available_tools = Array.isArray(flags.tools) ? flags.tools : String(flags.tools).split(',').map((s) => s.trim());
-        }
-        if (flags.noTools) {
-            command.ignore_tools = Array.isArray(flags.noTools) ? flags.noTools : String(flags.noTools).split(',').map((s) => s.trim());
-        }
-        // MCP servers
-        const serverRegistry = ServerRegistry.init(this.options.mcpFile);
-        const mcpServers = {
-            ...configManager.getMCPServers(),
-            ...(command?.mcpServers || {}),
-            ...(this.options.mcpServers || {}),
-        };
-        const disableMcp = command.disable_mcp === true || configManager.getRawConfig()?.disable_mcp === true;
-        if (!disableMcp) {
-            serverRegistry.setTomlMCPConfigs(mcpServers);
-        }
-        const generalInstructions = configManager.getGeneralInstructions();
-        const systemPrompt = configManager.getSystemPrompt();
-        this.sessionContext = await SessionContext.newSessionContext(flags, command, generalInstructions, systemPrompt, undefined, flags.sid);
-        // Determine effective working directory
-        // Prefer the earlier effectiveCwd we already computed for agent discovery.
-        const effectiveCwd2 = effectiveCwd;
-        try {
-            this.sessionContext.setExecutionCwd?.(effectiveCwd2);
-        }
-        catch { /* best-effort: method may not exist */ }
-        const roots = [effectiveCwd2, ...((this.options.additionalPaths || []).map((r) => canonicalizePathSync(r)))];
-        try {
-            await this.sessionContext.setAccessiblePaths(roots);
-        }
-        catch { /* best-effort: accessible paths are non-critical */ }
-        if (!disableMcp) {
-            await mcpInitialization();
-        }
-        // Prefetch context summaries from other sessions (equivalent to CLI --with)
-        if (this.options.contextSessionIds && this.options.contextSessionIds.length > 0) {
-            try {
-                const agentTmp = new AgentAPI(this.sessionContext);
-                const { computeNextTaskFocus } = await import('../context/taskFocus.js');
-                const taskFocus = computeNextTaskFocus(command.instructions, '', extractSetFlags(flags));
-                const summaries = await agentTmp.tryPrefetchSummarization(this.options.contextSessionIds, taskFocus);
-                for (const [sid, summary] of Object.entries(summaries)) {
-                    this.sessionContext.addPreviousSessionSummarization(sid, summary);
-                }
-            }
-            catch { /* best-effort: context prefetch failure should not block run */ }
-        }
-        // Per-client message manager and agent
-        this.messageManager = new MessageManager();
-        this.agent = new AgentAPI(this.sessionContext);
-        const backend = ServerData.getInstance();
-        this.pushEvent(SdkEventType.Init, this.sessionContext.getSessionId(), {
-            sdk_version: getSdkVersion(),
-            protocol: 'qodo.sdk.v2',
-            pid: process.pid,
-            backend: {
-                base_url: backend.getBaseUrl(),
-                source: backend.getBaseUrlSource(),
-            },
-            model: this.sessionContext.getModel(),
-        });
-        this.setupEventListeners();
-        this.core = new AgentRunnerCore(this.sessionContext, this.messageManager, this.agent, 
-        // No-op emit: we emit via message manager listeners
-        () => { }, this.options.autoApproveTools !== false);
-        this.initialized = true;
-        this.lastInitMeta = {
-            commandName: cmdName,
-            promptMode,
-            projectPath: effectiveCwd2,
-            agentSource,
-        };
-        return this.lastInitMeta;
-    }
-    async maybeApproveTool(req) {
-        const { sid, tool_call_id } = req;
-        if (this.toolApprovalEmitted.has(tool_call_id) || this.toolApprovalInFlight.has(tool_call_id)) {
-            return;
-        }
-        this.toolApprovalInFlight.add(tool_call_id);
-        let approved = this.options.autoApproveTools !== false;
-        let reason = undefined;
-        if (this.options.autoApproveTools === false) {
-            if (this.options.toolApproval) {
-                try {
-                    const res = await this.options.toolApproval({
-                        tool_call_id: req.tool_call_id,
-                        server_name: req.server_name,
-                        tool_name: req.tool_name,
-                        tool_args: req.tool_args,
-                        reasoning: req.reasoning,
-                    });
-                    approved = !!res;
-                    if (!approved)
-                        reason = 'Declined by toolApproval callback';
-                }
-                catch (e) {
-                    approved = false;
-                    reason = e?.message || 'toolApproval callback threw';
-                }
-            }
-            else {
-                approved = false;
-                reason = 'Auto-approval disabled and no toolApproval callback provided';
-            }
-        }
-        // Emit decision
-        this.pushEvent(SdkEventType.ToolApproved, sid, {
-            tool_call_id,
-            approved,
-            ...(approved ? {} : { reason }),
-        });
-        this.toolApprovalEmitted.add(tool_call_id);
-        // IMPORTANT: respond to backend so the run can continue.
-        try {
-            await this.agent.toolApproval(tool_call_id, approved);
-        }
-        catch (e) {
-            // Surface approval send failures as sdk.error but do not crash the stream.
-            this.pushEvent(SdkEventType.Error, sid, {
-                message: `Failed to submit tool approval for ${tool_call_id}`,
-                cause: e?.message || e,
-            });
-        }
-        finally {
-            this.toolApprovalInFlight.delete(tool_call_id);
-        }
-    }
-    extractToolLifecycleFromLangChain(lcMessages, sid) {
-        for (const msg of lcMessages) {
-            const type = msg?.type;
-            const data = msg?.data;
-            if (!type || !data)
-                continue;
-            // Tool request is represented as AI message with tool_calls
-            if (type === 'ai' && Array.isArray(data.tool_calls) && data.tool_calls.length > 0) {
-                // Determine pending approval from additional_kwargs
-                const pendingApproval = !!data.additional_kwargs?.pending_approval;
-                const serverName = data.additional_kwargs?.server_name || 'unknown';
-                for (const call of data.tool_calls) {
-                    const toolCallId = String(call?.id || data.id || 'unknown');
-                    const toolName = String(call?.name || 'unknown');
-                    const serverStr = String(serverName);
-                    // Record mapping for later sdk.tool.executed
-                    if (toolCallId && toolCallId !== 'unknown') {
-                        this.toolRegistry.set(toolCallId, { server_name: serverStr, tool_name: toolName });
-                    }
-                    // Emit tool.requested once per tool_call_id
-                    if (!this.toolRequestedEmitted.has(toolCallId)) {
-                        this.pushEvent(SdkEventType.ToolRequested, sid, {
-                            tool_call_id: toolCallId,
-                            server_name: serverStr,
-                            tool_name: toolName,
-                            tool_args: call?.args,
-                            reasoning: typeof data.content === 'string' ? data.content : undefined,
-                            pending_approval: pendingApproval,
-                        });
-                        this.toolRequestedEmitted.add(toolCallId);
-                    }
-                    // Approval handling
-                    if (!this.toolApprovalEmitted.has(toolCallId)) {
-                        if (pendingApproval) {
-                            // Approval required: decide and respond via AgentAPI.toolApproval
-                            void this.maybeApproveTool({
-                                sid,
-                                tool_call_id: toolCallId,
-                                server_name: serverStr,
-                                tool_name: toolName,
-                                tool_args: call?.args,
-                                reasoning: typeof data.content === 'string' ? data.content : undefined,
-                            });
-                        }
-                        else {
-                            // No approval required (auto-approved / read-only)
-                            this.pushEvent(SdkEventType.ToolApproved, sid, {
-                                tool_call_id: toolCallId,
-                                approved: true,
-                            });
-                            this.toolApprovalEmitted.add(toolCallId);
-                        }
-                    }
-                }
-            }
-            // Tool execution result is represented as ToolMessage
-            if (type === 'tool') {
-                const toolCallId = String(data.tool_call_id || data.id || 'unknown');
-                if (!this.toolExecutedEmitted.has(toolCallId)) {
-                    const serverName = String(data.additional_kwargs?.server_name || this.toolRegistry.get(toolCallId)?.server_name || 'unknown');
-                    const toolName = String(this.toolRegistry.get(toolCallId)?.tool_name || 'unknown');
-                    const status = data.status;
-                    const dryRun = !!(this.sessionContext?.isDryRun?.());
-                    this.pushEvent(SdkEventType.ToolExecuted, sid, {
-                        tool_call_id: toolCallId,
-                        server_name: serverName,
-                        tool_name: toolName,
-                        result: {
-                            isError: status === 'error',
-                            content: data.content,
-                            raw: data,
-                        },
-                        ...(dryRun ? { dry_run: true } : {}),
-                    });
-                    this.toolExecutedEmitted.add(toolCallId);
-                }
-            }
-        }
-    }
-    async *stream(commandOrPrompt, options) {
-        if (this.activeRuns > 0) {
-            // Initialized parents fork() to share warm MCP connections
-            const delegated = this.initialized ? await this.fork() : new QodoSDK(this.options);
-            try {
-                yield* delegated.stream(commandOrPrompt, options);
-            }
-            finally {
-                try {
-                    await delegated.dispose();
-                }
-                catch { /* cleanup: dispose must not throw in finally */ }
-            }
-            return;
-        }
-        this.activeRuns++;
-        try {
-            this.done = false;
-            this.eventQueue = [];
-            this.pendingResolvers = [];
-            this.lastAiText = '';
-            this.lastAiMessageId = '';
-            this.toolRequestedEmitted.clear();
-            this.toolApprovalEmitted.clear();
-            this.toolApprovalInFlight.clear();
-            this.toolExecutedEmitted.clear();
-            this.toolRegistry.clear();
-            this.runOutputZodSchema = undefined;
-            // Initialize per-run metadata
-            this.runId = uuid();
-            this.seq = 0;
-            this.runStartMs = Date.now();
-            const env = this.env;
-            const self = this;
-            async function* inner() {
-                // If already initialized and user passed a different command name, reinit (same behavior as old QodoClient)
-                if (self.initialized) {
-                    try {
-                        const cm = ConfigManager.getInstance();
-                        const cmds = cm.listCommands();
-                        const isCommand = commandOrPrompt && cmds.includes(commandOrPrompt);
-                        if (isCommand) {
-                            const currentName = (self.sessionContext?.getCommand()?.name) || '';
-                            if (commandOrPrompt !== currentName) {
-                                await self.dispose();
-                            }
-                        }
-                    }
-                    catch { /* best-effort: reinit check should not block new run */ }
-                }
-                let initMeta = null;
-                let initFailed = false;
-                try {
-                    initMeta = await self.ensureInitialized(commandOrPrompt);
-                }
-                catch (e) {
-                    initFailed = true;
-                    // Event-first: initialization errors should produce sdk.error + sdk.final
-                    const sid = '';
-                    self.pushEvent(SdkEventType.Error, sid, {
-                        message: e?.message || String(e),
-                        cause: e?.cause || e,
-                    });
-                    self.pushEvent(SdkEventType.Final, sid, {
-                        success: false,
-                        error: e?.message || String(e),
-                        model: self.options.model || '',
-                        result: {},
-                        messages: { langchain: [], openai: [] },
-                        meta: { tools_auto_approved: self.options.autoApproveTools !== false, subagents_used: false, ...(options?.dryRun ? { dry_run: true } : {}), ...(() => { const _ee = self.sessionContext?.getCommand?.()?.exit_expression; return _ee ? { exit_expression: _ee } : {}; })() },
-                    });
-                    // Do NOT return here – we still want to drain the queued events below.
-                }
-                if (!initFailed) {
-                    // Thread per-run dryRun flag into session context
-                    const isDryRun = !!(options?.dryRun);
-                    try {
-                        self.sessionContext.getFlags().dryRun = isDryRun;
-                    }
-                    catch { /* best-effort: dryRun flag threading is non-critical */ }
-                    // Emit run.started
-                    try {
-                        const sid = self.sessionContext.getSessionId();
-                        self.pushEvent(SdkEventType.RunStarted, sid, {
-                            session_id: sid,
-                            command: initMeta.commandName,
-                            prompt_mode: initMeta.promptMode,
-                            cwd: initMeta.projectPath,
-                            agent: initMeta.agentSource,
-                            tools_auto_approved: self.options.autoApproveTools !== false,
-                            dry_run: isDryRun,
-                        });
-                    }
-                    catch { /* non-fatal: run.started event emission is best-effort */ }
-                }
-                const extra = options?.extraInstructions || '';
-                const args = options?.args || {};
-                // Prompt-first behavior:
-                // - If commandOrPrompt matches a configured command name -> run that command.
-                // - Otherwise treat it as a free-form prompt and pass it as extraInstructions.
-                let prompt;
-                let promptExtra;
-                try {
-                    const cm = ConfigManager.getInstance();
-                    const cmds = cm.listCommands();
-                    if (commandOrPrompt && cmds.includes(commandOrPrompt)) {
-                        prompt = commandOrPrompt;
-                        promptExtra = extra;
-                    }
-                    else {
-                        prompt = '';
-                        promptExtra = commandOrPrompt ? `${commandOrPrompt}${extra ? ` ${extra}` : ''}` : extra;
-                    }
-                }
-                catch {
-                    prompt = '';
-                    promptExtra = commandOrPrompt ? `${commandOrPrompt}${extra ? ` ${extra}` : ''}` : extra;
-                }
-                // Inject dry-run playbook into the prompt so the agent understands
-                // that tool results are simulated and adapts its behaviour.
-                if (options?.dryRun) {
-                    const dryRunPlaybook = [
-                        '',
-                        '--- DRY RUN MODE ---',
-                        'This run is executing in dry-run mode. Important rules:',
-                        '1. Every tool call you make will be intercepted. You will receive simulated (mock) responses marked with "[DRY RUN]".',
-                        '2. Treat simulated results as plausible placeholders — reason about them as if they were real data.',
-                        '3. Continue your analysis normally. Describe what actions you would take and what results you would expect.',
-                        '4. Do NOT tell the user that tools are unavailable or that you cannot access the filesystem. Tools are working — their results are simply simulated.',
-                        '5. In your final answer, clearly summarize the plan of actions you would execute in a real run, including which tools you called and why.',
-                        '--- END DRY RUN MODE ---',
-                        '',
-                    ].join('\n');
-                    promptExtra = promptExtra ? `${promptExtra}\n${dryRunPlaybook}` : dryRunPlaybook;
-                }
-                if (!initFailed) {
-                    try {
-                        // If the command was built with sdkCommand({ args: <zod schema> }), validate args here.
-                        // This keeps v2 behavior strict and provides actionable errors.
-                        try {
-                            const cmdAny = self.sessionContext?.getCommand?.();
-                            const schema = cmdAny?.__sdk?.argsSchema;
-                            if (schema) {
-                                const { parseArgsWithSchema } = await import('./schemas.js');
-                                parseArgsWithSchema(schema, args);
-                            }
-                        }
-                        catch (e) {
-                            throw e;
-                        }
-                        // Resolve Zod schema for runtime validation of structured_output.
-                        // Priority: options.outputSchema (if Zod) > command.__sdk.outputSchema
-                        if (options?.outputSchema && isZodSchema(options.outputSchema)) {
-                            self.runOutputZodSchema = options.outputSchema;
-                        }
-                        else {
-                            const cmdSdk = self.sessionContext?.getCommand?.();
-                            const cmdZod = cmdSdk?.__sdk?.outputSchema;
-                            if (cmdZod && isZodSchema(cmdZod)) {
-                                self.runOutputZodSchema = cmdZod;
-                            }
-                        }
-                        await self.core.start(prompt, promptExtra, args, options?.outputSchema);
-                    }
-                    catch (e) {
-                        const sid = self.sessionContext?.getSessionId() || '';
-                        self.pushEvent(SdkEventType.Error, sid, { message: e?.message || String(e) });
-                        self.pushEvent(SdkEventType.Final, sid, {
-                            success: false,
-                            error: e?.message || String(e),
-                            model: self.sessionContext?.getModel() || '',
-                            result: {},
-                            messages: { langchain: [], openai: [] },
-                            meta: { tools_auto_approved: self.options.autoApproveTools !== false, subagents_used: false, ...(options?.dryRun ? { dry_run: true } : {}), ...(() => { const _ee = self.sessionContext?.getCommand?.()?.exit_expression; return _ee ? { exit_expression: _ee } : {}; })() },
-                        });
-                        // Do not set done=true here; allow the event drain loop to see sdk.final and terminate.
-                    }
-                }
-                while (true) {
-                    if (self.eventQueue.length > 0) {
-                        const ev = self.eventQueue.shift();
-                        // SDK default: keep internal logs muted for the entire stream.
-                        // (Consumers can still write to stdout directly if they need streaming output.)
-                        yield ev;
-                        if (ev.type === SdkEventType.Final) {
-                            self.done = true;
-                            // drain
-                            while (self.eventQueue.length > 0) {
-                                const drained = self.eventQueue.shift();
-                                yield drained;
-                            }
-                            break;
-                        }
-                    }
-                    else {
-                        const next = await new Promise((resolve) => {
-                            self.pendingResolvers.push((res) => {
-                                if (res.done)
-                                    resolve(null);
-                                else
-                                    resolve(res.value);
-                            });
-                            if (self.eventQueue.length > 0) {
-                                const ev = self.eventQueue.shift();
-                                const r = self.pendingResolvers.shift();
-                                if (r)
-                                    r({ value: ev, done: false });
-                            }
-                        });
-                        if (next) {
-                            yield next;
-                            if (next.type === SdkEventType.Final) {
-                                self.done = true;
-                                while (self.eventQueue.length > 0) {
-                                    const drained = self.eventQueue.shift();
-                                    yield drained;
-                                }
-                                break;
-                            }
-                        }
-                    }
-                    // Only terminate once we've yielded sdk.final and there are no queued events left.
-                    // (self.done may flip to true from internal listeners before sdk.final is drained.)
-                    if (self.done && self.eventQueue.length === 0)
-                        break;
-                }
-            }
-            // Set up execution timeout if specified
-            let timeoutTimer;
-            if (options?.timeout && options.timeout > 0) {
-                const timeoutMs = options.timeout;
-                timeoutTimer = setTimeout(() => {
-                    const sid = this.sessionContext?.getSessionId?.() || '';
-                    try {
-                        this.cancel();
-                    }
-                    catch { /* best-effort: cancel must not prevent timeout event emission */ }
-                    this.pushEvent(SdkEventType.Error, sid, {
-                        message: `Execution timed out after ${timeoutMs}ms`,
-                    });
-                    this.pushEvent(SdkEventType.Final, sid, {
-                        success: false,
-                        error: `Execution timed out after ${timeoutMs}ms`,
-                        model: this.sessionContext?.getModel?.() || '',
-                        result: {},
-                        messages: { langchain: [], openai: [] },
-                        meta: {
-                            tools_auto_approved: this.options.autoApproveTools !== false,
-                            subagents_used: false,
-                            timed_out: true,
-                            ...(options?.dryRun ? { dry_run: true } : {}),
-                            ...(() => { const _ee = this.sessionContext?.getCommand?.()?.exit_expression; return _ee ? { exit_expression: _ee } : {}; })(),
-                        },
-                    });
-                }, timeoutMs);
-                // Prevent the timer from keeping the process alive
-                if (typeof timeoutTimer === 'object' && 'unref' in timeoutTimer) {
-                    timeoutTimer.unref();
-                }
-            }
-            try {
-                const innerGen = inner();
-                while (true) {
-                    const { value, done } = await runWithEnvironment(env, () => innerGen.next());
-                    if (done)
-                        return;
-                    yield value;
-                }
-            }
-            finally {
-                if (timeoutTimer !== undefined)
-                    clearTimeout(timeoutTimer);
-            }
-        }
-        finally {
-            this.activeRuns = Math.max(0, this.activeRuns - 1);
-        }
-    }
-    async run(commandOrPrompt, options) {
-        const maxRetries = options?.maxRetries ?? 0;
-        let lastFinal = null;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            lastFinal = null;
-            // On retry attempts, create a fresh SDK instance to get a clean session
-            if (attempt > 0) {
-                try {
-                    await this.dispose();
-                }
-                catch { /* cleanup: dispose must not throw between retries */ }
-            }
-            // Strip maxRetries from inner options to prevent recursive retry
-            const innerOpts = maxRetries > 0
-                ? { ...options, maxRetries: 0 }
-                : options;
-            for await (const ev of this.stream(commandOrPrompt, innerOpts)) {
-                if (ev.type === SdkEventType.Final)
-                    lastFinal = ev.data;
-            }
-            await new Promise((r) => setTimeout(r, 10));
-            // If successful, return immediately
-            if (lastFinal?.success) {
-                return lastFinal;
-            }
-            // If retries remain, loop; otherwise return the last failure
-            if (attempt < maxRetries) {
-                this.logger.info(`[retry] Attempt ${attempt + 1} failed, retrying (${maxRetries - attempt - 1} retries remaining)...`);
-            }
-        }
-        return lastFinal;
-    }
-    /**
-     * SDK-first friendly API: treat input as a free-form prompt (never a command name).
-     */
-    prompt(text, options) {
-        const extraInstructions = text;
-        return this.run('', { ...options, extraInstructions });
-    }
-    /**
-     * SDK-first friendly API: stream events for a free-form prompt.
-     */
-    streamPrompt(text, options) {
-        const extraInstructions = text;
-        return this.stream('', { ...options, extraInstructions });
-    }
-    cancel() {
-        if (!this.initialized)
-            return;
-        this.core.cancel();
-        // AgentRunnerCore.cancel() aborts the agent's AbortController and drops
-        // the WebSocket, but nothing in that path guarantees the stream iterator
-        // ever produces another event. When we cancel during a mid-turn wait
-        // (e.g. the Slack bot's inactivity timer fires because a ToolRequested
-        // was lost in a reconnect), the iterator is blocked on a
-        // ``pendingResolvers`` promise that would otherwise never resolve —
-        // ``for await`` hangs, no final update is written back to the caller,
-        // and the user-visible status message freezes at the last delta.
-        //
-        // Emit a synthetic Error + Final pair so the iterator drains cleanly.
-        // Guarded by ``!this.done`` so a real Final arriving just before cancel
-        // doesn't get clobbered.
-        if (!this.done) {
-            const sid = this.sessionContext?.getSessionId?.() || '';
-            this.pushEvent(SdkEventType.Error, sid, { message: 'Cancelled' });
-            this.pushEvent(SdkEventType.Final, sid, {
-                success: false,
-                error: 'Cancelled',
-                model: this.options.model || '',
-                result: {},
-                messages: { langchain: [], openai: [] },
-                meta: {
-                    tools_auto_approved: this.options.autoApproveTools !== false,
-                    subagents_used: false,
-                    timed_out: true,
-                },
-            });
-        }
-    }
-    async dispose() {
-        if (!this.initialized) {
-            return;
-        }
-        const env = this.env;
-        await runWithEnvironment(env, async () => {
-            try {
-                // Remove event listeners FIRST to prevent stale callbacks during core teardown
-                for (const cleanup of this._listenerCleanups) {
-                    try {
-                        cleanup();
-                    }
-                    catch { /* cleanup must not throw */ }
-                }
-                this._listenerCleanups = [];
-                await this.core.dispose();
-                try {
-                    this.agent.cleanup?.();
-                }
-                catch { /* cleanup: agent teardown must not throw */ }
-                // Forks share the parent's MCP — only the parent should tear it down.
-                if (!this.isFork) {
-                    if (this._activeForkCount > 0) {
-                        this.logger.warn(`[sdk] dispose() called while ${this._activeForkCount} fork(s) are still active. Fork operations may fail.`);
-                    }
-                    try {
-                        const { MCPManager } = await import('../mcp/MCPManager.js');
-                        try {
-                            await MCPManager.getInstance().dispose();
-                        }
-                        catch { /* cleanup: MCP dispose must not throw */ }
-                    }
-                    catch { /* cleanup: MCP import may fail if never initialized */ }
-                }
-                else if (this._forkParent) {
-                    this._forkParent._activeForkCount = Math.max(0, this._forkParent._activeForkCount - 1);
-                    this._forkParent = undefined; // break reference to allow GC and prevent double-decrement
-                }
-            }
-            finally {
-                this.initialized = false;
-            }
-        });
-    }
-}
-//# sourceMappingURL=QodoSDK.js.map