relaycast 0.3.2 → 1.1.1

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCli } from './index.js';
+const exitCode = await runCli(process.argv.slice(2), {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    env: process.env,
+});
+process.exit(exitCode);
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;IACnD,MAAM,EAAE,OAAO,CAAC,MAAM;IACtB,MAAM,EAAE,OAAO,CAAC,MAAM;IACtB,GAAG,EAAE,OAAO,CAAC,GAAG;CACjB,CAAC,CAAC;AAEH,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC"}

package/dist/index.d.ts

@@ -1,3 +1,36 @@
-#!/usr/bin/env node
-export declare const CLI_VERSION: "0.1.2";
+type WritableStreamLike = {
+    write(chunk: string): unknown;
+};
+type EnvLike = Record<string, string | undefined>;
+type JsonObject = Record<string, unknown>;
+type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+};
+type ToolDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema?: JsonSchema;
+};
+type CliIo = {
+    stdout: WritableStreamLike;
+    stderr: WritableStreamLike;
+    env?: EnvLike;
+};
+type CliConfig = {
+    apiKey?: string;
+    baseUrl?: string;
+    agentToken?: string;
+    agentName?: string;
+    agentType?: 'agent' | 'human';
+    strictAgentName?: boolean;
+    workspacesJson?: string;
+    defaultWorkspace?: string;
+};
+export declare function runCli(argv: string[], io: CliIo): Promise<number>;
+export declare function listCliTools(config?: CliConfig): Promise<ToolDefinition[]>;
+export declare function callCliTool(name: string, args: JsonObject, config?: CliConfig): Promise<unknown>;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAiBA,eAAO,MAAM,WAAW,EAAG,OAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,KAAK,kBAAkB,GAAG;IAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAC5D,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAClD,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAC1C,KAAK,UAAU,GAAG;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB,CAAC;AACF,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,CAAC;CAC1B,CAAC;AACF,KAAK,KAAK,GAAG;IACX,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAQF,KAAK,SAAS,GAAG;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAC9B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkBF,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAiDvE;AAED,wBAAsB,YAAY,CAAC,MAAM,GAAE,SAAc,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAQpF;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,SAAc,GACrB,OAAO,CAAC,OAAO,CAAC,CAOlB"}

package/dist/index.js

