@2kw/ai 6.3.0-dev.98 → 6.4.0-dev.10

package/README.md

@@ -112,7 +112,7 @@ 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` | Run agents and decide approvals; apply, export and scaffold agent.yaml; manage versions, labels, approvals and tool catalogs |
+| `agents` | Run agents and answer paused runs (approvals and relayed tool calls); apply, export and scaffold agent.yaml; manage versions, labels, approvals and tool catalogs |
 | `skills` | Import and export SKILL.md bundles; manage skill versions and labels |
 | `plugins` | Install plugin repositories, sync them, and inspect their reports |
 | `conversations` | Create and manage conversations and their items |

package/dist/agent-config/schema.d.ts

@@ -221,6 +221,25 @@ export declare const agentSchema: {
                 };
             };
         };
+        readonly bashTool: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "backbone.bash";
+                };
+                readonly approval: {
+                    readonly enum: readonly ["sandbox", "pause"];
+                };
+                readonly outputs: {
+                    readonly enum: readonly ["immediate", "held"];
+                };
+                readonly annotations: {
+                    readonly $ref: "#/$defs/annotations";
+                };
+            };
+        };
         readonly functionTool: {
             readonly type: "object";
             readonly additionalProperties: false;
@@ -335,6 +354,18 @@ export declare const agentSchema: {
                 readonly then: {
                     readonly $ref: "#/$defs/skillTool";
                 };
+            }, {
+                readonly if: {
+                    required: string[];
+                    properties: {
+                        type: {
+                            const: string;
+                        };
+                    };
+                };
+                readonly then: {
+                    readonly $ref: "#/$defs/bashTool";
+                };
             }, {
                 readonly if: {
                     required: string[];

package/dist/agent-config/schema.js

@@ -21,6 +21,12 @@ const oneOfLowercase = (...values) => ({ type: "string", enum: values });
 export const NON_AUTHORABLE_TOOL_TYPES = {
     "backbone.tool_search": "the planner adds it automatically",
     "backbone.skill_read": "it is added at run time when skills are pinned",
+    // #944: SkillsetPinner injects it for eligible callers and strips any stored copy (#779).
+    "backbone.skills_apply": "it is added at run time for callers allowed to author skills",
+    // #1241: injected while the conversation's outputs are held; an authored copy is dropped.
+    "backbone.deliver": "it is added at run time while sandbox outputs are held",
+    // #1244: injected wherever backbone.bash is advertised; an authored copy is dropped.
+    "backbone.view_image": "it is added at run time wherever the sandboxed shell is",
     web_search: "it has no executor and is skipped",
 };
 const BUILTIN_TYPES = [
@@ -29,6 +35,7 @@ const BUILTIN_TYPES = [
     "backbone.document_convert",
     "backbone.todo",
     "backbone.skill",
+    "backbone.bash",
     "function",
 ];
 const typeIs = (t) => ({ required: ["type"], properties: { type: { const: t } } });
@@ -155,6 +162,19 @@ export const agentSchema = {
                 skills: { type: "array", minItems: 1, maxItems: 20, uniqueItems: true, items: { type: "string", pattern: SKILL_REF } },
             },
         },
+        // The envelope BashToolEntryValidator accepts: no name, no requiresConfirmation, and none of
+        // the egress of the withdrawn per-agent network design (#925).
+        bashTool: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type"],
+            properties: {
+                type: { const: "backbone.bash" },
+                approval: { enum: ["sandbox", "pause"] },
+                outputs: { enum: ["immediate", "held"] },
+                annotations: { $ref: "#/$defs/annotations" },
+            },
+        },
         functionTool: {
             type: "object",
             additionalProperties: false,
@@ -188,6 +208,7 @@ export const agentSchema = {
                 { if: typeIs("backbone.document_convert"), then: { $ref: "#/$defs/documentConvertTool" } },
                 { if: typeIs("backbone.todo"), then: { $ref: "#/$defs/todoTool" } },
                 { if: typeIs("backbone.skill"), then: { $ref: "#/$defs/skillTool" } },
+                { if: typeIs("backbone.bash"), then: { $ref: "#/$defs/bashTool" } },
                 { if: typeIs("function"), then: { $ref: "#/$defs/functionTool" } },
                 {
                     // The validator reports these with the reason from NON_AUTHORABLE_TOOL_TYPES; this keeps the published schema honest.

package/dist/agent-config/template.js

@@ -33,6 +33,8 @@ tools: []
 #   - type: backbone.todo
 #   - type: backbone.skill
 #     skills: [skill-name@latest]
+#   - type: backbone.bash
+#     approval: sandbox
 #   - type: function
 #     name: lookup_order
 #     description: Look up an order by number

package/dist/commands/agent-run.js

@@ -6,7 +6,7 @@ import { BackboneApiError, CliUsageError } from "../lib/errors.js";
 import { withSpinner } from "../lib/output.js";
 import { resolveAgent, splitAgentRef, suggestAgents } from "../lib/agent-lookup.js";
 import { buildRunEnvelope, EXIT_CODES, MODE_OPTION_HELP, modeItem, parseModeOption, printRunText, stripControl, } from "../lib/agent-run.js";
-import { continueWithDecisions, decisionsFromAnswers, fetchPendingApprovals, planDecisions, } from "../lib/agent-decide.js";
+import { continueWithDecisions, decisionsFromAnswers, fetchPendingApprovals, parseToolAnswers, planContinuation, } from "../lib/agent-decide.js";
 import { PromptAbortedError, promptApprovals, readlineAsk } from "../lib/approval-prompt.js";
 import { withModelOverride } from "../lib/agent-models.js";
 import { readStdinInput } from "./ai.js";
@@ -171,9 +171,11 @@ export function makeAgentRunCommand() {
         });
     });
 }
+/** Repeatable `--output` / `--fail`: a variadic `<v...>` would swallow the arguments that follow it. */
+const collect = (value, previous = []) => [...previous, value];
 export function makeAgentDecideCommand() {
     return new Command("decide")
-        .description("Decide every pending approval of a paused run and continue it")
+        .description("Answer a paused run: decide every pending approval and answer every relayed tool call in one call, then continue it")
         .argument("<agent>", "Agent name or id, optionally with @label and #model (use the same @label and #model the run used)")
         .requiredOption("--response <responseId>", "The paused response id (responseId in the run envelope)")
         .option("--approve <ids...>", "Approval ids to approve")
@@ -182,11 +184,15 @@ export function makeAgentDecideCommand() {
         .option("--reject-all", "Reject every pending approval of the response")
         .option("--reason <text>", "Reason recorded on each decision (the model sees it on rejects)")
         .option("--remember", "Also approve later calls of the same tool in this conversation")
+        .option("--output <callId=value>", "Answer a relayed tool call: <callId>=<text>, <callId>=@<file> or <callId>=@- for stdin; within one hour of the pause (repeatable)", collect)
+        .option("--fail <callId=message>", "Answer a relayed tool call as failed: <callId>=<message> (same @file / @- forms; repeatable)", collect)
         .option("--mode <mode>", MODE_OPTION_HELP)
         .option("--raw", "Print the untouched API response")
         .action(async (agentRef, opts, command) => {
         await runAction(command, async () => {
             const mode = parseModeOption(opts.mode);
+            // Syntax, duplicates and file reads are checked before any request (#671 D4).
+            const toolAnswers = parseToolAnswers(opts.output, opts.fail);
             const client = getClient(command);
             const { name, label, model } = splitAgentRef(agentRef);
             // Dropped silently, an empty override would continue the run on the default model.
@@ -194,15 +200,15 @@ export function makeAgentDecideCommand() {
                 throw new CliUsageError(`Empty #model in '${agentRef}': use the model the run used, or drop the '#'.`);
             const agent = await resolveAgent(client, name);
             const pending = await fetchPendingApprovals(client, String(agent.id), opts.response);
