chatbase 0.0.1 → 0.1.1

package/dist/client/client.js

@@ -0,0 +1,175 @@
+import os from 'node:os';
+import createClient from 'openapi-fetch';
+import { EnvHttpProxyAgent, getGlobalDispatcher, fetch as undiciFetch } from 'undici';
+import { resolveTimeoutMs } from '../config/resolve.js';
+import { parseErrorResponse } from '../errors/errors.js';
+import { VERSION } from '../version.js';
+import { computeRetryDelayMs, shouldRetry } from './retry.js';
+import { getSigintSignal } from './signals.js';
+export const DEFAULT_BASE_URL = 'https://www.chatbase.co/api/v2';
+/**
+ * Base-URL resolution: explicit option > CHATBASE_API_URL env > production.
+ * The env override exists for developing against a local API server.
+ */
+export function resolveBaseUrl(explicit) {
+    if (explicit)
+        return explicit;
+    const env = process.env.CHATBASE_API_URL;
+    if (env && env.length > 0)
+        return env;
+    return DEFAULT_BASE_URL;
+}
+export function buildUserAgent() {
+    return `chatbase-cli/${VERSION} (${os.platform()}-${os.arch()}; node/${process.versions.node})`;
+}
+const hasProxyEnv = () => [
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'http_proxy',
+    'https_proxy',
+    'ALL_PROXY'
+].some((k) => process.env[k] && process.env[k].length > 0);
+let proxyAgent;
+export function dispatcher() {
+    // Node's fetch ignores HTTP(S)_PROXY by default; EnvHttpProxyAgent honors it.
+    if (!hasProxyEnv())
+        return getGlobalDispatcher();
+    proxyAgent ??= new EnvHttpProxyAgent();
+    return proxyAgent;
+}
+/** setTimeout that also rejects the moment `signal` aborts — the retry
+ * backoff must honor Ctrl-C / per-call cancels, not wait out the delay. */
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        return reject(signal.reason);
+    const timer = setTimeout(() => resolve(), ms);
+    signal?.addEventListener('abort', () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+    }, { once: true });
+});
+/**
+ * Node's global `Request` and the undici package's `Request` are two copies
+ * of the same class — and undici rejects objects made by the other copy
+ * (it stringifies them and tries to use "[object Request]" as the URL).
+ * openapi-fetch hands us Node-flavored Request objects, so we unpack them
+ * into plain values (url, method, headers, body) that can't fail any
+ * identity check. Also accepts plain URL strings (the rawApiFetch path),
+ * normalizing both shapes into one.
+ *
+ * When touching this: url, METHOD, headers, and body must ALL survive the
+ * unpacking — method was once dropped here, silently turning every request
+ * into a GET (caught by review; wire-level tests now pin it).
+ */
+async function toPlainRequestInit(input, init) {
+    if (typeof input === 'string' || input instanceof URL) {
+        const method = (init?.method ?? 'GET').toUpperCase();
+        return {
+            url: String(input),
+            method,
+            requestInit: { ...init, method },
+            signal: init?.signal
+        };
+    }
+    const method = (init?.method ?? input.method ?? 'GET').toUpperCase();
+    const headers = {};
+    for (const [key, value] of input.headers)
+        headers[key] = value;
+    const body = input.body ? Buffer.from(await input.arrayBuffer()) : undefined;
+    return {
+        url: input.url,
+        method,
+        requestInit: { headers, body, ...init, method },
+        // Per-request cancel (e.g. Ctrl-C cancels one chat response without
+        // killing the interactive session). Always defined, inert when unused.
+        signal: input.signal
+    };
+}
+export function makeFetch(opts) {
+    const timeoutMs = opts.timeoutMs ?? resolveTimeoutMs();
+    return async (input, init) => {
+        const { url, method, requestInit, signal } = await toPlainRequestInit(input, init);
+        for (let attempt = 1;; attempt++) {
+            const attemptSignal = AbortSignal.any([
+                getSigintSignal(),
+                ...(signal ? [signal] : [AbortSignal.timeout(timeoutMs)])
+            ]);
+            if (opts.verbose) {
+                const retryTag = attempt > 1 ? ` (attempt ${attempt})` : '';
+                process.stderr.write(`» ${method} ${url}${retryTag}\n`);
+            }
+            const started = Date.now();
+            const response = await undiciFetch(url, {
+                ...requestInit,
+                dispatcher: dispatcher(),
+                signal: attemptSignal
+            });
+            if (opts.verbose) {
+                const requestId = response.headers.get('x-request-id');
+                process.stderr.write(`« ${response.status}${requestId ? ` (request-id: ${requestId})` : ''} in ${Date.now() - started}ms\n`);
+            }
+            if (response.ok || !shouldRetry(response.status, method, attempt))
+                return response;
+            // Draining before the retry avoids leaking the unread response
+            // body's underlying connection while we sleep and loop.
+            await response.body?.cancel();
+            // Same signal as the fetch above, so Ctrl-C (or the REPL's
+            // per-call cancel) interrupts the backoff wait too instead of
+            // only taking effect on the next attempt.
+            await sleep(computeRetryDelayMs(attempt, response.headers.get('x-ratelimit-reset'), Date.now()), attemptSignal);
+        }
+    };
+}
+export function createApiClient(opts = {}) {
+    const client = createClient({
+        baseUrl: resolveBaseUrl(opts.baseUrl),
+        fetch: makeFetch(opts)
+    });
+    client.use({
+        onRequest({ request }) {
+            request.headers.set('User-Agent', buildUserAgent());
+            if (opts.apiKey)
+                request.headers.set('Authorization', `Bearer ${opts.apiKey}`);
+            return request;
+        }
+    });
+    return client;
+}
+export function throwIfError(response, errorBody) {
+    if (response.ok)
+        return;
+    throw parseErrorResponse(response.status, errorBody, response.headers.get('x-request-id') ?? undefined);
+}
+/**
+ * Untyped HTTP call — the `chatbase api` escape hatch (like `gh api` in
+ * GitHub's CLI: any method, any path, JSON in/out). Uses the same
+ * proxy/timeout/retry/SIGINT wrappers as the typed client.
+ */
+export async function rawApiFetch(method, path, opts = {}) {
+    const url = new URL(`${resolveBaseUrl(opts.baseUrl)}${path}`);
+    for (const [key, value] of opts.query ?? []) {
+        url.searchParams.append(key, value);
+    }
+    const hasBody = opts.body !== undefined;
+    const response = await makeFetch(opts)(url.toString(), {
+        method,
+        headers: {
+            'User-Agent': buildUserAgent(),
+            ...(opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}),
+            ...(hasBody ? { 'Content-Type': 'application/json' } : {})
+        },
+        ...(hasBody ? { body: JSON.stringify(opts.body) } : {})
+    });
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = undefined;
+    }
+    return {
+        status: response.status,
+        requestId: response.headers.get('x-request-id') ?? undefined,
+        body
+    };
+}

