@qodo/sdk 0.1.0

package/dist/sdk/QodoSDK.js

@@ -0,0 +1,786 @@
+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 } 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 { QodoInfoClient, QodoSessionsClient } from '../clients/index.js';
+import { canonicalizePathSync, extractSetFlags } from '../utils/index.js';
+import * as path from 'path';
+import { extractProgress } from './runner/progress.js';
+import { toLangChainDict, toOpenAIChat } from './runner/formats.js';
+import { buildFinalResult } 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;
+    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;
+    // 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();
+    constructor(options = {}) {
+        this.options = options;
+        this.info = QodoInfoClient.fromSdkOptions(options);
+        this.sessions = QodoSessionsClient.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 });
+    }
+    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, cwd: this.options.cwd ? canonicalizePathSync(this.options.cwd) : canonicalizePathSync(process.cwd()), agentSource: { source: 'default' } };
+        }
+        // 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 } : {}),
+        };
+        if (this.options.model)
+            flags.model = this.options.model;
+        // Resolve effective cwd first (used for agent discovery and tool defaults)
+        const explicitCwd = this.options.cwd ? canonicalizePathSync(this.options.cwd) : undefined;
+        const agentFilePathOpt = this.options.agentFile ? canonicalizePathSync(this.options.agentFile) : undefined;
+        const derivedCwd = !explicitCwd && agentFilePathOpt ? path.dirname(agentFilePathOpt) : undefined;
+        const effectiveCwd = explicitCwd || derivedCwd || 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.subagents === true) {
+            const list = command.available_tools;
+            if (Array.isArray(list) && list.length > 0) {
+                const hasSubagents = list.some((t) => String(t).split('.')[0] === 'subagents');
+                if (!hasSubagents) {
+                    command.available_tools = [...list, 'subagents'];
+                }
+            }
+        }
+        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 agentFilePath = this.options.agentFile ? canonicalizePathSync(this.options.agentFile) : undefined;
+        const derivedCwd2 = !explicitCwd && agentFilePath ? path.dirname(agentFilePath) : undefined;
+        const effectiveCwd2 = effectiveCwd || derivedCwd2 || canonicalizePathSync(process.cwd());
+        try {
+            this.sessionContext.setExecutionCwd?.(effectiveCwd2);
+        }
+        catch { }
+        const roots = [effectiveCwd2, ...((this.options.projectRoots || []).map((r) => canonicalizePathSync(r)))];
+        try {
+            await this.sessionContext.setProjectRootPaths(roots);
+        }
+        catch { }
+        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 { }
+        }
+        // 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(),
+        });
+        // Observe message list changes to emit:
+        // - sdk.message.full
+        // - sdk.message.delta (best effort from last AI message)
+        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 { }
+            // tool lifecycle extraction from LangChain dict (AIMessage tool_calls + ToolMessage results)
+            try {
+                this.extractToolLifecycleFromLangChain(lc, sid);
+            }
+            catch { }
+            // 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 { }
+        });
+        // Finalization
+        this.messageManager.addLoadingListener(async (isLoading) => {
+            const sid = this.sessionContext.getSessionId();
+            if (!isLoading) {
+                try {
+                    await this.agent.finishCurrentTask(false);
+                }
+                catch { }
+                // 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);
+                    this.pushEvent(SdkEventType.Final, sid, {
+                        success: true,
+                        model: this.sessionContext.getModel(),
+                        result: {
+                            ...(finalized.structured_output ? { structured_output: finalized.structured_output } : {}),
+                            ...(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.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.done = true;
+                }
+            }
+        });
+        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 { }
+        });
+        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,
+            cwd: 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;
+                    this.pushEvent(SdkEventType.ToolExecuted, sid, {
+                        tool_call_id: toolCallId,
+                        server_name: serverName,
+                        tool_name: toolName,
+                        result: {
+                            isError: status === 'error',
+                            content: data.content,
+                            raw: data,
+                        },
+                    });
+                    this.toolExecutedEmitted.add(toolCallId);
+                }
+            }
+        }
+    }
+    async *stream(commandOrPrompt, options) {
+        if (this.activeRuns > 0) {
+            const delegated = new QodoSDK(this.options);
+            try {
+                yield* delegated.stream(commandOrPrompt, options);
+            }
+            finally {
+                try {
+                    await delegated.dispose();
+                }
+                catch { }
+            }
+            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();
+            // 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 { }
+                }
+                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 },
+                    });
+                    // Do NOT return here – we still want to drain the queued events below.
+                }
+                if (!initFailed) {
+                    // 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.cwd,
+                            agent: initMeta.agentSource,
+                            tools_auto_approved: self.options.autoApproveTools !== false,
+                        });
+                    }
+                    catch { }
+                }
+                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;
+                }
+                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;
+                        }
+                        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 },
+                        });
+                        // 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;
+                }
+            }
+            const innerGen = inner();
+            while (true) {
+                const { value, done } = await runWithEnvironment(env, () => innerGen.next());
+                if (done)
+                    return;
+                yield value;
+            }
+        }
+        finally {
+            this.activeRuns = Math.max(0, this.activeRuns - 1);
+        }
+    }
+    async run(commandOrPrompt, options) {
+        let final = null;
+        for await (const ev of this.stream(commandOrPrompt, options)) {
+            if (ev.type === SdkEventType.Final)
+                final = ev.data;
+        }
+        await new Promise((r) => setTimeout(r, 10));
+        return final;
+    }
+    /**
+     * 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();
+    }
+    async dispose() {
+        if (!this.initialized) {
+            return;
+        }
+        const env = this.env;
+        await runWithEnvironment(env, async () => {
+            try {
+                await this.core.dispose();
+                try {
+                    this.agent.cleanup?.();
+                }
+                catch { }
+                try {
+                    const { MCPManager } = await import('../mcp/MCPManager.js');
+                    try {
+                        await MCPManager.getInstance().dispose();
+                    }
+                    catch { }
+                }
+                catch { }
+            }
+            finally {
+                this.initialized = false;
+            }
+        });
+    }
+}
+//# sourceMappingURL=QodoSDK.js.map