@@ -1,137 +1,463 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { registerWorkspaceCommands } from './commands/workspace.js';
-import { registerAgentCommands } from './commands/agent.js';
-import { registerConfigCommands } from './commands/config.js';
-import { registerChannelCommands } from './commands/channel.js';
-import { registerMessagingCommands } from './commands/messaging.js';
-import { registerReadCommands } from './commands/read.js';
-import { registerSearchCommands } from './commands/search.js';
-import { registerReactionCommands } from './commands/reactions.js';
-import { registerFileCommands } from './commands/files.js';
-import { registerBillingCommands } from './commands/billing.js';
-import { registerOpenClawCommands } from './commands/openclaw.js';
-import { registerTelemetryCommands } from './commands/telemetry.js';
-import { createCliTelemetry } from './telemetry.js';
-export const CLI_VERSION = '0.1.2';
-const program = new Command();
-const telemetry = createCliTelemetry(CLI_VERSION);
-let activeCommandPath = null;
-let activeCommandStartedAt = 0;
-function getCommandPath(command) {
-    const names = [];
-    let current = command;
-    while (current && current.parent) {
-        const name = current.name();
-        if (name)
-            names.unshift(name);
-        current = current.parent;
-    }
-    return names.join(' ');
-}
-function captureDerivedEvents(commandPath, args) {
-    if (commandPath === 'workspace create') {
-        telemetry.capture('relaycast_workspace_created', { source_surface: 'cli' });
-        return;
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { createRelayMcpServer, parseWorkspaceEnv, } from '@relaycast/mcp';
+import { CLI_VERSION } from './version.js';
+const GLOBAL_FLAG_NAMES = new Set([
+    'relay-api-key',
+    'relay-base-url',
+    'relay-agent-token',
+    'relay-agent-name',
+    'relay-agent-type',
+    'relay-strict-agent-name',
+    'relay-workspaces-json',
+    'relay-default-workspace',
+    'json',
+    'help',
+    'h',
+]);
+const TOOL_JSON_FLAG_NAMES = new Set(['json-args', 'args-json']);
+export async function runCli(argv, io) {
+    try {
+        if (argv.length === 1 && (argv[0] === 'version' || argv[0] === '--version' || argv[0] === '-v')) {
+            io.stdout.write(`relaycast ${CLI_VERSION}\n`);
+            return 0;
+        }
+        const parsed = parseCliArgs(argv, io.env ?? process.env);
+        if (parsed.command === 'version') {
+            io.stdout.write(`relaycast ${CLI_VERSION}\n`);
+            return 0;
+        }
+        const session = await createCliMcpSession(parsed.config);
+        try {
+            const tools = await session.listTools();
+            const toolDefinitions = tools.tools;
+            if (!parsed.command || parsed.command === 'help' || parsed.command === '--help' || parsed.command === '-h') {
+                io.stdout.write(formatHelp(toolDefinitions));
+                return 0;
+            }
+            if (parsed.command === 'tools' || parsed.command === 'tool.list') {
+                if (parsed.outputJson) {
+                    io.stdout.write(`${JSON.stringify(toolDefinitions, null, 2)}\n`);
+                }
+                else {
+                    io.stdout.write(formatToolList(toolDefinitions));
+                }
+                return 0;
+            }
+            const tool = toolDefinitions.find((candidate) => candidate.name === parsed.command);
+            if (parsed.help) {
+                io.stdout.write(formatToolHelp(parsed.command, tool));
+                return 0;
+            }
+            const toolArgs = parseToolArgs(parsed.commandArgs, tool?.inputSchema);
+            const result = await session.callTool(parsed.command, toolArgs);
+            writeToolResult(io.stdout, result, parsed.outputJson);
+            return isToolErrorResult(result) ? 1 : 0;
+        }
+        finally {
+            await session.close();
+        }
     }
-    if (commandPath === 'send') {
-        const target = typeof args[0] === 'string' ? args[0] : '';
-        telemetry.capture('relaycast_message_sent', {
-            source_surface: 'cli',
-            message_kind: target.startsWith('@') ? 'dm' : 'channel',
-            command: commandPath,
-        });
-        return;
+    catch (err) {
+        io.stderr.write(`${formatError(err)}\n`);
+        return 1;
+    }
+}
+export async function listCliTools(config = {}) {
+    const session = await createCliMcpSession(config);
+    try {
+        const tools = await session.listTools();
+        return tools.tools;
+    }
+    finally {
+        await session.close();
+    }
+}
+export async function callCliTool(name, args, config = {}) {
+    const session = await createCliMcpSession(config);
+    try {
+        return await session.callTool(name, args);
+    }
+    finally {
+        await session.close();
+    }
+}
+function parseCliArgs(argv, env) {
+    const config = {
+        apiKey: env.RELAY_API_KEY,
+        baseUrl: env.RELAY_BASE_URL,
+        agentToken: env.RELAY_AGENT_TOKEN,
+        agentName: env.RELAY_AGENT_NAME,
+        agentType: parseAgentType(env.RELAY_AGENT_TYPE),
+        strictAgentName: parseBooleanFlag(env.RELAY_STRICT_AGENT_NAME),
+        workspacesJson: env.RELAY_WORKSPACES_JSON,
+        defaultWorkspace: env.RELAY_DEFAULT_WORKSPACE,
+    };
+    let outputJson = false;
+    let help = false;
+    let command = null;
+    const commandArgs = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!command && isFlag(token)) {
+            const { name, inlineValue, negated } = splitFlag(token);
+            if (negated || !GLOBAL_FLAG_NAMES.has(name)) {
+                throw new Error(`Unknown global option "${token}". Put tool arguments after the tool name.`);
+            }
+            const value = readGlobalFlagValue(argv, i, name, inlineValue);
+            if (value.consumed)
+                i += 1;
+            applyGlobalFlag(config, name, value.value, () => { outputJson = true; }, () => { help = true; });
+            continue;
+        }
+        if (!command) {
+            command = token;
+            continue;
+        }
+        if (isFlag(token)) {
+            const { name, inlineValue, negated } = splitFlag(token);
+            if (!negated && GLOBAL_FLAG_NAMES.has(name)) {
+                const value = readGlobalFlagValue(argv, i, name, inlineValue);
+                if (value.consumed)
+                    i += 1;
+                applyGlobalFlag(config, name, value.value, () => { outputJson = true; }, () => { help = true; });
+                continue;
+            }
+        }
+        commandArgs.push(token);
+    }
+    return { command, commandArgs, config, outputJson, help };
+}
+async function createCliMcpSession(config) {
+    const options = {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        agentToken: config.agentToken,
+        agentName: config.agentName,
+        agentType: config.agentType,
+        strictAgentName: config.strictAgentName,
+        defaultWorkspace: config.defaultWorkspace,
+        workspaces: config.workspacesJson ? parseWorkspaceEnv(config.workspacesJson) : undefined,
+        telemetryTransport: 'stdio',
+    };
+    const server = createRelayMcpServer(options);
+    const client = new Client({ name: 'relaycast', version: CLI_VERSION });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await Promise.all([
+        client.connect(clientTransport),
+        server.connect(serverTransport),
+    ]);
+    return {
+        listTools: () => client.listTools(),
+        callTool: (name, args) => client.callTool({ name, arguments: args }),
+        close: async () => {
+            await Promise.allSettled([
+                client.close(),
+                server.close(),
+            ]);
+        },
+    };
+}
+function parseToolArgs(argv, inputSchema) {
+    const jsonFlagIndex = argv.findIndex((arg) => isFlag(arg) && TOOL_JSON_FLAG_NAMES.has(splitFlag(arg).name));
+    if (jsonFlagIndex >= 0) {
+        const token = argv[jsonFlagIndex];
+        const { inlineValue } = splitFlag(token);
+        const raw = inlineValue ?? argv[jsonFlagIndex + 1];
+        if (!raw) {
+            throw new Error(`Missing value for ${token}`);
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`${token} must be a JSON object`);
+        }
+        return parsed;
     }
-    if (commandPath === 'reply') {
-        telemetry.capture('relaycast_message_sent', {
-            source_surface: 'cli',
-            message_kind: 'thread_reply',
-            command: commandPath,
-        });
+    const args = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!isFlag(token)) {
+            throw new Error(`Unexpected positional argument "${token}". Use --name value arguments.`);
+        }
+        const { name, inlineValue, negated } = splitFlag(token);
+        const key = normalizeArgName(name);
+        const schema = inputSchema?.properties?.[key];
+        let rawValue;
+        if (negated) {
+            rawValue = false;
+        }
+        else if (inlineValue != null) {
+            rawValue = inlineValue;
+        }
+        else {
+            const isBoolean = schemaHasType(schema, 'boolean');
+            const value = readFlagValue(argv, i, name, isBoolean);
+            rawValue = value.value;
+            if (value.consumed)
+                i += 1;
+        }
+        const value = coerceToolValue(rawValue, schema);
+        appendArgValue(args, key, value, schema);
+    }
+    return args;
+}
+function formatHelp(tools) {
+    return [
+        'relaycast - Relaycast command line tools',
+        '',
+        'Usage:',
+        '  relaycast tools',
+        '  relaycast <mcp-tool-name> [--arg value]',
+        '  relaycast <mcp-tool-name> --json-args \'{"key":"value"}\'',
+        '',
+        'Global options:',
+        '  --relay-api-key <key>          Workspace key, defaults to RELAY_API_KEY',
+        '  --relay-base-url <url>         API base URL, defaults to RELAY_BASE_URL',
+        '  --relay-agent-token <token>    Agent token, defaults to RELAY_AGENT_TOKEN',
+        '  --relay-agent-name <name>      Agent name, defaults to RELAY_AGENT_NAME',
+        '  --json                         Print raw JSON output',
+        '',
+        'Commands:',
+        formatToolList(tools).trimEnd(),
+    ].join('\n') + '\n';
+}
+function formatToolList(tools) {
+    const width = tools.reduce((max, tool) => Math.max(max, tool.name.length), 0);
+    return tools
+        .map((tool) => {
+        const summary = tool.title ?? firstSentence(tool.description) ?? '';
+        return `  ${tool.name.padEnd(width)}  ${summary}`.trimEnd();
+    })
+        .join('\n') + '\n';
+}
+function formatToolHelp(command, tool) {
+    if (!tool) {
+        return [
+            `No MCP tool named "${command}" was found in the tool list.`,
+            'Legacy MCP aliases are still accepted when called directly.',
+            '',
+            `Usage: relaycast ${command} --json-args '{"key":"value"}'`,
+        ].join('\n') + '\n';
+    }
+    const lines = [
+        `${tool.name}${tool.title ? ` - ${tool.title}` : ''}`,
+        '',
+        tool.description ?? '',
+        '',
+        `Usage: relaycast ${tool.name} [--arg value]`,
+    ];
+    const properties = tool.inputSchema?.properties ?? {};
+    const argLines = Object.entries(properties).map(([name, schema]) => `  --${name.replace(/_/g, '-')}  ${formatSchemaType(schema)}`);
+    if (argLines.length) {
+        lines.push('', 'Arguments:', ...argLines);
+    }
+    return lines.filter((line, index) => line || index !== 2).join('\n') + '\n';
+}
+function writeToolResult(stdout, result, rawJson) {
+    if (rawJson) {
+        stdout.write(`${JSON.stringify(result, null, 2)}\n`);
         return;
     }
-    if (commandPath === 'group-dm') {
-        const participants = Array.isArray(args[0]) ? args[0].length : undefined;
-        telemetry.capture('relaycast_message_sent', {
-            source_surface: 'cli',
-            message_kind: 'group_dm',
-            participants_count: participants,
-            command: commandPath,
-        });
+    const structured = getStructuredContent(result);
+    if (structured !== undefined) {
+        stdout.write(`${JSON.stringify(structured, null, 2)}\n`);
         return;
     }
-    if (commandPath === 'inbox') {
-        telemetry.capture('relaycast_inbox_checked', { source_surface: 'cli' });
+    const contentText = getTextContent(result);
+    if (contentText) {
+        stdout.write(`${contentText}\n`);
         return;
     }
-    if (commandPath === 'agent register') {
-        telemetry.capture('relaycast_agent_registered', { source_surface: 'cli' });
-    }
-}
-program
-    .name('relaycast')
-    .description('Relaycast — agent-to-agent messaging CLI')
-    .version(CLI_VERSION);
-registerWorkspaceCommands(program);
-registerAgentCommands(program);
-registerConfigCommands(program);
-registerChannelCommands(program);
-registerMessagingCommands(program);
-registerReadCommands(program);
-registerSearchCommands(program);
-registerReactionCommands(program);
-registerFileCommands(program);
-registerBillingCommands(program);
-registerOpenClawCommands(program);
-registerTelemetryCommands(program, telemetry);
-program.hook('preAction', (_thisCommand, actionCommand) => {
-    const commandPath = getCommandPath(actionCommand);
-    if (!commandPath)
+    stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+function isToolErrorResult(result) {
+    if (!result || typeof result !== 'object')
+        return false;
+    return result.isError === true;
+}
+function getStructuredContent(result) {
+    if (!result || typeof result !== 'object')
+        return undefined;
+    return result.structuredContent;
+}
+function getTextContent(result) {
+    if (!result || typeof result !== 'object')
+        return null;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = content
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return null;
+        const text = item.text;
+        return typeof text === 'string' ? text : null;
+    })
+        .filter((item) => item != null);
+    return parts.length ? parts.join('\n') : null;
+}
+function splitFlag(token) {
+    const trimmed = token.replace(/^--?/, '');
+    const eqIndex = trimmed.indexOf('=');
+    const rawName = eqIndex >= 0 ? trimmed.slice(0, eqIndex) : trimmed;
+    const negated = rawName.startsWith('no-');
+    return {
+        name: negated ? rawName.slice(3) : rawName,
+        inlineValue: eqIndex >= 0 ? trimmed.slice(eqIndex + 1) : undefined,
+        negated,
+    };
+}
+function isFlag(token) {
+    return token.startsWith('-') && token.length > 1;
+}
+function readFlagValue(argv, index, flagName, allowBooleanDefault = false) {
+    const next = argv[index + 1];
+    if (!next || isFlag(next)) {
+        if (allowBooleanDefault) {
+            return { value: true, consumed: false };
+        }
+        throw new Error(`Missing value for --${flagName}`);
+    }
+    return { value: next, consumed: true };
+}
+function readGlobalFlagValue(argv, index, flagName, inlineValue) {
+    if (inlineValue != null) {
+        return { value: inlineValue, consumed: false };
+    }
+    if (flagName === 'json' || flagName === 'help' || flagName === 'h' || flagName === 'relay-strict-agent-name') {
+        return { value: true, consumed: false };
+    }
+    return readFlagValue(argv, index, flagName, false);
+}
+function applyGlobalFlag(config, flag, value, setJson, setHelp) {
+    const stringValue = value === true ? undefined : String(value);
+    switch (flag) {
+        case 'relay-api-key':
+            config.apiKey = stringValue;
+            break;
+        case 'relay-base-url':
+            config.baseUrl = stringValue;
+            break;
+        case 'relay-agent-token':
+            config.agentToken = stringValue;
+            break;
+        case 'relay-agent-name':
+            config.agentName = stringValue;
+            break;
+        case 'relay-agent-type':
+            config.agentType = parseAgentType(stringValue);
+            break;
+        case 'relay-strict-agent-name':
+            config.strictAgentName = parseBooleanFlag(value);
+            break;
+        case 'relay-workspaces-json':
+            config.workspacesJson = stringValue;
+            break;
+        case 'relay-default-workspace':
+            config.defaultWorkspace = stringValue;
+            break;
+        case 'json':
+            setJson();
+            break;
+        case 'help':
+        case 'h':
+            setHelp();
+            break;
+        default:
+            throw new Error(`Unknown global option "--${flag}"`);
+    }
+}
+function normalizeArgName(name) {
+    return name.replace(/-/g, '_');
+}
+function appendArgValue(args, key, value, schema) {
+    if (schemaHasType(schema, 'array')) {
+        const existing = args[key];
+        if (Array.isArray(value)) {
+            args[key] = Array.isArray(existing) ? [...existing, ...value] : value;
+        }
+        else {
+            args[key] = Array.isArray(existing) ? [...existing, value] : [value];
+        }
         return;
-    activeCommandPath = commandPath;
-    activeCommandStartedAt = Date.now();
-});
-program.hook('postAction', async (_thisCommand, actionCommand) => {
-    const commandPath = getCommandPath(actionCommand);
-    if (!commandPath)
+    }
+    if (Object.prototype.hasOwnProperty.call(args, key)) {
+        const existing = args[key];
+        args[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
         return;
-    const durationMs = Math.max(Date.now() - activeCommandStartedAt, 0);
-    telemetry.capture('relaycast_cli_command_completed', {
-        command: commandPath,
-        duration_ms: durationMs,
-        source_surface: 'cli',
-    });
-    captureDerivedEvents(commandPath, actionCommand.processedArgs);
-    activeCommandPath = null;
-    activeCommandStartedAt = 0;
-    await telemetry.flush();
-});
-telemetry.capture('relaycast_cli_started', {
-    source_surface: 'cli',
-    command_count: Math.max(process.argv.length - 2, 0),
-});
-telemetry.captureFirstRunIfNeeded();
-process.on('beforeExit', () => {
-    void telemetry.flush();
-});
-void program.parseAsync().catch(async (error) => {
-    if (activeCommandPath) {
-        const durationMs = Math.max(Date.now() - activeCommandStartedAt, 0);
-        telemetry.capture('relaycast_cli_command_failed', {
-            command: activeCommandPath,
-            duration_ms: durationMs,
-            source_surface: 'cli',
-            error_name: error instanceof Error ? error.name : 'UnknownError',
-        });
-    }
-    await telemetry.flush();
-    if (error instanceof Error) {
-        console.error(error.message);
-    }
-    else {
-        console.error(String(error));
-    }
-    process.exit(1);
-});
+    }
+    args[key] = value;
+}
+function coerceToolValue(value, schema) {
+    if (typeof value === 'boolean')
+        return value;
+    if (schemaHasType(schema, 'array')) {
+        const parsed = parseJsonIfPossible(value);
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+        return [coerceToolValue(value, schema?.items)];
+    }
+    if (schemaHasType(schema, 'object')) {
+        return JSON.parse(value);
+    }
+    if (schemaHasType(schema, 'number') || schemaHasType(schema, 'integer')) {
+        const parsed = Number(value);
+        if (Number.isNaN(parsed)) {
+            throw new Error(`Expected number, received "${value}"`);
+        }
+        return parsed;
+    }
+    if (schemaHasType(schema, 'boolean')) {
+        return parseBooleanFlag(value);
+    }
+    return value;
+}
+function schemaHasType(schema, type) {
+    if (!schema?.type)
+        return false;
+    return Array.isArray(schema.type) ? schema.type.includes(type) : schema.type === type;
+}
+function parseJsonIfPossible(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseBooleanFlag(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'boolean')
+        return value;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return undefined;
+}
+function parseAgentType(value) {
+    if (value === 'agent' || value === 'human')
+        return value;
+    return undefined;
+}
+function firstSentence(value) {
+    if (!value)
+        return undefined;
+    const [sentence] = value.split('.');
+    return sentence ? `${sentence}.` : value;
+}
+function formatSchemaType(schema) {
+    if (!schema.type)
+        return 'value';
+    return Array.isArray(schema.type) ? schema.type.join('|') : schema.type;
+}
+function formatError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
 //# sourceMappingURL=index.js.map