@dharta/cli 0.6.77 → 0.6.78

package/src/model-settings.ts

@@ -0,0 +1,222 @@
+// RFC 0070 model-selection inputs shared by `dharta agent model` and
+// `dharta org model set`. Both commands accept the same connector order,
+// model reference, and portable parameter flags, so the parsing, the
+// validation, and the request patch live here once.
+//
+// Like validators.ts, everything here rejects a value the user typed, so every
+// failure is a usage error and exits 2 (see exit-codes.ts).
+
+import { CliUsageError } from "./exit-codes.js";
+import { closestChoice, normalizeNonBlank, parsePositiveInteger } from "./validators.js";
+
+export const MAX_OUTPUT_TOKENS = 1_000_000;
+export const REASONING_EFFORTS = ["low", "medium", "high"] as const;
+
+// The synthetic platform connector. It is orderable like a stored connector
+// but has no credential of its own.
+export const PLATFORM_CONNECTOR_SLUG = "karta";
+// At most this many connectors in one order, matching the server.
+const MAX_CONNECTOR_ORDER = 32;
+// A connector slug is a lowercase DNS label of at most 63 characters.
+const CONNECTOR_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+// `connector:` and `route:` introduce a model reference, so neither word can
+// also name a connector.
+const RESERVED_CONNECTOR_SLUGS = ["connector", "route"] as const;
+
+export interface ModelParameterOptions {
+  temperature?: string;
+  clearTemperature?: boolean;
+  topP?: string;
+  clearTopP?: boolean;
+  maxOutputTokens?: string;
+  clearMaxOutputTokens?: boolean;
+  reasoningEffort?: string;
+  clearReasoningEffort?: boolean;
+}
+
+// Validate a slug that names a stored connector, as `--slug` does on create.
+// The platform slug is rejected here: it is orderable, not storable.
+export function normalizeStoredConnectorSlug(value: string, flag: string): string {
+  const normalized = normalizeConnectorSlug(value, flag);
+  if (normalized === PLATFORM_CONNECTOR_SLUG) {
+    throw new CliUsageError(`${flag} cannot be ${PLATFORM_CONNECTOR_SLUG}: that slug names the platform connector.`);
+  }
+  return normalized;
+}
+
+// Validate a slug that can appear in a connector order, where the platform
+// slug is allowed.
+export function normalizeConnectorSlug(value: string, flag: string): string {
+  const normalized = normalizeNonBlank(value, flag);
+  if (!CONNECTOR_SLUG_PATTERN.test(normalized)) {
+    throw new CliUsageError(
+      `${flag} must be a lowercase DNS label of 1 to 63 characters: letters, numbers, and hyphens, ` +
+        "starting and ending with a letter or number, for example openai-primary.",
+    );
+  }
+  // An all-digit path segment is always read as a connector id, so an
+  // all-digit slug could never be addressed by slug. Refuse to mint one.
+  if (/^\d+$/.test(normalized)) {
+    throw new CliUsageError(
+      `${flag} cannot be all digits: an all-digit reference is always read as a connector id.`,
+    );
+  }
+  if ((RESERVED_CONNECTOR_SLUGS as readonly string[]).includes(normalized)) {
+    throw new CliUsageError(`${flag} cannot be ${normalized}: that word is reserved for model references.`);
+  }
+  return normalized;
+}
+
+// Parse `--connector <slug[,slug...]>` into the ordered slug list the API
+// stores. An empty value produces an empty list, which means "inherit".
+export function parseConnectorOrder(value: string, flag: string): string[] {
+  const slugs = value.split(/[\s,]+/).map((part) => part.trim()).filter(Boolean);
+  if (slugs.length > MAX_CONNECTOR_ORDER) {
+    throw new CliUsageError(`${flag} accepts at most ${MAX_CONNECTOR_ORDER} connectors.`);
+  }
+  const normalized = slugs.map((slug) => normalizeConnectorSlug(slug, flag));
+  const seen = new Set<string>();
+  for (const slug of normalized) {
+    if (seen.has(slug)) throw new CliUsageError(`${flag} lists ${slug} more than once.`);
+    seen.add(slug);
+  }
+  return normalized;
+}
+
+// Normalize `--model-ref <reference>`. The server owns the grammar; the CLI
+// only rejects shapes that can never resolve, so a typo fails before a
+// round trip. An empty value clears the reference.
+//
+// A structured reference is rebuilt from its validated components rather than
+// passed through, so `connector: openai-primary / gpt-5.2` cannot reach the
+// server with the whitespace still embedded in the slug or the model id.
+export function normalizeModelReference(value: string, flag: string): string {
+  const normalized = value.trim();
+  if (!normalized) return "";
+  if (normalized.startsWith("connector:")) {
+    const rest = normalized.slice("connector:".length);
+    const separator = rest.indexOf("/");
+    if (separator === -1) {
+      throw new CliUsageError(`${flag} connector reference needs a model: connector:<slug>/<model>.`);
+    }
+    const slug = normalizeConnectorSlug(rest.slice(0, separator), `${flag} connector slug`);
+    const model = rest.slice(separator + 1).trim();
+    if (!model) {
+      throw new CliUsageError(`${flag} connector reference needs a model: connector:<slug>/<model>.`);
+    }
+    return `connector:${slug}/${model}`;
+  }
+  if (normalized.startsWith("route:")) {
+    const route = normalized.slice("route:".length).trim();
+    if (!route) {
+      throw new CliUsageError(`${flag} route reference needs a name: route:<name>.`);
+    }
+    // A route name uses the same grammar as a connector slug.
+    return `route:${normalizeConnectorSlug(route, `${flag} route name`)}`;
+  }
+  return normalized;
+}
+
+export function modelParameterOptionPresent(opts: ModelParameterOptions): boolean {
+  return opts.temperature !== undefined || opts.clearTemperature === true ||
+    opts.topP !== undefined || opts.clearTopP === true ||
+    opts.maxOutputTokens !== undefined || opts.clearMaxOutputTokens === true ||
+    opts.reasoningEffort !== undefined || opts.clearReasoningEffort === true;
+}
+
+export function validateModelParameterOptions(opts: ModelParameterOptions): void {
+  validateParameterPair(opts.temperature, opts.clearTemperature, "--temperature", "--clear-temperature");
+  validateParameterPair(opts.topP, opts.clearTopP, "--top-p", "--clear-top-p");
+  validateParameterPair(
+    opts.maxOutputTokens,
+    opts.clearMaxOutputTokens,
+    "--max-output-tokens",
+    "--clear-max-output-tokens",
+  );
+  validateParameterPair(
+    opts.reasoningEffort,
+    opts.clearReasoningEffort,
+    "--reasoning-effort",
+    "--clear-reasoning-effort",
+  );
+  if (opts.temperature !== undefined) parseBoundedNumber(opts.temperature, "--temperature", 0, 2, false);
+  if (opts.topP !== undefined) parseBoundedNumber(opts.topP, "--top-p", 0, 1, true);
+  if (opts.maxOutputTokens !== undefined) {
+    const value = parsePositiveInteger(opts.maxOutputTokens, "--max-output-tokens");
+    if (value > MAX_OUTPUT_TOKENS) {
+      throw new CliUsageError(`--max-output-tokens must be at most ${MAX_OUTPUT_TOKENS}.`);
+    }
+  }
+  if (opts.reasoningEffort !== undefined && !(REASONING_EFFORTS as readonly string[]).includes(opts.reasoningEffort)) {
+    const suggestion = closestChoice(opts.reasoningEffort, REASONING_EFFORTS);
+    throw new CliUsageError(
+      "--reasoning-effort must be low, medium, or high." +
+        (suggestion ? ` Did you mean ${suggestion}?` : ""),
+    );
+  }
+}
+
+// Build the `model_parameters` patch. A null clears one parameter and leaves
+// the rest inherited.
+export function modelParameterPatch(opts: ModelParameterOptions): Record<string, number | string | null> {
+  const patch: Record<string, number | string | null> = {};
+  if (opts.temperature !== undefined) patch.temperature = Number(opts.temperature);
+  if (opts.clearTemperature) patch.temperature = null;
+  if (opts.topP !== undefined) patch.top_p = Number(opts.topP);
+  if (opts.clearTopP) patch.top_p = null;
+  if (opts.maxOutputTokens !== undefined) patch.max_output_tokens = Number(opts.maxOutputTokens);
+  if (opts.clearMaxOutputTokens) patch.max_output_tokens = null;
+  if (opts.reasoningEffort !== undefined) patch.reasoning_effort = opts.reasoningEffort;
+  if (opts.clearReasoningEffort) patch.reasoning_effort = null;
+  return patch;
+}
+
+export function normalizeModelParameterOptions<T extends ModelParameterOptions>(opts: T): T {
+  return {
+    ...opts,
+    temperature: normalizeOptionalFlag(opts.temperature, "--temperature"),
+    topP: normalizeOptionalFlag(opts.topP, "--top-p"),
+    maxOutputTokens: normalizeOptionalFlag(opts.maxOutputTokens, "--max-output-tokens"),
+    reasoningEffort: normalizeOptionalFlag(opts.reasoningEffort, "--reasoning-effort"),
+  };
+}
+
+// Trim a flag that may be absent. A flag present but blank is an error,
+// except where a command gives the empty string its own meaning.
+export function normalizeOptionalFlag(value: string | undefined, flag: string): string | undefined {
+  if (value === undefined) return undefined;
+  const normalized = value.trim();
+  if (normalized.length === 0) throw new CliUsageError(`${flag} cannot be blank.`);
+  return normalized;
+}
+
+export function formatModelParameters(parameters: object | undefined): string {
+  const entries = Object.entries(parameters ?? {});
+  if (entries.length === 0) return "";
+  return entries.map(([name, value]) => `${name}=${JSON.stringify(value)}`).join(", ");
+}
+
+function validateParameterPair(
+  value: string | undefined,
+  clear: boolean | undefined,
+  setFlag: string,
+  clearFlag: string,
+): void {
+  if (value !== undefined && clear) throw new CliUsageError(`Use either ${setFlag} or ${clearFlag}, not both.`);
+}
+
+function parseBoundedNumber(
+  value: string,
+  flag: string,
+  minimum: number,
+  maximum: number,
+  exclusiveMinimum: boolean,
+): number {
+  const parsed = Number(value);
+  const minimumOk = exclusiveMinimum ? parsed > minimum : parsed >= minimum;
+  if (!Number.isFinite(parsed) || !minimumOk || parsed > maximum) {
+    const lower = exclusiveMinimum ? `greater than ${minimum}` : `at least ${minimum}`;
+    throw new CliUsageError(`${flag} must be a finite number ${lower} and at most ${maximum}.`);
+  }
+  return parsed;
+}

