@2kw/ai 6.0.0 → 6.1.0-dev.10

package/README.md

@@ -99,7 +99,7 @@ kubectl-style contexts switch between organizations and environments:
 | `prompts` | Versioned prompt management, labels, compilation, testing |
 | `extractions` | Create extractions (text, file, images), list, re-run, estimate tokens |
 | `convert` | Convert PDF, DOCX, XLSX, images, and 20+ formats to Markdown/text/HTML/JSON |
-| `ai` | Chat completions and model listing via the OpenAI-compatible gateway |
+| `ai` | Chat completions, Responses (agent or direct model, streaming), and model listing via the OpenAI-compatible gateway |
 | `transcribe` | Transcribe audio (FLAC, MP3, MP4, OGG, WAV, WebM) |
 | `datasets` | Build datasets and dataset versions for evaluation |
 | `experiments` | Run experiments against datasets |
@@ -109,6 +109,11 @@ kubectl-style contexts switch between organizations and environments:
 | `providers` | Manage BYOK AI providers |
 | `analytics` | Usage analytics: spend, quality, providers, errors |
 | `billing` | Check subscription tier and usage limits |
+| `agents` | Manage agents, versions, labels, approvals, and tool catalogs |
+| `conversations` | Create and manage conversations and their items |
+| `knowledge` | Manage knowledge bases, documents, search, and citations |
+| `files` | Upload, download, and manage files |
+| `installations` | Manage surface installations, keys, origins, and pairing |
 | `docs` | Browse API documentation from the terminal |
 
 ### Global Options

package/dist/commands/agent-labels.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeAgentLabelsCommand(): Command;
+//# sourceMappingURL=agent-labels.d.ts.map

package/dist/commands/agent-labels.js

