@bctrl/cli 0.1.4 → 0.1.6

package/dist/commands/shared/{rest.js → operation.js}

@@ -1,11 +1,10 @@
+import { CLI_OPENAPI_ROUTES } from '../../generated/openapi-routes.js';
 import { Command } from 'commander';
-import { CliError } from '../../runtime/errors.js';
 import { readJsonFile } from './io.js';
 import { parsePositiveInteger } from './options.js';
 import { addOutputFlags, outputData } from './output.js';
-export function pathTemplate(template, params) {
-    return template.replace(/\{(\w+)\}/g, (_, key) => encodeURIComponent(params[key] ?? ''));
-}
+import { CliError } from '../../runtime/errors.js';
+import { addCliOperationHelp } from './help.js';
 export function addPaginationFlags(command) {
     return command
         .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
@@ -14,80 +13,125 @@ export function addPaginationFlags(command) {
 export function addJsonBodyFlag(command) {
     return command.option('--input <path>', 'Read JSON request body from file, or - for stdin');
 }
-export async function requestAndPrint(deps, method, path, options) {
-    const client = await deps.apiClient();
-    const requestOptions = options
-        ? {
-            ...(options.query !== undefined ? { query: options.query } : {}),
-            ...(options.body !== undefined ? { body: options.body } : {}),
-            ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
+export function outputFlags(options) {
+    return {
+        ...(typeof options.json === 'string' || typeof options.json === 'boolean'
+            ? { json: options.json }
+            : {}),
+        ...(typeof options.jq === 'string' ? { jq: options.jq } : {}),
+        ...(typeof options.template === 'string' ? { template: options.template } : {}),
+    };
+}
+export function operationPath(operationId, pathParams) {
+    const route = CLI_OPENAPI_ROUTES[operationId];
+    return route.path.replace(/\{([^}]+)\}/g, (_match, key) => {
+        const value = pathParams?.[key];
+        if (value === undefined) {
+            throw new Error(`Missing path parameter "${key}" for ${operationId}`);
         }
-        : undefined;
-    const clientOptions = requestOptions && Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
-    const result = method === 'get'
-        ? await client.get(path, clientOptions)
-        : method === 'post'
-            ? await client.post(path, clientOptions)
-            : method === 'patch'
-                ? await client.patch(path, clientOptions)
-                : method === 'put'
-                    ? await client.put(path, clientOptions)
-                    : await client.delete(path, clientOptions);
-    await outputData(deps.io, result, options?.output ? outputFlags(options.output) : undefined);
-}
-export async function bodyFromInputOption(path) {
-    return path ? readJsonFile(path) : {};
+        return encodeURIComponent(String(value));
+    });
+}
+export async function requestOperationAndPrint(deps, operationId, input) {
+    const result = await requestOperation(deps, operationId, input);
+    await outputData(deps.io, result, input.output);
+}
+export async function requestOperation(deps, operationId, input) {
+    const route = CLI_OPENAPI_ROUTES[operationId];
+    const client = await deps.apiClient();
+    const path = operationPath(operationId, input.pathParams);
+    const requestOptions = {
+        ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+        ...('body' in input && input.body !== undefined ? { body: input.body } : {}),
+        ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
+    };
+    const options = Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
+    const result = route.method === 'get'
+        ? await client.get(path, options)
+        : route.method === 'post'
+            ? await client.post(path, options)
+            : route.method === 'patch'
+                ? await client.patch(path, options)
+                : route.method === 'put'
+                    ? await client.put(path, options)
+                    : await client.delete(path, options);
+    return result;
 }
-export function createListCommand(factory, config) {
+export async function uploadOperationFile(deps, operationId, input) {
+    const client = await deps.apiClient();
+    return client.uploadFile(operationPath(operationId, input.pathParams), {
+        file: input.file,
+        fileName: input.fileName,
+        ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+        ...(input.fields ? { fields: input.fields } : {}),
+    });
+}
+export async function downloadOperation(deps, operationId, input) {
+    const client = await deps.apiClient();
+    return client.download(operationPath(operationId, input.pathParams));
+}
+export async function streamOperationText(deps, operationId, input) {
+    const client = await deps.apiClient();
+    return client.streamText(operationPath(operationId, input.pathParams), {
+        ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+    });
+}
+export function createOperationListCommand(factory, config) {
     let command = new Command(config.name ?? 'list').description(config.description);
+    command = addCliOperationHelp(command, config.operationId);
     command = config.configure ? config.configure(command) : addPaginationFlags(command);
     command = addOutputFlags(command);
     return command.action(async (options) => {
-        await requestAndPrint(factory, 'get', config.path, {
+        await requestOperationAndPrint(factory, config.operationId, {
             query: config.query ? config.query(options) : defaultListQuery(options),
             output: outputFlags(options),
         });
     });
 }
-export function createViewCommand(factory, config) {
+export function createOperationViewCommand(factory, config) {
     const argName = config.argName ?? 'id';
     let command = new Command(config.name ?? 'view')
         .description(config.description)
         .argument(`<${argName}>`);
+    command = addCliOperationHelp(command, config.operationId);
     command = config.configure ? config.configure(command) : command;
     command = addOutputFlags(command);
     return command.action(async (id, options) => {
-        await requestAndPrint(factory, 'get', pathTemplate(config.path, { [argName]: id, id }), {
+        await requestOperationAndPrint(factory, config.operationId, {
+            pathParams: { [argName]: id, id },
             query: config.query ? config.query(id, options) : undefined,
             output: outputFlags(options),
         });
     });
 }
-export function createDeleteCommand(factory, config) {
+export function createOperationDeleteCommand(factory, config) {
     const argNames = config.argNames ?? ['id'];
     let command = new Command(config.name ?? 'delete').description(config.description);
+    command = addCliOperationHelp(command, config.operationId);
     for (const arg of argNames)
         command = command.argument(`<${arg}>`);
     command = command.option('-y, --yes', 'Confirm deletion');
     command = config.configure ? config.configure(command) : command;
     command = addOutputFlags(command);
-    return command.action(async (...args) => {
-        const options = getActionOptions(args);
+    return command.action(async (...actionArgs) => {
+        const options = getActionOptions(actionArgs);
         if (options.yes !== true) {
             throw new CliError('Refusing to delete without --yes');
         }
         const params = {};
         for (let i = 0; i < argNames.length; i += 1)
-            params[argNames[i]] = String(args[i]);
-        await requestAndPrint(factory, 'delete', pathTemplate(config.path, params), {
+            params[argNames[i]] = String(actionArgs[i]);
+        await requestOperationAndPrint(factory, config.operationId, {
+            pathParams: params,
             query: config.query ? config.query(params, options) : undefined,
             output: outputFlags(options),
         });
     });
 }
-export function createJsonBodyCommand(factory, config) {
+export function createOperationJsonBodyCommand(factory, config) {
     const argNames = config.argNames ?? [];
     let command = new Command(config.name).description(config.description);
+    command = addCliOperationHelp(command, config.operationId);
     for (const arg of argNames)
         command = command.argument(`<${arg}>`);
     command = config.configure ? config.configure(command) : addJsonBodyFlag(command);
@@ -97,8 +141,11 @@ export function createJsonBodyCommand(factory, config) {
         const args = {};
         for (let i = 0; i < argNames.length; i += 1)
             args[argNames[i]] = String(actionArgs[i]);
-        const body = config.body ? await config.body(args, options) : await bodyFromInputOption(String(options.input ?? ''));
-        await requestAndPrint(factory, config.method, pathTemplate(config.path, args), {
+        const body = config.body
+            ? await config.body(args, options)
+            : await bodyFromInputOption(String(options.input ?? ''));
+        await requestOperationAndPrint(factory, config.operationId, {
+            pathParams: args,
             body,
             query: config.query ? config.query(args, options) : undefined,
             output: outputFlags(options),
@@ -111,14 +158,8 @@ function defaultListQuery(options) {
         cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
     };
 }
-export function outputFlags(options) {
-    return {
-        ...(typeof options.json === 'string' || typeof options.json === 'boolean'
-            ? { json: options.json }
-            : {}),
-        ...(typeof options.jq === 'string' ? { jq: options.jq } : {}),
-        ...(typeof options.template === 'string' ? { template: options.template } : {}),
-    };
+async function bodyFromInputOption(path) {
+    return path ? readJsonFile(path) : {};
 }
 function getActionOptions(args) {
     const candidate = args.at(-2);

package/dist/commands/space/index.js

@@ -1,71 +1,80 @@
 import { Command } from 'commander';
-import { createDeleteCommand, createJsonBodyCommand, createViewCommand } from '../shared/rest.js';
 import { readJsonFile } from '../shared/io.js';
+import { outputFlags, requestOperationAndPrint } from '../shared/operation.js';
+import { addOutputFlags } from '../shared/output.js';
+import { CliError } from '../../runtime/errors.js';
 import { createSpaceListCommand } from './list.js';
 export function createSpaceCommand(factory) {
     const command = new Command('space').description('Manage BCTRL spaces');
     command.addCommand(createSpaceListCommand(factory));
-    command.addCommand(createViewCommand(factory, {
-        name: 'get',
-        description: 'View a space',
-        path: '/spaces/{spaceId}',
-        argName: 'spaceId',
+    command.addCommand(addOutputFlags(new Command('get').description('View a space').argument('<spaceId>')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.get', {
+            pathParams: { spaceId },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'create',
-        description: 'Create a space',
-        method: 'post',
-        path: '/spaces',
-        configure: (cmd) => cmd
-            .option('--name <name>', 'Space name')
-            .option('--subaccount-id <id>', 'Subaccount id')
-            .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return {
-                name: options.name,
-                subaccountId: options.subaccountId,
-            };
-        },
+    command.addCommand(addOutputFlags(new Command('create')
+        .description('Create a space')
+        .option('--name <name>', 'Space name')
+        .option('--subaccount-id <id>', 'Subaccount id')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (options) => {
+        await requestOperationAndPrint(factory, 'spaces.create', {
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : {
+                    name: options.name,
+                    subaccountId: options.subaccountId,
+                },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'patch',
-        description: 'Edit a space',
-        method: 'patch',
-        path: '/spaces/{spaceId}',
-        argNames: ['spaceId'],
-        configure: (cmd) => cmd
-            .option('--name <name>', 'Space name')
-            .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return { name: options.name };
-        },
+    command.addCommand(addOutputFlags(new Command('patch')
+        .description('Edit a space')
+        .argument('<spaceId>')
+        .option('--name <name>', 'Space name')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.update', {
+            pathParams: { spaceId },
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : { name: options.name },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createDeleteCommand(factory, {
-        description: 'Delete a space',
-        path: '/spaces/{spaceId}',
-        argNames: ['spaceId'],
+    command.addCommand(addOutputFlags(new Command('delete')
+        .description('Delete a space')
+        .argument('<spaceId>')
+        .option('-y, --yes', 'Confirm deletion')).action(async (spaceId, options) => {
+        if (options.yes !== true) {
+            throw new CliError('Refusing to delete without --yes');
+        }
+        await requestOperationAndPrint(factory, 'spaces.delete', {
+            pathParams: { spaceId },
+            output: outputFlags(options),
+        });
     }));
     command.addCommand(createSpaceEnvironmentCommand(factory));
     return command;
 }
 function createSpaceEnvironmentCommand(factory) {
     const command = new Command('env').description('Manage a space environment');
-    command.addCommand(createViewCommand(factory, {
-        name: 'get',
-        description: 'Get a space environment',
-        path: '/spaces/{spaceId}/environment',
-        argName: 'spaceId',
+    command.addCommand(addOutputFlags(new Command('get').description('Get a space environment').argument('<spaceId>')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.environment.get', {
+            pathParams: { spaceId },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'patch',
-        description: 'Update a space environment',
-        method: 'patch',
-        path: '/spaces/{spaceId}/environment',
-        argNames: ['spaceId'],
+    command.addCommand(addOutputFlags(new Command('patch')
+        .description('Update a space environment')
+        .argument('<spaceId>')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.environment.update', {
+            pathParams: { spaceId },
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : {},
+            output: outputFlags(options),
+        });
     }));
     return command;
 }

package/dist/commands/space/list.js

@@ -1,16 +1,17 @@
-import { addPaginationFlags, createListCommand } from '../shared/rest.js';
+import { Command } from 'commander';
+import { addPaginationFlags, outputFlags, requestOperationAndPrint } from '../shared/operation.js';
+import { addOutputFlags } from '../shared/output.js';
 export function createSpaceListCommand(factory) {
-    return createListCommand(factory, {
-        description: 'List spaces',
-        path: '/spaces',
-        configure: (cmd) => addPaginationFlags(cmd)
-            .option('--subaccount <id>', 'Filter by subaccount id')
-            .option('--query <text>', 'Search by id or name'),
-        query: (options) => ({
-            subaccountId: typeof options.subaccount === 'string' ? options.subaccount : undefined,
-            query: typeof options.query === 'string' ? options.query : undefined,
-            limit: typeof options.limit === 'number' ? options.limit : undefined,
-            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
-        }),
+    return addOutputFlags(addPaginationFlags(new Command('list')
+        .description('List spaces')
+        .option('--subaccount <id>', 'Filter by subaccount id'))).action(async (options) => {
+        await requestOperationAndPrint(factory, 'spaces.list', {
+            query: {
+                subaccountId: options.subaccount,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        });
     });
 }

package/dist/commands/subaccount/index.js

@@ -2,12 +2,12 @@ import { Command } from 'commander';
 import { readJsonFile } from '../shared/io.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags } from '../shared/output.js';
-import { createJsonBodyCommand, addPaginationFlags, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+import { addPaginationFlags, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, outputFlags, requestOperationAndPrint, } from '../shared/operation.js';
 export function createSubaccountCommand(factory) {
     const command = new Command('subaccount').description('Manage subaccounts');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'subaccounts.list',
         description: 'List subaccounts',
-        path: '/subaccounts',
         query: (options) => ({
             limit: typeof options.limit === 'number' ? options.limit : undefined,
             cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
@@ -22,52 +22,45 @@ export function createSubaccountCommand(factory) {
             .option('--external-id <id>', 'Filter by external id')
             .option('--query <text>', 'Search by id, name, or external id'),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'subaccounts.get',
         name: 'get',
         description: 'Get a subaccount',
-        path: '/subaccounts/{subaccountId}',
         argName: 'subaccountId',
         configure: (cmd) => cmd.option('--include <value>', 'Include related data, for example usage'),
         query: (_id, options) => ({
             include: typeof options.include === 'string' ? options.include : undefined,
         }),
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'create',
-        description: 'Create a subaccount',
-        method: 'post',
-        path: '/subaccounts',
-        configure: (cmd) => cmd
-            .option('--name <name>', 'Subaccount name')
-            .option('--external-id <id>', 'External id')
-            .option('--metadata-file <path>', 'Metadata JSON file')
-            .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return {
-                name: options.name,
-                externalId: options.externalId,
-                metadata: typeof options.metadataFile === 'string'
-                    ? await readJsonFile(options.metadataFile, '--metadata-file')
-                    : undefined,
-            };
-        },
+    command.addCommand(createSubaccountWriteCommand(factory, 'create', 'subaccounts.create'));
+    command.addCommand(createSubaccountWriteCommand(factory, 'patch', 'subaccounts.update', ['subaccountId']));
+    command.addCommand(addOutputFlags(new Command('archive')
+        .description('Archive a subaccount')
+        .argument('<subaccountId>')
+        .requiredOption('-y, --yes', 'Confirm archive')).action(async (subaccountId, options) => {
+        await requestOperationAndPrint(factory, 'subaccounts.archive', {
+            pathParams: { subaccountId },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'patch',
-        description: 'Update a subaccount',
-        method: 'patch',
-        path: '/subaccounts/{subaccountId}',
-        argNames: ['subaccountId'],
+    command.addCommand(createSubaccountUsageCommand(factory));
+    return command;
+}
+function createSubaccountWriteCommand(factory, name, operationId, argNames = []) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId,
+        name,
+        description: name === 'create' ? 'Create a subaccount' : 'Update a subaccount',
+        argNames,
         configure: (cmd) => cmd
             .option('--name <name>', 'Subaccount name')
             .option('--external-id <id>', 'External id')
             .option('--metadata-file <path>', 'Metadata JSON file')
             .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
             return {
                 name: options.name,
                 externalId: options.externalId,
@@ -76,36 +69,25 @@ export function createSubaccountCommand(factory) {
                     : undefined,
             };
         },
-    }));
-    command.addCommand(addOutputFlags(new Command('archive')
-        .description('Archive a subaccount')
-        .argument('<id>')
-        .requiredOption('-y, --yes', 'Confirm archive'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'post', `/subaccounts/${encodeURIComponent(id)}/archive`, {
-            output: options,
-        });
-    }));
-    command.addCommand(createSubaccountUsageCommand(factory));
-    return command;
+    });
 }
 function createSubaccountUsageCommand(factory) {
     return addOutputFlags(new Command('usage')
         .description('Show subaccount usage')
         .argument('[id]')
         .option('-L, --limit <number>', 'Maximum number of usage records to return', parsePositiveInteger)
-        .option('--cursor <cursor>', 'Pagination cursor'))
-        .action(async (id, options) => {
+        .option('--cursor <cursor>', 'Pagination cursor')).action(async (id, options) => {
         if (id) {
-            await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}`, {
-                query: { include: 'usage' },
-                output: options,
+            await requestOperationAndPrint(factory, 'subaccounts.get', {
+                pathParams: { subaccountId: id },
+                query: { include: ['usage'] },
+                output: outputFlags(options),
             });
             return;
         }
-        await requestAndPrint(factory, 'get', '/subaccounts/usage', {
+        await requestOperationAndPrint(factory, 'subaccounts.usage.list', {
             query: { limit: options.limit, cursor: options.cursor },
-            output: options,
+            output: outputFlags(options),
         });
     });
 }

package/dist/commands/tool/index.js

@@ -1,48 +1,46 @@
 import { Command } from 'commander';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, } from '../shared/rest.js';
+import { parsePositiveInteger } from '../shared/options.js';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from '../shared/operation.js';
 export function createToolCommand(factory) {
     const command = new Command('tool').description('Manage tools');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'tools.list',
         description: 'List tools',
-        path: '/tools',
         configure: (cmd) => cmd
             .option('--space <id>', 'Filter by space id')
-            .option('--query <text>', 'Search tools')
-            .option('--status <status>', 'Filter by status'),
+            .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
+            .option('--cursor <cursor>', 'Pagination cursor'),
         query: (options) => ({
             spaceId: typeof options.space === 'string' ? options.space : undefined,
-            query: typeof options.query === 'string' ? options.query : undefined,
-            status: typeof options.status === 'string' ? options.status : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'tools.get',
         name: 'get',
         description: 'Get a tool',
-        path: '/tools/{id}',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.create',
         name: 'create',
         description: 'Create a tool',
-        method: 'post',
-        path: '/tools',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.update',
         name: 'patch',
         description: 'Update a tool',
-        method: 'patch',
-        path: '/tools/{id}',
         argNames: ['id'],
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.test',
         name: 'test',
         description: 'Test a tool',
-        method: 'post',
-        path: '/tools/{id}/test',
         argNames: ['id'],
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'tools.delete',
         description: 'Delete a tool',
-        path: '/tools/{id}',
     }));
     return command;
 }

package/dist/commands/tool-call/index.js

@@ -1,10 +1,10 @@
 import { Command } from 'commander';
-import { createListCommand, createViewCommand } from '../shared/rest.js';
+import { createOperationListCommand, createOperationViewCommand } from '../shared/operation.js';
 export function createToolCallCommand(factory) {
     const command = new Command('tool-call').description('Inspect BCTRL tool calls');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'tool-calls.list',
         description: 'List tool calls',
-        path: '/tool-calls',
         configure: (cmd) => cmd
             .option('--space <id>', 'Space id')
             .option('--tool <id>', 'Filter by tool id')
@@ -21,10 +21,10 @@ export function createToolCallCommand(factory) {
             actor: typeof options.actor === 'string' ? options.actor : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'tool-calls.get',
         name: 'get',
         description: 'View a tool call',
-        path: '/tool-calls/{id}',
     }));
     return command;
 }