package/dist/client/files.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { FormData as UndiciFormData } from 'undici';
+import { parseErrorResponse } from '../errors/errors.js';
+import { buildUserAgent, makeFetch } from './client.js';
+/** File upload host — documented at chatbase.co/docs/api-v2/sources/create-file-source */
+export const FILES_BASE_URL = 'https://files.chatbase.co/api/v2';
+export function resolveFilesBaseUrl(explicit) {
+    if (explicit)
+        return explicit;
+    const env = process.env.CHATBASE_FILES_URL;
+    if (env && env.length > 0)
+        return env;
+    return FILES_BASE_URL;
+}
+/**
+ * The cross-environment trap: CHATBASE_API_URL points somewhere non-default
+ * (a preview/staging deployment) while file uploads still go to the
+ * production files host — silently sending that environment's credential to
+ * a different one. Returns the warning to print, or null when the setup is
+ * consistent (no API override, or an explicit CHATBASE_FILES_URL).
+ */
+export function filesHostMismatchWarning() {
+    const apiOverride = process.env.CHATBASE_API_URL;
+    const filesOverride = process.env.CHATBASE_FILES_URL;
+    if (!apiOverride || filesOverride)
+        return null;
+    return `! File uploads go to ${FILES_BASE_URL} while CHATBASE_API_URL is overridden — set CHATBASE_FILES_URL if this environment has its own files host.`;
+}
+export async function uploadFileSource(opts) {
+    // Must use undici's FormData, not the global — global silently sends
+    // "[object FormData]" as plain text instead of real multipart. No error.
+    const form = new UndiciFormData();
+    const buffer = fs.readFileSync(opts.filePath);
+    const filename = path.basename(opts.filePath);
+    form.set('name', opts.name ?? filename);
+    form.set('file', new Blob([buffer]), filename);
+    const base = resolveFilesBaseUrl(opts.baseUrl);
+    const url = opts.sourceId
+        ? `${base}/agents/${opts.agentId}/sources/${opts.sourceId}`
+        : `${base}/agents/${opts.agentId}/sources`;
+    const method = opts.sourceId ? 'PUT' : 'POST';
+    const response = await makeFetch({
+        timeoutMs: opts.timeoutMs,
+        verbose: opts.verbose
+    })(url, {
+        method,
+        headers: {
+            Authorization: `Bearer ${opts.apiKey}`,
+            'User-Agent': buildUserAgent()
+        },
+        body: form
+    });
+    // Success body is the source object itself: { id, type, name, size, ... }
+    const body = (await response.json().catch(() => undefined));
+    if (!response.ok) {
+        throw parseErrorResponse(response.status, body, response.headers.get('x-request-id') ?? undefined);
+    }
+    const id = body?.id;
+    if (!id) {
+        throw new Error('Upload succeeded but the response did not contain a source ID');
+    }
+    return { id };
+}