package/src/money.ts

@@ -1,3 +1,5 @@
+import { CliUsageError } from "./exit-codes.js";
+
 export function parseDollarAmountToCents(value: string, flag: string): number {
   const trimmed = value.trim();
   const match = trimmed.match(/^(?:(\d+)(?:\.(\d{1,2}))?|\.(\d{1,2}))$/);
@@ -11,5 +13,7 @@ export function parseDollarAmountToCents(value: string, flag: string): number {
 }
 
 function amountError(flag: string): Error {
-  return new Error(`${flag} must be a dollar amount greater than 0 with at most two decimal places.`);
+  return new CliUsageError(
+    `${flag} must be a dollar amount greater than 0 with at most two decimal places.`,
+  );
 }

package/src/output.ts

@@ -1,3 +1,7 @@
+import type { Command } from "commander";
+
+import { applyJqFilter, jqExpression } from "./jq.js";
+
 // Output helpers. Tiny on purpose — the CLI's UX is "narrate one line
 // per row + occasional table"; pulling in cli-table or chalk costs
 // more than it buys at this scale.
@@ -20,3 +24,59 @@ export function table(rows: Array<Record<string, string>>): string {
 export function fmtTs(ts: string | null | undefined): string {
   return ts ?? "—";
 }
+
+// --json output (RFC 0013 §3), and the --jq filter layered on it. These live
+// here rather than in cli.ts because a command module cannot import cli.ts -
+// cli.ts imports the command modules - and `dharta genui` needs them.
+//
+// --json output: every command that produces a result
+// payload prints it as JSON when --json is set. Progress narration
+// (device-flow codes, download logs) moves to stderr so stdout stays
+// parseable. Commands whose stdout is a stream, a REPL, a script, or a
+// protocol rather than a result payload (dev, logs, completion,
+// git-credential, and `deploy --mode git` whose output is the live
+// push sideband) reject --json. `deploy --mode folder` returns a
+// single payload, so it supports --json.
+//
+// Mechanics: the flag is registered on every node of the command tree
+// so commander's
+// outermost option scan consumes it wherever it appears on the line -
+// so actions read it through optsWithGlobals() on their Command. Commands
+// that always reject JSON keep a hidden parser option so help/completions
+// do not advertise an invalid mode.
+export function isJson(cmd: Command): boolean {
+  const opts = cmd.optsWithGlobals();
+  // --jq implies --json: there is nothing to filter but the JSON payload, and
+  // requiring both flags is the papercut `gh --jq` deliberately avoids.
+  return Boolean(opts.json) || opts.jq !== undefined;
+}
+
+// The payload a command produced, held until the run finishes. With --jq armed
+// the filter is async and printing has to wait for it; without it the payload
+// is written straight through. Buffering in both cases keeps one code path,
+// and every command produces at most one payload.
+let jsonPayload: { value: unknown } | null = null;
+
+export function printJson(payload: unknown): void {
+  if (jqExpression() === null) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  jsonPayload = { value: payload };
+}
+
+/** Drop any held payload. cli.ts calls this before each run's action. */
+export function resetJsonPayload(): void {
+  jsonPayload = null;
+}
+
+export async function flushJsonPayload(): Promise<void> {
+  const held = jsonPayload;
+  jsonPayload = null;
+  if (held === null) return;
+  const filtered = await applyJqFilter(held.value);
+  // A filter that matches nothing prints nothing, the way jq and `gh --jq` do.
+  // A blank line would look like an empty result to a reader and would be one
+  // more line for `wc -l` to count.
+  if (filtered !== "") console.log(filtered);
+}

package/src/runtime.ts

@@ -11,7 +11,7 @@ import * as path from "node:path";
 import { spawn } from "node:child_process";
 
 // Ships with the CLI release; bump together with dharta-runtime.
-export const DHARTA_RUNTIME_PIN = "0.6.77";
+export const DHARTA_RUNTIME_PIN = "0.6.78";
 
 export const UV_INSTALL_HINT =
   "Install uv first:  curl -LsSf https://astral.sh/uv/install.sh | sh  (or: brew install uv)\n" +

package/src/scaffold.ts

@@ -8,6 +8,7 @@
 import { existsSync, promises as fs } from "node:fs";
 import * as path from "node:path";
 import { resolveTemplates } from "./templates.js";
+import { CliUsageError } from "./exit-codes.js";
 import { closestChoice, normalizeNonBlank } from "./validators.js";
 import {
   DEFAULT_CREATE_HARNESS,
@@ -46,7 +47,7 @@ export async function scaffoldTemplate(target: string, opts: ScaffoldOptions): P
   if (!template) {
     const keys = resolved.templates.map((t) => t.key);
     const suggestion = closestChoice(templateKey, keys);
-    throw new Error(
+    throw new CliUsageError(
       `Unknown template '${templateKey}'. Available: ${keys.join(", ")}.` +
         (suggestion ? ` Did you mean ${suggestion}?` : ""),
     );

package/src/validators.ts

@@ -1,3 +1,10 @@
+// Shared input validators. Everything here rejects a value the user typed, so
+// every failure is a usage error and exits 2 (see exit-codes.ts). Validators
+// living elsewhere - agent.ts, model-settings.ts, commands/org.ts - follow the
+// same rule: if the value came from the command line, throw CliUsageError.
+// Reserve a plain Error for a failure the user's arguments did not cause.
+import { CliUsageError } from "./exit-codes.js";
+
 export function validateDateOnly(value: string, flag: string): void {
   normalizeDateOnly(value, flag);
 }
@@ -5,7 +12,7 @@ export function validateDateOnly(value: string, flag: string): void {
 export function normalizeDateOnly(value: string, flag: string): string {
   const normalized = value.trim();
   if (!isDateOnly(normalized)) {
-    throw new Error(`${flag} must use YYYY-MM-DD, e.g. 2026-05-18.`);
+    throw new CliUsageError(`${flag} must use YYYY-MM-DD, e.g. 2026-05-18.`);
   }
   return normalized;
 }
@@ -29,14 +36,14 @@ export function normalizeIsoTimestamp(value: string, flag: string): string {
 
 export function parseReleaseVersion(value: string, flag: string): number {
   const normalized = value.trim();
-  if (!normalized) throw new Error(`${flag} cannot be blank.`);
+  if (!normalized) throw new CliUsageError(`${flag} cannot be blank.`);
   const stripped = normalized.startsWith("v") ? normalized.slice(1) : normalized;
   if (!/^[1-9]\d*$/.test(stripped)) {
-    throw new Error(`${flag} must be a release version like v3 or 3.`);
+    throw new CliUsageError(`${flag} must be a release version like v3 or 3.`);
   }
   const parsed = Number(stripped);
   if (!Number.isSafeInteger(parsed)) {
-    throw new Error(`${flag} must be a release version like v3 or 3.`);
+    throw new CliUsageError(`${flag} must be a release version like v3 or 3.`);
   }
   return parsed;
 }
@@ -44,18 +51,18 @@ export function parseReleaseVersion(value: string, flag: string): number {
 export function parsePositiveInteger(value: string, label: string): number {
   const normalized = value.trim();
   if (!/^[1-9]\d*$/.test(normalized)) {
-    throw new Error(`${label} must be a positive whole number.`);
+    throw new CliUsageError(`${label} must be a positive whole number.`);
   }
   const parsed = Number(normalized);
   if (!Number.isSafeInteger(parsed)) {
-    throw new Error(`${label} must be a positive whole number.`);
+    throw new CliUsageError(`${label} must be a positive whole number.`);
   }
   return parsed;
 }
 
 export function normalizeNonBlank(value: string, label: string): string {
   const normalized = value.trim();
-  if (!normalized) throw new Error(`${label} cannot be blank.`);
+  if (!normalized) throw new CliUsageError(`${label} cannot be blank.`);
   return normalized;
 }
 
@@ -65,10 +72,10 @@ export function normalizeHttpUrl(value: string, flag: string): string {
   try {
     parsed = new URL(normalized);
   } catch {
-    throw new Error(`${flag} must be an absolute http(s) URL.`);
+    throw new CliUsageError(`${flag} must be an absolute http(s) URL.`);
   }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`${flag} must be an absolute http(s) URL.`);
+    throw new CliUsageError(`${flag} must be an absolute http(s) URL.`);
   }
   return normalized;
 }
@@ -78,7 +85,7 @@ export function normalizeTimezone(value: string, flag: string): string {
   try {
     Intl.DateTimeFormat("en-US", { timeZone: normalized }).format(new Date());
   } catch {
-    throw new Error(`${flag} must be a valid IANA timezone, e.g. UTC or America/Los_Angeles.`);
+    throw new CliUsageError(`${flag} must be a valid IANA timezone, e.g. UTC or America/Los_Angeles.`);
   }
   return normalized;
 }
@@ -102,7 +109,7 @@ function isDateOnly(value: string): boolean {
 }
 
 function isoTimestampError(flag: string): Error {
-  return new Error(`${flag} must be an ISO timestamp, e.g. 2026-05-18T00:00:00Z.`);
+  return new CliUsageError(`${flag} must be an ISO timestamp, e.g. 2026-05-18T00:00:00Z.`);
 }
 
 function levenshtein(a: string, b: string): number {

package/src/version-check.ts

@@ -1,7 +1,7 @@
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
 
-export const NPM_LATEST_URL = "https://registry.npmjs.org/@dharta.ai%2fcli/latest";
+export const NPM_LATEST_URL = "https://registry.npmjs.org/@dharta%2fcli/latest";
 
 export interface VersionCheckOptions {
   root: string;

package/dist/commands/model-keys.d.ts

@@ -1,22 +0,0 @@
-import type { CliContext } from "../context.js";
-import type { ModelKey, ModelKeyProvider } from "@dharta/sdk";
-export declare const MODEL_API_FORMATS: readonly ["anthropic_messages", "openai_chat_completions", "openai_responses", "bedrock_converse", "vertex_generate_content"];
-export interface ModelKeyCreateOptions {
-    key?: string;
-    keyStdin?: boolean;
-    authType?: string;
-    endpointUrl?: string;
-    apiFormat?: string;
-}
-export declare function modelKeysListData(ctx: CliContext): Promise<ModelKey[]>;
-export declare function modelKeysList(ctx: CliContext): Promise<string>;
-export declare function modelKeysCreateData(ctx: CliContext, provider: ModelKeyProvider, name: string, opts?: ModelKeyCreateOptions): Promise<ModelKey>;
-export declare function modelKeysCreate(ctx: CliContext, provider: ModelKeyProvider, name: string, opts?: ModelKeyCreateOptions): Promise<string>;
-export declare function validateModelKeysCreateOptions(provider: ModelKeyProvider, name: string, opts?: ModelKeyCreateOptions): void;
-export declare function prepareModelKeysCreateOptions(provider: ModelKeyProvider, name: string, opts?: ModelKeyCreateOptions, read?: () => Promise<string>): Promise<ModelKeyCreateOptions>;
-export declare function modelKeysRevokeData(ctx: CliContext, id: string): Promise<{
-    id: number;
-    revoked: boolean;
-}>;
-export declare function modelKeysRevoke(ctx: CliContext, id: string): Promise<string>;
-export declare function validateModelKeyId(id: string): void;

package/dist/commands/model-keys.js

@@ -1,222 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { fmtTs, table } from "../output.js";
-import { closestChoice, normalizeHttpUrl, normalizeNonBlank, parsePositiveInteger } from "../validators.js";
-const MODEL_KEY_PROVIDERS = ["anthropic", "openai", "bedrock", "vertex", "openrouter", "xai", "google"];
-export const MODEL_API_FORMATS = [
-    "anthropic_messages",
-    "openai_chat_completions",
-    "openai_responses",
-    "bedrock_converse",
-    "vertex_generate_content",
-];
-const MODEL_KEY_AUTH_TYPES = ["api_key", "oauth_subscription"];
-export async function modelKeysListData(ctx) {
-    const res = await ctx.http.request({ path: "/model_keys" });
-    return res.data;
-}
-export async function modelKeysList(ctx) {
-    const keys = await modelKeysListData(ctx);
-    if (keys.length === 0)
-        return "No model keys. Store one with: dharta model-keys create <provider> <name> --key-stdin";
-    return table(keys.map((key) => ({
-        id: String(key.id),
-        provider: key.provider,
-        name: key.name,
-        tail: key.tail,
-        created: fmtTs(key.created_at),
-        revoked: fmtTs(key.revoked_at),
-    })));
-}
-export async function modelKeysCreateData(ctx, provider, name, opts = {}) {
-    validateModelKeysCreateOptions(provider, name, opts);
-    const normalizedProvider = normalizeProvider(provider);
-    const normalizedName = normalizeModelKeyName(name);
-    const plaintext = await resolvePlaintext(opts);
-    const normalizedAuthType = opts.authType === undefined ? undefined : normalizeAuthType(opts.authType);
-    const body = { provider: normalizedProvider, name: normalizedName, plaintext };
-    if (normalizedAuthType)
-        body.auth_type = normalizedAuthType;
-    if (opts.endpointUrl)
-        body.endpoint_url = normalizeEndpointUrl(opts.endpointUrl);
-    if (opts.apiFormat)
-        body.api_format = normalizeApiFormat(opts.apiFormat);
-    try {
-        const res = await ctx.http.request({
-            method: "POST",
-            path: "/model_keys",
-            body,
-            headers: { "Idempotency-Key": randomUUID() },
-        });
-        return res.model_key;
-    }
-    catch (error) {
-        throw addModelKeysWriteScopeGuidance(error);
-    }
-}
-export async function modelKeysCreate(ctx, provider, name, opts = {}) {
-    const key = await modelKeysCreateData(ctx, provider, name, opts);
-    return `Stored ${key.provider} connector ${key.name} (${key.id}).`;
-}
-export function validateModelKeysCreateOptions(provider, name, opts = {}) {
-    const normalizedProvider = normalizeProvider(provider);
-    normalizeModelKeyName(name);
-    const normalizedAuthType = opts.authType === undefined ? undefined : normalizeAuthType(opts.authType);
-    if (normalizedAuthType === "oauth_subscription" && normalizedProvider !== "anthropic") {
-        throw new Error("--auth-type oauth_subscription is only supported for the anthropic provider.");
-    }
-    if (opts.key !== undefined && opts.keyStdin) {
-        throw new Error("Use either --key or --key-stdin, not both.");
-    }
-    if (opts.key !== undefined) {
-        normalizePlaintext(opts.key, "--key");
-    }
-    else if (!opts.keyStdin) {
-        throw new Error("Model key plaintext is required. Pass --key or --key-stdin.");
-    }
-    else if (process.stdin.isTTY) {
-        throw new Error("No piped input. Usage: echo $PROVIDER_API_KEY | dharta model-keys create anthropic Claude --key-stdin");
-    }
-    if (opts.endpointUrl !== undefined) {
-        normalizeEndpointUrl(opts.endpointUrl);
-    }
-    if (opts.apiFormat !== undefined) {
-        normalizeApiFormat(opts.apiFormat);
-    }
-}
-function normalizeProvider(provider) {
-    const normalized = normalizeNonBlank(provider, "Model key provider");
-    if (MODEL_KEY_PROVIDERS.includes(normalized)) {
-        return normalized;
-    }
-    const suggestion = closestChoice(normalized, MODEL_KEY_PROVIDERS);
-    throw new Error(`Unknown model key provider ${normalized}. Allowed providers: ${MODEL_KEY_PROVIDERS.join(", ")}.` +
-        (suggestion ? ` Did you mean ${suggestion}?` : ""));
-}
-function normalizeAuthType(authType) {
-    const normalized = normalizeNonBlank(authType, "--auth-type");
-    if (MODEL_KEY_AUTH_TYPES.includes(normalized)) {
-        return normalized;
-    }
-    const suggestion = closestChoice(normalized, MODEL_KEY_AUTH_TYPES);
-    throw new Error(`Unknown --auth-type ${normalized}. Allowed auth types: ${MODEL_KEY_AUTH_TYPES.join(", ")}.` +
-        (suggestion ? ` Did you mean ${suggestion}?` : ""));
-}
-function normalizeApiFormat(apiFormat) {
-    const normalized = normalizeNonBlank(apiFormat, "--api-format");
-    if (MODEL_API_FORMATS.includes(normalized)) {
-        return normalized;
-    }
-    const suggestion = closestChoice(normalized, MODEL_API_FORMATS);
-    throw new Error(`Unknown --api-format ${normalized}. Allowed API formats: ${MODEL_API_FORMATS.join(", ")}.` +
-        (suggestion ? ` Did you mean ${suggestion}?` : ""));
-}
-export async function prepareModelKeysCreateOptions(provider, name, opts = {}, read = readModelKeyStdin) {
-    validateModelKeysCreateOptions(provider, name, opts);
-    if (!opts.keyStdin)
-        return opts;
-    return { ...opts, key: normalizeModelKeyStdin(await read()), keyStdin: false };
-}
-export async function modelKeysRevokeData(ctx, id) {
-    const normalizedId = normalizeNonBlank(id, "Model key id");
-    const numericId = parseModelKeyId(normalizedId);
-    try {
-        await ctx.http.request({
-            method: "DELETE",
-            path: `/model_keys/${encodeURIComponent(normalizedId)}`,
-            headers: { "Idempotency-Key": randomUUID() },
-        });
-    }
-    catch (error) {
-        throw addModelKeysWriteScopeGuidance(error);
-    }
-    return { id: numericId, revoked: true };
-}
-export async function modelKeysRevoke(ctx, id) {
-    const res = await modelKeysRevokeData(ctx, id);
-    return `Revoked ${res.id}.`;
-}
-export function validateModelKeyId(id) {
-    normalizeModelKeyId(id);
-}
-async function resolvePlaintext(opts) {
-    if (opts.key !== undefined && opts.keyStdin) {
-        throw new Error("Use either --key or --key-stdin, not both.");
-    }
-    if (opts.key !== undefined)
-        return normalizePlaintext(opts.key, "--key");
-    if (opts.keyStdin) {
-        return readModelKeyStdin();
-    }
-    throw new Error("Model key plaintext is required. Pass --key or --key-stdin.");
-}
-async function readModelKeyStdin() {
-    if (process.stdin.isTTY) {
-        throw new Error("No piped input. Usage: echo $PROVIDER_API_KEY | dharta model-keys create anthropic Claude --key-stdin");
-    }
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(Buffer.from(chunk));
-    return normalizeModelKeyStdin(Buffer.concat(chunks).toString("utf8"));
-}
-function normalizeModelKeyStdin(value) {
-    const text = value.trim();
-    if (text)
-        return text;
-    throw new Error("No model key on stdin. Usage: echo $PROVIDER_API_KEY | dharta model-keys create anthropic Claude --key-stdin");
-}
-function normalizeModelKeyName(name) {
-    const normalized = name.trim();
-    if (!normalized) {
-        throw new Error("Model key name cannot be blank.");
-    }
-    return normalized;
-}
-function normalizeModelKeyId(id) {
-    const normalized = normalizeNonBlank(id, "Model key id");
-    parseModelKeyId(normalized);
-    return normalized;
-}
-function parseModelKeyId(id) {
-    return parsePositiveInteger(id, "Model key id");
-}
-function normalizePlaintext(value, flag) {
-    const normalized = value.trim();
-    if (!normalized) {
-        throw new Error(`${flag} cannot be blank.`);
-    }
-    return normalized;
-}
-function normalizeEndpointUrl(value) {
-    const normalized = normalizeHttpUrl(value, "--endpoint-url");
-    const parsed = new URL(normalized);
-    if (parsed.protocol !== "https:") {
-        throw new Error("--endpoint-url must use https.");
-    }
-    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
-        throw new Error("--endpoint-url cannot include credentials, a query string, or a fragment.");
-    }
-    return normalized;
-}
-// Storing or revoking a connector needs `model_keys:write`, a tenant-admin
-// scope that the `dharta login` device-flow credential deliberately never
-// carries (that key is long-lived and non-admin, so it can't hold a
-// forced-expiry admin scope). A CLI login therefore always 403s here. The
-// generic scope hint says "manage key scopes", but the login key's scopes are
-// fixed — you cannot add the scope to it — so name the real path: store the
-// connector in the dashboard, or mint a bounded key and re-auth with a token.
-function addModelKeysWriteScopeGuidance(error) {
-    if (!(error instanceof Error))
-        return new Error(String(error));
-    const status = error.status;
-    if (status === 403 &&
-        /model_keys:write/.test(error.message) &&
-        !error.message.includes("dharta login --with-token")) {
-        error.message +=
-            `${error.message.endsWith(".") ? "" : "."} ` +
-                "The `dharta login` credential cannot hold model_keys:write. Store the connector from the dashboard " +
-                "(`dharta open model-keys`), or mint a bounded key with model_keys:write there (`dharta open api-keys`) " +
-                "and re-authenticate with `dharta login --with-token`.";
-    }
-    return error;
-}
-//# sourceMappingURL=model-keys.js.map