faces-cli 1.5.14 → 1.6.0

package/dist/client.d.ts

@@ -1,6 +1,15 @@
 export declare class FacesAPIError extends Error {
     statusCode: number;
-    constructor(statusCode: number, message: string);
+    errorCode?: string;
+    fallbackAvailable?: boolean;
+    constructor(statusCode: number, message: string, opts?: {
+        errorCode?: string;
+        fallbackAvailable?: boolean;
+    });
+}
+export interface ResponseWithHeaders<T = unknown> {
+    data: T;
+    headers: Record<string, string>;
 }
 export declare class FacesClient {
     private baseUrl;
@@ -19,6 +28,10 @@ export declare class FacesClient {
         requireJwt?: boolean;
         body?: unknown;
     }): Promise<unknown>;
+    postWithHeaders(path: string, opts?: {
+        requireJwt?: boolean;
+        body?: unknown;
+    }): Promise<ResponseWithHeaders>;
     postNoAuth(path: string, body: unknown): Promise<unknown>;
     patch(path: string, opts?: {
         requireJwt?: boolean;

package/dist/client.js

@@ -1,9 +1,13 @@
 export class FacesAPIError extends Error {
     statusCode;
-    constructor(statusCode, message) {
+    errorCode;
+    fallbackAvailable;
+    constructor(statusCode, message, opts) {
         super(message);
         this.statusCode = statusCode;
         this.name = 'FacesAPIError';
+        this.errorCode = opts?.errorCode;
+        this.fallbackAvailable = opts?.fallbackAvailable;
     }
 }
 export class FacesClient {
@@ -40,14 +44,24 @@ export class FacesClient {
     }
     async parseError(resp) {
         let msg = resp.statusText;
+        let errorCode;
+        let fallbackAvailable;
         try {
             const body = await resp.json();
-            const raw = body.detail ?? body.error ?? body.message ?? msg;
-            if (typeof raw === 'object' && raw !== null && 'message' in raw) {
-                msg = String(raw.message);
+            // Structured OAuth rejection (422)
+            if (body.error === 'oauth_rejected') {
+                errorCode = 'oauth_rejected';
+                fallbackAvailable = body.fallback_available;
+                msg = String(body.detail ?? 'OAuth request rejected');
             }
             else {
-                msg = typeof raw === 'object' ? JSON.stringify(raw) : String(raw);
+                const raw = body.detail ?? body.error ?? body.message ?? msg;
+                if (typeof raw === 'object' && raw !== null && 'message' in raw) {
+                    msg = String(raw.message);
+                }
+                else {
+                    msg = typeof raw === 'object' ? JSON.stringify(raw) : String(raw);
+                }
             }
         }
         catch {
@@ -57,7 +71,7 @@ export class FacesClient {
             msg = `Payment required: ${msg}`;
         if (resp.status === 403)
             msg = `Forbidden: ${msg}`;
-        return new FacesAPIError(resp.status, msg);
+        return new FacesAPIError(resp.status, msg, { errorCode, fallbackAvailable });
     }
     async get(path, opts = {}) {
         let url = this.url(path);
@@ -91,6 +105,26 @@ export class FacesClient {
             throw await this.parseError(resp);
         return resp.json();
     }
+    async postWithHeaders(path, opts = {}) {
+        let resp;
+        try {
+            resp = await fetch(this.url(path), {
+                method: 'POST',
+                headers: { ...this.authHeader(opts.requireJwt), 'Content-Type': 'application/json' },
+                body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+            });
+        }
+        catch (err) {
+            this.wrapNetworkError(err, path);
+        }
+        if (!resp.ok)
+            throw await this.parseError(resp);
+        const headers = {};
+        for (const [k, v] of resp.headers.entries())
+            headers[k] = v;
+        const data = await resp.json();
+        return { data, headers };
+    }
     async postNoAuth(path, body) {
         let resp;
         try {

package/dist/commands/account/preferences.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base.js';
+export default class AccountPreferences extends BaseCommand {
+    static description: string;
+    static flags: {
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        key: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<unknown>;
+}

package/dist/commands/account/preferences.js

@@ -0,0 +1,65 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+export default class AccountPreferences extends BaseCommand {
+    static description = 'View or update account preferences (api_fallback, default_model)';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static args = {
+        key: Args.string({ description: 'Preference key to update (api_fallback, default_model)' }),
+        value: Args.string({ description: 'New value' }),
+    };
+    static examples = [
+        'faces account:preferences',
+        'faces account:preferences default_model gpt-5.4',
+        'faces account:preferences api_fallback true',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(AccountPreferences);
+        const client = this.makeClient(flags);
+        // If no key provided, show current preferences
+        if (!args.key) {
+            let data;
+            try {
+                data = await client.get('/v1/user/preferences');
+            }
+            catch (err) {
+                if (err instanceof FacesAPIError)
+                    this.error(`Error (${err.statusCode}): ${err.message}`);
+                throw err;
+            }
+            if (!this.jsonEnabled())
+                this.printHuman(data);
+            return data;
+        }
+        // Update a preference
+        if (!args.value)
+            this.error('Provide a value to set.');
+        const validKeys = ['api_fallback', 'default_model'];
+        if (!validKeys.includes(args.key)) {
+            this.error(`Unknown preference '${args.key}'. Valid keys: ${validKeys.join(', ')}`);
+        }
+        let parsedValue = args.value;
+        if (args.key === 'api_fallback') {
+            if (args.value !== 'true' && args.value !== 'false') {
+                this.error('api_fallback must be "true" or "false"');
+            }
+            parsedValue = args.value === 'true';
+        }
+        let data;
+        try {
+            data = await client.patch('/v1/user/preferences', { body: { [args.key]: parsedValue } });
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError)
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            throw err;
+        }
+        if (!this.jsonEnabled()) {
+            this.log(`Set ${args.key} = ${args.value}`);
+            this.printHuman(data);
+        }
+        return data;
+    }
+}

package/dist/commands/catalog/backup.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../base.js';
+export default class CatalogBackup extends BaseCommand {
+    static description: string;
+    static flags: {
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/catalog/backup.js

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+import { flattenBasicFacts } from '../../utils.js';
+export default class CatalogBackup extends BaseCommand {
+    static description = 'Snapshot all faces and source material for migration';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(CatalogBackup);
+        const client = this.makeClient(flags);
+        const json = this.jsonEnabled();
+        // Fetch all faces
+        let faces;
+        try {
+            const resp = await client.get('/v1/faces');
+            faces = (resp.data ?? resp);
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError)
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            throw err;
+        }
+        if (!json)
+            process.stderr.write(`Found ${faces.length} face(s)\n`);
+        const backupFaces = [];
+        for (const face of faces) {
+            const alias = face.alias;
+            if (!json)
+                process.stderr.write(`  ${alias}: `);
+            const entry = {
+                alias,
+                name: face.name,
+                basic_facts: face.basic_facts ? flattenBasicFacts(face.basic_facts) : null,
+                default_model: face.default_model ?? null,
+                default_tools: face.default_tools ?? [],
+                formula: face.formula ?? null,
+                documents: [],
+                threads: [],
+            };
+            // Fetch documents
+            try {
+                const docs = await client.get('/v1/compile/documents', { params: { alias } });
+                for (const doc of docs) {
+                    entry.documents.push({
+                        label: doc.label ?? null,
+                        content: doc.content,
+                        perspective: doc.perspective ?? null,
+                    });
+                }
+            }
+            catch {
+                // face may have no documents
+            }
+            // Fetch threads
+            try {
+                const threads = await client.get('/v1/compile/threads', { params: { alias } });
+                for (const thread of threads) {
+                    const threadId = thread.thread_id;
+                    try {
+                        const full = await client.get(`/v1/compile/threads/${threadId}`);
+                        const messages = full.messages ?? [];
+                        entry.threads.push({
+                            label: thread.label ?? null,
+                            messages,
+                        });
+                    }
+                    catch {
+                        // skip threads we can't fetch
+                    }
+                }
+            }
+            catch {
+                // face may have no threads
+            }
+            if (!json)
+                process.stderr.write(`${entry.documents.length} doc(s), ${entry.threads.length} thread(s)\n`);
+            backupFaces.push(entry);
+        }
+        const backup = {
+            version: 1,
+            created_at: new Date().toISOString(),
+            faces: backupFaces,
+        };
+        const backupDir = path.join(os.homedir(), '.faces', 'backups');
+        fs.mkdirSync(backupDir, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const filePath = path.join(backupDir, `${timestamp}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(backup, null, 2));
+        const totalDocs = backupFaces.reduce((n, f) => n + f.documents.length, 0);
+        const totalThreads = backupFaces.reduce((n, f) => n + f.threads.length, 0);
+        if (!json) {
+            this.log(`\nBackup saved: ${filePath}`);
+            this.log(`  ${backupFaces.length} face(s), ${totalDocs} document(s), ${totalThreads} thread(s)`);
+        }
+        return { path: filePath, faces: backupFaces.length, documents: totalDocs, threads: totalThreads };
+    }
+}

package/dist/commands/catalog/restore.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base.js';
+export default class CatalogRestore extends BaseCommand {
+    static description: string;
+    static flags: {
+        compile: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<unknown>;
+    private createFace;
+    private findLatestBackup;
+}

package/dist/commands/catalog/restore.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+import { CatalogService } from '../../catalog.js';
+export default class CatalogRestore extends BaseCommand {
+    static description = 'Restore faces and source material from a backup snapshot';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        compile: Flags.boolean({ description: 'Run compile:all after restoring', default: false }),
+    };
+    static args = {
+        file: Args.string({ description: 'Backup file path (default: most recent in ~/.faces/backups/)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CatalogRestore);
+        const client = this.makeClient(flags);
+        const json = this.jsonEnabled();
+        const filePath = args.file ?? this.findLatestBackup();
+        if (!fs.existsSync(filePath))
+            this.error(`Backup file not found: ${filePath}`);
+        const backup = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (backup.version !== 1)
+            this.error(`Unsupported backup version: ${backup.version}`);
+        if (!json) {
+            this.log(`Restoring from: ${filePath}`);
+            this.log(`  Created: ${backup.created_at}`);
+            this.log(`  Faces: ${backup.faces.length}\n`);
+        }
+        const catalog = new CatalogService();
+        let facesCreated = 0;
+        let facesSkipped = 0;
+        let docsUploaded = 0;
+        let threadsUploaded = 0;
+        for (const face of backup.faces) {
+            if (!json)
+                process.stderr.write(`${face.alias}: `);
+            // Create face
+            const created = await this.createFace(client, face, json);
+            if (!created) {
+                facesSkipped++;
+                if (!json)
+                    process.stderr.write('exists, skipping\n');
+                continue;
+            }
+            facesCreated++;
+            // Write to local catalog
+            try {
+                catalog.writeFace({ alias: face.alias, name: face.name, basic_facts: face.basic_facts });
+            }
+            catch { /* non-fatal */ }
+            // Upload documents
+            for (const doc of face.documents) {
+                try {
+                    const payload = { alias: face.alias, content: doc.content };
+                    if (doc.label)
+                        payload.label = doc.label;
+                    if (doc.perspective)
+                        payload.perspective = doc.perspective;
+                    await client.post('/v1/compile/documents', { body: payload });
+                    docsUploaded++;
+                }
+                catch (err) {
+                    const msg = err instanceof FacesAPIError ? `${err.statusCode}: ${err.message}` : String(err);
+                    if (!json)
+                        process.stderr.write(`\n    warn: doc upload failed: ${msg}\n    `);
+                }
+            }
+            // Upload threads — create thread then PATCH messages in bulk
+            for (const thread of face.threads) {
+                try {
+                    const createPayload = { alias: face.alias };
+                    if (thread.label)
+                        createPayload.label = thread.label;
+                    const created = await client.post('/v1/compile/threads', { body: createPayload });
+                    const threadId = created.thread_id;
+                    // Overwrite the auto-generated messages with the backup messages
+                    if (thread.messages.length > 0) {
+                        await client.patch(`/v1/compile/threads/${threadId}/messages`, {
+                            body: { messages: thread.messages },
+                        });
+                    }
+                    threadsUploaded++;
+                }
+                catch (err) {
+                    const msg = err instanceof FacesAPIError ? `${err.statusCode}: ${err.message}` : String(err);
+                    if (!json)
+                        process.stderr.write(`\n    warn: thread upload failed: ${msg}\n    `);
+                }
+            }
+            if (!json)
+                process.stderr.write(`${face.documents.length} doc(s), ${face.threads.length} thread(s)\n`);
+        }
+        if (!json) {
+            this.log(`\nRestore complete:`);
+            this.log(`  Faces created: ${facesCreated}, skipped: ${facesSkipped}`);
+            this.log(`  Documents uploaded: ${docsUploaded}`);
+            this.log(`  Threads uploaded: ${threadsUploaded}`);
+        }
+        if (flags.compile) {
+            if (!json)
+                this.log('\nRunning compile:all...\n');
+            await this.config.runCommand('compile:all', json ? ['--json'] : []);
+        }
+        return { faces_created: facesCreated, faces_skipped: facesSkipped, documents: docsUploaded, threads: threadsUploaded };
+    }
+    async createFace(client, face, _json) {
+        const payload = { name: face.name, alias: face.alias };
+        if (face.formula) {
+            payload.formula = face.formula;
+            if (face.default_model)
+                payload.default_model = face.default_model;
+        }
+        else {
+            if (face.basic_facts && Object.keys(face.basic_facts).length > 0)
+                payload.basic_facts = face.basic_facts;
+            if (face.default_tools && face.default_tools.length > 0)
+                payload.default_tools = face.default_tools;
+            if (face.default_model)
+                payload.default_model = face.default_model;
+        }
+        try {
+            await client.post('/v1/faces', { body: payload });
+            return true;
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError && err.statusCode === 400) {
+                // likely "already have a face with alias"
+                return false;
+            }
+            throw err;
+        }
+    }
+    findLatestBackup() {
+        const backupDir = path.join(os.homedir(), '.faces', 'backups');
+        if (!fs.existsSync(backupDir))
+            this.error('No backups found in ~/.faces/backups/');
+        const files = fs.readdirSync(backupDir)
+            .filter(f => f.endsWith('.json'))
+            .sort();
+        if (files.length === 0)
+            this.error('No backups found in ~/.faces/backups/');
+        return path.join(backupDir, files[files.length - 1]);
+    }
+}

package/dist/commands/chat/chat.d.ts

@@ -10,6 +10,7 @@ export default class ChatChat extends BaseCommand {
         temperature: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         responses: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'oauth-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -21,4 +22,5 @@ export default class ChatChat extends BaseCommand {
     private runChatCompletions;
     private runMessages;
     private runResponses;
+    private extractText;
 }

package/dist/commands/chat/chat.js

@@ -20,6 +20,7 @@ export default class ChatChat extends BaseCommand {
         temperature: Flags.string({ description: 'Temperature (0.0-2.0)' }),
         file: Flags.string({ description: 'Read message from file' }),
         responses: Flags.boolean({ description: 'Use OpenAI Responses API instead of Chat Completions', default: false }),
+        'oauth-only': Flags.boolean({ description: 'Prevent fallback to paid system key (use OAuth only)', default: false }),
     };
     static args = {
         face_username: Args.string({ description: 'Face alias (or alias@model)', required: true }),
@@ -64,8 +65,15 @@ export default class ChatChat extends BaseCommand {
             }
         }
         catch (err) {
-            if (err instanceof FacesAPIError)
+            if (err instanceof FacesAPIError) {
+                if (err.errorCode === 'oauth_rejected') {
+                    const hint = err.fallbackAvailable
+                        ? 'Run `faces account:preferences api_fallback true` to allow paid fallback.'
+                        : 'Run `faces billing:topup` to add credits, then enable fallback with `faces account:preferences api_fallback true`.';
+                    this.error(`OAuth failed: ${err.message}\n${hint}`);
+                }
                 this.error(`Error (${err.statusCode}): ${err.message}`);
+            }
             throw err;
         }
     }
@@ -80,6 +88,8 @@ export default class ChatChat extends BaseCommand {
             payload.max_tokens = flags['max-tokens'];
         if (flags.temperature !== undefined)
             payload.temperature = Number.parseFloat(flags.temperature);
+        if (flags['oauth-only'])
+            payload.oauth_only = true;
         if (flags.stream) {
             for await (const line of client.stream('/v1/chat/completions', payload)) {
                 if (!line.startsWith('data: '))
@@ -99,13 +109,25 @@ export default class ChatChat extends BaseCommand {
             process.stdout.write('\n');
             return {};
         }
-        const data = (await client.post('/v1/chat/completions', { body: payload }));
-        if (this.jsonEnabled())
-            return data;
-        const choices = data.choices;
-        const message = choices?.[0]?.message;
-        this.log(String(message?.content ?? ''));
-        return data;
+        const { data, headers } = await client.postWithHeaders('/v1/chat/completions', { body: payload });
+        const body = data;
+        const routedEndpoint = headers['x-faces-routed-endpoint'];
+        // Extract text based on which format the backend used
+        const text = this.extractText(body, routedEndpoint);
+        if (this.jsonEnabled()) {
+            const meta = {};
+            if (headers['x-faces-provider'])
+                meta.provider = headers['x-faces-provider'];
+            if (headers['x-faces-cost-usd'])
+                meta.cost_usd = headers['x-faces-cost-usd'];
+            if (routedEndpoint)
+                meta.routed_endpoint = routedEndpoint;
+            if (Object.keys(meta).length > 0)
+                body._meta = meta;
+            return body;
+        }
+        this.log(text);
+        return body;
     }
     async runMessages(client, model, userMessages, flags) {
         const msgs = userMessages.map((m) => ({ role: 'user', content: m }));
@@ -117,6 +139,8 @@ export default class ChatChat extends BaseCommand {
         };
         if (flags.system)
             payload.system = flags.system;
+        if (flags['oauth-only'])
+            payload.oauth_only = true;
         if (flags.stream) {
             for await (const line of client.stream('/v1/messages', payload)) {
                 if (!line.startsWith('data: '))
@@ -137,21 +161,32 @@ export default class ChatChat extends BaseCommand {
             process.stdout.write('\n');
             return {};
         }
-        const data = (await client.post('/v1/messages', { body: payload }));
-        if (this.jsonEnabled())
-            return data;
+        const { data, headers } = await client.postWithHeaders('/v1/messages', { body: payload });
+        const body = data;
+        if (this.jsonEnabled()) {
+            const meta = {};
+            if (headers['x-faces-provider'])
+                meta.provider = headers['x-faces-provider'];
+            if (headers['x-faces-cost-usd'])
+                meta.cost_usd = headers['x-faces-cost-usd'];
+            if (Object.keys(meta).length > 0)
+                body._meta = meta;
+            return body;
+        }
         let content = '';
-        for (const block of data.content ?? []) {
+        for (const block of body.content ?? []) {
             if (block.type === 'text')
                 content += String(block.text ?? '');
         }
         this.log(content);
-        return data;
+        return body;
     }
     async runResponses(client, model, input, flags) {
         const payload = { model, input, stream: flags.stream };
         if (flags.system)
             payload.instructions = flags.system;
+        if (flags['oauth-only'])
+            payload.oauth_only = true;
         if (flags.stream) {
             for await (const line of client.stream('/v1/responses', payload)) {
                 if (!line.startsWith('data: '))
@@ -172,17 +207,52 @@ export default class ChatChat extends BaseCommand {
             process.stdout.write('\n');
             return {};
         }
-        const data = (await client.post('/v1/responses', { body: payload }));
-        if (this.jsonEnabled())
-            return data;
+        const { data, headers } = await client.postWithHeaders('/v1/responses', { body: payload });
+        const body = data;
+        if (this.jsonEnabled()) {
+            const meta = {};
+            if (headers['x-faces-provider'])
+                meta.provider = headers['x-faces-provider'];
+            if (headers['x-faces-cost-usd'])
+                meta.cost_usd = headers['x-faces-cost-usd'];
+            if (Object.keys(meta).length > 0)
+                body._meta = meta;
+            return body;
+        }
         let outputText = '';
-        for (const item of data.output ?? []) {
+        for (const item of body.output ?? []) {
             for (const block of item.content ?? []) {
                 if (block.type === 'output_text')
                     outputText += String(block.text ?? '');
             }
         }
         this.log(outputText);
-        return data;
+        return body;
+    }
+    extractText(body, routedEndpoint) {
+        if (routedEndpoint === '/v1/responses') {
+            // OpenAI Responses format
+            let text = '';
+            for (const item of body.output ?? []) {
+                for (const block of item.content ?? []) {
+                    if (block.type === 'output_text')
+                        text += String(block.text ?? '');
+                }
+            }
+            return text;
+        }
+        if (routedEndpoint === '/v1/messages') {
+            // Anthropic Messages format
+            let text = '';
+            for (const block of body.content ?? []) {
+                if (block.type === 'text')
+                    text += String(block.text ?? '');
+            }
+            return text;
+        }
+        // Standard chat/completions format (default)
+        const choices = body.choices;
+        const message = choices?.[0]?.message;
+        return String(message?.content ?? '');
     }
 }

package/dist/commands/chat/messages.d.ts

@@ -6,6 +6,7 @@ export default class ChatMessages extends BaseCommand {
         system: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         stream: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'max-tokens': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'oauth-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;