-            const decisions = planDecisions(pending, {
+            const decisions = planContinuation(pending, {
                 approve: opts.approve,
                 reject: opts.reject,
                 approveAll: opts.approveAll,
                 rejectAll: opts.rejectAll,
                 reason: opts.reason,
                 remember: opts.remember,
-            }, opts.response);
-            const result = await withSpinner("Continuing...", () => continueWithDecisions(client, String(agent.id), opts.response, decisions, label, model, mode));
+            }, toolAnswers, opts.response);
+            const result = await withSpinner("Continuing...", () => continueWithDecisions(client, String(agent.id), opts.response, decisions, label, model, mode, toolAnswers));
             await finishRun(command, client, { name, label, model, mode }, result, { raw: !!opts.raw, interactive: false });
         });
     });

package/dist/commands/ai.js

@@ -106,11 +106,11 @@ export function makeAiCommand() {
         .option("--agent <id>", "Invoke a stored agent by id or name, optionally with @label")
         .option("--model <id>", "Model in provider/model format; with --agent, one of the agent's models to run this request on")
         .option("--conversation <id>", "Conversation ID this response belongs to")
-        .option("--stream", "Stream the response (not supported by the server yet, #148)")
+        .option("--stream", "Stream the response (not supported by the CLI yet)")
         .action(async (input, opts, command) => {
         await runAction(command, async () => {
             if (opts.stream) {
-                throw new CliUsageError("Streaming is not supported by the server yet (#148). Run without --stream.");
+                throw new CliUsageError("Streaming is not supported by the CLI yet. Run without --stream.");
             }
             const model = resolveModel(opts);
             const inputText = input ?? readStdinInput();

package/dist/commands/billing.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
 import { isJsonOutput } from "../lib/config.js";
+import { CliUsageError } from "../lib/errors.js";
 import { formatDetail, formatList } from "../lib/output.js";
 import chalk from "chalk";
 export function makeBillingCommand() {
@@ -133,6 +134,107 @@ export function makeBillingCommand() {
             }
         });
     });
+    cmd.addCommand(makeOverageCommand());
+    cmd.addCommand(makeTopUpsCommand());
+    return cmd;
+}
+/** Whole euros from cents, e.g. 1234 → "€12.34". Amounts are net of VAT (#973 D-O). */
+function euros(cents) {
+    return `€${((cents ?? 0) / 100).toFixed(2)}`;
+}
+function parseWhole(value, name, min, max) {
+    const n = /^\d+$/.test(value) ? Number(value) : NaN;
+    if (!Number.isInteger(n) || n < min || n > max) {
+        throw new CliUsageError(`${name} must be a whole number between ${min} and ${max}, not '${value}'`);
+    }
+    return n;
+}
+/** `bb billing overage get|set` — the opt-in overage cap (#973, plan D-O). Reads need a member login. */
+function makeOverageCommand() {
+    const cmd = new Command("overage").description("Show or set the opt-in overage cap (euros, net of VAT)");
+    cmd
+        .command("get")
+        .description("Show the overage setting and this period's overage (needs `bb auth login`)")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/overage");
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(`Overage:   ${data?.enabled ? chalk.green("on") : chalk.dim("off")}`);
+            console.log(`Cap:       €${data?.capEuros ?? 0} (max €${data?.maxCapEuros ?? 0})`);
+            console.log(`Available: ${data?.available ? chalk.green("yes") : chalk.yellow(`no (${data?.unavailableReason ?? "unknown"})`)}`);
+            console.log(`Spent:     ${euros(data?.spentCents)}`);
+            console.log(`Reserved:  ${euros(data?.reservedCents)}`);
+            if (data?.periodStart || data?.periodEnd) {
+                console.log(chalk.dim(`Period: ${data?.periodStart?.slice(0, 10) ?? "?"} → ${data?.periodEnd?.slice(0, 10) ?? "?"}`));
+            }
+        });
+    });
+    cmd
+        .command("set")
+        .description("Turn overage on with a cap, or off (admin)")
+        .option("--cap <euros>", "Monthly cap in whole euros, 1-100; turns overage on")
+        .option("--off", "Turn overage off, keeping the stored cap")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            if (opts.off === Boolean(opts.cap)) {
+                throw new CliUsageError("Pass exactly one of --cap <euros> or --off");
+            }
+            // --off sends no cap: the backend keeps the stored one, and no read is needed (the read
+            // refuses API keys, the write admits an admin's).
+            const body = opts.off
+                ? { enabled: false }
+                : { enabled: true, capEuros: parseWhole(String(opts.cap), "cap", 1, 100) };
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/billing/overage", { body });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+/** `bb billing top-ups list|buy` — prepaid credit packs (#973, plan D-E). Never opens a browser. */
+function makeTopUpsCommand() {
+    const cmd = new Command("top-ups").description("List or buy prepaid credit (packs of 1,000 credits at €15)");
+    cmd
+        .command("list")
+        .description("List unexpired prepaid credit (needs `bb auth login`)")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/top-ups");
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const rows = (data ?? []).map((lot) => ({
+                kind: lot.kind,
+                purchased: euros(lot.purchasedCents),
+                remaining: euros(lot.remainingCents),
+                expires: lot.expiresAt?.slice(0, 10),
+            }));
+            formatList(rows, command, ["kind", "purchased", "remaining", "expires"]);
+        });
+    });
+    cmd
+        .command("buy")
+        .description("Start a Stripe Checkout for top-up packs and print its URL (admin)")
+        .requiredOption("--packs <n>", "Number of packs, 1-20")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const packs = parseWhole(String(opts.packs), "packs", 1, 20);
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/billing/top-ups", { body: { packs } });
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(`Open this page to pay: ${data?.checkoutUrl}`);
+            console.log(chalk.dim(`Expires: ${data?.expiresAt ?? "?"}`));
+        });
+    });
     return cmd;
 }
 //# sourceMappingURL=billing.js.map

