dexto 1.13.5 → 1.14.0

package/dist/cli/commands/mcp/standalone.js

@@ -0,0 +1,489 @@
+import { readFile, mkdir, open, rename, rm, lstat, writeFile, unlink, } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { resolve, dirname } from 'node:path';
+import { parseDocument } from 'yaml';
+import { z } from 'zod';
+import { StdioServerConfigSchema, HttpServerConfigSchema, SseServerConfigSchema, McpServerConfigSchema, MCPManager, MCPError, } from '@dexto/core/mcp';
+import { DextoLogger, DextoLogComponent } from '@dexto/core/logger';
+const configWriteFailureMessage = 'Cannot write MCP configuration. Use a regular file in a writable directory.';
+// Configuration edits keep templates literal; Core expands them at connection time.
+const literalString = z.string();
+const literalMap = z.record(z.string(), literalString);
+const storedServerSchema = z.discriminatedUnion('type', [
+    StdioServerConfigSchema.extend({
+        command: literalString.min(1),
+        args: z.array(literalString).default([]),
+        env: literalMap.default({}),
+    }),
+    HttpServerConfigSchema.extend({ url: literalString.min(1), headers: literalMap.default({}) }),
+    SseServerConfigSchema.extend({ url: literalString.min(1), headers: literalMap.default({}) }),
+]);
+const documentSchema = z
+    .object({ mcpServers: z.record(z.string(), storedServerSchema).default({}) })
+    .passthrough();
+export async function runStandaloneMcp(command, options) {
+    if ('server' in command && command.server.trim().length === 0) {
+        return {
+            exitCode: 2,
+            output: {
+                error: { code: 'invalid_server_name', message: 'Server name must not be blank.' },
+            },
+        };
+    }
+    const configPath = resolve(options.config ?? '.dexto/mcp.yml');
+    try {
+        if (command.command === 'add' || command.command === 'remove')
+            return await editMcpConfiguration(command, configPath);
+        const { servers } = await loadStandaloneMcpConfiguration(configPath, false);
+        const config = { mcpServers: servers };
+        if (command.command !== 'list') {
+            const server = config.mcpServers[command.server];
+            if (!server || !Object.hasOwn(config.mcpServers, command.server))
+                return {
+                    exitCode: 2,
+                    output: {
+                        error: { code: 'server_not_found', message: 'Server is not configured.' },
+                    },
+                };
+            if (!server.enabled)
+                return {
+                    exitCode: 2,
+                    output: { error: { code: 'server_disabled', message: 'Server is disabled.' } },
+                };
+            if (command.command === 'get-prompt') {
+                let args;
+                try {
+                    args = z
+                        .record(z.string(), z.string())
+                        .parse(JSON.parse(command.argumentsJson));
+                }
+                catch {
+                    return {
+                        exitCode: 2,
+                        output: {
+                            error: {
+                                code: 'invalid_arguments',
+                                message: 'Prompt arguments must be a valid JSON object of strings.',
+                            },
+                        },
+                    };
+                }
+                return await runMcpOperation({
+                    command: 'get-prompt',
+                    server: command.server,
+                    prompt: command.prompt,
+                    arguments: args,
+                }, McpServerConfigSchema.parse(server), {});
+            }
+            let args = {};
+            if (command.command === 'call') {
+                try {
+                    args = z
+                        .record(z.string(), z.unknown())
+                        .parse(JSON.parse(command.argumentsJson));
+                }
+                catch {
+                    return {
+                        exitCode: 2,
+                        output: {
+                            error: {
+                                code: 'invalid_arguments',
+                                message: 'Tool arguments must be a valid JSON object.',
+                            },
+                        },
+                    };
+                }
+            }
+            return await runMcpOperation(command, McpServerConfigSchema.parse(server), args);
+        }
+        return {
+            exitCode: 0,
+            output: {
+                servers: Object.entries(config.mcpServers).map(([name, server]) => ({
+                    name,
+                    type: server.type,
+                    enabled: server.enabled,
+                    status: server.enabled ? 'configured' : 'disabled',
+                })),
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof McpConfigurationError)
+            return { exitCode: 2, output: { error: { code: error.code, message: error.message } } };
+        if (typeof error === 'object' && error !== null && 'code' in error)
+            return {
+                exitCode: 2,
+                output: {
+                    error: {
+                        code: 'config_write_failed',
+                        message: configWriteFailureMessage,
+                    },
+                },
+            };
+        return {
+            exitCode: 2,
+            output: {
+                error: { code: 'invalid_config', message: 'Cannot validate MCP configuration.' },
+            },
+        };
+    }
+}
+async function rejectMcpConfigurationSymlink(path) {
+    try {
+        if ((await lstat(path)).isSymbolicLink())
+            throw new McpConfigurationError('config_write_failed', configWriteFailureMessage);
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
+/** Replace POSIX files privately; retain Windows in-place permissions. */
+async function writeMcpConfiguration(path, content) {
+    if (process.platform === 'win32') {
+        await rejectMcpConfigurationSymlink(path);
+        await writeFile(path, content, { mode: 0o600 });
+        return;
+    }
+    const temporaryPath = `${path}.${randomUUID()}.tmp`;
+    const file = await open(temporaryPath, 'wx', 0o600);
+    try {
+        await file.chmod(0o600);
+        await file.writeFile(content, 'utf8');
+        await file.close();
+        await rejectMcpConfigurationSymlink(path);
+        await rename(temporaryPath, path);
+    }
+    catch (error) {
+        await file.close().catch(() => undefined);
+        await rm(temporaryPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function editMcpConfiguration(command, configPath) {
+    const lockPath = `${configPath}.lock`;
+    if (command.command === 'add')
+        await mkdir(dirname(configPath), { recursive: true });
+    const editLock = await open(lockPath, 'wx', 0o600).catch((error) => {
+        if (typeof error === 'object' && error !== null && 'code' in error) {
+            if (error.code === 'EEXIST')
+                throw new McpConfigurationError('config_busy', 'MCP configuration is being edited. Retry after the current edit completes.');
+            if (command.command === 'remove' && error.code === 'ENOENT')
+                throw new McpConfigurationError('config_read_failed', 'Cannot read MCP configuration. Check --config and file permissions.');
+        }
+        throw error;
+    });
+    let committed = false;
+    try {
+        await rejectMcpConfigurationSymlink(configPath);
+        const { document, servers } = await loadStandaloneMcpConfiguration(configPath, command.command === 'add');
+        if (command.command === 'remove') {
+            if (!Object.hasOwn(servers, command.server))
+                return {
+                    exitCode: 2,
+                    output: {
+                        error: { code: 'server_not_found', message: 'Server is not configured.' },
+                    },
+                };
+            document.deleteIn(['mcpServers', command.server]);
+            await writeMcpConfiguration(configPath, document.toString());
+            committed = true;
+            return { exitCode: 0, output: { server: command.server, status: 'removed' } };
+        }
+        let raw;
+        try {
+            raw = JSON.parse(command.serverConfig);
+            storedServerSchema.parse(raw);
+        }
+        catch {
+            return {
+                exitCode: 2,
+                output: {
+                    error: {
+                        code: 'invalid_server_config',
+                        message: 'Server configuration must be a valid MCP server JSON object.',
+                    },
+                },
+            };
+        }
+        if (Object.hasOwn(servers, command.server) && !command.replace)
+            return {
+                exitCode: 2,
+                output: {
+                    error: {
+                        code: 'duplicate_server',
+                        message: 'Server already configured. Use --replace to overwrite it.',
+                    },
+                },
+            };
+        document.setIn(['mcpServers', command.server], raw);
+        await writeMcpConfiguration(configPath, document.toString());
+        committed = true;
+        return { exitCode: 0, output: { server: command.server, status: 'configured' } };
+    }
+    finally {
+        await releaseMcpConfigurationEditLock(editLock, lockPath, committed);
+    }
+}
+async function releaseMcpConfigurationEditLock(editLock, lockPath, committed) {
+    try {
+        try {
+            await editLock.close();
+        }
+        finally {
+            await unlink(lockPath);
+        }
+    }
+    catch {
+        // Failed edits retain their original error; committed edits must surface cleanup failure.
+        if (committed)
+            throw new McpConfigurationError('config_lock_cleanup_failed', 'MCP configuration edit cleanup failed. The edit may already have committed; inspect the configuration before retrying or removing its lock.');
+    }
+}
+class McpConfigurationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/** Load MCP-only YAML for direct commands or the aggregation host without agent setup. */
+export async function loadStandaloneMcpConfiguration(path, allowMissing) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (allowMissing &&
+            typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT')
+            text = 'mcpServers: {}\n';
+        else
+            throw new McpConfigurationError('config_read_failed', 'Cannot read MCP configuration. Check --config and file permissions.');
+    }
+    try {
+        const document = parseDocument(text);
+        if (document.errors.length)
+            throw new Error('Invalid YAML');
+        const config = documentSchema.parse(document.toJS());
+        return { document, servers: config.mcpServers };
+    }
+    catch {
+        throw new McpConfigurationError('invalid_config', 'Invalid MCP YAML or server configuration.');
+    }
+}
+async function runMcpOperation(command, config, args) {
+    const logger = new DextoLogger({
+        level: 'error',
+        component: DextoLogComponent.MCP,
+        agentId: 'mcp-cli',
+        transports: [],
+    });
+    const manager = new MCPManager(logger);
+    const server = command.server;
+    const cancellation = new AbortController();
+    let interruption;
+    const interrupt = (signal) => {
+        if (interruption !== undefined)
+            return;
+        interruption = signal;
+        cancellation.abort();
+    };
+    const onSigint = () => interrupt('SIGINT');
+    const onSigterm = () => interrupt('SIGTERM');
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    let connected = false;
+    let result = {
+        exitCode: 3,
+        output: {
+            server,
+            error: {
+                code: 'mcp_connection_failed',
+                message: 'Cannot connect to MCP server. Check its configuration, credentials and availability.',
+            },
+        },
+    };
+    try {
+        await manager.connectServer(server, config);
+        connected = true;
+        if (!cancellation.signal.aborted) {
+            result = await performMcpOperation(manager, command, args, config.timeout, cancellation.signal);
+        }
+    }
+    catch (error) {
+        if (connected) {
+            const notFound = typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'mcp_tool_not_found';
+            result = {
+                exitCode: 4,
+                output: {
+                    server,
+                    error: {
+                        code: notFound ? 'mcp_tool_not_found' : 'mcp_operation_failed',
+                        message: notFound
+                            ? 'Tool is not advertised by the selected server.'
+                            : 'MCP operation failed. Check the selected operation and its arguments.',
+                    },
+                },
+            };
+        }
+    }
+    finally {
+        try {
+            const cleanup = await Promise.allSettled([manager.disconnectAll()]);
+            cleanup.push(...(await Promise.allSettled([logger.destroy()])));
+            if (cleanup.some((item) => item.status === 'rejected') && result.exitCode === 0) {
+                result = {
+                    exitCode: 4,
+                    output: {
+                        server,
+                        error: {
+                            code: 'mcp_cleanup_failed',
+                            message: 'MCP connection cleanup failed.',
+                        },
+                    },
+                };
+            }
+        }
+        finally {
+            process.off('SIGINT', onSigint);
+            process.off('SIGTERM', onSigterm);
+        }
+    }
+    if (interruption !== undefined) {
+        return {
+            exitCode: interruption === 'SIGINT' ? 130 : 143,
+            output: {
+                server,
+                signal: interruption,
+                error: { code: 'mcp_interrupted', message: 'MCP operation interrupted.' },
+            },
+        };
+    }
+    return result;
+}
+async function performMcpOperation(manager, command, args, timeout, signal) {
+    const server = command.server;
+    switch (command.command) {
+        case 'connect':
+            return { exitCode: 0, output: { server, status: 'connected', connection: 'closed' } };
+        case 'tools':
+            return {
+                exitCode: 0,
+                output: { server, tools: manager.getToolDescriptors(), connection: 'closed' },
+            };
+        case 'resources':
+            return {
+                exitCode: 0,
+                output: {
+                    server,
+                    resources: await manager.listAllResources(),
+                    connection: 'closed',
+                },
+            };
+        case 'prompts':
+            return {
+                exitCode: 0,
+                output: { server, prompts: manager.getAllPromptMetadata(), connection: 'closed' },
+            };
+        case 'get-prompt': {
+            const protocol = await getConnectedServerProtocol(manager, server);
+            const result = await protocol.getPrompt({ name: command.prompt, arguments: command.arguments }, { timeout, signal });
+            return {
+                exitCode: 0,
+                output: { server, prompt: command.prompt, result, connection: 'closed' },
+            };
+        }
+        case 'read-resource': {
+            const protocol = await getConnectedServerProtocol(manager, server);
+            const result = await protocol.readResource({ uri: command.uri }, { timeout, signal });
+            return {
+                exitCode: 0,
+                output: { server, uri: command.uri, result, connection: 'closed' },
+            };
+        }
+        case 'call': {
+            const descriptor = manager
+                .getToolDescriptors()
+                .find((tool) => tool.identity.connectionId === server &&
+                tool.identity.toolName === command.tool);
+            if (!descriptor)
+                throw MCPError.toolNotFound(command.tool);
+            const input = manager.validateToolInput(descriptor.name, args);
+            const result = await manager.callToolDirect({
+                identity: descriptor.identity,
+                arguments: input,
+                signal,
+            });
+            return {
+                exitCode: result.isError === true ? 4 : 0,
+                output: { server, tool: command.tool, result, connection: 'closed' },
+            };
+        }
+    }
+}
+async function getConnectedServerProtocol(manager, server) {
+    const client = manager.getClients().get(server);
+    if (!client)
+        throw new Error('Connected MCP client missing');
+    return await client.getConnectedClient();
+}
+/** Convert CLI setup forms to literal configuration without expanding credentials. */
+export function serverConfigurationFromOptions(options) {
+    const { serverConfig, transport, command, arg, env, url, header } = options;
+    if (serverConfig !== undefined) {
+        if ([transport, command, arg, env, url, header].some((value) => value !== undefined))
+            throw new Error('Conflicting setup options');
+        return serverConfig;
+    }
+    if (command !== undefined &&
+        url === undefined &&
+        header === undefined &&
+        (transport === undefined || transport === 'stdio')) {
+        return JSON.stringify({
+            type: 'stdio',
+            command,
+            args: arg ?? [],
+            env: parseAssignments(env ?? []),
+        });
+    }
+    if (url !== undefined &&
+        command === undefined &&
+        arg === undefined &&
+        env === undefined &&
+        (transport === undefined || transport === 'http' || transport === 'sse')) {
+        return JSON.stringify({
+            type: transport ?? 'http',
+            url,
+            headers: parseAssignments(header ?? []),
+        });
+    }
+    throw new Error('Invalid or conflicting setup options');
+}
+function parseAssignments(values) {
+    const result = {};
+    for (const value of values) {
+        const separator = value.indexOf('=');
+        if (separator <= 0)
+            throw new Error('Expected NAME=VALUE');
+        const name = value.slice(0, separator);
+        if (Object.hasOwn(result, name))
+            throw new Error('Duplicate assignment');
+        Object.defineProperty(result, name, {
+            value: value.slice(separator + 1),
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return result;
+}

package/dist/cli/commands/run/headless.d.ts

@@ -1,8 +1,10 @@
 import { type DextoAgent } from '@dexto/core';
+import { type HeadlessApprovalRequired, type HeadlessOutputFormat } from './output.js';
 export type HeadlessRunResult = {
     finalMessage?: string;
     totalTokens?: number;
     fatalError?: Error;
+    approvalRequired?: HeadlessApprovalRequired[];
 };
 export declare function resolveHeadlessPrompt(promptArg?: string): Promise<string>;
 export declare function printHeadlessMcpStartup(agent: DextoAgent): void;
@@ -13,7 +15,7 @@ export declare function printHeadlessRunSummary(params: {
     agentPath: string;
     cliVersion: string;
 }): void;
-export declare function executeHeadlessRun(agent: DextoAgent, sessionId: string, prompt: string): Promise<HeadlessRunResult>;
+export declare function executeHeadlessRun(agent: DextoAgent, sessionId: string, prompt: string, format?: HeadlessOutputFormat): Promise<HeadlessRunResult>;
 export declare function printHeadlessAssistantResponse(message: string, totalTokens?: number): void;
 export declare function writeFinalMessageToStdout(message: string): void;
 export declare function writeHeadlessError(message: string): void;

package/dist/cli/commands/run/headless.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headless.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/headless.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,UAAU,EAIlB,MAAM,aAAa,CAAC;AAWrB,MAAM,MAAM,iBAAiB,GAAG;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,KAAK,CAAC;CACtB,CAAC;AA0IF,wBAAsB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAgC/D;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC5C,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAgBP;AAED,wBAAsB,kBAAkB,CACpC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,iBAAiB,CAAC,CAuH5B;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAM1F;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAM/D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAExD"}
+{"version":3,"file":"headless.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/headless.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,UAAU,EAIlB,MAAM,aAAa,CAAC;AAErB,OAAO,EAGH,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EAC5B,MAAM,aAAa,CAAC;AAWrB,MAAM,MAAM,iBAAiB,GAAG;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,gBAAgB,CAAC,EAAE,wBAAwB,EAAE,CAAC;CACjD,CAAC;AA0IF,wBAAsB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAgC/D;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC5C,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAgBP;AAED,wBAAsB,kBAAkB,CACpC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,oBAA6B,GACtC,OAAO,CAAC,iBAAiB,CAAC,CAmI5B;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAM1F;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAM/D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAExD"}

package/dist/cli/commands/run/headless.js

@@ -1,4 +1,5 @@
 import { isTextPart, safeStringify, } from '@dexto/core';
+import { writeHeadlessEvent, toHeadlessApprovalRequired, } from './output.js';
 const HEADLESS_TOOL_OUTPUT_MAX_LINES = 20;
 const HEADLESS_SECTION_SEPARATOR = '========================================';
 function writeHeadlessLine(line = '') {
@@ -163,15 +164,24 @@ export function printHeadlessRunSummary(params) {
     writeHeadlessSeparator();
     writeHeadlessTaggedBlock('USER', prompt);
 }
-export async function executeHeadlessRun(agent, sessionId, prompt) {
+export async function executeHeadlessRun(agent, sessionId, prompt, format = 'text') {
     const toolCallState = new Map();
+    const approvalRequired = [];
     let anonymousToolCallCounter = 0;
     let finalMessage;
     let totalTokens;
     let fatalError;
     try {
         for await (const event of await agent.stream(prompt, sessionId)) {
+            if (format === 'jsonl')
+                await writeHeadlessEvent(event);
             switch (event.name) {
+                case 'approval:request': {
+                    const required = toHeadlessApprovalRequired(event);
+                    approvalRequired.push(required);
+                    writeHeadlessTaggedLine('APPROVAL_REQUIRED', `${'toolName' in required ? required.toolName : required.approvalType}: ${required.message} (approval ${required.approvalId})`);
+                    break;
+                }
                 case 'llm:tool-call': {
                     const callKey = event.callId ?? `anonymous-${++anonymousToolCallCounter}`;
                     const call = {
@@ -264,6 +274,8 @@ export async function executeHeadlessRun(agent, sessionId, prompt) {
     if (fatalError !== undefined) {
         result.fatalError = fatalError;
     }
+    if (approvalRequired.length)
+        result.approvalRequired = approvalRequired;
     return result;
 }
 export function printHeadlessAssistantResponse(message, totalTokens) {

package/dist/cli/commands/run/output.d.ts

@@ -0,0 +1,21 @@
+import { ApprovalType, type ApprovalRequest, type StreamingEvent } from '@dexto/core';
+import type { HeadlessRunResult } from './headless.js';
+export type HeadlessOutputFormat = 'text' | 'json' | 'jsonl';
+export type HeadlessApprovalRequired = {
+    approvalId: string;
+    sessionId?: string;
+    message: string;
+} & ({
+    approvalType: typeof ApprovalType.TOOL_APPROVAL;
+    toolName: string;
+    toolCallId: string;
+} | {
+    approvalType: typeof ApprovalType.COMMAND_APPROVAL;
+    toolName: string;
+} | {
+    approvalType: Exclude<ApprovalRequest['type'], typeof ApprovalType.TOOL_APPROVAL | typeof ApprovalType.COMMAND_APPROVAL>;
+});
+export declare function toHeadlessApprovalRequired(request: ApprovalRequest): HeadlessApprovalRequired;
+export declare function writeHeadlessResult(format: HeadlessOutputFormat, result: HeadlessRunResult, sessionId: string | undefined): Promise<void>;
+export declare function writeHeadlessEvent(event: StreamingEvent): Promise<void>;
+//# sourceMappingURL=output.d.ts.map

package/dist/cli/commands/run/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAEtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE7D,MAAM,MAAM,wBAAwB,GAAG;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACnB,GAAG,CACE;IAAE,YAAY,EAAE,OAAO,YAAY,CAAC,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACzF;IAAE,YAAY,EAAE,OAAO,YAAY,CAAC,gBAAgB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACxE;IACI,YAAY,EAAE,OAAO,CACjB,eAAe,CAAC,MAAM,CAAC,EACvB,OAAO,YAAY,CAAC,aAAa,GAAG,OAAO,YAAY,CAAC,gBAAgB,CAC3E,CAAC;CACL,CACN,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,GAAG,wBAAwB,CAuB7F;AAED,wBAAsB,mBAAmB,CACrC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,MAAM,GAAG,SAAS,GAC9B,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C7E"}

package/dist/cli/commands/run/output.js

@@ -0,0 +1,95 @@
+import { ApprovalType } from '@dexto/core';
+import { HEADLESS_APPROVAL_MESSAGE } from '../../approval/headless-approval-handler.js';
+export function toHeadlessApprovalRequired(request) {
+    const correlation = {
+        approvalId: request.approvalId,
+        ...(request.sessionId !== undefined ? { sessionId: request.sessionId } : {}),
+        message: HEADLESS_APPROVAL_MESSAGE,
+    };
+    switch (request.type) {
+        case ApprovalType.TOOL_APPROVAL:
+            return {
+                ...correlation,
+                approvalType: request.type,
+                toolName: request.metadata.toolName,
+                toolCallId: request.metadata.toolCallId,
+            };
+        case ApprovalType.COMMAND_APPROVAL:
+            return {
+                ...correlation,
+                approvalType: request.type,
+                toolName: request.metadata.toolName,
+            };
+        default:
+            return { ...correlation, approvalType: request.type };
+    }
+}
+export async function writeHeadlessResult(format, result, sessionId) {
+    if (format === 'text')
+        return;
+    await writeJsonLineToStdout({
+        version: 1,
+        ...(format === 'json'
+            ? { status: result.fatalError ? 'failed' : 'completed' }
+            : { type: result.fatalError ? 'error' : 'complete' }),
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(result.finalMessage !== undefined ? { content: result.finalMessage } : {}),
+        ...(result.totalTokens !== undefined ? { totalTokens: result.totalTokens } : {}),
+        ...(result.fatalError ? { error: result.fatalError.message } : {}),
+        ...(result.approvalRequired?.length ? { approvalRequired: result.approvalRequired } : {}),
+    });
+}
+export async function writeHeadlessEvent(event) {
+    let payload;
+    switch (event.name) {
+        case 'approval:request':
+            payload = { type: 'approval_required', ...toHeadlessApprovalRequired(event) };
+            break;
+        case 'llm:chunk':
+            payload = { type: 'message_delta', content: event.content };
+            break;
+        case 'llm:tool-call':
+            payload = {
+                type: 'tool_call',
+                toolName: event.toolName,
+                args: event.args,
+                ...(event.callId ? { callId: event.callId } : {}),
+            };
+            break;
+        case 'llm:tool-result':
+            payload = {
+                type: 'tool_result',
+                toolName: event.toolName,
+                success: event.success,
+                ...(event.callId ? { callId: event.callId } : {}),
+                ...(!event.success && event.error ? { error: event.error } : {}),
+            };
+            break;
+        case 'llm:unsupported-input':
+            payload = { type: 'warning', errors: event.errors };
+            break;
+        case 'llm:error':
+            payload = {
+                type: 'run_error',
+                recoverable: event.recoverable,
+                error: event.error.message,
+            };
+            break;
+        case 'llm:response':
+            payload = { type: 'response', content: event.content };
+            break;
+        default:
+            return;
+    }
+    await writeJsonLineToStdout({ version: 1, ...payload });
+}
+function writeJsonLineToStdout(payload) {
+    return new Promise((resolve, reject) => {
+        process.stdout.write(`${JSON.stringify(payload)}\n`, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}

package/dist/cli/commands/run/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/register.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAE5E,wBAAgB,kBAAkB,CAAC,EAC/B,OAAO,EACP,UAAU,EACV,4BAA4B,GAC/B,EAAE,6BAA6B,GAAG,IAAI,CA+FtC"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/register.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAE5E,wBAAgB,kBAAkB,CAAC,EAC/B,OAAO,EACP,UAAU,EACV,4BAA4B,GAC/B,EAAE,6BAA6B,GAAG,IAAI,CAoItC"}