package/dist/client/paginate.js

@@ -0,0 +1,40 @@
+import { throwIfError } from './client.js';
+/** Pause between pages on `--all` so a long crawl is less likely to share
+ * a contested API key's rate-limit window with other traffic. Solo use is
+ * well under the v2 limit (1000/10s); this is a courtesy, not a hard pace. */
+const PAGE_DELAY_MS = 200;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Fetches one page — or, with `opts.all`, every page — of a cursor-paginated
+ * endpoint, following `pagination.cursor` until `hasMore` is false.
+ *
+ * Returns both the raw `pages` (list commands need these verbatim for
+ * `--json`, where `--all` must merge `data` across pages but keep the API's
+ * envelope shape for the single-page case) and the flattened `items`
+ * (display rows, and callers like resolveAgentRef/listAllSources that only
+ * need "every item").
+ *
+ * The caller supplies a `fetcher` that wraps `client.GET(path, { params })`
+ * for its specific endpoint and path params — this helper never sees path
+ * templates or param shapes, only the `{cursor, limit}` query it asks for
+ * and the `{data, error, response}` result every generated GET returns.
+ */
+export async function fetchPages(fetcher, opts = {}) {
+    const pages = [];
+    let cursor = opts.cursor;
+    let hasMore = false;
+    do {
+        if (pages.length > 0)
+            await sleep(PAGE_DELAY_MS);
+        const { data, error, response } = await fetcher({
+            cursor,
+            limit: opts.limit
+        });
+        throwIfError(response, error);
+        const page = data;
+        pages.push(page);
+        cursor = page.pagination.cursor ?? undefined;
+        hasMore = page.pagination.hasMore;
+    } while (opts.all && hasMore && cursor);
+    return { pages, items: pages.flatMap((p) => p.data) };
+}

package/dist/client/pairing.js

