@orchagent/cli 0.3.51 → 0.3.53

package/dist/commands/index.js

@@ -28,6 +28,7 @@ const test_1 = require("./test");
 const security_1 = require("./security");
 const billing_1 = require("./billing");
 const agent_keys_1 = require("./agent-keys");
+const schedule_1 = require("./schedule");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -56,4 +57,5 @@ function registerCommands(program) {
     (0, security_1.registerSecurityCommand)(program);
     (0, billing_1.registerBillingCommand)(program);
     (0, agent_keys_1.registerAgentKeysCommand)(program);
+    (0, schedule_1.registerScheduleCommand)(program);
 }

package/dist/commands/publish.js

@@ -269,15 +269,38 @@ function registerPublishCommand(program) {
         if (!manifest.name) {
             throw new errors_1.CliError('orchagent.json must have name');
         }
-        // Warn about deprecated fields that are ignored
+        // Warn about deprecated prompt field
         if (manifest.prompt) {
             process.stderr.write(chalk_1.default.yellow('Warning: "prompt" field in orchagent.json is ignored. Use prompt.md file instead.\n'));
         }
-        if (manifest.input_schema) {
-            process.stderr.write(chalk_1.default.yellow('Warning: "input_schema" field in orchagent.json is ignored. Use schema.json file instead.\n'));
+        // Auto-migrate inline schemas to schema.json
+        const schemaPath = path_1.default.join(cwd, 'schema.json');
+        let schemaFileExists = false;
+        try {
+            await promises_1.default.access(schemaPath);
+            schemaFileExists = true;
         }
-        if (manifest.output_schema) {
-            process.stderr.write(chalk_1.default.yellow('Warning: "output_schema" field in orchagent.json is ignored. Use schema.json file instead.\n'));
+        catch {
+            // File doesn't exist
+        }
+        if ((manifest.input_schema || manifest.output_schema) && !schemaFileExists) {
+            // Auto-create schema.json from inline schemas
+            const schemaContent = {};
+            if (manifest.input_schema)
+                schemaContent.input = manifest.input_schema;
+            if (manifest.output_schema)
+                schemaContent.output = manifest.output_schema;
+            if (options.dryRun) {
+                process.stderr.write(chalk_1.default.cyan('Would create schema.json from inline schemas in orchagent.json\n'));
+            }
+            else {
+                await promises_1.default.writeFile(schemaPath, JSON.stringify(schemaContent, null, 2) + '\n');
+                process.stderr.write(chalk_1.default.green('Created schema.json from inline schemas in orchagent.json\n'));
+                process.stderr.write(chalk_1.default.yellow('You can now remove input_schema/output_schema from orchagent.json\n'));
+            }
+        }
+        else if ((manifest.input_schema || manifest.output_schema) && schemaFileExists) {
+            process.stderr.write(chalk_1.default.yellow('Warning: inline schemas in orchagent.json are ignored (schema.json takes priority).\n'));
         }
         // Check for misplaced manifest fields at top level (common user error)
         const manifestFields = ['manifest_version', 'dependencies', 'max_hops', 'timeout_ms', 'per_call_downstream_cap'];
@@ -362,7 +385,6 @@ function registerPublishCommand(program) {
         let inputSchema;
         let outputSchema;
         let schemaFromFile = false;
-        const schemaPath = path_1.default.join(cwd, 'schema.json');
         try {
             const raw = await promises_1.default.readFile(schemaPath, 'utf-8');
             const schemas = JSON.parse(raw);

package/dist/commands/run.js

@@ -54,6 +54,7 @@ const spinner_1 = require("../lib/spinner");
 const llm_1 = require("../lib/llm");
 const analytics_1 = require("../lib/analytics");
 const pricing_1 = require("../lib/pricing");
+const package_json_1 = __importDefault(require("../../package.json"));
 const DEFAULT_VERSION = 'latest';
 const AGENTS_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent', 'agents');
 // Local execution environment variables
@@ -797,13 +798,21 @@ async function executeAgentLocally(agentDir, prompt, inputData, outputSchema, cu
         proc.stdout?.on('data', (data) => {
             stdout += data.toString();
         });
+        let lastUsage = null;
         proc.stderr?.on('data', (data) => {
             const text = data.toString();
             stderr += text;
             // Filter out heartbeat dots and orchagent events, show human-readable lines
             for (const line of text.split('\n')) {
-                if (line.startsWith('@@ORCHAGENT_EVENT:'))
+                if (line.startsWith('@@ORCHAGENT_EVENT:')) {
+                    try {
+                        const evt = JSON.parse(line.slice('@@ORCHAGENT_EVENT:'.length));
+                        if (evt.usage)
+                            lastUsage = evt.usage;
+                    }
+                    catch { /* ignore parse errors */ }
                     continue;
+                }
                 if (line.trim() === '.' || line.trim() === '')
                     continue;
                 process.stderr.write(line + '\n');
@@ -816,6 +825,12 @@ async function executeAgentLocally(agentDir, prompt, inputData, outputSchema, cu
                 resolve(1);
             });
         });
+        // Display token usage if available
+        const usage = lastUsage;
+        if (usage && (usage.input_tokens || usage.output_tokens)) {
+            const total = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+            process.stderr.write(chalk_1.default.gray(`${total.toLocaleString()} tokens (${(usage.input_tokens || 0).toLocaleString()} in, ${(usage.output_tokens || 0).toLocaleString()} out)\n`));
+        }
         // 7. Parse and print result
         if (stdout.trim()) {
             try {
@@ -1601,6 +1616,7 @@ async function executeCloud(agentRef, file, options) {
     const endpoint = options.endpoint?.trim() || agentMeta.default_endpoint || 'analyze';
     const headers = {
         Authorization: `Bearer ${resolved.apiKey}`,
+        'X-CLI-Version': package_json_1.default.version,
     };
     if (options.tenant) {
         headers['X-OrchAgent-Tenant'] = options.tenant;
@@ -1889,6 +1905,15 @@ async function executeCloud(agentRef, file, options) {
                     '  orch billing balance  # check current balance\n';
             throw new errors_1.CliError(errorMessage, errors_1.ExitCodes.PERMISSION_DENIED);
         }
+        if (errorCode === 'CLI_VERSION_TOO_OLD') {
+            spinner?.fail('CLI version too old');
+            const minVersion = typeof payload === 'object' && payload
+                ? payload.error?.min_version
+                : undefined;
+            throw new errors_1.CliError(`Your CLI version (${package_json_1.default.version}) is too old.\n\n` +
+                (minVersion ? `Minimum required: ${minVersion}\n` : '') +
+                'Update with: npm update -g @orchagent/cli');
+        }
         if (errorCode === 'LLM_KEY_REQUIRED') {
             spinner?.fail('LLM key required');
             throw new errors_1.CliError('This public agent requires you to provide an LLM key.\n' +
@@ -1978,6 +2003,11 @@ async function executeCloud(agentRef, file, options) {
                     if (typeof meta.execution_time_ms === 'number') {
                         parts.push(`${(meta.execution_time_ms / 1000).toFixed(1)}s execution`);
                     }
+                    const usage = meta.usage;
+                    if (usage && (usage.input_tokens || usage.output_tokens)) {
+                        const total = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+                        parts.push(`${total.toLocaleString()} tokens (${(usage.input_tokens || 0).toLocaleString()} in, ${(usage.output_tokens || 0).toLocaleString()} out)`);
+                    }
                     if (parts.length > 0) {
                         process.stderr.write(chalk_1.default.gray(`${parts.join(' · ')}\n`));
                     }
@@ -2044,6 +2074,11 @@ async function executeCloud(agentRef, file, options) {
             if (typeof meta.execution_time_ms === 'number') {
                 parts.push(`${(meta.execution_time_ms / 1000).toFixed(1)}s execution`);
             }
+            const usage = meta.usage;
+            if (usage && (usage.input_tokens || usage.output_tokens)) {
+                const total = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+                parts.push(`${total.toLocaleString()} tokens (${(usage.input_tokens || 0).toLocaleString()} in, ${(usage.output_tokens || 0).toLocaleString()} out)`);
+            }
             if (parts.length > 0) {
                 process.stderr.write(chalk_1.default.gray(`\n${parts.join(' · ')}\n`));
             }

package/dist/commands/schedule.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScheduleCommand = registerScheduleCommand;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const output_1 = require("../lib/output");
+const agent_ref_1 = require("../lib/agent-ref");
+const api_2 = require("../lib/api");
+// ============================================
+// HELPERS
+// ============================================
+async function resolveWorkspaceId(config, slug) {
+    const configFile = await (0, config_1.loadConfig)();
+    const targetSlug = slug ?? configFile.workspace;
+    if (!targetSlug) {
+        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
+    }
+    const response = await (0, api_1.request)(config, 'GET', '/workspaces');
+    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+    if (!workspace) {
+        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    }
+    return workspace.id;
+}
+function formatDate(iso) {
+    if (!iso)
+        return '-';
+    return new Date(iso).toLocaleString();
+}
+function statusColor(status) {
+    if (!status)
+        return '-';
+    switch (status) {
+        case 'completed': return chalk_1.default.green(status);
+        case 'failed': return chalk_1.default.red(status);
+        case 'running': return chalk_1.default.yellow(status);
+        default: return status;
+    }
+}
+// ============================================
+// COMMAND REGISTRATION
+// ============================================
+function registerScheduleCommand(program) {
+    const schedule = program
+        .command('schedule')
+        .description('Manage scheduled agent runs (cron and webhooks)');
+    // orch schedule list
+    schedule
+        .command('list')
+        .description('List schedules in your workspace')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .option('--agent <name>', 'Filter by agent name')
+        .option('--type <type>', 'Filter by type (cron or webhook)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const params = new URLSearchParams();
+        if (options.agent)
+            params.set('agent_id', options.agent);
+        if (options.type)
+            params.set('schedule_type', options.type);
+        params.set('limit', '100');
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        const result = await (0, api_1.request)(config, 'GET', `/workspaces/${workspaceId}/schedules${qs}`);
+        if (options.json) {
+            (0, output_1.printJson)(result);
+            return;
+        }
+        if (result.schedules.length === 0) {
+            process.stdout.write('No schedules found.\n');
+            process.stdout.write(chalk_1.default.gray('\nCreate one with: orch schedule create <org/agent> --cron "0 9 * * *"\n'));
+            return;
+        }
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.bold('ID'),
+                chalk_1.default.bold('Agent'),
+                chalk_1.default.bold('Type'),
+                chalk_1.default.bold('Schedule'),
+                chalk_1.default.bold('Enabled'),
+                chalk_1.default.bold('Last Run'),
+                chalk_1.default.bold('Status'),
+                chalk_1.default.bold('Runs'),
+            ],
+        });
+        result.schedules.forEach((s) => {
+            table.push([
+                s.id.slice(0, 8),
+                `${s.agent_name}@${s.agent_version}`,
+                s.schedule_type,
+                s.schedule_type === 'cron' ? (s.cron_expression ?? '-') : 'webhook',
+                s.enabled ? chalk_1.default.green('yes') : chalk_1.default.red('no'),
+                formatDate(s.last_run_at),
+                statusColor(s.last_run_status),
+                s.run_count.toString(),
+            ]);
+        });
+        process.stdout.write(`\n${table.toString()}\n`);
+        process.stdout.write(chalk_1.default.gray(`\n${result.total} schedule(s) total\n`));
+    });
+    // orch schedule create <agent>
+    schedule
+        .command('create <agent>')
+        .description('Create a cron or webhook schedule (org/agent[@version])')
+        .option('--cron <expression>', 'Cron expression (e.g., "0 9 * * 1" for every Monday 9am)')
+        .option('--webhook', 'Create a webhook-triggered schedule instead of cron')
+        .option('--timezone <tz>', 'Timezone for cron schedule (default: UTC)', 'UTC')
+        .option('--input <json>', 'Input data as JSON string')
+        .option('--provider <provider>', 'LLM provider (anthropic, openai, gemini)')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .action(async (agentArg, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        if (!options.cron && !options.webhook) {
+            throw new errors_1.CliError('Specify --cron <expression> or --webhook');
+        }
+        if (options.cron && options.webhook) {
+            throw new errors_1.CliError('Cannot use both --cron and --webhook. Choose one.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const ref = (0, agent_ref_1.parseAgentRef)(agentArg);
+        // Resolve agent to get the ID
+        const agent = await (0, api_2.getAgentWithFallback)(config, ref.org, ref.agent, ref.version);
+        // Parse input data
+        let inputData;
+        if (options.input) {
+            try {
+                inputData = JSON.parse(options.input);
+            }
+            catch {
+                throw new errors_1.CliError('Invalid JSON in --input. Use single quotes: --input \'{"key": "value"}\'');
+            }
+        }
+        const scheduleType = options.webhook ? 'webhook' : 'cron';
+        const body = {
+            agent_id: agent.id,
+            agent_name: ref.agent,
+            agent_version: ref.version === 'latest' ? (agent.version ?? ref.version) : ref.version,
+            schedule_type: scheduleType,
+            timezone: options.timezone ?? 'UTC',
+        };
+        if (options.cron)
+            body.cron_expression = options.cron;
+        if (inputData)
+            body.input_data = inputData;
+        if (options.provider)
+            body.llm_provider = options.provider;
+        const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules`, {
+            body: JSON.stringify(body),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const s = result.schedule;
+        process.stdout.write(chalk_1.default.green('\u2713') + ` Schedule created\n\n`);
+        process.stdout.write(`  ID:     ${s.id}\n`);
+        process.stdout.write(`  Agent:  ${s.agent_name}@${s.agent_version}\n`);
+        process.stdout.write(`  Type:   ${s.schedule_type}\n`);
+        if (s.schedule_type === 'cron') {
+            process.stdout.write(`  Cron:   ${s.cron_expression}\n`);
+            process.stdout.write(`  TZ:     ${s.timezone}\n`);
+            if (s.next_run_at) {
+                process.stdout.write(`  Next:   ${formatDate(s.next_run_at)}\n`);
+            }
+        }
+        else {
+            if (s.webhook_url) {
+                process.stdout.write(`\n  ${chalk_1.default.bold('Webhook URL')} (save this — secret shown once):\n`);
+                process.stdout.write(`  ${s.webhook_url}\n`);
+            }
+        }
+        process.stdout.write('\n');
+    });
+    // orch schedule update <schedule-id>
+    schedule
+        .command('update <schedule-id>')
+        .description('Update a schedule')
+        .option('--cron <expression>', 'New cron expression')
+        .option('--timezone <tz>', 'New timezone')
+        .option('--input <json>', 'New input data as JSON')
+        .option('--provider <provider>', 'New LLM provider')
+        .option('--enable', 'Enable the schedule')
+        .option('--disable', 'Disable the schedule')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .action(async (scheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        if (options.enable && options.disable) {
+            throw new errors_1.CliError('Cannot use both --enable and --disable');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const updates = {};
+        if (options.cron)
+            updates.cron_expression = options.cron;
+        if (options.timezone)
+            updates.timezone = options.timezone;
+        if (options.provider)
+            updates.llm_provider = options.provider;
+        if (options.enable)
+            updates.enabled = true;
+        if (options.disable)
+            updates.enabled = false;
+        if (options.input) {
+            try {
+                updates.input_data = JSON.parse(options.input);
+            }
+            catch {
+                throw new errors_1.CliError('Invalid JSON in --input');
+            }
+        }
+        if (Object.keys(updates).length === 0) {
+            throw new errors_1.CliError('Nothing to update. Specify at least one option.');
+        }
+        const result = await (0, api_1.request)(config, 'PATCH', `/workspaces/${workspaceId}/schedules/${scheduleId}`, {
+            body: JSON.stringify(updates),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const s = result.schedule;
+        process.stdout.write(chalk_1.default.green('\u2713') + ` Schedule updated\n\n`);
+        process.stdout.write(`  ID:      ${s.id}\n`);
+        process.stdout.write(`  Enabled: ${s.enabled ? chalk_1.default.green('yes') : chalk_1.default.red('no')}\n`);
+        if (s.cron_expression) {
+            process.stdout.write(`  Cron:    ${s.cron_expression}\n`);
+            process.stdout.write(`  TZ:      ${s.timezone}\n`);
+        }
+        if (s.next_run_at) {
+            process.stdout.write(`  Next:    ${formatDate(s.next_run_at)}\n`);
+        }
+        process.stdout.write('\n');
+    });
+    // orch schedule delete <schedule-id>
+    schedule
+        .command('delete <schedule-id>')
+        .description('Delete a schedule')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .action(async (scheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        await (0, api_1.request)(config, 'DELETE', `/workspaces/${workspaceId}/schedules/${scheduleId}`);
+        process.stdout.write(chalk_1.default.green('\u2713') + ` Schedule ${scheduleId} deleted\n`);
+    });
+    // orch schedule trigger <schedule-id>
+    schedule
+        .command('trigger <schedule-id>')
+        .description('Manually trigger a schedule execution')
+        .option('--input <json>', 'Override input data as JSON')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .action(async (scheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        let body;
+        if (options.input) {
+            try {
+                JSON.parse(options.input); // validate
+                body = options.input;
+            }
+            catch {
+                throw new errors_1.CliError('Invalid JSON in --input');
+            }
+        }
+        process.stdout.write('Triggering schedule...\n');
+        const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules/${scheduleId}/trigger`, body ? {
+            body,
+            headers: { 'Content-Type': 'application/json' },
+        } : {});
+        process.stdout.write(chalk_1.default.green('\u2713') + ` Run completed\n\n`);
+        process.stdout.write(`  Run ID:   ${result.run_id}\n`);
+        process.stdout.write(`  Status:   ${statusColor(result.status)}\n`);
+        process.stdout.write(`  Duration: ${result.duration_ms}ms\n`);
+        if (result.error) {
+            process.stdout.write(`  Error:    ${chalk_1.default.red(result.error)}\n`);
+        }
+        if (result.output) {
+            process.stdout.write(`\n  Output:\n`);
+            process.stdout.write(`  ${JSON.stringify(result.output, null, 2).split('\n').join('\n  ')}\n`);
+        }
+        process.stdout.write('\n');
+    });
+}

package/dist/lib/api.js

@@ -32,6 +32,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiError = void 0;
 exports.safeFetch = safeFetch;
@@ -65,6 +68,7 @@ exports.listAgentKeys = listAgentKeys;
 exports.createAgentKey = createAgentKey;
 exports.deleteAgentKey = deleteAgentKey;
 const errors_1 = require("./errors");
+const package_json_1 = __importDefault(require("../../package.json"));
 const DEFAULT_TIMEOUT_MS = 15000;
 const CALL_TIMEOUT_MS = 120000; // 2 minutes for agent calls (can take time)
 const MAX_RETRIES = 3;
@@ -195,6 +199,7 @@ async function request(config, method, path, options = {}) {
         method,
         headers: {
             Authorization: `Bearer ${config.apiKey}`,
+            'X-CLI-Version': package_json_1.default.version,
             ...(options.headers ?? {}),
         },
         body: options.body,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.51",
+  "version": "0.3.53",
   "description": "Command-line interface for orchagent — deploy and run AI agents for your team",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",

package/src/resources/agent_runner.py

@@ -414,6 +414,12 @@ class AnthropicProvider:
             if b.type == "tool_use":
                 yield b.id, b.name, b.input
 
+    def extract_usage(self, r):
+        u = getattr(r, "usage", None)
+        if u:
+            return {"input_tokens": u.input_tokens, "output_tokens": u.output_tokens}
+        return {"input_tokens": 0, "output_tokens": 0}
+
     def append_turn(self, messages, response, tool_results):
         messages.append({"role": "assistant", "content": response.content})
         results = []
@@ -466,6 +472,12 @@ class OpenAIProvider:
         for tc in r.choices[0].message.tool_calls:
             yield tc.id, tc.function.name, json.loads(tc.function.arguments)
 
+    def extract_usage(self, r):
+        u = getattr(r, "usage", None)
+        if u:
+            return {"input_tokens": getattr(u, "prompt_tokens", 0) or 0, "output_tokens": getattr(u, "completion_tokens", 0) or 0}
+        return {"input_tokens": 0, "output_tokens": 0}
+
     def append_turn(self, messages, response, tool_results):
         msg = response.choices[0].message
         # Build assistant message dict with tool_calls
@@ -598,6 +610,12 @@ class GeminiProvider:
             if p.function_call:
                 yield str(i), p.function_call.name, dict(p.function_call.args)
 
+    def extract_usage(self, r):
+        u = getattr(r, "usage_metadata", None)
+        if u:
+            return {"input_tokens": getattr(u, "prompt_token_count", 0) or 0, "output_tokens": getattr(u, "candidates_token_count", 0) or 0}
+        return {"input_tokens": 0, "output_tokens": 0}
+
     def append_turn(self, messages, response, tool_results):
         types = self._genai_types
         # Append the model's response as a Content object
@@ -711,6 +729,7 @@ def main():
     tools = provider.convert_tools(canonical_tools)
 
     messages = [{"role": "user", "content": json.dumps(input_data, indent=2)}]
+    total_usage = {"input_tokens": 0, "output_tokens": 0}
 
     for turn in range(args.max_turns):
         emit_event("turn_start", turn=turn + 1, max_turns=args.max_turns)
@@ -721,11 +740,15 @@ def main():
             try:
                 response = provider.call(system_prompt, messages, tools)
             except Exception as e:
-                emit_event("error", message=str(e)[:200])
+                emit_event("error", message=str(e)[:200], usage=total_usage)
                 error_exit("LLM API error (%s): %s" % (provider_name, e))
 
+        turn_usage = provider.extract_usage(response)
+        total_usage["input_tokens"] += turn_usage["input_tokens"]
+        total_usage["output_tokens"] += turn_usage["output_tokens"]
+
         if not provider.has_tool_use(response):
-            emit_event("done")
+            emit_event("done", usage=total_usage)
             final_text = provider.extract_text(response)
             try:
                 result = json.loads(final_text)
@@ -742,7 +765,7 @@ def main():
             emit_event("tool_result", turn=turn + 1, tool=name, status="error" if result_text.startswith("[ERROR]") else "ok")
 
             if is_submit:
-                emit_event("done")
+                emit_event("done", usage=total_usage)
                 try:
                     result = json.loads(result_text)
                 except json.JSONDecodeError:
@@ -760,7 +783,7 @@ def main():
         else:
             print("[agent] Turn %d/%d completed (%d tool calls)" % (turn + 1, args.max_turns, num_calls), file=sys.stderr)
 
-    emit_event("error", message="max turns reached")
+    emit_event("error", message="max turns reached", usage=total_usage)
     error_exit("Agent reached maximum turns (%d) without submitting a result" % args.max_turns)