@method-ai-hq/sdk 0.0.0-stage → 0.14.2

package/dist/packages/sdk/examples/support-triage/README.md

@@ -0,0 +1,77 @@
+# Triage a support ticket
+
+When a ticket arrives, this Method reads it from the help desk, chooses its queue, priority, and tags, drafts a first reply, and updates the ticket. When the team is not clear, the ticket goes to the triage queue and a person chooses the team.
+
+| Step | Type | What it does |
+| --- | --- | --- |
+| `read` | run | Reads the ticket with `HELPDESK_TOKEN`. |
+| `team` | classify, options | billing, technical, account, or `unclear`. |
+| `refund` | classify, `answer: yes_no` | Does the customer ask for money back? |
+| `urgency` | classify, `levels` | low, normal, high, or urgent. |
+| `route` | run | The rule: the team's queue at 80% or more, else triage and a person; the refund tag at 50% or more. |
+| `draft_reply` | call, `model: writer` | A first reply for an agent to check. The prompt shows two replies that the team liked. |
+| `update` | run, changes the help desk | Sets queue, priority, and tags, and adds the reply as an internal note. |
+| `ask_person` | ask, when a person is needed | "Which team should handle it?" |
+| `move` | run, when a person is needed | Moves the ticket to the team that the person chose. |
+
+What the file shows:
+
+- **`models:`** names the model of the reply step: `writer: anthropic/claude-haiku-4.5`. Hosted models need no key.
+- **`secrets:`** declares `HELPDESK_TOKEN`. Scripts read it from their environment. It never goes into the Method or the run records.
+- **Three classify forms**, each with one question. The `unclear` option lets the classifier say that it cannot choose; a guess is not hidden.
+- **The rule is in a script**, not in a prompt, so it is the same on every run and `triage.test.mjs` tests it.
+- **An effect on each help desk change.** The http observer reads the ticket back. A 200 response shows only that the help desk accepted the request. The `update` effect checks the priority but not the queue, because the `move` step changes the queue after a person's answer.
+- **`run_data: device`** keeps the run records on this computer. The classify and call steps still send the ticket text to the classifier and the model.
+
+## Try it on this computer
+
+`fake-helpdesk.mjs` is a small help desk with the three tickets in `sample-tickets.json`. It keeps them in memory.
+
+```sh
+method secret set HELPDESK_TOKEN          # opens a private form; enter any test value
+HELPDESK_TOKEN=THE_SAME_VALUE node fake-helpdesk.mjs 4310 &
+method bind support-triage.method helpdesk --connection http://127.0.0.1:4310
+method run support-triage.method --inputs inputs.json
+```
+
+For your own help desk, run `method secret find` in this folder. It lists the key files nearby and the names in each, never the values, and prints the `method secret import` command for the file that has `HELPDESK_TOKEN`. Then bind `helpdesk` to your help desk's API URL. A help desk that needs a token for reads too gets it from `METHOD_OBSERVER_TOKEN`: the http observer sends that as a Bearer token.
+
+T-1042 (charged twice) goes to Billing with the `refund_request` tag. T-1043 ("Can't get in") does not say enough, so the run stops at `ask_person` with exit code 2. Answer it with `--human`:
+
+```sh
+echo '{"steps": {"ask_person:0": {"outputs": {"chosen_queue": "account"}}}}' > answer.json
+method run support-triage.method --run-dir RUN_DIR --resume --human answer.json
+```
+
+## The case in cases/
+
+`cases/double-charge-to-billing` keeps the right result for T-1042: queue billing, tag `refund_request`, no person asked. It was made with `method case new support-triage.method --id double-charge-to-billing --passing-run RUN --expect expect.json`, where `expect.json` has three `equals` checks on `outputs.decision`. The classify answers in its recording came from a fixed test classifier, so the case checks the rule and not the classifier. `method test support-triage.method` replays it: steps that did not change return their recorded outputs. When you change the route rule, the route step runs again and the case shows whether T-1042 still goes to Billing.
+
+## Tests
+
+`node --test triage.test.mjs` tests the rule at its thresholds, the change that the scripts send, and the scripts against the fake help desk (the token, a repeated update, and a missing ticket).
+
+## Put it in your app
+
+Publish the Method and connect your app to it:
+
+```sh
+method connect ../my-app
+```
+
+`method connect` publishes the Method if it has no published version, makes a service key for the app, writes it to the app's `.env` without showing it, and prints the code to add. For a Python app the code is like this:
+
+```python
+from withmethod import Method
+
+method = Method()  # reads METHOD_API_KEY from the environment or .env
+
+def on_ask(question):
+    # question.step is "ask_person", question.question is the text, question.form the answer's JSON Schema.
+    return None  # return {"chosen_queue": "billing"}, or None to send the question to the team inbox
+
+run = method.run("METHOD_ID", {"ticket_id": ticket_id}, on_ask=on_ask, idempotency_key=f"ticket-{ticket_id}")
+result = run["result"]
+```
+
+In Node, use `new Method().run({method, inputs, idempotencyKey, onAsk})`. One idempotency key for each ticket means that a repeated webhook does not triage the ticket twice. A question that the app does not answer waits in the team inbox until a person answers it there or with `method answer RUN_ID`.