@@ -0,0 +1,75 @@
+/**
+ * CLI-side of the browser pairing login flow:
+ *   1. POST /api/cli-pairing/create → get user_code + device_code
+ *   2. User approves at verification_uri
+ *   3. Poll POST /api/cli-pairing/exchange until approved
+ *   4. Receive the minted API key + workspace info
+ *
+ */
+import os from 'node:os';
+import { parseErrorResponse, UsageError } from '../errors/errors.js';
+import { rawApiFetch, resolveBaseUrl } from './client.js';
+import { wasInterrupted } from './signals.js';
+export function pairingBaseUrl(baseUrl) {
+    return new URL(resolveBaseUrl(baseUrl)).origin;
+}
+export async function startPairing(opts) {
+    const res = await rawApiFetch('POST', '/api/cli-pairing/create', {
+        baseUrl: pairingBaseUrl(opts?.baseUrl),
+        body: { device_name: os.hostname() }
+    });
+    if (res.status >= 400) {
+        throw parseErrorResponse(res.status, res.body);
+    }
+    const d = res.body;
+    return {
+        deviceCode: d.device_code,
+        userCode: d.user_code,
+        verificationUri: d.verification_uri,
+        expiresIn: d.expires_in,
+        interval: d.interval
+    };
+}
+export async function pollExchange(deviceCode, opts) {
+    const deadline = Date.now() + opts.timeoutMs;
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const baseUrl = pairingBaseUrl(opts.baseUrl);
+    for (;;) {
+        opts.onPoll?.();
+        const attempt = await rawApiFetch('POST', '/api/cli-pairing/exchange', { baseUrl, body: { device_code: deviceCode } }).then((r) => ({
+            ok: true,
+            status: r.status,
+            body: r.body
+        }), (cause) => ({ ok: false, cause }));
+        if (!attempt.ok) {
+            const name = attempt.cause?.name;
+            if (name === 'AbortError' && wasInterrupted())
+                throw attempt.cause;
+            if (Date.now() >= deadline) {
+                throw new UsageError('Pairing request expired. Run `chatbase auth login` to try again.');
+            }
+            await sleep(opts.intervalMs);
+            continue;
+        }
+        if (attempt.status < 400) {
+            const result = attempt.body;
+            return {
+                apiKey: result.api_key,
+                workspace: result.workspace
+            };
+        }
+        const errorBody = attempt.body;
+        const code = errorBody?.error?.code;
+        if (code === 'PAIRING_PENDING' || code === 'PAIRING_SLOW_DOWN') {
+            if (Date.now() >= deadline) {
+                throw new UsageError('Pairing request expired. Run `chatbase auth login` to try again.');
+            }
+            const delay = code === 'PAIRING_SLOW_DOWN'
+                ? opts.intervalMs * 2
+                : opts.intervalMs;
+            await sleep(delay);
+            continue;
+        }
+        throw parseErrorResponse(attempt.status, attempt.body);
+    }
+}

package/dist/client/retry.js

@@ -0,0 +1,40 @@
+/**
+ * Retry policy: 429 (rate limit) retries up to 3 times for ANY method —
+ * a rate-limited request was never executed, so repeating it is safe.
+ * 5xx retries once, GETs only: reads are safe to repeat, writes are not
+ * (the server may have half-done the work before failing).
+ */
+export function shouldRetry(status, method, attempt) {
+    if (status === 429)
+        return attempt <= 3;
+    if (status >= 500 && method.toUpperCase() === 'GET')
+        return attempt <= 1;
+    return false;
+}
+// Epoch timestamps come in seconds (~1.7e9 today) or milliseconds (~1.7e12);
+// the number's size reveals its unit. Anything under 1e11 can only be
+// seconds (1e11 seconds = year 5138; 1e11 ms = 1973, long past). Our API
+// sends seconds — this tolerates ms too in case that ever changes.
+const SECONDS_MS_THRESHOLD = 1e11;
+/**
+ * How long to sleep before a retry.
+ *
+ * Preferred: the X-RateLimit-Reset header says exactly when the rate window
+ * reopens — wait precisely until then (capped at 60s so a bad header can't
+ * stall the CLI; a past timestamp means the window is already open).
+ *
+ * Fallback (no usable header): exponential backoff — 500ms, 1s, 2s — plus
+ * 0-250ms random jitter so many clients rate-limited together don't all
+ * retry at the same instant and collide again.
+ */
+export function computeRetryDelayMs(attempt, resetHeader, nowMs) {
+    if (resetHeader && /^\d+$/.test(resetHeader)) {
+        const raw = Number(resetHeader);
+        const resetMs = raw < SECONDS_MS_THRESHOLD ? raw * 1000 : raw;
+        const wait = resetMs - nowMs;
+        if (wait > 0)
+            return Math.min(wait, 60_000);
+    }
+    const base = 500 * 2 ** (attempt - 1);
+    return base + Math.floor(Math.random() * 250);
+}