package/dist/commands/convert.js

@@ -1,9 +1,8 @@
 import { Command } from "commander";
 import { readFileSync, writeFileSync } from "node:fs";
 import chalk from "chalk";
-import { getClient, resolveAuthHeader, runAction } from "../lib/client.js";
-import { resolveConfig, isJsonOutput } from "../lib/config.js";
-import { BackboneApiError } from "../lib/errors.js";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
 import { formatDetail, withSpinner } from "../lib/output.js";
 import { fileToBlob, getMimeType } from "../lib/multipart.js";
 function mapFormat(format) {
@@ -136,34 +135,19 @@ function buildFormData(paths, opts) {
     formData.append("options", new Blob([JSON.stringify(pipelineOptions)], { type: "application/json" }));
     return formData;
 }
+/**
+ * POST the multipart body through the typed client. The generated type describes `files` as string[],
+ * which FormData cannot match, so the placeholder body satisfies the type and bodySerializer sends the
+ * real parts; the client's auth and error middleware apply.
+ */
 async function multipartConvert(command, formData, endpoint, pipeline) {
-    const config = resolveConfig(command);
-    const authHeader = await resolveAuthHeader(config);
-    const baseUrl = config.baseUrl.replace(/\/+$/, "");
-    const url = pipeline
-        ? `${baseUrl}${endpoint}?pipeline=${encodeURIComponent(pipeline)}`
-        : `${baseUrl}${endpoint}`;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { Authorization: authHeader },
-        body: formData,
+    const client = getClient(command);
+    const { data } = await client.POST(endpoint, {
+        params: { query: { pipeline } },
+        body: { files: [] },
+        bodySerializer: () => formData,
     });
-    if (!res.ok) {
-        let body;
-        try {
-            body = await res.json();
-        }
-        catch {
-            body = {
-                error: res.statusText,
-                message: `HTTP ${res.status}: ${res.statusText}`,
-                status: res.status,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        throw new BackboneApiError(body);
-    }
-    return (await res.json());
+    return data;
 }
 export function makeConvertCommand() {
     const cmd = new Command("convert").description("Convert documents");

package/dist/commands/experiments.js

@@ -16,8 +16,18 @@ function formatComparisonCell(result) {
         return chalk.red("ERROR");
     const scores = result.scores ?? [];
     if (scores.length > 0) {
-        const avg = scores.reduce((sum, s) => sum + (s.score ?? 0), 0) / scores.length;
-        return avg.toFixed(2);
+        // A SKIP carries a placeholder 0.0 that is not a rating, and a comment-only
+        // score has no number; neither takes part in the average (#693).
+        const rated = scores.filter((s) => s.label !== "SKIP" && s.score != null);
+        if (rated.length > 0) {
+            return (rated.reduce((sum, s) => sum + s.score, 0) / rated.length).toFixed(2);
+        }
+        // A label-only verdict (#1163) has no number; show its label, as the console does.
+        const verdict = scores.find((s) => s.label && s.label !== "SKIP");
+        if (verdict)
+            return String(verdict.label);
+        if (scores.every((s) => s.label === "SKIP"))
+            return chalk.dim("skipped");
     }
     return result.durationMs != null ? `${result.durationMs}ms` : chalk.dim("done");
 }
@@ -392,8 +402,14 @@ export function makeExperimentsCommand() {
                 console.log(chalk.dim(`Page ${(page.number ?? 0) + 1} of ${page.totalPages ?? 0} (${page.totalElements ?? 0} total)`));
             }
             if (aggregates.length > 0) {
+                const skippedOf = (agg) => Object.entries((agg.skippedEvaluatorCounts ?? {}))
+                    .filter(([, n]) => n > 0)
+                    .map(([evaluatorId, n]) => `${evaluatorId}: ${n}`)
+                    .join(", ");
+                // Only when something was skipped, so a clean run keeps its narrow table (#693).
+                const showSkipped = aggregates.some((agg) => skippedOf(agg) !== "");
                 const aggTable = new Table({
-                    head: ["Variant", "Items", "Avg Duration", "Avg Tokens", "Total Cost"].map((h) => chalk.cyan(h)),
+                    head: ["Variant", "Items", "Avg Duration", "Avg Tokens", "Total Cost", ...(showSkipped ? ["Skipped"] : [])].map((h) => chalk.cyan(h)),
                     wordWrap: true,
                 });
                 for (const agg of aggregates) {
@@ -403,6 +419,7 @@ export function makeExperimentsCommand() {
                         agg.avgDurationMs != null ? `${Math.round(agg.avgDurationMs)}ms` : "—",
                         agg.avgTokens != null ? Math.round(agg.avgTokens) : "—",
                         agg.totalCost != null ? `$${agg.totalCost}` : "—",
+                        ...(showSkipped ? [skippedOf(agg) || "—"] : []),
                     ]);
                 }
                 console.log(chalk.bold("\nAggregates:"));

package/dist/commands/installations.js

@@ -1,7 +1,22 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
+import { CliUsageError } from "../lib/errors.js";
 import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+const MIN_MONTHLY_PERCENT = 0;
+const MAX_MONTHLY_PERCENT = 1000;
+/**
+ * Validated inside the action rather than as commander's argument parser, so the refusal
+ * travels through `runAction` and exits 2 like every other usage error (see `parsePort` in
+ * connectors.ts).
+ */
+function parseMonthlyPercent(value) {
+    const percent = /^\d+$/.test(value) ? Number(value) : NaN;
+    if (!Number.isInteger(percent) || percent < MIN_MONTHLY_PERCENT || percent > MAX_MONTHLY_PERCENT) {
+        throw new CliUsageError(`percent must be a whole number between ${MIN_MONTHLY_PERCENT} and ${MAX_MONTHLY_PERCENT}, not '${value}'`);
+    }
+    return percent;
+}
 export function makeInstallationsCommand() {
     const cmd = new Command("installations").description("Manage surface installations");
     const list = new Command("list").description("List installations");
@@ -172,6 +187,36 @@ export function makeInstallationsCommand() {
         });
     });
     cmd.addCommand(keys);
+    const budget = new Command("budget").description("Manage an installation's monthly budget: a share of the organisation's pool");
+    budget
+        .command("get")
+        .description("Read an installation's current budget: percent, period, and usage")
+        .argument("<id>", "Installation ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/installations/{id}/budget", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    budget
+        .command("set")
+        .description("Set or change an installation's monthly budget share, 0-1000 percent")
+        .argument("<id>", "Installation ID")
+        .argument("<percent>", "Monthly percent of the organisation's pool, 0-1000")
+        .action(async (id, percent, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/installations/{id}/budget", {
+                params: { path: { id } },
+                body: { monthlyPercent: parseMonthlyPercent(percent) },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(budget);
     return cmd;
 }
 //# sourceMappingURL=installations.js.map

package/dist/commands/knowledge.js

@@ -37,7 +37,7 @@ export function makeKnowledgeCommand() {
         .description("Create a knowledge base and its first configuration version")
         .requiredOption("-n, --name <name>", "Knowledge base name")
         .requiredOption("--slug <slug>", "Unique slug")
-        .requiredOption("--embedding-provider <id>", "Embedding provider ID")
+        .requiredOption("--embedding-provider <id>", "Embedding provider: a provider ID, or builtin for the platform's built-in models (text-embedding-3-small, text-embedding-3-large; charged per input token)")
         .requiredOption("--embedding-model <model>", "Embedding model")
         .requiredOption("--embedding-dim <n>", "Embedding dimension", parseInt)
         .option("-d, --description <text>", "Description")
@@ -47,6 +47,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "Parent chunk size (hierarchical chunking)", parseInt)
         .option("--reranker-provider <id>", "Reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Text-search language for the lexical leg (default simple)")
         .action(async (opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -64,6 +65,7 @@ export function makeKnowledgeCommand() {
                     parentChunkSize: opts.parentChunkSize,
                     rerankerProviderId: opts.rerankerProvider,
                     hybridSearchEnabled: opts.hybridSearch !== undefined ? opts.hybridSearch === "true" : undefined,
+                    textSearchLanguage: opts.textSearchLanguage,
                 },
             });
             formatDetail(data, command);
@@ -75,7 +77,7 @@ export function makeKnowledgeCommand() {
         .argument("<id>", "Knowledge base ID")
         .option("-n, --name <name>", "New name")
         .option("-d, --description <text>", "New description")
-        .option("--embedding-provider <id>", "New embedding provider ID")
+        .option("--embedding-provider <id>", "New embedding provider ID, or builtin. Re-embeds nothing: stored vectors stay comparable only if the new provider serves the same model at the same width; the safe move is a new knowledge base with the documents uploaded again")
         .option("--embedding-model <model>", "New embedding model")
         .option("--chunking-strategy <strategy>", "New chunking strategy (AUTO, FIXED, HIERARCHICAL, CUSTOM)")
         .option("--chunk-size <n>", "New chunk size", parseInt)
@@ -83,6 +85,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "New parent chunk size", parseInt)
         .option("--reranker-provider <id>", "New reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Change the text-search language (reindexes in the background); omit to leave it untouched")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -107,6 +110,8 @@ export function makeKnowledgeCommand() {
                 body.rerankerProviderId = opts.rerankerProvider;
             if (opts.hybridSearch !== undefined)
                 body.hybridSearchEnabled = opts.hybridSearch === "true";
+            if (opts.textSearchLanguage)
+                body.textSearchLanguage = opts.textSearchLanguage;
             const { data } = await client.PATCH("/v1/knowledge-bases/{id}", {
                 params: { path: { id } },
                 body: body,
@@ -173,7 +178,7 @@ export function makeKnowledgeCommand() {
     cmd
         .command("embedding-models")
         .description("List embedding models a provider serves that fit a provisioned dimension")
-        .argument("<providerId>", "Provider ID")
+        .argument("<providerId>", "Provider ID, or builtin for the platform's built-in embedding models")
         .action(async (providerId, _opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);

package/dist/commands/skills.js

@@ -149,18 +149,16 @@ export function makeSkillsCommand() {
                 }
                 ({ blob, filename } = fileToBlob(path));
             }
-            const config = resolveConfig(command);
-            const authHeader = await resolveAuthHeader(config);
             const formData = new FormData();
             formData.append("file", blob, filename);
+            const client = getClient(command);
             const data = await withSpinner("Importing skill...", async () => {
-                const res = await fetch(`${config.baseUrl.replace(/\/+$/, "")}/v1/skills/import`, {
-                    method: "POST",
-                    headers: { Authorization: authHeader },
-                    body: formData,
+                // Placeholder body for the generated type; bodySerializer sends the real part.
+                const result = await client.POST("/v1/skills/import", {
+                    body: { file: "" },
+                    bodySerializer: () => formData,
                 });
-                await checkResponse(res);
-                return res.json();
+                return result.data;
             });
             formatDetail(data, command);
         });

package/dist/commands/tracing.js

@@ -77,6 +77,7 @@ export function makeTracingCommand() {
     const sessions = new Command("sessions").description("Session-level trace views (spans grouped by exporter-stamped session id)");
     const sessionsList = new Command("list").description("List trace sessions");
     sessionsList.option("--search <query>", "Free-text search across session id and name");
+    sessionsList.option("--session-id <sessionId>", "Exact match on the session.id the exporter stamped (slashes allowed)");
     sessionsList.option("--from <iso>", "Start of time range (ISO-8601)");
     sessionsList.option("--to <iso>", "End of time range (ISO-8601)");
     sessionsList.option("--page <n>", "Page index (0-based)", "0");
@@ -88,6 +89,7 @@ export function makeTracingCommand() {
                 params: {
                     query: {
                         search: opts.search,
+                        sessionId: opts.sessionId,
                         from: opts.from,
                         to: opts.to,
                         page: parseInt(opts.page, 10),
@@ -96,17 +98,17 @@ export function makeTracingCommand() {
                 },
             });
             const page = data;
-            formatList((page?.content ?? []), command, ["sessionId", "name", "startTime", "durationMs", "turnCount", "errorCount", "costUsd"]);
+            formatList((page?.content ?? []), command, ["id", "sessionId", "name", "startTime", "durationMs", "turnCount", "errorCount", "costUsd"]);
         });
     });
     sessions.addCommand(sessionsList);
     const sessionsGet = new Command("get").description("Get all spans of a session by id, sorted chronologically");
-    sessionsGet.argument("<sessionId>", "Session id");
-    sessionsGet.action(async (sessionId, _opts, command) => {
+    sessionsGet.argument("<id>", "Session id: the id column of `sessions list` (find one by session.id with --session-id)");
+    sessionsGet.action(async (id, _opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
-            const { data } = await client.GET("/v1/traces/sessions/{sessionId}", {
-                params: { path: { sessionId } },
+            const { data } = await client.GET("/v1/traces/sessions/{id}", {
+                params: { path: { id } },
             });
             formatDetail(data, command);
         });