package/dist/packages/sdk/examples/support-triage/TASK.md

@@ -0,0 +1,3 @@
+# Request
+
+When a support ticket arrives, choose its team, priority, and tags, write a first reply for an agent to check, and update the ticket in the help desk. When the team is not clear, put the ticket in the triage queue and ask a person which team should take it.

package/dist/packages/sdk/examples/support-triage/cases/double-charge-to-billing/case.json

@@ -0,0 +1,40 @@
+{
+  "format": "method-case/1",
+  "id": "double-charge-to-billing",
+  "status": "active",
+  "method_file": "support-triage.method",
+  "note": "A customer charged twice asks for the second charge back. The ticket goes to Billing with the refund_request tag, and no person is asked.",
+  "author": null,
+  "created": "2026-10-10T02:31:11.810Z",
+  "source": {
+    "run_dir": "/work/support-triage/run2",
+    "execution_id": "6707d77c-38bc-4e10-a5f3-cebd56ddeb71",
+    "method_sha256": "bbbb45763b9b8db47305c6af4940052c2282f4b8a1e607b36eb6732b97a41fb9",
+    "passing_run_dir": "/work/support-triage/run2"
+  },
+  "expect": [
+    {
+      "kind": "equals",
+      "ref": "outputs.decision.queue",
+      "value": "billing"
+    },
+    {
+      "kind": "equals",
+      "ref": "outputs.decision.tags",
+      "value": [
+        "refund_request"
+      ]
+    },
+    {
+      "kind": "equals",
+      "ref": "outputs.decision.needs_person",
+      "value": false
+    }
+  ],
+  "runs": null,
+  "min_pass": null,
+  "supersedes": [],
+  "superseded_by": null,
+  "retention_until": "2027-10-10",
+  "redacted": true
+}

package/dist/packages/sdk/examples/support-triage/cases/double-charge-to-billing/recording.json

