@myapihq/cli 1.3.6 → 1.3.11

package/dist/commands/funnel.js

@@ -14,6 +14,13 @@ export const EXPOSES = [
     'POST /funnel/orgs/{org_id}/funnels/{funnel_id}/verify',
     'POST /funnel/orgs/{org_id}/funnels/{funnel_id}/files',
     'GET /funnel/orgs/{org_id}/funnels/{funnel_id}/pages',
+    // form bindings — created/listed/removed via `funnel form --capture-to`
+    // and the underlying SDK helpers. List/Delete don't have dedicated CLI
+    // subcommands yet; the SDK functions are wired and customers using the
+    // SDK directly need them in EXPOSES for coverage to be honest.
+    'POST /funnel/orgs/{org_id}/funnels/{funnel_id}/forms',
+    'GET /funnel/orgs/{org_id}/funnels/{funnel_id}/forms',
+    'DELETE /funnel/orgs/{org_id}/funnels/{funnel_id}/forms/{slug}',
     'GET /hq/orgs/{org_id}',
 ];
 export const SCHEMA = {
@@ -21,6 +28,12 @@ export const SCHEMA = {
     slug: 'string',
     env: 'string',
     'api-fn': 'string',
+    // form
+    fields: 'string',
+    cta: 'string',
+    success: 'string',
+    'capture-to': 'string',
+    honeypot: 'string',
 };
 // Backend (2026-05-15): POST /funnels accepts an optional `name` (defaults
 // to the org's preview_subdomain for back-compat). Mirror the backend's
@@ -70,16 +83,12 @@ export async function get(id, flags) {
     const orgId = requireOrg(flags, config, 'myapi funnel get <id> [--org <id>]');
     if (!id)
         error('Missing required arguments.\nUsage: myapi funnel get <id> [--org <id>]');
-    const raw = await sdkFunnel.getFunnel(config.api_key, orgId, id);
-    // Backend response shape varies between two layouts:
-    //   1) { funnel: {...}, subdomain_url, domain_url }    (newer, wrapped)
-    //   2) { id, ..., subdomain_url, domain_url }          (older, flat)
-    // Coalesce both so this works regardless of which shape we get back.
-    const funnel = raw.funnel ?? raw;
-    const subdomain_url = raw.subdomain_url ?? funnel.subdomain_url;
-    const domain_url = raw.domain_url ?? funnel.domain_url;
+    // SDK normalizes the wire shape to the wrapped envelope. `--json`
+    // still emits the envelope (back-compat: legacy consumers parse it).
+    const result = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+    const { funnel, subdomain_url, domain_url } = result;
     if (flags.json) {
-        printJson(raw);
+        printJson(result);
         return;
     }
     info(`ID:          ${funnel.id}`);
@@ -91,8 +100,8 @@ export async function get(id, flags) {
         info(`Created:     ${formatDate(funnel.created_at)}`);
     if (funnel.updated_at)
         info(`Updated:     ${formatDate(funnel.updated_at)}`);
-    if (Array.isArray(funnel.pages))
-        info(`Pages:       ${funnel.pages.length}`);
+    // `pages` isn't part of the typed Funnel; backend doesn't include it
+    // here (use `myapi funnel pages` for that). Drop the inline count.
 }
 export async function del(id, flags) {
     const config = requireConfig();
@@ -178,6 +187,157 @@ export async function push(slug, flags) {
         }
     }
 }
+function parseField(token) {
+    // <name>[:<modifier>]... — modifiers are types or `required`, order-free.
+    const parts = token.split(':').map(p => p.trim()).filter(Boolean);
+    const name = parts[0];
+    if (!name || !/^[a-z][a-z0-9_]*$/i.test(name)) {
+        error(`Invalid field name "${name}". Lowercase letters/digits/underscores; starts with a letter.`);
+    }
+    let type;
+    let required = false;
+    for (const mod of parts.slice(1)) {
+        const m = mod.toLowerCase();
+        if (m === 'required')
+            required = true;
+        else if (m === 'text' || m === 'email' || m === 'number' || m === 'tel')
+            type = m;
+        else
+            error(`Unknown field modifier "${mod}" on "${name}". Use one of: text, email, number, tel, required.`);
+    }
+    if (!type) {
+        const n = name.toLowerCase();
+        type = n === 'email' ? 'email'
+            : n === 'phone' || n === 'tel' ? 'tel'
+                : 'text';
+    }
+    return { name, type, required };
+}
+function parseCaptureTo(raw) {
+    const m = raw.match(/^(webhook|workflow):([a-f0-9-]{36})$/i);
+    if (!m)
+        error(`Invalid --capture-to "${raw}". Expected webhook:<uuid> or workflow:<uuid>.`);
+    return { kind: m[1].toLowerCase(), id: m[2] };
+}
+export async function formCmd(funnelArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi funnel form [funnel-id] [--slug <s>] [--fields <spec>] [--capture-to <dest>] [--honeypot <name>] [--cta "<text>"] [--success "<text>"] [--org <id>] [--json]');
+    // Resolve funnel id the same way push/verify do.
+    let funnelId = funnelArg || flags.funnel || config.default_funnel;
+    if (!funnelId) {
+        const existing = await sdkFunnel.listFunnels(config.api_key, orgId);
+        if (existing.length === 0)
+            error('No funnel found for this org. Create one with: myapi funnel create');
+        if (existing.length > 1) {
+            error(`Multiple funnels exist and no default is set.\nPass the funnel id, or set a default:\n  myapi config set-funnel <id>\n\nFunnels:\n${existing.map(f => `  ${f.id}`).join('\n')}`);
+        }
+        funnelId = existing[0].id;
+    }
+    const rawSlug = flags.slug || 'join';
+    const slug = rawSlug.startsWith('/') ? rawSlug.slice(1) : rawSlug;
+    if (!/^[a-z0-9][a-z0-9-]{0,40}$/i.test(slug)) {
+        error(`Invalid --slug "${slug}". Lowercase letters/digits/hyphens, 1-41 chars, starts with a letter or digit.`);
+    }
+    // `--fields email:required,name,phone:tel,plan:text:required`
+    const fieldsArg = (flags.fields || 'email:email:required').trim();
+    const fieldSpecs = fieldsArg.split(',').map(s => s.trim()).filter(Boolean).map(parseField);
+    if (fieldSpecs.length === 0)
+        error('--fields must list at least one field. Example: --fields email:required,name');
+    // Honeypot field — match the backend default unless --honeypot overrides.
+    const honeypot = flags.honeypot || 'middle_name';
+    if (!/^[a-z][a-z0-9_]*$/i.test(honeypot))
+        error(`Invalid --honeypot "${honeypot}".`);
+    for (const f of fieldSpecs)
+        if (f.name === honeypot)
+            error(`Honeypot "${honeypot}" collides with a real field. Pick a different --honeypot name.`);
+    const cta = flags.cta || 'Sign up';
+    const successMsg = flags.success || "Thanks — we'll be in touch.";
+    // Resolve the binding destination.
+    //
+    // Without a binding, the backend falls submissions through to the
+    // funnel's default webhook with NO honeypot / field validation. That
+    // makes the on-page honeypot purely cosmetic and lets trivial bots
+    // write to your CRM. So: always register a binding. When
+    // `--capture-to` is omitted, target the funnel's auto-provisioned
+    // `org_webhook_id` — same destination as the fallback, just with
+    // server-side guards turned on. Backend POST upserts on duplicate
+    // slug, so re-runs are safe.
+    let registeredBinding;
+    let autoBound = false;
+    let dest = null;
+    if (typeof flags['capture-to'] === 'string' && flags['capture-to']) {
+        dest = parseCaptureTo(flags['capture-to']);
+    }
+    else {
+        const { funnel } = await sdkFunnel.getFunnel(config.api_key, orgId, funnelId);
+        if (funnel.org_webhook_id) {
+            dest = { kind: 'webhook', id: funnel.org_webhook_id };
+            autoBound = true;
+        }
+        // Legacy funnels migrated before 2026-06-03 may briefly lack
+        // org_webhook_id — emit the HTML without a binding and warn.
+    }
+    if (dest) {
+        const binding = {
+            slug,
+            destination: `${dest.kind}:${dest.id}`,
+            fields: fieldSpecs.map(f => ({ name: f.name, required: f.required })),
+            honeypot_field: honeypot,
+        };
+        registeredBinding = await sdkFunnel.createFormBinding(config.api_key, orgId, funnelId, binding);
+    }
+    const url = `https://api.myapihq.com/funnel/funnels/${funnelId}/submit/${encodeURIComponent(slug)}`;
+    const escAttr = (s) => s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const escText = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    // Per-field labels — Email uses the canonical placeholder; others
+    // Title-Case the name.
+    const inputs = fieldSpecs.map(f => {
+        const label = f.name.charAt(0).toUpperCase() + f.name.slice(1).replace(/_/g, ' ');
+        const req = f.required ? ' required' : '';
+        return `  <label>${escText(label)} <input type="${f.type}" name="${escAttr(f.name)}"${req}></label>`;
+    }).join('\n');
+    // Honeypot — hidden via inline style, off the tab order, autocomplete
+    // disabled. Bots fill it; humans don't.
+    const honeypotInput = `  <input type="text" name="${escAttr(honeypot)}" style="display:none" tabindex="-1" autocomplete="off">`;
+    const html = `<form action="${escAttr(url)}" method="POST" data-myapi-form>
+${inputs}
+${honeypotInput}
+  <button type="submit">${escText(cta)}</button>
+</form>
+<script>
+document.querySelectorAll('[data-myapi-form]').forEach(f => {
+  f.addEventListener('submit', async e => {
+    e.preventDefault();
+    const r = await fetch(f.action, { method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify(Object.fromEntries(new FormData(f))) });
+    if (r.ok) f.outerHTML = ${JSON.stringify(`<p>${escText(successMsg)}</p>`)};
+  });
+});
+</script>`;
+    if (flags.json) {
+        printJson({
+            action_url: url,
+            slug,
+            fields: fieldSpecs,
+            honeypot_field: honeypot,
+            binding_registered: !!registeredBinding,
+            binding: registeredBinding,
+            html,
+        });
+        return;
+    }
+    if (registeredBinding) {
+        // Print confirmation on stderr so stdout stays the clean snippet.
+        const tag = autoBound ? ' (auto, default webhook)' : '';
+        process.stderr.write(`✓ Registered form binding: slug=${slug} → ${registeredBinding.destination}${tag}\n`);
+    }
+    else {
+        // No org_webhook_id and no --capture-to → honeypot/field guards
+        // won't fire. Surface it so the agent can act.
+        process.stderr.write(`⚠  No binding registered (funnel has no org_webhook_id). Honeypot and field guards are NOT enforced for this slug. Pass --capture-to webhook:<id> or workflow:<id>, or wait for the backend migration to backfill org_webhook_id.\n`);
+    }
+    process.stdout.write(html + '\n');
+}
 // Verify uses the same shape as push: slug positional (default '/'), funnel
 // resolved from --funnel / default / the org's only funnel.
 export async function verify(slug, flags) {
@@ -260,10 +420,51 @@ export async function publish(dir, flags) {
 }
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
-    'list': 'myapi funnel list [--org <id>] [--json]',
     'create': 'myapi funnel create [--name <name>] [--org <id>]',
-    'get': 'myapi funnel get <id> [--org <id>] [--json]',
     'delete': 'myapi funnel delete <id> [--org <id>]',
+    'form': `myapi funnel form [funnel-id] [--slug <slug>] [--fields <spec>]
+       [--capture-to <dest>] [--honeypot <name>]
+       [--cta "<button text>"] [--success "<message>"] [--org <id>] [--json]
+
+Emits a ready-to-paste HTML snippet for a form that posts to the canonical
+funnel submit proxy. Submissions to any slug fall through to the funnel's
+auto-provisioned webhook by default (CRM ingest + bound workflows fire
+without further wiring). The proxy URL is platform-stable; slug names the
+form so workflows can route on it; an auto-honeypot field stops casual
+bots.
+
+  --slug <s>          Form identifier — appears in the proxy URL.
+                      Defaults to "join". Lowercase letters/digits/hyphens.
+  --fields <spec>     Comma-separated field specs.
+                      Each spec: <name>[:<type>][:required] (modifiers
+                      order-free). Types: text (default), email, number,
+                      tel. Name auto-promotes to email if name="email",
+                      to tel if name="phone" or "tel".
+                      Defaults to "email:email:required".
+  --capture-to <dest> Optional. Register a per-slug binding to the
+                      destination via POST /funnel/.../forms. Format:
+                      webhook:<uuid> or workflow:<uuid>. Without it,
+                      submissions fall through to the funnel's default
+                      webhook (most agents want this).
+  --honeypot <name>   Hidden bot-trap input name. Default "middle_name".
+  --cta "<text>"      Submit button text. Defaults to "Sign up".
+  --success "<text>"  Message shown on successful submit.
+
+Examples:
+  myapi funnel form                                        # email-required on default funnel
+  myapi funnel form --slug waitlist --fields email:required,name
+  myapi funnel form <funnel> --slug checkout \\
+    --fields email:required,plan,phone:tel \\
+    --capture-to webhook:<checkout_webhook_id>
+  myapi funnel form --json                                 # machine-readable
+  myapi funnel form --slug join > form.html                # snippet to a file
+
+Do NOT hardcode webhook inbound URLs into funnel HTML. Use this verb
+instead — the proxy preserves slug routing, hides the URL, and gets
+future platform features (rate-limit, captcha, field validation) for
+free.`,
+    'get': 'myapi funnel get <id> [--org <id>] [--json]',
+    'list': 'myapi funnel list [--org <id>] [--json]',
     'pages': 'myapi funnel pages [funnel_id] [--funnel <id>] [--org <id>] [--json]',
     'publish': `myapi funnel publish <dir> [--funnel <id>] [--env dev|prod] [--api-fn <id>] [--org <id>]
 
@@ -314,6 +515,7 @@ export async function run(subcommand, args, flags) {
 Subcommands:
   create     Create a funnel (optional --name; backend defaults to org's preview_subdomain)
   delete     Delete a funnel
+  form       Emit HTML for a form that posts to the canonical submit proxy
   get <id>   Get funnel details
   list       List funnels
   pages      List the pages currently published to a funnel
@@ -333,14 +535,15 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;
     }
     switch (subcommand) {
-        case 'list': return list(flags);
         case 'create': return create(flags);
-        case 'get': return get(args[0], flags);
         case 'delete': return del(args[0], flags);
+        case 'form': return formCmd(args[0], flags);
+        case 'get': return get(args[0], flags);
+        case 'list': return list(flags);
+        case 'pages': return pages(args[0], flags);
         case 'publish': return publish(args[0], flags);
         case 'push': return push(args[0], flags);
         case 'verify': return verify(args[0], flags);
-        case 'pages': return pages(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi funnel --help" for a list of valid subcommands.`);
     }
 }

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/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}',