package/dist/client/signals.js

@@ -0,0 +1,43 @@
+/**
+ * The Ctrl-C contract. Registering a SIGINT listener replaces Node's
+ * die-instantly default, so this file owns the guarantee that Ctrl-C
+ * always works:
+ *
+ *   1st Ctrl-C  → say "Interrupted", abort the shared signal (every
+ *                 in-flight request is wired to it via AbortSignal.any),
+ *                 let the code unwind → catch() exits 130 silently.
+ *   2nd Ctrl-C  → exit immediately, skipping even fast teardown.
+ *
+ * 130 = 128 + SIGINT's signal number (2) — the Unix convention shells and
+ * CI check for "user cancelled", as distinct from "failed".
+ */
+const controller = new AbortController();
+let interrupts = 0;
+let installed = false;
+export function getSigintSignal() {
+    return controller.signal;
+}
+/** True once SIGINT has been received at least once (see installSigintHandler). */
+export function wasInterrupted() {
+    return interrupts > 0;
+}
+/** Idempotent — every command's init() calls this; only one listener ever. */
+export function installSigintHandler() {
+    if (installed)
+        return;
+    installed = true;
+    process.on('SIGINT', () => {
+        interrupts += 1;
+        if (interrupts === 1) {
+            process.stderr.write('\nInterrupted\n');
+            controller.abort();
+            // Insurance: if graceful teardown hangs, force-exit in 2s.
+            // unref() is load-bearing — without it this timer would keep
+            // the process alive 2s on EVERY Ctrl-C, even after clean exit.
+            setTimeout(() => process.exit(130), 2000).unref();
+        }
+        else {
+            process.exit(130);
+        }
+    });
+}

package/dist/client/stream.js

@@ -0,0 +1,79 @@
+/**
+ * Hand-rolled SSE parser (~50 lines) instead of a library (e.g. eventsource-parser)
+ * because SSE is trivial (`data: <json>\n\n`) and the real work is Chatbase-specific:
+ * idle-timeout racing and mapping our event types (text-delta, message-metadata).
+ * A library would replace ~15 lines of string splitting and add a dependency to maintain.
+ */
+export async function parseSseStream(body, onEvent, opts = {}) {
+    const idleMs = opts.idleTimeoutMs ?? 60_000;
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            let timer;
+            const idle = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    const seconds = Math.round(idleMs / 1000);
+                    reject(new Error(`Stream idle timeout — no data for ${seconds}s`));
+                }, idleMs);
+            });
+            const result = await Promise.race([reader.read(), idle]).finally(() => clearTimeout(timer));
+            const { done, value } = result;
+            if (done)
+                return;
+            buffer += decoder.decode(value, { stream: true });
+            for (;;) {
+                const idx = buffer.indexOf('\n\n');
+                if (idx === -1)
+                    break;
+                const block = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 2);
+                for (const line of block.split('\n')) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const payload = line.slice(6);
+                    if (payload === '[DONE]') {
+                        onEvent({ type: 'done' });
+                        return;
+                    }
+                    let part;
+                    try {
+                        part = JSON.parse(payload);
+                    }
+                    catch {
+                        onEvent({
+                            type: 'warning',
+                            message: 'Skipped an unparseable stream chunk'
+                        });
+                        continue;
+                    }
+                    if (part.type === 'text-delta' &&
+                        typeof part.delta === 'string') {
+                        onEvent({ type: 'text', text: part.delta });
+                    }
+                    else if (part.type === 'error') {
+                        onEvent({
+                            type: 'error',
+                            message: typeof part.errorText === 'string'
+                                ? part.errorText
+                                : 'The agent stopped with an error'
+                        });
+                    }
+                    else if (part.type === 'message-metadata' ||
+                        part.type === 'finish') {
+                        const meta = (part.messageMetadata ?? {});
+                        onEvent({
+                            type: 'metadata',
+                            conversationId: meta.conversationId,
+                            messageId: meta.messageId
+                        });
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+    }
+}

package/dist/commands/agents/auto-retrain.js