@@ -0,0 +1,460 @@
+{
+  "format": "method-recording/1",
+  "method_sha256": "bbbb45763b9b8db47305c6af4940052c2282f4b8a1e607b36eb6732b97a41fb9",
+  "execution_id": "6707d77c-38bc-4e10-a5f3-cebd56ddeb71",
+  "inputs": {
+    "ticket_id": "T-1042"
+  },
+  "initial_state": {},
+  "environment": {
+    "helpdesk": "http://127.0.0.1:4310"
+  },
+  "keys": {
+    "read": "805c11d820c39324d89adfabacd41b1f731a48ffe07e2586f9942ac241b7d04d",
+    "team": "918e0fd113af5eda3e22bc00dca64ab97dc73c6f394b677ea2a51601e7204dad",
+    "refund": "5b1ed20adcd1824089d1fd3d3682192ebd4fb73fdce0d263cb579850f3ad1611",
+    "urgency": "e5cea1552cda483b2de24883c9e5bf68a313410c8775e1d73bf20372c2ccc037",
+    "route": "d9ddd5a766745b9711eafd66a5b3b7a7e8426dcc34bbe03a79d8cc66e3a1562f",
+    "draft_reply": "a119986f42b583466a238edce83358d413d9fe65c401428990741225ebf5a0cd",
+    "update": "35ec1f944048dcfd8300d9b835a68aa7b3e0984dfa9d7bc101da694c4f67ee07",
+    "ask_person": "565ad1d8cd09f8dc42f0baaf09e45046666c47c66a670d74dd2b6cdb3e2b96a9",
+    "move": "0d7b538af952c7d552beb15e03495082c27176299976ea861a5f8496579c726a"
+  },
+  "iterations": {
+    "read": [
+      {
+        "inputs": {
+          "ticket_id": "T-1042",
+          "helpdesk": "http://127.0.0.1:4310"
+        },
+        "candidate": {
+          "ticket": {
+            "id": "T-1042",
+            "subject": "Charged twice this month",
+            "body": "Hi, my card was charged $49 two times on October 3 for the Team plan. We only have one workspace. Please refund the second charge."
+          }
+        }
+      }
+    ],
+    "team": [
+      {
+        "inputs": {
+          "subject": "Charged twice this month",
+          "body": "Hi, my card was charged $49 two times on October 3 for the Team plan. We only have one workspace. Please refund the second charge."
+        },
+        "candidate": {
+          "team": {
+            "choice": "billing",
+            "probabilities": {
+              "billing": 0.93,
+              "technical": 0.02,
+              "account": 0.03,
+              "unclear": 0.02
+            }
+          }
+        }
+      }
+    ],
+    "refund": [
+      {
+        "inputs": {
+          "body": "Hi, my card was charged $49 two times on October 3 for the Team plan. We only have one workspace. Please refund the second charge."
+        },
+        "candidate": {
+          "refund": {
+            "answer": true,
+            "probability": 0.96
+          }
+        }
+      }
+    ],
+    "urgency": [
+      {
+        "inputs": {
+          "subject": "Charged twice this month",
+          "body": "Hi, my card was charged $49 two times on October 3 for the Team plan. We only have one workspace. Please refund the second charge."
+        },
+        "candidate": {
+          "urgency": {
+            "level": "normal",
+            "score": 1.25,
+            "probabilities": {
+              "low": 0.1,
+              "normal": 0.6,
+              "high": 0.25,
+              "urgent": 0.05
+            }
+          }
+        }
+      }
+    ],
+    "route": [
+      {
+        "inputs": {
+          "team": {
+            "choice": "billing",
+            "probabilities": {
+              "billing": 0.93,
+              "technical": 0.02,
+              "account": 0.03,
+              "unclear": 0.02
+            }
+          },
+          "refund": {
+            "answer": true,
+            "probability": 0.96
+          },
+          "urgency": {
+            "level": "normal",
+            "score": 1.25,
+            "probabilities": {
+              "low": 0.1,
+              "normal": 0.6,
+              "high": 0.25,
+              "urgent": 0.05
+            }
+          }
+        },
+        "candidate": {
+          "decision": {
+            "priority": "normal",
+            "tags": [
+              "refund_request"
+            ],
+            "queue": "billing",
+            "needs_person": false,
+            "rule": "team_meets_threshold",
+            "reason": "the classifier chose billing with 93% probability"
+          }
+        }
+      }
+    ],
+    "draft_reply": [
+      {
+        "inputs": {
+          "ticket": {
+            "id": "T-1042",
+            "subject": "Charged twice this month",
+            "body": "Hi, my card was charged $49 two times on October 3 for the Team plan. We only have one workspace. Please refund the second charge."
+          }
+        },
+        "candidate": {
+          "reply": "Thank you for telling us about the two $49 charges on October 3. Our billing team will check your Team plan payment records for that date. We will write to you again when we know what caused the second charge.\n\nThe support team"
+        }
+      }
+    ],
+    "update": [
+      {
+        "inputs": {
+          "ticket_id": "T-1042",
+          "queue": "billing",
+          "priority": "normal",
+          "tags": [
+            "refund_request"
+          ],
+          "note": "Thank you for telling us about the two $49 charges on October 3. Our billing team will check your Team plan payment records for that date. We will write to you again when we know what caused the second charge.\n\nThe support team",
+          "helpdesk": "http://127.0.0.1:4310"
+        },
+        "candidate": {
+          "updated": {
+            "id": "T-1042",
+            "queue": "billing",
+            "priority": "normal"
+          }
+        }
+      }
+    ]
+  },
+  "observations": {
+    "update/0/updated": [
+      {
+        "source": "http",
+        "ref": "GET /tickets/T-1042",
+        "data": {
+          "status": 200,
+          "json": true,
+          "fields": {
+            "priority": "normal"
+          }
+        }
+      }
+    ]
+  },
+  "method": {
+    "format": "method/3.4",
+    "name": "Triage a support ticket",
+    "goal": "Read a new help desk ticket, choose its queue and priority, draft a first reply, and update the ticket. Ask a person when the team is unclear.",
+    "run_data": "device",
+    "models": {
+      "writer": {
+        "agent": "claude"
+      }
+    },
+    "secrets": {
+      "HELPDESK_TOKEN": "API token for the help desk. read-ticket.mjs and set-ticket.mjs send it as a Bearer token."
+    },
+    "inputs": {
+      "ticket_id": {
+        "type": "text",
+        "description": "ID of the new ticket in the help desk, such as T-1042."
+      }
+    },
+    "environment": {
+      "helpdesk": {
+        "type": "service",
+        "description": "Help desk API. GET /tickets/ID reads a ticket; PATCH /tickets/ID sets its queue, priority, tags, and internal note."
+      }
+    },
+    "steps": {
+      "read": {
+        "name": "Read the ticket",
+        "purpose": "Reads the ticket from the help desk with HELPDESK_TOKEN and returns its id, subject, and text. Fails when the help desk does not return the ticket. Changes nothing.",
+        "in": {
+          "ticket_id": "inputs.ticket_id",
+          "helpdesk": "environment.helpdesk"
+        },
+        "do": {
+          "kind": "run",
+          "runtime": "node",
+          "entrypoint": "read-ticket.mjs"
+        },
+        "out": {
+          "ticket": {
+            "type": "record",
+            "fields": {
+              "id": "text",
+              "subject": "text",
+              "body": "text"
+            },
+            "description": "The ticket as the help desk returned it."
+          }
+        }
+      },
+      "team": {
+        "name": "Choose the team",
+        "in": {
+          "subject": "ticket.subject",
+          "body": "ticket.body"
+        },
+        "do": {
+          "kind": "classify",
+          "question": "Which team should handle the main request in this support ticket?",
+          "options": {
+            "billing": "Billing - invoices, charges, refunds, and plan changes.",
+            "technical": "Technical - errors, outages, and problems using the product.",
+            "account": "Account - sign-in, users, and access.",
+            "unclear": "Unclear - the ticket does not say enough to choose, or no listed team fits."
+          }
+        },
+        "out": "team"
+      },
+      "refund": {
+        "name": "Check for a refund request",
+        "in": {
+          "body": "ticket.body"
+        },
+        "do": {
+          "kind": "classify",
+          "question": "Does the customer ask for money back?",
+          "answer": "yes_no"
+        },
+        "out": "refund"
+      },
+      "urgency": {
+        "name": "Score the urgency",
+        "in": {
+          "subject": "ticket.subject",
+          "body": "ticket.body"
+        },
+        "do": {
+          "kind": "classify",
+          "question": "How urgent is this support ticket for the customer?",
+          "levels": [
+            "low",
+            "normal",
+            "high",
+            "urgent"
+          ]
+        },
+        "out": "urgency"
+      },
+      "route": {
+        "name": "Choose the queue and priority",
+        "purpose": "Chooses the team's queue when the team is not unclear and its probability is at least 80%. Otherwise chooses the triage queue and marks the ticket for a person. The priority is the most likely urgency level. Adds the tag refund_request when the probability of a refund request is at least 50%. Returns the rule used. Changes nothing.",
+        "in": {
+          "team": "team",
+          "refund": "refund",
+          "urgency": "urgency"
+        },
+        "do": {
+          "kind": "run",
+          "runtime": "node",
+          "entrypoint": "route.mjs"
+        },
+        "out": {
+          "decision": {
+            "type": "record",
+            "description": "The queue, priority, and tags, whether a person must choose the team, and the rule used.",
+            "fields": {
+              "queue": "text",
+              "priority": "text",
+              "tags": {
+                "type": "list",
+                "items": "text"
+              },
+              "needs_person": "boolean",
+              "rule": "text",
+              "reason": "text"
+            }
+          }
+        }
+      },
+      "draft_reply": {
+        "name": "Draft the first reply",
+        "in": {
+          "ticket": "ticket"
+        },
+        "do": {
+          "kind": "call",
+          "model": "writer",
+          "prompt": "Write the first reply to this support ticket, for a support agent to check and send.\nThank the customer in one sentence. Then say in one or two sentences what happens next.\nIf the ticket does not say what is wrong, ask for the one detail that is missing.\nDo not promise a refund, a date, or a fix. Sign it \"The support team\".\n\nSubject: {{ticket.subject}}\n{{ticket.body}}\n\nTwo replies that the team liked:\n\nTicket: \"I was charged twice for October.\"\nReply: \"Thank you for telling us about the double charge. Our billing team will check your October invoices and reply within one business day. The support team\"\n\nTicket: \"The export button does nothing.\"\nReply: \"Thank you for the report. Which browser do you use, and does the export fail for every report or only for one? With that, our technical team can look into it. The support team\"\n"
+        },
+        "out": {
+          "reply": {
+            "type": "text",
+            "description": "The reply draft for a support agent to check."
+          }
+        }
+      },
+      "update": {
+        "name": "Update the ticket",
+        "purpose": "Sets the ticket's queue, priority, and tags, and adds the reply draft as an internal note, with one PATCH request. A repeated request sets the same values, so a retry is safe. A ticket whose team is unclear goes to the triage queue.",
+        "in": {
+          "ticket_id": "inputs.ticket_id",
+          "queue": "decision.queue",
+          "priority": "decision.priority",
+          "tags": "decision.tags",
+          "note": "reply",
+          "helpdesk": "environment.helpdesk"
+        },
+        "do": {
+          "kind": "run",
+          "runtime": "node",
+          "entrypoint": "set-ticket.mjs"
+        },
+        "changes": [
+          "environment.helpdesk"
+        ],
+        "effects": {
+          "updated": {
+            "intent": "The ticket has the chosen priority. The queue is not part of this effect, because the move step changes it after a person's answer.",
+            "in": {
+              "ticket_id": "inputs.ticket_id",
+              "priority": "decision.priority"
+            },
+            "observe": {
+              "kind": "http",
+              "path": "/tickets/{inputs.ticket_id}",
+              "expect": {
+                "fields": {
+                  "priority": "{inputs.priority}"
+                }
+              }
+            }
+          }
+        },
+        "out": {
+          "updated": {
+            "type": "record",
+            "fields": {
+              "id": "text",
+              "queue": "text",
+              "priority": "text"
+            },
+            "description": "The queue and priority that the help desk returned."
+          }
+        }
+      },
+      "ask_person": {
+        "name": "Ask a person for the team",
+        "when": "decision.needs_person",
+        "after": "update",
+        "in": {
+          "ticket": "ticket",
+          "reason": "decision.reason"
+        },
+        "ask": "Ticket {{ticket.id}} is in the triage queue: {{reason}}.\nSubject: {{ticket.subject}}\n\nWhich team should handle it: billing, technical, or account?\n",
+        "out": {
+          "chosen_queue": {
+            "type": "text",
+            "description": "billing, technical, or account"
+          }
+        }
+      },
+      "move": {
+        "name": "Move the ticket to the chosen team",
+        "when": "decision.needs_person",
+        "purpose": "Rejects an answer that is not billing, technical, or account. Then sets that queue with one PATCH request and keeps the priority and tags. A repeated request sets the same values.",
+        "in": {
+          "ticket_id": "inputs.ticket_id",
+          "queue": "chosen_queue",
+          "priority": "decision.priority",
+          "tags": "decision.tags",
+          "helpdesk": "environment.helpdesk"
+        },
+        "do": {
+          "kind": "run",
+          "runtime": "node",
+          "entrypoint": "set-ticket.mjs",
+          "args": [
+            "--team-only"
+          ]
+        },
+        "changes": [
+          "environment.helpdesk"
+        ],
+        "effects": {
+          "moved": {
+            "intent": "The ticket is in the queue that the person chose.",
+            "in": {
+              "ticket_id": "inputs.ticket_id",
+              "queue": "chosen_queue"
+            },
+            "observe": {
+              "kind": "http",
+              "path": "/tickets/{inputs.ticket_id}",
+              "expect": {
+                "fields": {
+                  "queue": "{inputs.queue}"
+                }
+              }
+            }
+          }
+        },
+        "out": {
+          "moved": {
+            "type": "record",
+            "fields": {
+              "id": "text",
+              "queue": "text",
+              "priority": "text"
+            },
+            "description": "The queue and priority that the help desk returned."
+          }
+        },
+        "accept": {
+          "unused_output": "The receipt stays in the run record. The result cannot name it, because the step is skipped when the team is clear."
+        }
+      }
+    },
+    "result": {
+      "decision": "decision",
+      "reply": "reply",
+      "ticket": "updated"
+    },
+    "files": [
+      "helpdesk.mjs",
+      "triage.mjs"
+    ]
+  }
+}

