@myapihq/cli 1.3.5 → 1.3.8

package/dist/commands/image.js

@@ -191,12 +191,12 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi image <subcommand>
 
 Subcommands:
-  list                List all your generated images
+  delete <job_id>     Delete the asset (job history retained)
   generate <prompt>   Generate a new AI image (async, polls up to 90s; pricing per model — see "image models")
   get <job_id>        Fetch full job metadata (JSON or human-readable)
   get-url <job_id>    Print just the asset URL (curl-friendly)
+  list                List all your generated images
   models              List available image models with per-image pricing
-  delete <job_id>     Delete the asset (job history retained)
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).
 The asset lands in your org's storage and is also visible via "myapi storage list".`);

package/dist/commands/keys.js

@@ -174,8 +174,8 @@ slot grants, and an optional spend cap. A minted key is always a subset of the
 key that minted it (no privilege escalation).
 
 Subcommands:
-  list                 List keys with kind, scope, grants, and spend cap
   create               Mint a new key (value shown once)
+  list                 List keys with kind, scope, grants, and spend cap
   revoke <id>          Revoke one key by ID
   revoke-all           Kill switch — revoke every key (or --kind function|manual|account)
 

package/dist/commands/llm.js

@@ -7,6 +7,7 @@ export const EXPOSES = [
     'POST /llm/orgs/{org_id}/complete',
     'POST /llm/orgs/{org_id}/embed',
     'GET /llm/orgs/{org_id}/models',
+    'POST /llm/orgs/{org_id}/tasks/{verb}',
 ];
 export const SCHEMA = {
     org: 'string',
@@ -16,8 +17,36 @@ export const SCHEMA = {
     temperature: 'number',
     stop: 'string',
     file: 'string',
+    // verb-specific
+    labels: 'string',
+    multi: 'boolean',
+    schema: 'string',
+    style: 'string',
     kind: 'string',
+    context: 'string',
+    prompt: 'string',
+    tier: 'string',
 };
+// Cache the catalog once per CLI invocation so verbs (which don't take a
+// --model flag) can fall back to "the first chat model" without an extra
+// network round-trip per command.
+let cachedModels = null;
+async function loadModels(apiKey, orgId) {
+    if (cachedModels)
+        return cachedModels;
+    const res = await sdkLlm.listModels(apiKey, orgId);
+    cachedModels = res.models;
+    return cachedModels;
+}
+async function defaultChatModel(apiKey, orgId) {
+    const models = await loadModels(apiKey, orgId);
+    const chat = models.find(m => m.kind === 'chat');
+    if (!chat) {
+        error('No chat model available — run "myapi llm models" to inspect the catalog.');
+        throw new Error('unreachable'); // satisfy the type checker
+    }
+    return chat.id;
+}
 function readPromptArg(promptArg, flags) {
     if (typeof flags.file === 'string' && flags.file) {
         return fs.readFileSync(flags.file, 'utf-8');
@@ -27,11 +56,62 @@ function readPromptArg(promptArg, flags) {
     }
     return promptArg ?? '';
 }
-const DEFAULT_CHAT_MODEL = 'gemini-3.1-flash-lite-preview';
+function fmtCostCents(cents) {
+    // Sub-cent calls (the common case for short prompts) get four decimals so
+    // the footer stays informative — "0.0063¢" reads honestly as "less than a
+    // cent." Larger numbers collapse to two decimals.
+    return cents < 1 ? `${cents.toFixed(4)}¢` : `${cents.toFixed(2)}¢`;
+}
+function parseSchemaFlag(flags) {
+    if (typeof flags.schema !== 'string' || !flags.schema)
+        return null;
+    // Accept either a path to a JSON file or an inline JSON string.
+    let raw = flags.schema;
+    if (fs.existsSync(raw)) {
+        try {
+            raw = fs.readFileSync(raw, 'utf-8');
+        }
+        catch (e) {
+            error(`Could not read --schema file: ${e.message}`);
+        }
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        error('--schema must be valid JSON (inline) or a path to a JSON file');
+        return null;
+    }
+}
+function parseContextFlag(flags) {
+    if (typeof flags.context !== 'string' || !flags.context)
+        return undefined;
+    try {
+        const parsed = JSON.parse(flags.context);
+        if (typeof parsed === 'object' && parsed !== null)
+            return parsed;
+        error('--context must be a JSON object');
+        return undefined;
+    }
+    catch {
+        error('--context must be valid JSON');
+        return undefined;
+    }
+}
+function tierFromFlag(flags) {
+    if (typeof flags.tier !== 'string' || !flags.tier)
+        return undefined;
+    if (flags.tier === 'fast' || flags.tier === 'reasoning' || flags.tier === 'cheap')
+        return flags.tier;
+    error('--tier must be one of: fast, reasoning, cheap');
+}
+// ── raw ──────────────────────────────────────────────────────────────────
 async function complete(promptArg, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi llm complete "<prompt>" [--model <id>] [--system <s>] [--max-tokens N] [--temperature 0..1] [--stop <csv>] [--org <id>]');
-    const model = typeof flags.model === 'string' && flags.model ? flags.model : DEFAULT_CHAT_MODEL;
+    const model = typeof flags.model === 'string' && flags.model
+        ? flags.model
+        : await defaultChatModel(config.api_key, orgId);
     const prompt = readPromptArg(promptArg, flags);
     if (!prompt.trim())
         error('Empty prompt. Pass <prompt> as an argument, "-" to read stdin, or --file <path>.');
@@ -56,7 +136,7 @@ async function complete(promptArg, flags) {
     }
     info(res.content);
     // Usage footer on stderr so it doesn't pollute piped output.
-    process.stderr.write(`\n— ${res.model} · ${res.usage.input_tokens}+${res.usage.output_tokens} tokens · $${res.usage.cost_usd.toFixed(6)} · ${res.finish_reason}\n`);
+    process.stderr.write(`\n— ${res.model} · ${res.usage.input_tokens}+${res.usage.output_tokens ?? 0} tokens · ${fmtCostCents(res.usage.cost_cents)} · ${res.finish_reason}\n`);
 }
 async function embed(inputArg, flags) {
     const config = requireConfig();
@@ -73,7 +153,7 @@ async function embed(inputArg, flags) {
         return;
     }
     const first = res.embeddings[0] ?? [];
-    info(`${res.model} · dim=${first.length} · ${res.usage.input_tokens} tokens · $${res.usage.cost_usd.toFixed(6)}`);
+    info(`${res.model} · dim=${first.length} · ${res.usage.input_tokens} tokens · ${fmtCostCents(res.usage.cost_cents)}`);
     info(`first 5: [${first.slice(0, 5).map(n => n.toFixed(6)).join(', ')}${first.length > 5 ? ', ...' : ''}]`);
     info(`(pass --json for the full vector)`);
 }
@@ -90,49 +170,198 @@ async function listModels(flags) {
     printTable(models.map(m => ({
         id: m.id,
         kind: m.kind,
-        context: m.context ?? '',
+        context: m.context_window ?? '',
         dimensions: m.dimensions ?? '',
-        in_per_1m: `$${m.input_per_1m}`,
-        out_per_1m: m.output_per_1m != null ? `$${m.output_per_1m}` : '',
+        'in ¢/1M': m.input_cost_per_1m_cents,
+        'out ¢/1M': m.output_cost_per_1m_cents != null ? m.output_cost_per_1m_cents : '',
     })), { flags, empty: 'No models available.' });
 }
+// ── verbs ────────────────────────────────────────────────────────────────
+function printVerbFooter(usage) {
+    process.stderr.write(`\n— tier=${usage.tier_used} · ${usage.tokens_in}+${usage.tokens_out} tokens · ${fmtCostCents(usage.cost_cents)}\n`);
+}
+async function classify(inputArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi llm classify "<input>" --labels <csv> [--multi] [--tier <t>] [--org <id>]');
+    const input = readPromptArg(inputArg, flags);
+    if (!input.trim())
+        error('Empty input. Pass <input> as an argument, "-" to read stdin, or --file <path>.');
+    if (typeof flags.labels !== 'string' || !flags.labels) {
+        error('Missing required flag: --labels <comma-separated>');
+        return;
+    }
+    const labels = flags.labels.split(',').map(s => s.trim()).filter(Boolean);
+    if (labels.length === 0)
+        error('--labels must contain at least one label');
+    const multi = flags.multi === true;
+    const res = await sdkLlm.classify(config.api_key, orgId, { input, labels, multi, tier: tierFromFlag(flags) });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    if (multi) {
+        const arr = res.data.labels ?? [];
+        info(arr.length ? arr.join(', ') : '(no matching labels)');
+    }
+    else {
+        info(res.data.label ?? '(no label)');
+    }
+    printVerbFooter(res.usage);
+}
+async function extract(inputArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi llm extract "<input>" --schema <path|json> [--tier <t>] [--org <id>]');
+    const input = readPromptArg(inputArg, flags);
+    if (!input.trim())
+        error('Empty input. Pass <input> as an argument, "-" to read stdin, or --file <path>.');
+    const schema = parseSchemaFlag(flags);
+    if (!schema) {
+        error('Missing required flag: --schema <path|json>');
+        return;
+    }
+    const res = await sdkLlm.extract(config.api_key, orgId, { input, schema, tier: tierFromFlag(flags) });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    info(JSON.stringify(res.data.data, null, 2));
+    printVerbFooter(res.usage);
+}
+async function summarize(inputArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi llm summarize "<input>" [--style brief|exec|bullet] [--tier <t>] [--org <id>]');
+    const input = readPromptArg(inputArg, flags);
+    if (!input.trim())
+        error('Empty input. Pass <input> as an argument, "-" to read stdin, or --file <path>.');
+    const style = typeof flags.style === 'string' && flags.style ? flags.style : undefined;
+    if (style && !['brief', 'exec', 'bullet'].includes(style)) {
+        error('--style must be one of: brief, exec, bullet');
+    }
+    const res = await sdkLlm.summarize(config.api_key, orgId, {
+        input,
+        style: style,
+        tier: tierFromFlag(flags),
+    });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    info(res.data.summary);
+    printVerbFooter(res.usage);
+}
+async function draft(inputArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi llm draft --kind <what> [--prompt "<instructions>"] [--context <json>] ["<source text>"] [--tier <t>] [--org <id>]');
+    if (typeof flags.kind !== 'string' || !flags.kind) {
+        error('Missing required flag: --kind <email|message|reply|...>');
+        return;
+    }
+    const input = readPromptArg(inputArg, flags);
+    const promptText = typeof flags.prompt === 'string' ? flags.prompt : '';
+    const ctx = parseContextFlag(flags);
+    if (!input.trim() && !promptText.trim() && (!ctx || Object.keys(ctx).length === 0)) {
+        error('draft needs at least one of: <source text> (arg or --file), --prompt, or --context.');
+    }
+    const res = await sdkLlm.draft(config.api_key, orgId, {
+        input: input || undefined,
+        kind: flags.kind,
+        context: ctx,
+        prompt: promptText || undefined,
+        tier: tierFromFlag(flags),
+    });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    info(res.data.text);
+    printVerbFooter(res.usage);
+}
+// ── help ─────────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     complete: `myapi llm complete "<prompt>" [--model <id>]
        [--system "<system msg>"] [--max-tokens N] [--temperature 0..1]
        [--stop <csv>] [--file <path>] [--org <id>] [--json]
 
-  Default model: gemini-3.1-flash-lite-preview (cheap + fast). Pass --model
-  to override; run "myapi llm models" to see the catalog.
+  Raw chat completion against a self-hosted catalog model. Without --model,
+  picks the first chat model from "myapi llm models" (today:
+  Qwen/Qwen3-Coder-30B-A3B-Instruct).
 
-  Pass "-" as the prompt to read from stdin. The reply goes to stdout;
-  a one-line usage footer (tokens + cost) goes to stderr so it doesn't
-  pollute piped output.
+  Pass "-" as the prompt to read from stdin. The reply goes to stdout; a
+  one-line usage footer (tokens + cost in cents) goes to stderr so it
+  doesn't pollute piped output.
 
   Examples:
     myapi llm complete "summarize: $(cat README.md)"
-    cat draft.md | myapi llm complete - --model gemini-3.1-pro-preview --system "You are an editor"
-    myapi llm complete --file prompt.txt --max-tokens 200`,
+    cat draft.md | myapi llm complete - --system "You are an editor" --max-tokens 200`,
     embed: `myapi llm embed "<text>" --model <id> [--file <path>] [--org <id>] [--json]
 
-  Returns a vector summary by default; pass --json for the full vector.
+  No embedding model is served on the raw catalog today — this returns
+  EMBED_NOT_AVAILABLE until one is. Use a dedicated embedding API for now.`,
+    models: `myapi llm models [--kind chat|embed] [--org <id>] [--json]
+
+  Lists the live model catalog with per-1M-token pricing in cents.
+  The catalog reflects exactly what the inference gateway serves.`,
+    classify: `myapi llm classify "<input>" --labels <a,b,c> [--multi]
+       [--tier fast|reasoning|cheap] [--file <path>] [--org <id>] [--json]
+
+  Pick the best label (or with --multi, all applicable labels) from a set.
+  Output goes to stdout; usage footer to stderr.
 
   Examples:
-    myapi llm embed "the quick brown fox" --model gemini-embedding-001
-    myapi llm embed --file doc.txt --model gemini-embedding-001 --json > doc.vec.json`,
-    models: `myapi llm models [--kind chat|embed] [--org <id>] [--json]
+    myapi llm classify "I was charged twice and need a refund" \\
+      --labels billing,technical,sales,spam
+    cat email.txt | myapi llm classify - --labels urgent,bug,question --multi`,
+    extract: `myapi llm extract "<input>" --schema <path|json>
+       [--tier <t>] [--file <path>] [--org <id>] [--json]
+
+  Extract data from <input> conforming to a JSON Schema. --schema accepts
+  an inline JSON string OR a path to a .json file. Stdout is the extracted
+  JSON object.
+
+  Examples:
+    myapi llm extract "Acme Corp has 250 employees" \\
+      --schema '{"type":"object","properties":{"company":{"type":"string"},"employees":{"type":"integer"}}}'
+    myapi llm extract - --schema ./order.schema.json < order.eml`,
+    summarize: `myapi llm summarize "<input>" [--style brief|exec|bullet]
+       [--tier <t>] [--file <path>] [--org <id>] [--json]
 
-  Lists the model catalog with per-1M-token pricing at upstream rates.
-  Models prefixed with vendor name pass through to that vendor; un-prefixed
-  models (when available) run on MyAPI's own inference.`,
+  Summarize text. Default style 'brief' (1-2 sentences); 'exec' is a
+  decision-maker summary; 'bullet' is a short list.
+
+  Examples:
+    myapi llm summarize --file long-thread.txt --style bullet
+    cat report.md | myapi llm summarize - --style exec`,
+    draft: `myapi llm draft --kind <what> [--prompt "<instructions>"]
+       [--context '<json>'] ["<source text>"] [--file <path>]
+       [--tier <t>] [--org <id>] [--json]
+
+  Draft a piece of writing (email, reply, message, …). Provide at least one
+  of: <source text> (arg or --file), --prompt, or --context (JSON of facts).
+
+  Examples:
+    myapi llm draft --kind email \\
+      --prompt "Friendly welcome to the beta. Under 60 words." \\
+      --context '{"recipient":"a new signup","product":"MyAPI"}'
+    cat inbound.eml | myapi llm draft - --kind reply --prompt "Acknowledge and ask for the order ID"`,
 };
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
         info(`Usage: myapi llm <subcommand>
 
+Two surfaces:
+
+  Raw — you pick a self-hosted catalog model and shape the prompt yourself.
+  Verbs — you ask for a task done; the model is implementation detail and
+          is never named in the response.
+
 Subcommands:
-  complete   Chat completion — returns reply + usage (default model: gemini-3.1-flash-lite-preview)
-  embed      Text embedding — returns vector + usage
-  models     List available models (chat + embed) with pricing
+  classify    Pick a label from a set
+  complete    Raw chat completion against a catalog model
+  draft       Write something (email | reply | message | …)
+  embed       Raw embeddings (no model served on raw today)
+  extract     Pull structured data conforming to a JSON Schema
+  models      List the live model catalog (id, kind, context, cents/1M)
+  summarize   Summarize text (brief | exec | bullet)
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).
 Use this for workflow steps and scripted pipelines — not as a replacement
@@ -151,6 +380,10 @@ for your own reasoning. The agent has its own model already.`);
         case 'complete': return complete(args[0], flags);
         case 'embed': return embed(args[0], flags);
         case 'models': return listModels(flags);
+        case 'classify': return classify(args[0], flags);
+        case 'extract': return extract(args[0], flags);
+        case 'summarize': return summarize(args[0], flags);
+        case 'draft': return draft(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi llm --help" for valid subcommands.`);
     }
 }

