@myapihq/cli 1.3.6 → 1.3.11

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())) {

package/dist/completion.js

@@ -26,7 +26,7 @@ const BLOCK_END = `# end ${PROGRAM} completion`;
 // test/smoke/completion.test.ts, which fails if a command in `myapi --help`
 // is missing here.
 export const COMMANDS = [
-    'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
+    'account', 'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
     'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'git', 'help', 'image',
     'doctor', 'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel', 'queue',
     'setup', 'status', 'storage', 'task', 'update', 'url', 'webhook', 'whoami',
@@ -35,10 +35,11 @@ export const COMMANDS = [
 // command → subcommands, for `myapi <command> <TAB>`. Mirrors each
 // command's dispatcher; commands absent here take no subcommand.
 export const SUBCOMMANDS = {
+    account: ['mailing-address'],
     auth: ['setup', 'import-key', 'whoami', 'link', 'switch', 'install-skills', 'config', 'registrant', 'api-keys'],
     org: ['create', 'delete', 'get', 'import', 'list', 'sync-brand', 'update'],
     billing: ['balance', 'history', 'usage', 'setup', 'topup', 'spend-cap'],
-    domain: ['assign', 'check', 'email-setup', 'import', 'list', 'records', 'register', 'renew', 'retry-provisioning', 'settings', 'status'],
+    domain: ['assign', 'check', 'email-setup', 'import', 'list', 'mail-server-resync', 'records', 'register', 'renew', 'retry-provisioning', 'settings', 'status'],
     funnel: ['create', 'delete', 'get', 'list', 'pages', 'publish', 'push', 'verify'],
     webhook: ['create', 'delete', 'delivery', 'list', 'update'],
     workflow: ['create', 'delete', 'disable', 'enable', 'get', 'get-run', 'list', 'runs', 'update'],
@@ -49,7 +50,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/exposes.test.js

@@ -6,6 +6,7 @@ import * as url from 'url';
 // EXPOSES array so the coverage tool (S-102) can introspect the full CLI
 // surface.
 const COMMAND_MODULES = [
+    './commands/account.js',
     './commands/auth.js',
     './commands/billing.js',
     './commands/config.js',

package/dist/index.js

@@ -6,6 +6,7 @@ import * as fs from 'fs';
 import { parseFlags } from './flags.js';
 const pkgPath = new URL('../package.json', import.meta.url);
 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+import * as accountCmd from './commands/account.js';
 import * as keysCmd from './commands/keys.js';
 import * as billingCmd from './commands/billing.js';
 import * as orgCmd from './commands/org.js';
@@ -40,6 +41,7 @@ import * as doctorCmd from './commands/doctor.js';
 // into a single schema for the upfront parse, so adding a new value flag in
 // one command means editing one file (its SCHEMA), not a global allowlist.
 const COMBINED_SCHEMA = {
+    ...accountCmd.SCHEMA,
     ...authCmd.SCHEMA,
     ...billingCmd.SCHEMA,
     ...configCmd.SCHEMA,
@@ -170,6 +172,9 @@ async function main() {
             case 'org':
                 await orgCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'account':
+                await accountCmd.run(subcommand, restArgs, flags);
+                break;
             case 'billing':
                 await billingCmd.run(subcommand, restArgs, flags);
                 break;
@@ -367,6 +372,7 @@ const HELP_TARGETS = {
     task: f => taskCmd.run(undefined, [], f),
     doctor: f => doctorCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
+    account: f => accountCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
     config: f => configCmd.run(undefined, [], f),
@@ -399,6 +405,7 @@ Usage: myapi <command> [subcommand] [args]
        myapi --version
 
 Commands:
+  account         Account-scoped settings (mailing address)
   audience        Save filter snapshots as named audiences (people or companies)
   auth            Manage account · setup · whoami · link
   billing         Check balance and manage billing

package/dist/skills/my-funnel-api/SKILL.md

@@ -17,7 +17,7 @@ Funnels are the publishing surface. You create a funnel under an org (one comman
 
 By default, your funnel lives on a free preview subdomain (`*.makeautonomous.com`) you get with every org. To serve on a custom domain, register and assign one via **mydomainapi** first.
 
-Every funnel includes two public proxy endpoints your HTML can call directly (no API key needed): a **form submit** endpoint that forwards POSTs to your org's webhook, and an **analytics/event ingest** for pageviews and click tracking.
+Every funnel auto-provisions a **webhook** at creation time (`org_webhook_id`). The funnel exposes two public proxy endpoints your HTML can call directly (no API key needed): a **form submit** at `POST /funnel/funnels/{id}/submit/{slug}` that delivers submissions through that webhook (CRM upsert + bound workflows fire automatically), and an **analytics/event ingest** for pageviews and click tracking. For multi-form funnels you can bind individual slugs to specific destinations with `myapi funnel form ... --capture-to webhook:<id>`.
 <!-- llm:end -->
 
 ## Commands
@@ -30,6 +30,7 @@ Every funnel includes two public proxy endpoints your HTML can call directly (no
 | `myapi funnel delete <id>` | Delete the funnel and purge its edge pages |
 | `myapi funnel push [slug]` | Push HTML from stdin to a slug (default: `/`) |
 | `myapi funnel pages [funnel_id]` | List the pages currently published to a funnel |
+| `myapi funnel form [funnel_id]` | Emit canonical form HTML (and register a binding with `--capture-to`) |
 | `myapi funnel verify [slug]` | Verify a published page is reachable + check links/webhooks |
 <!-- generated:end -->
 
@@ -58,12 +59,41 @@ myapi funnel delete <funnel_id>
 Omitting `[slug]` defaults to `/`. The funnel id is resolved from `--funnel`, the saved default funnel, or — only if the org has exactly one funnel — auto-picked.
 <!-- llm:end -->
 
-## Form Submissions & Analytics
+## Form submissions (canonical recipe)
 
-Funnels expose two public proxy endpoints your published HTML can hit directly (no API key needed):
+The funnel submit proxy is the canonical form-capture path. **Never hardcode `https://api.mywebhookapi.com/webhook/in/<slug>` into funnel HTML** — that URL leaks into your git history, breaks on rotation, gets scraped, and locks the platform out of future form-quality features (rate-limit, captcha, anti-bot, field validation). Use the proxy instead — same plumbing, hidden URL, automatic CRM ingest on `email`.
 
-- **Form submit:** `POST /funnel/funnels/{id}/submit/{slug}` — validates payload and forwards to your org's configured webhook.
-- **Analytics/tracking:** `POST /funnel/funnels/{id}/event` — proxies pageviews, clicks, and pixel events to your webhook. Rate-limited to 60 req/min per funnel.
+Zero-config form (the happy path most agents want):
+
+```bash
+myapi funnel create
+myapi funnel form --slug join --fields email:required,name > snippet.html
+# paste snippet.html into your page (or pipe through funnel push):
+cat page-with-snippet.html | myapi funnel push /
+# Submissions land in the funnel's auto-provisioned webhook → CRM upsert on `email` → any bound workflow fires.
+```
+
+`funnel form` always registers a per-slug binding (idempotent on repeat). Without `--capture-to` it auto-targets the funnel's `org_webhook_id` — same destination as the fallback, with server-side honeypot + field validation turned on.
+
+Multi-form funnel (each slug to a different destination):
+
+```bash
+# Bind /checkout to a specific webhook:
+myapi funnel form <funnel_id> --slug checkout \
+  --fields email:required,plan,phone:tel \
+  --capture-to webhook:<checkout_webhook_id>
+
+# Bind /survey to a workflow directly:
+myapi funnel form <funnel_id> --slug survey \
+  --fields email:required,score:number \
+  --capture-to workflow:<survey_workflow_id>
+```
+
+`--capture-to` registers the per-slug binding via `POST /funnel/orgs/.../funnels/{id}/forms`. Without it, submissions fall through to the funnel's default webhook.
+
+## Analytics
+
+`POST /funnel/funnels/{id}/event` — public proxy for pageviews, clicks, and pixel events (no API key needed). Rate-limited to 60 req/min per funnel.
 
 ## Notes
 

package/dist/skills/my-llm-api/README.md

@@ -1,19 +1,29 @@
 # my-llm-api
 
-Provider-agnostic LLM completions and embeddings, billed at upstream cost. Today routes to Gemini; the model id is just a string, so additional providers land without breaking callers.
+Two-surface LLM primitive. Self-hosted open-source inference on the raw surface, objective verbs on the verb surface. Pricing is in cents per 1M tokens at upstream rate.
 
 ## What it does
 
-- **Chat completion** — messages array (role/content), get reply + usage + cost
-- **Embeddings** — single string or batch, returns vector(s) + usage
-- **Model catalog** — list available models with per-1M-token pricing
+Two surfaces, one credential, one balance:
+
+- **Raw** — `complete`, `embed`, `models`. You pick a self-hosted catalog model and shape the prompt yourself. Today's catalog: `Qwen/Qwen3-Coder-30B-A3B-Instruct` (1 chat model, no embed model). Proprietary models are not callable here — that's how MyAPI stays off the reseller framing.
+- **Verbs** — `classify`, `extract`, `summarize`, `draft`. You ask for a task done; the model is implementation detail and is never named in the response. This is where any future proprietary model lives, wrapped behind the verb contract.
 
 ## Quickstart
 
 ```bash
+# Catalog (live — reflects what the gateway actually serves)
 myapi llm models
-myapi llm complete "explain HMAC in two sentences"   # defaults to gemini-3.1-flash-lite-preview
-myapi llm embed "the quick brown fox" --model gemini-embedding-001
+
+# Raw — picks the first chat model from the catalog automatically
+myapi llm complete "explain HMAC in two sentences"
+
+# Verbs — recommended for workflow steps
+myapi llm classify "I want a refund" --labels billing,sales,support
+myapi llm extract "Acme Corp has 250 employees" \
+  --schema '{"type":"object","properties":{"company":{"type":"string"},"employees":{"type":"integer"}}}'
+myapi llm summarize --file long.md --style exec
+myapi llm draft --kind email --prompt "Friendly welcome, under 60 words"
 ```
 
 ## Authentication
@@ -26,10 +36,10 @@ Requires `api_key` and `org_id` from **myapihq**. Inference cost is debited from
 
 ## When to use
 
-This is the **workflow-step LLM** — use it inside scripted pipelines (summarize a doc, classify an email, embed text for similarity). It is **not** a replacement for your own reasoning if you're an agent; you already have a model.
+This is the **workflow-step LLM** — use it inside scripted pipelines (summarize a doc, classify an email, extract structured data, draft a reply). It is **not** a replacement for your own reasoning if you're an agent; you already have a model.
 
 ## Documentation
 
-Model catalog, message shapes, and cost semantics: see `SKILL.md`.
+Two-surface design, raw/verb shapes, and cost semantics: see `SKILL.md`.
 
 Run `myapi llm --help` for inline reference.

package/dist/skills/my-llm-api/SKILL.md

@@ -1,29 +1,39 @@
 ---
 name: my-llm-api
-version: 1.0.0
+version: 1.1.0
 description: >
-  Provider-agnostic LLM completions and embeddings, billed at upstream cost.
-  The model id is just a string — today routes to Gemini, more providers land
-  without breaking callers. Use this inside workflow steps and scripted
-  pipelines, not as a replacement for your own reasoning.
-triggers: [llm, completion, chat, embed, embedding, gemini, inference, summarize, classify, vector]
+  Two-surface LLM primitive. Raw chat completion against self-hosted
+  open-source models (you pick the model), and objective verbs
+  (classify / extract / summarize / draft) that hide the model behind a
+  task. Pricing in cents per 1M tokens; charged from your MyAPI balance.
+triggers: [llm, completion, chat, embed, embedding, inference, classify, extract, summarize, draft, qwen]
 checksum: sha256-pending
 ---
 
 # MyLLMAPI
 
-A thin, OpenAI-compatible-shape LLM gateway. Three endpoints: `complete` (chat), `embed` (vectors), `models` (catalog). Pricing is per-1M tokens at the upstream rate while we build our own inference; cost is debited from your MyAPI balance.
+A two-surface LLM gateway:
+
+- **Raw** — `complete` / `embed` / `models`. You pick a self-hosted catalog model (today: `Qwen/Qwen3-Coder-30B-A3B-Instruct`). Proprietary models are not callable here.
+- **Verbs** — `classify` / `extract` / `summarize` / `draft`. You ask for a task done; the model is implementation detail and is never named in the response.
+
+Pricing is in cents per 1M tokens at the actual upstream rate; cost is debited from your MyAPI balance.
 
 ## Capabilities
 <!-- llm:start -->
-Use this for workflow tasks — summarize a doc, classify an inbound email, embed text for similarity, expand a one-line prompt into structured copy. The reply goes to stdout; a one-line usage footer (tokens + cost + finish reason) goes to stderr, so `myapi llm complete ... | jq` and similar pipelines work as expected.
+Use this for workflow tasks — summarize a doc, classify an inbound email, extract structured data, draft a reply. The reply goes to stdout; a one-line usage footer (tokens + cost + finish reason) goes to stderr, so `myapi llm complete ... | jq` and similar pipelines work as expected.
+
+**Don't use this as your own model.** If you're an agent reading this, you already have a more capable model than what's exposed here. Reach for the LLM verbs when you're scripting a recurring step where a small/cheap model is the right tool — not for one-shot reasoning you can just do yourself.
 
-**Don't use this as your own model.** If you're an agent reading this, you already have a more capable model than what's exposed here. Reach for `llm complete` when you're scripting a recurring step where a small/cheap model is the right tool — not for one-shot reasoning that you can just do yourself.
+### Raw vs. verbs
 
-### Messages shape
+- **Raw `complete`** — full control: pick the model, build the `messages` array, set `max_tokens`/`temperature`/`stop`. Use when shape matters.
+- **Verbs** — you want a *result* (label, JSON, summary, draft). Use when you don't care which model runs underneath.
+
+### Raw `complete` request
 ```json
 {
-  "model": "gemini-3.1-flash-lite-preview",
+  "model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
   "messages": [
     { "role": "system", "content": "You are a terse editor." },
     { "role": "user",   "content": "Tighten this paragraph: ..." }
@@ -36,90 +46,109 @@ Use this for workflow tasks — summarize a doc, classify an inbound email, embe
 
 Roles: `system | user | assistant`. Multiple system messages collapse to one instruction. `max_tokens`, `temperature`, and `stop` are optional — per-model defaults apply.
 
-### Complete response
+### Raw `complete` response
 ```json
 {
-  "model": "gemini-3.1-flash-lite-preview",
+  "model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
   "content": "...assistant reply...",
   "finish_reason": "stop",
-  "usage": { "input_tokens": 42, "output_tokens": 87, "cost_usd": 0.000029 }
+  "usage": { "input_tokens": 42, "output_tokens": 87, "cost_cents": 0.029 }
 }
 ```
 
-`finish_reason` is typically `stop` (model returned naturally), `length` (hit max_tokens — increase if you need more), or `safety` (blocked).
+`finish_reason` is one of `stop` (normal), `length` (hit max_tokens), `filter` (blocked).
 
-### Embed response
-```json
-{
-  "model": "gemini-embedding-001",
-  "embeddings": [[-0.0226, 0.0118, ...]],
-  "usage": { "input_tokens": 5, "cost_usd": 0.0000007 }
-}
-```
+If `model` isn't in the self-hosted catalog the server returns `MODEL_NOT_IN_RAW_CATALOG` — that's the signal to use a verb instead, not to retry with a different `--model`.
+
+### Raw `embed`
 
-`embeddings` is always `number[][]` — even a single-string input returns a one-element array of vectors. Embed-only usage has no `output_tokens`.
+No embedding model is served on the raw catalog today; calls return `EMBED_NOT_AVAILABLE`. Use a dedicated embedding API for now.
 
 ### Model catalog
-- Chat models: `id`, `kind: 'chat'`, `context` (token window), `input_per_1m`, `output_per_1m`
-- Embed models: `id`, `kind: 'embed'`, `dimensions`, `input_per_1m`
+- Chat models: `id`, `kind: 'chat'`, `context_window`, `input_cost_per_1m_cents`, `output_cost_per_1m_cents`
+- Embed models: `id`, `kind: 'embed'`, `dimensions`, `input_cost_per_1m_cents`
+
+The catalog is **live** — it reflects what the inference gateway actually serves, refreshed every 15 minutes. Always query `models` rather than hard-coding ids.
+
+### Verb requests + responses
+
+Every verb takes an optional `tier` (`fast | reasoning | cheap`) — opaque routing hint, server picks the model. Response usage block is identical across verbs.
+
+| Verb | Request body | Response `data` |
+|---|---|---|
+| `classify` | `{ input, labels: string[], multi?: boolean, tier? }` | `{ label }` or `{ labels: string[] }` (when `multi`) |
+| `extract`  | `{ input, schema: <json-schema>, tier? }`              | `{ data: <object conforming to schema> }` |
+| `summarize`| `{ input, style?: 'brief'\|'exec'\|'bullet', tier? }`  | `{ summary }` |
+| `draft`    | `{ input?, kind: string, context?: object, prompt?: string, tier? }` | `{ text }` |
+
+Shared usage block on every verb:
+
+```json
+{ "tier_used": "fast", "tokens_in": 65, "tokens_out": 37, "cost_cents": 0.005 }
+```
+
+The model/provider is **never** named in the verb response. That's the point — the verb is the contract, the model is implementation.
 
-Today: `gemini-3.1-pro-preview`, `gemini-3.1-flash-lite-preview`, `gemini-embedding-001`. Catalog is live — always query `models` rather than hard-coding ids.
 <!-- llm:end -->
 
 ## Commands
 <!-- generated:start -->
 | Command | What it does |
 |---|---|
-| `myapi llm models [--kind chat\|embed] [--json]` | List available models with pricing |
-| `myapi llm complete "<prompt>" [--model <id>] [--system "<s>"] [--max-tokens N] [--temperature 0..1] [--stop <csv>] [--file <path>] [--json]` | Chat completion; reply to stdout, usage to stderr. Default model: `gemini-3.1-flash-lite-preview` |
-| `myapi llm embed "<text>" --model <id> [--file <path>] [--json]` | Embed a string; default render shows model + dim + first 5 values |
+| `myapi llm models [--kind chat\|embed] [--json]` | List the live model catalog with pricing (cents/1M) |
+| `myapi llm complete "<prompt>" [--model <id>] [--system "<s>"] [--max-tokens N] [--temperature 0..1] [--stop <csv>] [--file <path>] [--json]` | Raw chat completion; reply to stdout, usage to stderr. Defaults to the first chat model in the catalog |
+| `myapi llm embed "<text>" --model <id> [--json]` | Embed a string (no model served today — returns EMBED_NOT_AVAILABLE) |
+| `myapi llm classify "<input>" --labels <csv> [--multi] [--tier <t>] [--json]` | Pick a label from a set |
+| `myapi llm extract "<input>" --schema <path\|json> [--tier <t>] [--json]` | Pull structured data conforming to a JSON Schema |
+| `myapi llm summarize "<input>" [--style brief\|exec\|bullet] [--tier <t>] [--json]` | Summarize text |
+| `myapi llm draft --kind <what> [--prompt "<s>"] [--context <json>] ["<src>"] [--tier <t>] [--json]` | Draft an email / reply / message / … |
 <!-- generated:end -->
 
-Pass `-` as the prompt to read from stdin. Pass `--file <path>` to read a longer prompt from disk.
+Pass `-` as the prompt/input to read from stdin. Pass `--file <path>` to read longer content from disk.
 
 ## Examples
 <!-- llm:start -->
 ```bash
-# List the catalog
+# List the live catalog
 myapi llm models
-# Filter to embed-only
-myapi llm models --kind embed --json | jq '.models[].id'
+myapi llm models --kind chat --json | jq '.models[].id'
 
-# One-shot completion (default model = gemini-3.1-flash-lite-preview)
+# Raw completion — picks the first chat model from the catalog
 myapi llm complete "Summarize in 12 words: $(cat README.md)"
 
-# Override the model (e.g. when you need pro-tier quality)
-myapi llm complete "Polish this draft: ..." \
-  --model gemini-3.1-pro-preview \
-  --system "You are a terse copy editor" \
-  --max-tokens 300
+# Pin a specific model
+myapi llm complete "Refactor this function: ..." \
+  --model Qwen/Qwen3-Coder-30B-A3B-Instruct \
+  --system "You are a careful Go reviewer." \
+  --max-tokens 600
 
-# Read from stdin (useful in pipelines)
-cat email.txt | myapi llm complete - \
-  --system "Classify intent: support | sales | spam"
+# ── Verbs (recommended for workflow steps) ──────────────────────────────
 
-# Embed and save the vector
-myapi llm embed --file doc.txt --model gemini-embedding-001 --json \
-  > doc.vec.json
-```
+myapi llm classify "I was charged twice — please refund." \
+  --labels billing,technical,sales,spam
 
-### End-to-end recipe — classify inbound webhooks
-```bash
-# Pull the last delivery body, classify with a tiny model, route accordingly
-BODY=$(myapi webhook delivery <delivery_id> --json | jq -r '.body')
-INTENT=$(printf '%s' "$BODY" | myapi llm complete - \
-  --system 'Respond with one word: support, sales, or spam.' \
-  --max-tokens 5)
-echo "Routing $INTENT"
+myapi llm extract "Acme Corp employs 250 people in Berlin." \
+  --schema '{"type":"object","properties":{"company":{"type":"string"},"employees":{"type":"integer"}}}'
+
+myapi llm summarize --file long-thread.txt --style bullet
+
+myapi llm draft --kind email \
+  --prompt "Friendly welcome, under 60 words." \
+  --context '{"recipient":"a new signup","product":"MyAPI"}'
+
+# Classify + route an inbound webhook delivery
+BODY=$(myapi webhook delivery <id> --json | jq -r '.body')
+INTENT=$(printf '%s' "$BODY" | myapi llm classify - \
+  --labels support,sales,spam --json | jq -r '.data.label')
 ```
 <!-- llm:end -->
 
 ## Notes
 
-- **No upstream tokens involved.** MyAPI never holds your Gemini/OpenAI/Anthropic credentials — we hold ours, you pay us at-cost while we build our own inference. The model id is just a string; routing happens server-side.
-- **Latency.** Flash-lite ≈ 200–800ms first token. Pro ≈ 600ms–2s. Embeddings sub-second.
-- **Cost.** `usage.cost_usd` is the authoritative number — debited at upstream rate (no MyAPI markup today). Use this for cost-accounting in workflows.
-- **Streaming.** Not exposed yet — `complete` returns the full reply. Add streaming support when there's a use case that requires it.
-- **Bring-your-own-key.** Not supported by design. MyAPI's value here is unified billing + a stable API across providers; managing your upstream keys would defeat both.
-
-Run `myapi llm --help` for inline reference.
+- **`draft` context safety — what the platform does and doesn't do.** Every field in `context` is quoted into the prompt as referent data the model is told to incorporate.  Sensitive-named keys (`secret`, `api_key`, `password`, `token`, etc.) are **not** automatically redacted — if you pass `{"secret": "abc123"}`, the model may include `"abc123"` in the output.  The verb does two things on top:
+  - **Injection defense.** Keys named `instructions`, `system`, `system_prompt`, `prompt`, `override`, `directives`, and the JS prototype-pollution sentinels are stripped at the boundary and surfaced in `meta.warnings`; the model can't be hijacked through them.
+  - **Output guardrail.** After generation, every fact value (length ≥ 4) is substring-scanned in the output; matches surface under `meta.guardrails.facts_in_output: ["secret", "api_key", ...]`.  This is a **signal, not a redaction** — you see when a value landed in the body.
+  Rule of thumb: if a value must not appear in the output, **do not put it in `context`**.  Pass identifiers (recipient name, account id, topic) and let the prompt reference them indirectly; keep credentials, PII, and any internal-only metadata out of the body entirely.
+- **Self-hosted raw, server-picked verbs.** Raw runs on MyAPI's TPU; verbs route wherever the server picks (future proprietary models land here, wrapped behind the verb contract).
+- **Cost + latency.** `usage.cost_cents` is authoritative — no markup today. Qwen3-Coder-30B-A3B: 200–600ms to first token, 1–3s end-to-end on a few-hundred-token reply.
+- **Live catalog, no streaming, no BYOK.** Don't hard-code model ids — `models` is the source of truth (CLI picks if `--model` omitted). Full reply only.

package/dist/skills/my-webhook-api/SKILL.md

@@ -2,8 +2,8 @@
 name: my-webhook-api
 version: 1.0.0
 description: >
-  Inbound webhook endpoints. Receive HTTP POSTs from third parties (forms, Stripe, GitHub, etc.) and either inspect deliveries directly or wire them to a workflow.
-triggers: [webhook, inbound, receiver, form submission, stripe events, slack notification, delivery, payload, event ingest]
+  Inbound webhook endpoints for non-funnel sources — Stripe, GitHub, custom services. Funnel forms use the my-funnel-api proxy.
+triggers: [webhook, inbound, receiver, stripe events, github webhook, slack notification, delivery, payload, event ingest]
 checksum: sha256-pending
 ---
 
@@ -13,6 +13,8 @@ Per-org HTTP endpoints that accept inbound POSTs and durably store every deliver
 
 ## Capabilities
 <!-- llm:start -->
+**Scope: non-funnel inbound.** Use this for Stripe → MyAPI, GitHub → MyAPI, custom services → MyAPI, anything where an *external* system POSTs to you. **Funnel forms use the funnel proxy** (see `my-funnel-api`: `myapi funnel form ... --capture-to webhook:<id>` if you need to bind a specific destination; otherwise the funnel's auto-provisioned webhook handles it). Don't hardcode `api.mywebhookapi.com/webhook/in/<slug>` URLs into funnel HTML.
+
 Each endpoint has a unique inbound URL minted at create time. Anyone who knows the URL can POST to it; the body is stored verbatim along with headers and a timestamp. Deliveries are kept indefinitely (until you delete the endpoint).
 
 The inbound URL accepts **any JSON body** — no enforced schema, no required fields. Whatever you POST is what gets stored. Two consequences:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "1.3.6",
+  "version": "1.3.11",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [
@@ -24,12 +24,13 @@
     "check-coverage": "npm run build && node scripts/check-coverage.js",
     "check-coverage:live": "npm run build && node scripts/check-coverage.js --live",
     "update-schema": "node scripts/update-schema.js",
+    "lint:changelog": "node ../../scripts/lint-changelog.js",
+    "lint:help-order": "node scripts/lint-help-order.js",
     "lint:skills": "node scripts/lint-skills.js",
-    "lint:skills:strict": "node scripts/lint-skills.js --strict",
-    "lint:changelog": "node ../../scripts/lint-changelog.js"
+    "lint:skills:strict": "node scripts/lint-skills.js --strict"
   },
   "dependencies": {
-    "@myapihq/sdk": "^1.3.6"
+    "@myapihq/sdk": "^1.3.11"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",