package/dist/packages/sdk/examples/support-triage/fake-helpdesk.mjs

@@ -0,0 +1,38 @@
+// A small help desk for trying support-triage.method on this computer. It keeps tickets in memory.
+// Run: HELPDESK_TOKEN=... node fake-helpdesk.mjs [PORT]   (default port 4310; tickets from sample-tickets.json)
+import {createServer} from 'node:http';
+import {readFileSync} from 'node:fs';
+
+/** Starts the help desk. GET /tickets/ID is open, like the read-only observer; PATCH needs the token. */
+export function startHelpdesk({token, tickets, port = 0}) {
+  const store = new Map(tickets.map(ticket => [ticket.id, structuredClone(ticket)]));
+  const patches = [];
+  const server = createServer(async (req, res) => {
+    let text = '';
+    for await (const chunk of req) text += chunk;
+    const send = (status, body) => { res.writeHead(status, {'content-type': 'application/json'}); res.end(JSON.stringify(body)); };
+    const id = /^\/tickets\/([A-Za-z0-9_-]+)$/.exec(req.url ?? '')?.[1];
+    const ticket = id && store.get(id);
+    if (!ticket) return send(404, {error: 'not_found'});
+    if (req.method === 'GET') return send(200, ticket);
+    if (req.method !== 'PATCH') return send(405, {error: 'method_not_allowed'});
+    if (req.headers.authorization !== `Bearer ${token}`) return send(401, {error: 'unauthorized'});
+    const {queue, priority, tags, internal_note} = JSON.parse(text || '{}');
+    patches.push({id, queue, priority, tags, internal_note});
+    Object.assign(ticket, {queue, priority, tags});
+    if (internal_note && !ticket.notes.includes(internal_note)) ticket.notes.push(internal_note);
+    return send(200, ticket);
+  });
+  return new Promise(resolve => server.listen(port, '127.0.0.1', () => resolve({
+    url: `http://127.0.0.1:${server.address().port}`, store, patches,
+    close: () => new Promise(done => { server.closeAllConnections(); server.close(done); }),
+  })));
+}
+
+if (process.argv[1]?.endsWith('fake-helpdesk.mjs')) {
+  const token = process.env.HELPDESK_TOKEN;
+  if (!token) { console.error('Set HELPDESK_TOKEN to the token that PATCH requests must send.'); process.exit(1); }
+  const tickets = JSON.parse(readFileSync(new URL('./sample-tickets.json', import.meta.url), 'utf8'));
+  const desk = await startHelpdesk({token, tickets, port: Number(process.argv[2] ?? 4310)});
+  console.log(`Help desk at ${desk.url} with tickets ${tickets.map(t => t.id).join(', ')}. Stop it with Ctrl-C.`);
+}