@@ -0,0 +1,46 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentCommand } from '../../base/agent-command.js';
+import { throwIfError } from '../../client/client.js';
+import { UsageError } from '../../errors/errors.js';
+export default class AgentsAutoRetrain extends AgentCommand {
+    static description = 'Enable or disable automatic retraining for an agent';
+    static examples = [
+        '<%= config.bin %> agents auto-retrain agt_123 --enabled',
+        '<%= config.bin %> agents auto-retrain --enabled'
+    ];
+    static args = {
+        agentId: Args.string({
+            required: false,
+            description: 'Agent ID'
+        })
+    };
+    static flags = {
+        ...AgentCommand.baseFlags,
+        enabled: Flags.boolean({
+            description: 'Enable automatic retraining',
+            exactlyOne: ['enabled', 'disabled']
+        }),
+        disabled: Flags.boolean({
+            description: 'Disable automatic retraining',
+            exactlyOne: ['enabled', 'disabled']
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(AgentsAutoRetrain);
+        if (args.agentId && (flags.agent || flags['agent-name'])) {
+            throw new UsageError('Pass the agent ID either positionally or via -a/--agent-name, not both.');
+        }
+        const body = {
+            enabled: flags.enabled === true
+        };
+        const client = this.apiClient(flags);
+        const agentId = args.agentId ?? (await this.agentId(flags, client));
+        const { error, response } = await client.PUT('/agents/{agentId}/auto-retrain', {
+            params: { path: { agentId } },
+            body
+        });
+        throwIfError(response, error);
+        const status = flags.enabled ? 'enabled' : 'disabled';
+        this.success(flags, `Auto-retrain ${status} for ${agentId}`);
+    }
+}

package/dist/commands/agents/clone.js

@@ -0,0 +1,28 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base/base-command.js';
+import { throwIfError } from '../../client/client.js';
+export default class AgentsClone extends BaseCommand {
+    static description = 'Clone an agent, including all its sources (excluding Notion)';
+    static examples = ['<%= config.bin %> agents clone agt_123'];
+    static args = {
+        agentId: Args.string({
+            required: true,
+            description: 'Agent ID to clone'
+        })
+    };
+    static flags = { ...BaseCommand.baseFlags };
+    async run() {
+        const { args, flags } = await this.parse(AgentsClone);
+        const client = this.apiClient(flags);
+        const { data, error, response } = await client.POST('/agents/{agentId}/clone', { params: { path: { agentId: args.agentId } } });
+        throwIfError(response, error);
+        const id = data.id;
+        if (flags.json) {
+            process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+        }
+        else {
+            this.success(flags, `Cloned agent ${args.agentId} → ${id}`);
+            process.stdout.write(`${id}\n`);
+        }
+    }
+}

package/dist/commands/agents/create.js

@@ -0,0 +1,43 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand, bodyFieldFlags } from '../../base/base-command.js';
+import { readBodyData } from '../../base/body-input.js';
+import { throwIfError } from '../../client/client.js';
+export default class AgentsCreate extends BaseCommand {
+    static description = 'Create a new agent';
+    static examples = [
+        '<%= config.bin %> agents create --name "Support Bot" --instructions "Be helpful"',
+        '<%= config.bin %> agents create --data @agent.json'
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        ...bodyFieldFlags,
+        name: Flags.string({ description: 'Agent name' }),
+        instructions: Flags.string({ description: 'System instructions' }),
+        model: Flags.string({ description: 'Model ID' }),
+        data: Flags.string({
+            description: 'JSON body (@file, @-, or inline). Fields: name, instructions, model, visibility, temp'
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(AgentsCreate);
+        const body = {
+            ...(await readBodyData(flags.data, flags.field)),
+            ...(flags.name ? { name: flags.name } : {}),
+            ...(flags.instructions ? { instructions: flags.instructions } : {}),
+            ...(flags.model ? { model: flags.model } : {})
+        };
+        const client = this.apiClient(flags);
+        const { data, error, response } = await client.POST('/agents', {
+            body: body
+        });
+        throwIfError(response, error);
+        const id = data.id;
+        if (flags.json) {
+            process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+        }
+        else {
+            this.success(flags, `Created agent ${id}`);
+            process.stdout.write(`${id}\n`);
+        }
+    }
+}