@@ -0,0 +1,72 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatList, formatDetail, formatSuccess } from "../lib/output.js";
+export function makeAgentLabelsCommand() {
+    const cmd = new Command("labels").description("Manage agent labels");
+    cmd
+        .command("list")
+        .description("List labels for an agent")
+        .requiredOption("--agent <id>", "Agent ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{agentId}/labels", {
+                params: { path: { agentId: opts.agent } },
+            });
+            formatList(data, command, [
+                "name",
+                "agentVersionId",
+                "versionNumber",
+                "createdAt",
+            ]);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a label for an agent version")
+        .requiredOption("--agent <id>", "Agent ID")
+        .requiredOption("-n, --name <name>", "Label name")
+        .requiredOption("--version-id <id>", "Agent version ID to label")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/agents/{agentId}/labels", {
+                params: { path: { agentId: opts.agent } },
+                body: { name: opts.name, agentVersionId: opts.versionId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Repoint a label to a different agent version")
+        .argument("<labelName>", "Label name")
+        .requiredOption("--agent <id>", "Agent ID")
+        .requiredOption("--version-id <id>", "New agent version ID")
+        .action(async (labelName, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/agents/{agentId}/labels/{labelName}", {
+                params: { path: { agentId: opts.agent, labelName } },
+                body: { agentVersionId: opts.versionId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete an agent label")
+        .argument("<labelName>", "Label name")
+        .requiredOption("--agent <id>", "Agent ID")
+        .action(async (labelName, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/agents/{agentId}/labels/{labelName}", {
+                params: { path: { agentId: opts.agent, labelName } },
+            });
+            formatSuccess(`Label "${labelName}" deleted.`, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=agent-labels.js.map

package/dist/commands/agent-versions.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeAgentVersionsCommand(): Command;
+//# sourceMappingURL=agent-versions.d.ts.map

package/dist/commands/agent-versions.js

@@ -0,0 +1,103 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeAgentVersionsCommand() {
+    const cmd = new Command("versions").description("Manage agent versions");
+    const list = new Command("list").description("List versions of an agent");
+    addPaginationOptions(list);
+    list.requiredOption("--agent <id>", "Agent ID");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{agentId}/versions", {
+                params: {
+                    path: { agentId: opts.agent },
+                    query: paginationParams(opts),
+                },
+            });
+            formatPage(data, command, ["id", "versionNumber", "model", "changeDescription", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a specific agent version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--agent <id>", "Agent ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{agentId}/versions/{versionId}", { params: { path: { agentId: opts.agent, versionId } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("latest")
+        .description("Get the latest version of an agent")
+        .requiredOption("--agent <id>", "Agent ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{agentId}/versions/latest", { params: { path: { agentId: opts.agent } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new agent version")
+        .requiredOption("--agent <id>", "Agent ID")
+        .requiredOption("-m, --model <model>", "Model (provider/model)")
+        .option("-i, --instructions <text>", "System instructions")
+        .option("--options <json>", "Model options as JSON")
+        .option("--tools <json>", "Tool definitions as JSON")
+        .option("--skills <json>", "Skill definitions as JSON")
+        .option("--hitl-policy <json>", "Human-in-the-loop policy as JSON")
+        .option("-c, --change-description <text>", "Change description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/agents/{agentId}/versions", {
+                params: { path: { agentId: opts.agent } },
+                body: {
+                    model: opts.model,
+                    instructions: opts.instructions,
+                    changeDescription: opts.changeDescription,
+                    options: opts.options ? JSON.parse(opts.options) : undefined,
+                    tools: opts.tools ? JSON.parse(opts.tools) : undefined,
+                    skills: opts.skills ? JSON.parse(opts.skills) : undefined,
+                    hitlPolicy: opts.hitlPolicy ? JSON.parse(opts.hitlPolicy) : undefined,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("activate")
+        .description("Re-activate a historical agent version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--agent <id>", "Agent ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/agents/{agentId}/versions/{versionId}/activate", { params: { path: { agentId: opts.agent, versionId } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Deactivate (soft-delete) an agent version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--agent <id>", "Agent ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/agents/{agentId}/versions/{versionId}", {
+                params: { path: { agentId: opts.agent, versionId } },
+            });
+            formatSuccess(`Agent version ${versionId} deactivated.`, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=agent-versions.js.map

package/dist/commands/agents.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeAgentsCommand(): Command;
+//# sourceMappingURL=agents.d.ts.map

package/dist/commands/agents.js

@@ -0,0 +1,154 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { makeAgentVersionsCommand } from "./agent-versions.js";
+import { makeAgentLabelsCommand } from "./agent-labels.js";
+export function makeAgentsCommand() {
+    const cmd = new Command("agents").description("Manage agents");
+    const list = new Command("list").description("List agents");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents", {
+                params: { query: { search: opts.search, ...paginationParams(opts) } },
+            });
+            formatPage(data, command, ["id", "name", "model", "latestVersionId", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get an agent by ID")
+        .argument("<id>", "Agent ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new agent")
+        .requiredOption("-n, --name <name>", "Agent name")
+        .requiredOption("-m, --model <model>", "Model (provider/model)")
+        .option("-d, --description <text>", "Agent description")
+        .option("-i, --instructions <text>", "System instructions")
+        .option("--options <json>", "Model options as JSON")
+        .option("--tools <json>", "Tool definitions as JSON")
+        .option("--skills <json>", "Skill definitions as JSON")
+        .option("--hitl-policy <json>", "Human-in-the-loop policy as JSON")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/agents", {
+                body: {
+                    name: opts.name,
+                    model: opts.model,
+                    description: opts.description,
+                    instructions: opts.instructions,
+                    options: opts.options ? JSON.parse(opts.options) : undefined,
+                    tools: opts.tools ? JSON.parse(opts.tools) : undefined,
+                    skills: opts.skills ? JSON.parse(opts.skills) : undefined,
+                    hitlPolicy: opts.hitlPolicy ? JSON.parse(opts.hitlPolicy) : undefined,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update an agent's metadata and configuration")
+        .argument("<id>", "Agent ID")
+        .option("-n, --name <name>", "New name")
+        .option("-m, --model <model>", "New model (provider/model)")
+        .option("-d, --description <text>", "New description")
+        .option("-i, --instructions <text>", "New system instructions")
+        .option("--options <json>", "New model options as JSON")
+        .option("--tools <json>", "New tool definitions as JSON")
+        .option("--skills <json>", "New skill definitions as JSON")
+        .option("--hitl-policy <json>", "New human-in-the-loop policy as JSON")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.model)
+                body.model = opts.model;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            if (opts.instructions !== undefined)
+                body.instructions = opts.instructions;
+            if (opts.options)
+                body.options = JSON.parse(opts.options);
+            if (opts.tools)
+                body.tools = JSON.parse(opts.tools);
+            if (opts.skills)
+                body.skills = JSON.parse(opts.skills);
+            if (opts.hitlPolicy)
+                body.hitlPolicy = JSON.parse(opts.hitlPolicy);
+            const { data } = await client.PUT("/v1/agents/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete an agent and cascade-delete its versions and labels")
+        .argument("<id>", "Agent ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/agents/{id}", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Agent ${id} deleted.`, command);
+        });
+    });
+    const approvals = new Command("approvals").description("List tool approvals raised by an agent");
+    addPaginationOptions(approvals);
+    approvals.requiredOption("--agent <id>", "Agent ID");
+    approvals.option("--status <status>", "Filter by status (pending, approved, rejected, cancelled)");
+    approvals.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{agentId}/approvals", {
+                params: {
+                    path: { agentId: opts.agent },
+                    query: { status: opts.status, ...paginationParams(opts) },
+                },
+            });
+            formatPage(data, command, ["id", "tool", "policyClass", "status", "createdAt"]);
+        });
+    });
+    cmd.addCommand(approvals);
+    const toolCatalogs = new Command("tool-catalogs").description("List tool-catalog sync history for an agent");
+    addPaginationOptions(toolCatalogs);
+    toolCatalogs.requiredOption("--agent <id>", "Agent ID");
+    toolCatalogs.option("--installation <id>", "Narrow to one installation");
+    toolCatalogs.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/agents/{agentId}/tool-catalogs", {
+                params: {
+                    path: { agentId: opts.agent },
+                    query: { installationId: opts.installation, ...paginationParams(opts) },
+                },
+            });
+            formatPage(data, command, ["id", "installationId", "active", "toolCount", "syncedAt"]);
+        });
+    });
+    cmd.addCommand(toolCatalogs);
+    cmd.addCommand(makeAgentVersionsCommand());
+    cmd.addCommand(makeAgentLabelsCommand());
+    return cmd;
+}
+//# sourceMappingURL=agents.js.map

package/dist/commands/ai.d.ts

@@ -1,3 +1,57 @@
 import { Command } from "commander";
+/**
+ * Reads a single text input from stdin, or `undefined` when stdin is a TTY
+ * (nothing was piped in) or empty. Mirrors the `-` stdin convention used by
+ * `bb convert file`, but always reads stdin implicitly (there is no `-`
+ * sentinel here since `respond` takes a plain input string).
+ */
+export declare function readStdinInput(): string | undefined;
+/**
+ * Resolves the `model` field for `POST /v1/responses` from the CLI's
+ * `--agent` / `--model` options, per {@code ModelReferenceResolver}'s
+ * grammar: a stored agent is addressed as `agent/{ref}` (an `--agent`
+ * value of `ref@label` naturally composes into `agent/ref@label`), a
+ * direct gateway call is a plain `provider/model` string.
+ */
+export declare function resolveModel(opts: {
+    agent?: string;
+    model?: string;
+}): string;
+interface ResponseContentPart {
+    type?: string;
+    text?: string;
+}
+interface ResponseOutputItem {
+    type?: string;
+    role?: string;
+    content?: ResponseContentPart[];
+}
+interface ResponseUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+}
+interface ResponseResult {
+    id?: string;
+    status?: string;
+    model?: string;
+    output?: ResponseOutputItem[];
+    usage?: ResponseUsage;
+    conversation?: {
+        id?: string;
+    };
+}
+/**
+ * Extracts the assistant's text from a Responses API result: the
+ * `output_text` content parts of every `message` output item, in order.
+ */
+export declare function extractResponseText(result: ResponseResult | undefined): string;
+/**
+ * Extracts the text delta from one line of an SSE stream, or `undefined`
+ * when the line carries nothing to print (not a `data:` line, `[DONE]`, an
+ * event with no textual delta, or unparsable JSON).
+ */
+export declare function extractSseDelta(line: string): string | undefined;
 export declare function makeAiCommand(): Command;
+export {};
 //# sourceMappingURL=ai.d.ts.map

package/dist/commands/ai.js

@@ -1,8 +1,162 @@
 import { Command } from "commander";
-import { getClient, runAction } from "../lib/client.js";
-import { isJsonOutput } from "../lib/config.js";
+import { readFileSync } from "node:fs";
+import { getClient, resolveAuthHeader, runAction } from "../lib/client.js";
+import { resolveConfig, isJsonOutput } from "../lib/config.js";
+import { BackboneApiError } from "../lib/errors.js";
 import { formatList, withSpinner } from "../lib/output.js";
 import chalk from "chalk";
+/**
+ * Reads a single text input from stdin, or `undefined` when stdin is a TTY
+ * (nothing was piped in) or empty. Mirrors the `-` stdin convention used by
+ * `bb convert file`, but always reads stdin implicitly (there is no `-`
+ * sentinel here since `respond` takes a plain input string).
+ */
+export function readStdinInput() {
+    if (process.stdin.isTTY)
+        return undefined;
+    try {
+        const text = readFileSync(0, "utf-8").trim();
+        return text.length > 0 ? text : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolves the `model` field for `POST /v1/responses` from the CLI's
+ * `--agent` / `--model` options, per {@code ModelReferenceResolver}'s
+ * grammar: a stored agent is addressed as `agent/{ref}` (an `--agent`
+ * value of `ref@label` naturally composes into `agent/ref@label`), a
+ * direct gateway call is a plain `provider/model` string.
+ */
+export function resolveModel(opts) {
+    if (opts.agent && opts.model) {
+        throw new Error("Use either --agent or --model, not both.");
+    }
+    if (opts.agent)
+        return `agent/${opts.agent}`;
+    if (opts.model)
+        return opts.model;
+    throw new Error("Either --agent or --model is required.");
+}
+/**
+ * Extracts the assistant's text from a Responses API result: the
+ * `output_text` content parts of every `message` output item, in order.
+ */
+export function extractResponseText(result) {
+    const parts = [];
+    for (const item of result?.output ?? []) {
+        if (item.type !== "message")
+            continue;
+        for (const part of item.content ?? []) {
+            if (part.type === "output_text" && part.text) {
+                parts.push(part.text);
+            }
+        }
+    }
+    return parts.join("\n");
+}
+function printResponseResult(result, command) {
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const text = extractResponseText(result);
+    if (text) {
+        console.log(text);
+    }
+    if (result?.status && result.status !== "completed") {
+        console.log(chalk.yellow(`\n[status: ${result.status}]`));
+    }
+    if (result?.usage) {
+        const usage = result.usage;
+        console.log(chalk.dim(`\n[${result.model} | ${usage.input_tokens} in / ${usage.output_tokens} out / ${usage.total_tokens} total tokens]`));
+    }
+    if (result?.conversation?.id) {
+        console.log(chalk.dim(`[conversation: ${result.conversation.id}]`));
+    }
+}
+/**
+ * Extracts the text delta from one line of an SSE stream, or `undefined`
+ * when the line carries nothing to print (not a `data:` line, `[DONE]`, an
+ * event with no textual delta, or unparsable JSON).
+ */
+export function extractSseDelta(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:"))
+        return undefined;
+    const payload = trimmed.slice(5).trim();
+    if (!payload || payload === "[DONE]")
+        return undefined;
+    try {
+        const event = JSON.parse(payload);
+        const delta = event.delta;
+        return typeof delta === "string" ? delta : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function parseErrorResponse(res) {
+    let body = {};
+    try {
+        body = await res.json();
+    }
+    catch {
+        // Fall through to the defaults below.
+    }
+    return new BackboneApiError({
+        status: body.status ?? res.status,
+        error: body.error ?? res.statusText,
+        message: body.message ?? `HTTP ${res.status}: ${res.statusText}`,
+        timestamp: body.timestamp ?? new Date().toISOString(),
+    });
+}
+/**
+ * Streams `POST /v1/responses` over SSE, printing text deltas as they
+ * arrive. Bypasses the typed openapi-fetch client (like the multipart raw
+ * `fetch` calls in convert.ts/transcribe.ts) because the response body must
+ * be read incrementally rather than parsed whole.
+ */
+async function streamResponse(command, body) {
+    const config = resolveConfig(command);
+    const authHeader = await resolveAuthHeader(config);
+    const baseUrl = config.baseUrl.replace(/\/+$/, "");
+    const res = await withSpinner("Connecting...", () => fetch(`${baseUrl}/v1/responses`, {
+        method: "POST",
+        headers: {
+            Authorization: authHeader,
+            "Content-Type": "application/json",
+            Accept: "text/event-stream",
+        },
+        body: JSON.stringify(body),
+    }));
+    if (!res.ok || !res.body) {
+        throw await parseErrorResponse(res);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let wroteAny = false;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const delta = extractSseDelta(line);
+            if (delta) {
+                process.stdout.write(delta);
+                wroteAny = true;
+            }
+        }
+    }
+    if (wroteAny) {
+        process.stdout.write("\n");
+    }
+}
 export function makeAiCommand() {
     const cmd = new Command("ai").description("AI gateway operations");
     cmd
@@ -50,6 +204,44 @@ export function makeAiCommand() {
             }
         });
     });
+    cmd
+        .command("respond")
+        .description("Send a request to the OpenAI-compatible Responses endpoint")
+        .argument("[input]", "Input text (reads stdin if omitted)")
+        .option("--agent <id>", "Invoke a stored agent by id or name (mutually exclusive with --model)")
+        .option("--model <id>", "Model in provider/model format (mutually exclusive with --agent)")
+        .option("--conversation <id>", "Conversation ID this response belongs to")
+        .option("--stream", "Stream the response as it is generated")
+        .action(async (input, opts, command) => {
+        await runAction(command, async () => {
+            const model = resolveModel(opts);
+            const inputText = input ?? readStdinInput();
+            if (!inputText) {
+                throw new Error("Input is required as an argument or via stdin.");
+            }
+            const body = {
+                model,
+                input: inputText,
+                stream: !!opts.stream,
+            };
+            if (opts.conversation)
+                body.conversation = opts.conversation;
+            if (opts.stream) {
+                await streamResponse(command, body);
+            }
+            else {
+                const client = getClient(command);
+                const { data } = await withSpinner("Generating response...", () => 
+                // The wire `input` field also accepts a bare string (shorthand for
+                // a single user message; see ResponseItemInputDeserializer), which
+                // the generated type does not model — hence the cast, same as the
+                // untyped convert.ts source-conversion calls.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                client.POST("/v1/responses", { body }));
+                printResponseResult(data, command);
+            }
+        });
+    });
     cmd
         .command("models")
         .description("List available AI models")

package/dist/commands/billing.js

@@ -97,6 +97,40 @@ export function makeBillingCommand() {
             }
         });
     });
+    cmd
+        .command("has-available")
+        .description("Check whether a metered resource has enough available capacity")
+        .argument("<type>", "extraction-credits, conversion-credits, or gateway-tokens")
+        .option("--required <n>", "Amount required (default: 1)")
+        .action(async (type, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const typeMap = {
+                "extraction-credits": "EXTRACTION_CREDITS",
+                "conversion-credits": "CONVERSION_CREDITS",
+                "gateway-tokens": "GATEWAY_TOKENS",
+            };
+            const apiType = typeMap[type] ?? type.toUpperCase();
+            const { data } = await client.GET("/v1/billing/has-available", {
+                params: {
+                    query: {
+                        type: apiType,
+                        required: opts.required !== undefined ? Number(opts.required) : undefined,
+                    },
+                },
+            });
+            const result = data?.result;
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify({ type: apiType, hasAvailable: result }));
+            }
+            else if (result) {
+                console.log(chalk.green(`${apiType} has available capacity.`));
+            }
+            else {
+                console.log(chalk.yellow(`${apiType} does NOT have available capacity.`));
+            }
+        });
+    });
     return cmd;
 }
 //# sourceMappingURL=billing.js.map