package/dist/packages/sdk/examples/support-triage/helpdesk.mjs

@@ -0,0 +1,33 @@
+// Help desk requests for the scripts of support-triage.method. Every request sends HELPDESK_TOKEN and stops after 10 seconds.
+export async function readInput() {
+  let text = '';
+  for await (const chunk of process.stdin) text += chunk;
+  return JSON.parse(text);
+}
+
+export async function helpdesk(base, path, {method = 'GET', body} = {}) {
+  if (typeof base !== 'string' || !/^https?:\/\//.test(base)) throw Error('The helpdesk connection must be an http or https URL.');
+  const token = process.env.HELPDESK_TOKEN;
+  if (!token) throw Error('HELPDESK_TOKEN is not set. Run method secret find, or method secret set HELPDESK_TOKEN.');
+  const response = await fetch(new URL(path, base.endsWith('/') ? base : base + '/'), {
+    method, signal: AbortSignal.timeout(10_000), redirect: 'error',
+    headers: {authorization: `Bearer ${token}`, accept: 'application/json', ...(body ? {'content-type': 'application/json'} : {})},
+    ...(body ? {body: JSON.stringify(body)} : {}),
+  });
+  if (!response.ok) throw Error(`The help desk returned ${response.status} for ${method} ${path}.`);
+  return response.json();
+}
+
+export function ticketPath(id) {
+  if (typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/.test(id)) throw Error('Expected a ticket ID of letters, digits, - and _.');
+  return `tickets/${id}`;
+}
+
+export async function main(run) {
+  try {
+    process.stdout.write(JSON.stringify(await run(await readInput())) + '\n');
+  } catch (error) {
+    process.stderr.write(error.message + '\n');
+    process.exitCode = 1;
+  }
+}

package/dist/packages/sdk/examples/support-triage/inputs.json

@@ -0,0 +1 @@
+{"ticket_id": "T-1042"}

package/dist/packages/sdk/examples/support-triage/read-ticket.mjs

@@ -0,0 +1,8 @@
+import {helpdesk, main, ticketPath} from './helpdesk.mjs';
+
+await main(async ({ticket_id, helpdesk: base}) => {
+  const ticket = await helpdesk(base, ticketPath(ticket_id));
+  if (ticket.id !== ticket_id || typeof ticket.subject !== 'string' || typeof ticket.body !== 'string')
+    throw Error(`The help desk did not return ticket ${ticket_id} with a subject and a body.`);
+  return {ticket: {id: ticket.id, subject: ticket.subject, body: ticket.body}};
+});

package/dist/packages/sdk/examples/support-triage/route.mjs

@@ -0,0 +1,4 @@
+import {main} from './helpdesk.mjs';
+import {route} from './triage.mjs';
+
+await main(async ({team, refund, urgency}) => ({decision: route(team, refund, urgency)}));