package/dist/commands/org.js

@@ -217,12 +217,12 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi org <subcommand>
 
 Subcommands:
-  list        List organizations
   create      Create an organization (e.g. myapi org create "Name" --yes)
-  update      Update an organization's fields (name, tagline, description, etc.)
-  get         Get details of an organization
   delete      Delete an organization
-  sync-brand  Sync brand info (name, logo, description) from an existing website`);
+  get         Get details of an organization
+  list        List organizations
+  sync-brand  Sync brand info (name, logo, description) from an existing website
+  update      Update an organization's fields (name, tagline, description, etc.)`);
         return;
     }
     if (flags.help) {

package/dist/commands/payments.js

@@ -189,12 +189,12 @@ Take payments with Stripe Checkout. Connect your Stripe account, then
 create one-off or recurring charges and refund them.
 
 Subcommands:
-  connect              Link your Stripe account (T0 — bring your own key)
-  status               Show the org's Stripe connection status
   charge               Create a charge and get a hosted checkout URL
-  list                 List charges in your org
+  connect              Link your Stripe account (T0 — bring your own key)
   get <charge_id>      Inspect a charge
+  list                 List charges in your org
   refund <charge_id>   Full-refund a charge
+  status               Show the org's Stripe connection status
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;

package/dist/commands/people.js

@@ -113,8 +113,8 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi people <subcommand>
 
 Subcommands:
-  search    Filter people across the Goldfox database
   get       Get a single person (with embedded company)
+  search    Filter people across the Goldfox database
 
 All commands accept --org <id> (or set a default: myapi config set-org <id>).
 Filter shape is shared with company + audience — see myapi audience --help.`);

package/dist/commands/pixel.js

@@ -156,12 +156,12 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi pixel <subcommand>
 
 Subcommands:
+  audience       Geographic distribution sample of your pixel audience
+  events         Engagement events (sent / open / click / page_visit) by campaign or domain
+  identity       Resolve the identity graph (emails, IPs, profiles) for a pixel ID
   interactions   Get a unified timeline of visits and events
                  (requires at least one filter: --website, --campaign-id, or --domain)
   visits         Page-visit timeline scoped to a website host
-  events         Engagement events (sent / open / click / page_visit) by campaign or domain
-  audience       Geographic distribution sample of your pixel audience
-  identity       Resolve the identity graph (emails, IPs, profiles) for a pixel ID
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;

package/dist/commands/queue.js

@@ -7,6 +7,7 @@ export const EXPOSES = [
     'POST /queue/orgs/{org_id}/queues',
     'GET /queue/orgs/{org_id}/queues',
     'GET /queue/orgs/{org_id}/queues/{name}',
+    'DELETE /queue/orgs/{org_id}/queues/{name}',
     'POST /queue/orgs/{org_id}/queues/{name}/jobs',
     'GET /queue/orgs/{org_id}/queues/{name}/jobs',
     'GET /queue/orgs/{org_id}/jobs/{id}',

package/dist/commands/storage.js

@@ -141,12 +141,12 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi storage <subcommand>
 
 Subcommands:
-  list                List all your stored assets
-  ingest <url>        Server pulls a public URL into storage
-  upload <file>       Direct upload of a local file
+  delete <asset_id>   Permanently delete a stored asset
   get <asset_id>      Fetch asset metadata (name, URL, created_at)
   get-url <asset_id>  Print the public CDN URL (no API call)
-  delete <asset_id>   Permanently delete a stored asset
+  ingest <url>        Server pulls a public URL into storage
+  list                List all your stored assets
+  upload <file>       Direct upload of a local file
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;

package/dist/commands/webhook.js

@@ -159,11 +159,11 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi webhook <subcommand>
 
 Subcommands:
-  list       List all inbound webhook endpoints
   create     Create a new endpoint to receive data (returns an inbound URL)
-  update     Patch endpoint name / description / crm-email-path / forward-url
   delete     Delete a webhook endpoint
   delivery   Inspect a specific webhook delivery (payload, received_at)
+  list       List all inbound webhook endpoints
+  update     Patch endpoint name / description / crm-email-path / forward-url
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).
 

package/dist/commands/workflow-validation.test.js

@@ -94,10 +94,19 @@ describe('_validateSteps — http_request / http (2026-05-15)', () => {
             .toMatch(/missing required field "url"/);
     });
     it('rejects non-http(s) URLs', () => {
+        // post-brutalize: real URL parse instead of prefix regex —
+        // /must use http:\/\/ or https:\/\/ scheme/  applies to anything
+        // that parses to a non-http(s) protocol (ftp, javascript, file,
+        // gopher, data, …); strings that don't parse as URLs at all get
+        // the separate "not a valid URL" message.
         expect(_validateSteps([{ ...VALID_HTTP, url: 'ftp://example.com' }]))
-            .toMatch(/must start with http:\/\/ or https:\/\//);
+            .toMatch(/must use http:\/\/ or https:\/\/ scheme/);
         expect(_validateSteps([{ ...VALID_HTTP, url: 'javascript:alert(1)' }]))
-            .toMatch(/must start with http:\/\/ or https:\/\//);
+            .toMatch(/must use http:\/\/ or https:\/\/ scheme/);
+        expect(_validateSteps([{ ...VALID_HTTP, url: 'file:///etc/passwd' }]))
+            .toMatch(/must use http:\/\/ or https:\/\/ scheme/);
+        expect(_validateSteps([{ ...VALID_HTTP, url: 'not a url' }]))
+            .toMatch(/is not a valid URL/);
     });
     it('rejects unknown HTTP methods', () => {
         expect(_validateSteps([{ ...VALID_HTTP, method: 'TRACE' }]))

package/dist/commands/workflow.js

@@ -91,8 +91,21 @@ export function _validateSteps(steps) {
             if (!s.url || typeof s.url !== 'string') {
                 return `${where} (${s.type}): missing required field "url".`;
             }
-            if (!/^https?:\/\//.test(s.url)) {
-                return `${where} (${s.type}): "url" must start with http:// or https:// — got "${s.url}".`;
+            // Real URL parse instead of prefix regex — catches javascript:,
+            // file:, gopher:, data:, and whitespace/null-byte hosts that pass
+            // /^https?:\/\// but fail proper parsing. Mirrors the scheme check
+            // on webhook.forward_url and queue.consumer_url; same shape as the
+            // SDK helper. The backend ALSO validates — see
+            // docs/cross-repo-prompts/backend-workflow-step-validation.md.
+            let parsedUrl;
+            try {
+                parsedUrl = new URL(s.url);
+            }
+            catch {
+                return `${where} (${s.type}): "url" is not a valid URL — got "${s.url}".`;
+            }
+            if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+                return `${where} (${s.type}): "url" must use http:// or https:// scheme — got "${parsedUrl.protocol}" in "${s.url}".`;
             }
             if (s.method !== undefined) {
                 if (typeof s.method !== 'string' || !HTTP_METHODS.has(s.method.toUpperCase())) {
@@ -360,15 +373,15 @@ export async function run(subcommand, args, flags) {
     myapi workflow create --help
 
 Subcommands:
-  list                 List all workflows
-  get <id>             Show a single workflow
   create               Create a workflow (enabled by default; --no-enable to stage)
-  update <id>          Patch name / endpoint-id / steps
-  enable <id>          Enable a workflow
-  disable <id>         Disable a workflow
   delete <id>          Delete a workflow
-  runs <workflow_id>   List recent executions of a workflow
+  disable <id>         Disable a workflow
+  enable <id>          Enable a workflow
+  get <id>             Show a single workflow
   get-run <run_id>     Show a single run with full payload
+  list                 List all workflows
+  runs <workflow_id>   List recent executions of a workflow
+  update <id>          Patch name / endpoint-id / steps
 
 Step types for --steps:
   send_email     {"type":"send_email","from":"<mailbox>","to":"{{payload.email}}","subject":"...","template_id":"<id>"|"html":"..."}

package/dist/completion.js

@@ -49,7 +49,7 @@ export const SUBCOMMANDS = {
     people: ['search', 'get'],
     company: ['search', 'get'],
     audience: ['create', 'list', 'get', 'update', 'delete', 'members', 'refresh'],
-    llm: ['complete', 'embed', 'models'],
+    llm: ['complete', 'embed', 'models', 'classify', 'extract', 'summarize', 'draft'],
     database: ['namespaces', 'create', 'delete-namespace', 'keys', 'get', 'set', 'del'],
     crm: ['contacts', 'companies'],
     url: ['shorten'],

package/dist/index.js

@@ -399,40 +399,40 @@ Usage: myapi <command> [subcommand] [args]
        myapi --version
 
 Commands:
+  audience        Save filter snapshots as named audiences (people or companies)
   auth            Manage account · setup · whoami · link
-  status          Single-screen view of account + resources in the default org
-  install-skills  Install or update the MyAPI skills pack for AI agents
   billing         Check balance and manage billing
-  org             Manage organizations (tip: myapi org create "name" --yes to auto-set as default)
-  update          Update CLI and skills to the latest version
+  company         Search the company database (filter by industry, size, country, ...)
+  container       Run containers — services, workers, and scheduled jobs
+  crm             Canonical store of engaged contacts + companies, with auto-ingest from webhooks
+  database        KV store with namespaces + CAS — the substrate for stateful agent apps
+  doctor          Org-wide consistency check — funnels, webhooks, domains, containers
   domain          Manage domain configurations
-  funnel          Manage websites (publish pages, custom domains, funnels)
+  email           Manage mailboxes, send/read email, templates, and campaigns
   fn              Create and deploy functions on the edge runtime
-  container       Run containers — services, workers, and scheduled jobs
+  funnel          Manage websites (publish pages, custom domains, funnels)
   git             Hosted git repositories — repos, commits, branches, history
+  image           Generate AI images and manage them in storage
+  install-skills  Install or update the MyAPI skills pack for AI agents
+  llm             Run LLM completions and embeddings (chat + embed, with usage/cost)
+  org             Manage organizations (tip: myapi org create "name" --yes to auto-set as default)
+  payments        Take payments with Stripe Checkout (connect, charge, refund)
+  people          Search the contact database (filter by industry, seniority, country, ...)
+  pixel           Read pixel analytics: visits, events, identity resolution
   queue           Durable job queue — enqueue work, retried against an HTTP consumer
+  status          Single-screen view of account + resources in the default org
+  storage         Upload, ingest, list, and serve assets from edge storage
   task            Agent-task queue — file, claim, and resolve units of work
-  doctor          Org-wide consistency check — funnels, webhooks, domains, containers
-  payments        Take payments with Stripe Checkout (connect, charge, refund)
+  update          Update CLI and skills to the latest version
+  url             Shorten URLs to compact myurlto.com links
   webhook         Manage inbound webhook endpoints and inspect deliveries
-  email           Manage mailboxes, send/read email, templates, and campaigns
   workflow        Run actions (send email, post to Slack) when a webhook fires
-  image           Generate AI images and manage them in storage
-  storage         Upload, ingest, list, and serve assets from edge storage
-  pixel           Read pixel analytics: visits, events, identity resolution
-  people          Search the contact database (filter by industry, seniority, country, ...)
-  company         Search the company database (filter by industry, size, country, ...)
-  audience        Save filter snapshots as named audiences (people or companies)
-  llm             Run LLM completions and embeddings (chat + embed, with usage/cost)
-  database        KV store with namespaces + CAS — the substrate for stateful agent apps
-  crm             Canonical store of engaged contacts + companies, with auto-ingest from webhooks
-  url             Shorten URLs to compact myurlto.com links
 
 Aliases:
-  whoami          → myapi auth whoami
+  config          → myapi auth config
   keys            → myapi auth api-keys
   setup           → myapi auth setup
-  config          → myapi auth config
+  whoami          → myapi auth whoami
 
 Run "myapi <command> --help" for subcommand help.