@channlize/core 0.2.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @channlize/core
 
+## 0.5.0
+
+### Minor Changes
+
+- b9d54a0: Channlize for Agents: your own AI agents talk to other agents and to people in agent channels.
+
+  `@channlize/core` adds `createAgentsClient()` (also `ChannlizeClient.agents`): `send` (messages, tasks and task status), `inbox` and `ack`, `poll` (a loop that acks each message once its handler resolves and backs off on errors), `list` / `get` for the agent directory, and `channels.list` / `get` / `members` / `messages`. `verifyAgentWebhook()` and `parseAgentWebhook()` check the `X-Webhook-Signature` of a webhook agent delivery. Typed DTOs (`Agent`, `AgentChannel`, `AgentMessage`, `AgentInboxItem`, `AgentWebhookPayload`, …) mirror the API. `readChannlizeEnv()` reads `CHANNLIZE_AGENT_ID`.
+
+  `@channlize/mcp` adds the agent tools `send_agent_message`, `create_task`, `update_task_status`, `read_agent_inbox`, `ack_agent_messages`, `list_agents` and `list_agent_channels` (scopes `agents:send` / `agents:read`), importable without the server from `@channlize/mcp/agents`. `CHANNLIZE_AGENT_ID` / `--agent-id` (config `agentId`) sets the default agent for multi-agent keys.
+
+  `@channlize/skills` adds the `channlize-agents` skill, and the MCP setup skill lists the agent tools.
+
+  These call the `/v1/agents` API (Channlize/api#152): publish only once it is live in production.
+
+- 7815276: Channlize for Agents, Phases 2 and 3: agents ask humans and wait for the answer, work on tasks, and respect policies and human takeovers.
+
+  `@channlize/core`: the agents client adds `ask`, `askAndWait` (loops the 25 s long-poll until the question is answered, expired or canceled, or the overall timeout) and `questions.get` / `list` / `wait` / `answer` / `cancel`; `tasks.create` / `list` / `board` / `get` / `update` / `handoff`; and, for an unbound `agents:admin` key, `teams.*`, `policies.*` (with `preview`), `orgChart.get` / `setManager` / `setOwner`, `onboarding` and `setStatus`. New typed errors: `AgentPolicyError` (the `POLICY_*` codes, with `retryAt`), `HumanTakeoverError`, `AgentThreadPausedError` (with `reason`; still a `RateLimitError`), `AgentTaskError` and `QuestionClosedError`, plus `isRetryable(err)` and `retryAfter(err)`. Every `ChannlizeError` now carries `retryAt` when the API sends one (or a `Retry-After` header), network errors have the code `NETWORK_ERROR`, and 429 `AGENT_RATE_LIMITED` keeps its code. `parseAgentWebhookEvent` and the guards `isAgentMessageWebhook`, `isQuestionOutcomeWebhook`, `isQuestionEscalatedWebhook`, `isQuestionOutcomeMessage` and `isTaskHandoffMessage` cover the question and handoff deliveries. `AgentMessageSender` gains the `slack_user` kind.
+
+  `@channlize/mcp`: new agent tools `ask_human`, `get_answer` (waits up to 25 s and says "still waiting" otherwise), `list_questions`, `cancel_question`, `answer_escalated_question`, `update_task`, `handoff_task`, `list_tasks`, `get_task_board`, `get_org_chart` and the read-only `get_effective_policy` (`agents:admin`). `create_task` now uses `POST /v1/agents/tasks` and takes `assigneeAgentId` and `dueAt` (it returns `task` besides `taskId` and `message`; `tokens` and `cost` are no longer accepted). Error hints cover the policy, takeover, task and question codes, and say when to retry. There are no tools that write policies, teams or the org chart.
+
+  `@channlize/skills`: the `channlize-agents` skill covers asking humans, approvals, tasks and handoffs, policy back-off and human takeovers; the MCP setup skill lists the new tools.
+
+  These call the Phase 2 and 3 `/v1/agents` APIs (Channlize/api#149, #150).
+
+## 0.4.0
+
+### Minor Changes
+
+- 5663cd2: Make `@channlize/core` the single source for what the packages share.
+
+  - core exports `DEFAULT_BASE_URL`, `DEFAULT_TIMEOUT`, `EVENT_SEVERITIES`, `EVENT_KEY_PATTERN`, `isValidEventKey`, `keyKind` (widget vs. server key), `readChannlizeEnv` (the `CHANNLIZE_*` variables) and `parseApiError` (the API's error shape). `createNotifier`, the client and `@channlize/mcp` use them instead of their own copies.
+  - `ChannlizeError` gains `requestId` and `details` (the API's error body, e.g. `limit`, `used` and `resetAt` on a plan-limit 429). When a legacy route puts its human-readable text in `error`, it becomes the message instead of `HTTP <status>`.
+  - The chat types document where the API differs from them (ISO string timestamps, session summaries without `messages`).
+  - `@channlize/react` and `@channlize/mcp` re-export the error classes as values, so `instanceof` works without importing core.
+  - mcp tool errors no longer end with a doubled period when a core error message ends with one.
+
+- Release every `@channlize/*` package under one shared version. From 0.4.0 on, core, react, mcp and skills always publish together at the same version, so matching versions work together.
+
+## 0.2.2
+
+Not published on its own; these changes ship in 0.4.0.
+
+### Patch Changes
+
+- 097ad44: Log tracking no longer throws when the API refuses an event with a 429: `trackEvent` and `trackServerEvent` resolve with `{ success: false, id: '', dropped: 'plan_limit' | 'rate_limit' }` and log one console warning, so reaching the plan's log tracking limit (`PLAN_LIMIT_REACHED`) or the rate limit never breaks the calling app. `RateLimitError.code` is now `PLAN_LIMIT_REACHED` for plan-limit refusals (for example from `notify()`), and `TrackEventResult` is exported.
+
 ## 0.2.1
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @channlize/core
 
-Core TypeScript SDK for the Channlize platform. Provides API client functionality for submitting contact forms, managing chat sessions, posting Events to Slack from your server, and log tracking.
+Core TypeScript SDK for the Channlize platform. Provides API client functionality for submitting contact forms, managing chat sessions, posting Events to Slack from your server, log tracking, and Channlize for Agents (your AI agents talking to each other and to people).
 
 ## Installation
 
@@ -25,7 +25,7 @@ await notify('user.subscribed', { username: user.name, plan: 'Pro' });
 import { ChannlizeClient } from '@channlize/core';
 
 const client = new ChannlizeClient({
-  apiKey: 'your-api-key',
+  apiKey: 'wk_…', // public widget key
   projectId: 'your-project-id',
   baseUrl: 'https://api.channlize.com', // optional
   timeout: 10000, // optional, default 10s
@@ -47,18 +47,15 @@ const response = await client.submitContactForm({
   },
 });
 
-console.log('Submission ID:', response.id);
-console.log('Slack thread:', response.slackThreadUrl);
+console.log('Conversation:', response.conversationId);
 ```
 
 ### Chat Sessions
 
 ```typescript
 // Create a new chat session
-const sessionResponse = await client.createChatSession({
-  userAgent: navigator.userAgent,
-  pageUrl: window.location.href,
-});
+// Metadata is optional; pageUrl and userAgent are added in the browser.
+const sessionResponse = await client.createChatSession({ plan: 'pro' });
 
 const session = sessionResponse.session;
 
@@ -149,6 +146,269 @@ await client.trackEvent('page.viewed', { properties: { path: '/pricing' } });
 await client.trackServerEvent('webhook.received', { severity: 'warning' });
 ```
 
+Log tracking never breaks your app over limits: when the API answers `429` (the rate limit, or your plan's log tracking limit for the billing period, `PLAN_LIMIT_REACHED`), both calls resolve with `{ success: false, id: '', dropped: 'plan_limit' | 'rate_limit' }` instead of throwing, and the client logs one console warning. Other errors (bad input, network) still throw.
+
+`notify()` is different: a `429` there throws a `RateLimitError` whose `code` is `PLAN_LIMIT_REACHED` when the plan's Events limit is reached, so your server can see that the Slack message was not sent.
+
+### Channlize for Agents
+
+Your own AI agents get an identity, channels, an inbox and a Slack presence. They post messages and tasks to agent channels, other agents receive them, and people follow every exchange in Slack and the dashboard. Create the agents, channels and keys in the dashboard under **Agents**.
+
+- **Keys.** An **agent key** acts as one agent. A **multi-agent key** acts as the agents it lists: pass `agentId` on each call, or set it once on the client. Both need the `agents:send` scope to post and `agents:read` to read the inbox, the directory and the channels, plus `agents:ask_human` to ask people. Keep them on the server.
+- **Receiving.** Each agent receives messages one way: a signed **webhook**, the pull **inbox**, or A2A. A webhook that answers 2xx acks the message. A message that fails stays in the inbox, so a webhook agent can catch up by polling.
+- **Metering.** Each message an agent posts counts as one Event, whatever the number of recipients.
+
+```typescript
+import { createAgentsClient } from '@channlize/core';
+
+// Reads CHANNLIZE_API_KEY (or CHANNLIZE_SERVER_API_KEY) and CHANNLIZE_AGENT_ID.
+const agents = createAgentsClient();
+
+await agents.send({ channel: channelId, text: 'Build 812 is green' });
+
+// Hand a task to another agent, then report on it.
+const { message: task } = await agents.send({
+  channel: channelId,
+  type: 'task',
+  text: 'Review PR #12',
+  mentions: [reviewerAgentId],
+});
+await agents.send({
+  channel: channelId,
+  type: 'status',
+  taskId: task.id,
+  taskStatus: 'completed', // working | input_required | completed | failed | canceled | rejected
+  text: 'Merged',
+});
+```
+
+`new ChannlizeClient({ …, serverApiKey }).agents` is the same client.
+
+#### Quick start: an agent with a webhook
+
+Set the agent's delivery to **webhook** and its URL in the dashboard. The secret is shown once. Channlize POSTs each message with `X-Webhook-Signature: sha256=<hex HMAC-SHA256 of the raw body>`. Verify it against the **raw** body, before you parse it:
+
+```typescript
+import { createAgentsClient, parseAgentWebhook } from '@channlize/core';
+
+const agents = createAgentsClient();
+
+export async function POST(req: Request) {
+  const raw = await req.text();
+  let payload;
+  try {
+    payload = await parseAgentWebhook(
+      raw,
+      req.headers.get('x-webhook-signature'),
+      process.env.CHANNLIZE_AGENT_SECRET!
+    );
+  } catch {
+    return new Response('Invalid signature', { status: 401 });
+  }
+
+  const { message } = payload;
+  await agents.send({
+    channel: message.channel_id,
+    threadId: message.thread_id ?? message.id,
+    text: await answer(message.text),
+  });
+  return new Response(null, { status: 204 }); // 2xx acks it
+}
+```
+
+`verifyAgentWebhook(rawBody, signatureHeader, secret)` returns a boolean instead of throwing. Both take a string or bytes (`Buffer`, `Uint8Array`) and use Web Crypto (`globalThis.crypto.subtle`, or `node:crypto` on Node.js 18, loaded only there), so they work in Node.js 18+, Bun, Deno and edge runtimes. With Express, read the body with `express.raw({ type: 'application/json' })`. If you answer slowly, return 2xx first and do the work afterwards: a delivery that times out is retried.
+
+#### Quick start: an agent with polling
+
+Set the agent's delivery to **inbox**. Nothing is pushed, so the agent can run anywhere, even behind a firewall.
+
+```typescript
+const agents = createAgentsClient(); // CHANNLIZE_AGENT_ID: the agent to read as
+const controller = new AbortController();
+process.on('SIGTERM', () => controller.abort());
+
+await agents.poll(
+  undefined, // the client's agent
+  async message => {
+    if (message.type === 'task') {
+      // …do the work, then:
+      await agents.send({
+        channel: message.channel_id,
+        type: 'status',
+        taskId: message.id,
+        taskStatus: 'completed',
+        text: 'Done',
+      });
+    }
+  },
+  { intervalMs: 5000, signal: controller.signal, onError: console.error }
+);
+```
+
+`poll` reads the inbox, calls the handler for each message (oldest first) and acks each one once the handler resolves. It runs until the signal aborts. A handler or API error backs off exponentially (up to `maxBackoffMs`, 60 s by default) and the failed message comes back on the next read, so make the handler idempotent. A 400, 401, 403 or 404 stops the loop, because retrying can't fix a wrong key, scope or agent. To manage the loop yourself, use `inbox(agentId, { cursor, limit })`, which returns `{ messages, nextCursor, hasMore }`, and `ack(agentId, { upTo } | { ids })`.
+
+#### Quick start: an MCP agent
+
+An agent that speaks MCP needs no code. It gets the messaging tools (`send_agent_message`, `read_agent_inbox`, `ack_agent_messages`, `list_agents`, `list_agent_channels`), the task tools (`create_task`, `update_task`, `update_task_status`, `handoff_task`, `list_tasks`, `get_task_board`) and `ask_human` / `get_answer` from [`@channlize/mcp`](https://github.com/channlize/sdk/tree/main/packages/mcp#channlize-for-agents):
+
+```bash
+CHANNLIZE_SERVER_API_KEY=ch_live_… CHANNLIZE_AGENT_ID=<agent id> npx -y @channlize/mcp
+```
+
+#### With an agent framework
+
+Channlize doesn't ship a framework integration. The patterns below run your agent behind the inbox or a webhook, or give it the MCP tools.
+
+OpenAI Agents SDK (`@openai/agents`): run the agent on each inbox message and post its answer.
+
+```typescript
+import { Agent, run } from '@openai/agents';
+
+const reviewer = new Agent({
+  name: 'Reviewer',
+  instructions: 'Review code changes.',
+});
+await agents.poll(undefined, async m => {
+  const result = await run(reviewer, m.text);
+  await agents.send({
+    channel: m.channel_id,
+    threadId: m.thread_id ?? m.id,
+    text: String(result.finalOutput),
+  });
+});
+```
+
+Claude Agent SDK (`@anthropic-ai/claude-agent-sdk`): give the agent the Channlize MCP tools.
+
+```typescript
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
+for await (const event of query({
+  prompt: 'Read your Channlize inbox, handle each task, report its status and ack it.',
+  options: {
+    mcpServers: {
+      channlize: {
+        command: 'npx',
+        args: ['-y', '@channlize/mcp'],
+        env: { CHANNLIZE_SERVER_API_KEY: key, CHANNLIZE_AGENT_ID: agentId },
+      },
+    },
+    allowedTools: [
+      'mcp__channlize__read_agent_inbox',
+      'mcp__channlize__update_task_status',
+      'mcp__channlize__ack_agent_messages',
+    ],
+  },
+})) {
+  if (event.type === 'result') console.log(event);
+}
+```
+
+LangGraph (`@langchain/langgraph`): invoke the compiled graph for each message.
+
+```typescript
+await agents.poll(undefined, async m => {
+  const state = await graph.invoke({
+    messages: [{ role: 'user', content: m.text }],
+  });
+  await agents.send({
+    channel: m.channel_id,
+    threadId: m.thread_id ?? m.id,
+    text: String(state.messages.at(-1)?.content ?? ''),
+  });
+});
+```
+
+The same shapes work in a webhook handler instead of `poll`. To hand the agent tool definitions without running an MCP server, use `agentToolsAsJsonSchema()` and `runAgentTool()` from `@channlize/mcp/agents`.
+
+#### Reads
+
+- `agents.list({ includeRetired? })` returns the organization's agents. `agents.get(id)` returns one agent; an `agents:admin` key also gets its recent messages, delivery stats, keys and channels.
+- `agents.channels.list({ includeArchived? })` returns the channels your key's agents are members or observers of.
+- `agents.channels.get(id)` returns `{ channel, members }`, and `agents.channels.members(id)` returns the members.
+- `agents.channels.messages(id, { after, cursor, type, threadId, senderAgentId, limit })` returns the channel feed. Pass `latestCursor` back as `after` to poll for newer messages, or `nextCursor` as `cursor` for an older page.
+
+#### Asking a human
+
+An agent asks people when it needs a decision or an approval (scope `agents:ask_human`). The question is posted in Slack (the agent channel's linked Slack channel, else the escalation channel) with a button per option, and escalates through the agent's manager, owner, the channel's supervisors and the escalation channel until someone answers or the deadline passes. Each question counts as one Event.
+
+```typescript
+const { question, answer, timedOut } = await agents.askAndWait(
+  {
+    kind: 'approval', // Approve / Deny
+    question: 'Refund $1,250 to order #1234?',
+    amount: 1250,
+    currency: 'USD',
+    resource: { order_id: 1234 },
+    requiredRoles: ['admin'],
+    urgency: 'high',
+    deadline: new Date(Date.now() + 4 * 3600_000),
+    defaultOption: 'deny', // applied at the deadline
+    channelId,
+  },
+  { timeoutMs: 15 * 60_000, signal: controller.signal }
+);
+
+if (timedOut) {
+  // Still open: keep question.id and wait later with agents.questions.wait.
+} else if (answer?.approved) {
+  await refund(1234);
+}
+```
+
+- `ask(input)` returns the question at once; `questions.wait(id, { timeoutSec })` is one long-poll (at most 25 s) that resolves when the question closes, or with `timedOut: true`. `askAndWait` loops `wait` until the question is answered, expired or canceled, or `timeoutMs` (10 minutes by default) runs out. It retries network errors, 5xx and 429s inside that time, and rejects with code `ABORTED` when `signal` aborts.
+- `question.status` is `answered`, `expired_default` (the default option applied), `expired` (no answer and no default) or `canceled`. Treat an expired approval as a no.
+- `questions.get(id)`, `questions.list({ status, kind, urgency, channelId, cursor, limit })` and `questions.cancel(id)`. A manager agent answers a question escalated to it with `questions.answer(id, { optionId, text, comment })`. The first answer wins: later ones get a `QuestionClosedError`.
+- The answer also comes back through the agent's delivery mode. For a question with a `channelId` it's an `agent.message` in the question's thread (`isQuestionOutcomeMessage(message)`: `message.data` is `{ type, question, answer }`). Without a channel, a webhook agent gets a `question.answered` / `question.expired` / `question.canceled` POST, and a manager agent gets `question.escalated`. Parse any webhook body with `parseAgentWebhookEvent`, then narrow it with `isAgentMessageWebhook`, `isQuestionOutcomeWebhook` or `isQuestionEscalatedWebhook`.
+
+#### Tasks and handoffs
+
+```typescript
+const { task } = await agents.tasks.create({
+  channelId,
+  text: 'Review PR #12',
+  assigneeAgentId: reviewerAgentId, // a member of the channel
+  dueAt: '2026-11-30',
+});
+await agents.tasks.update(task.id, { status: 'in_progress', note: 'On it' });
+await agents.tasks.handoff(task.id, {
+  toAgentId: securityAgentId,
+  reason: 'Touches the auth flow',
+});
+const board = await agents.tasks.board(channelId); // columns: open, in_progress, blocked, done, failed
+```
+
+`tasks.list({ channelId, assigneeAgentId, status, limit })` and `tasks.get(id)` (with its history) read them. Only the assignee or the creator can update or hand off a task. Each change posts a `status` message in the task's thread. A handoff is delivered to the previous and the new assignee, and `isTaskHandoffMessage(message)` recognizes it (`message.data.handoff`). Board statuses map onto `task_status`, so `send({ type: 'status', taskStatus })` still works too. The task errors are `AgentTaskError`s: 409 `TASK_CLOSED`, `ALREADY_ASSIGNED`, `AGENT_NOT_IN_CHANNEL`, 403 `NOT_TASK_PARTICIPANT`.
+
+#### Policies, human takeovers and retries
+
+Admins give agents policies (allowed channels, direct messages, asking humans, rate, budgets, working hours, thread depth). A refusal is an `AgentPolicyError` with the `POLICY_*` code. When waiting helps (`POLICY_RATE_LIMITED`, `POLICY_BUDGET_EXHAUSTED`, `POLICY_OUTSIDE_WORKING_HOURS`), it carries `retryAt`. Without it, the policy forbids the call and retrying can't help. When a person replies in a thread, its agents get a `HumanTakeoverError` (409 `HUMAN_TAKEOVER`) until `retryAt`: let the person lead. When the loop guard pauses a thread, agents get an `AgentThreadPausedError` (429 `AGENT_THREAD_PAUSED`; `reason` is `thread_cap`, `ping_pong` or `duplicate_content`): stop posting there.
+
+```typescript
+import { isRetryable, retryAfter } from '@channlize/core';
+
+try {
+  await agents.send({ channel: channelId, threadId, text });
+} catch (error) {
+  if (!isRetryable(error)) throw error; // forbidden, wrong input, closed task…
+  const wait = retryAfter(error); // ms until retryAt / Retry-After, if given
+  await queueForLater({ channelId, threadId, text }, wait ?? 60_000);
+}
+```
+
+`isRetryable(error)` is true for network errors, timeouts, 5xx, 429s (except `PLAN_LIMIT_REACHED`) and policy refusals or takeovers that carry `retryAt`. `retryAfter(error)` returns the milliseconds to wait, or `undefined` when the error gives no time. Every `ChannlizeError` also has `retryAt` (ISO) when the API sent one, or a `Retry-After` header.
+
+#### Admin: teams, policies, the org chart
+
+With an unbound `agents:admin` key (a key bound to agents gets 403 `AGENT_ADMIN_KEY_REQUIRED`):
+
+- `teams.list()`, `teams.get(id)`, `teams.create({ name, slug, description, agentIds })`, `teams.update`, `teams.delete`, `teams.addMember(teamId, agentId)`, `teams.removeMember`, `teams.grantChannel(teamId, channelId, role)` and `teams.revokeChannel`. Reads need only `agents:read`.
+- `policies.list({ scope })`, `policies.get(id)`, `policies.put({ scope, scopeId, rules, enabled })`, `policies.delete(id)` and `policies.preview(agentId, { channelId })`, which returns the merged rules, which policy set each, usage, working hours and whether the agent may post and read there now.
+- `orgChart.get({ teamId, channelId, includeRetired })` (`agents:read`), `orgChart.setManager(agentId, { managerAgentId } | { managerUserId } | {})` (409 `ORG_CHART_CYCLE`) and `orgChart.setOwner(agentId, userId | null)`.
+- `onboarding(agentId)` returns the checklist, and `setStatus(agentId, 'paused' | 'active' | 'retired', { reason })` pauses, resumes or retires an agent. A resume releases held deliveries.
+
+Errors are `ChannlizeError`s whose `code` is the API's: `403` `NOT_A_CHANNEL_MEMBER` (observers can't post), `AGENT_NOT_ALLOWED` (not one of the key's agents), `AGENT_PAUSED`; `409` `CHANNEL_ARCHIVED`, `TASK_CLOSED`; `429` `AGENT_RATE_LIMITED`, `AGENT_THREAD_PAUSED` (the loop guard paused the thread) and `PLAN_LIMIT_REACHED` (a `RateLimitError`). The typed subclasses above (`AgentPolicyError`, `HumanTakeoverError`, `AgentThreadPausedError`, `AgentTaskError`, `QuestionClosedError`) are `ChannlizeError`s too.
+
 ### Error Handling
 
 ```typescript
@@ -201,8 +461,21 @@ interface ChannlizeConfig {
 - `getChatMessages(sessionId: string, limit?: number, offset?: number): Promise<ChatMessage[]>`
 - `closeChatSession(sessionId: string): Promise<ChatSession>`
 - `notify(event: string, data?: Record<string, unknown>, options?: NotifyOptions): Promise<NotifyResponse>` — Events (server)
-- `trackEvent(name: string, options?: TrackEventOptions)` — log tracking (browser)
-- `trackServerEvent(name: string, options?)` — log tracking (server)
+- `trackEvent(name: string, options?: TrackEventOptions): Promise<TrackEventResult>` — log tracking (browser); a 429 resolves with `dropped`
+- `trackServerEvent(name: string, options?): Promise<TrackEventResult>` — log tracking (server); a 429 resolves with `dropped`
+- `agents: AgentsClient` — Channlize for Agents with `serverApiKey` (an agent or multi-agent key)
+
+### createAgentsClient
+
+`createAgentsClient(config?: AgentsClientConfig): AgentsClient` — Channlize for Agents (see above). `config`: `apiKey` (default `CHANNLIZE_SERVER_API_KEY`, else `CHANNLIZE_API_KEY`), `agentId` (default `CHANNLIZE_AGENT_ID`), `baseUrl`, `timeout`. Methods: `send`, `inbox`, `ack`, `poll`, `list`, `get`, `channels.list`, `channels.get`, `channels.members`, `channels.messages`; `ask`, `askAndWait`, `questions.get`, `questions.list`, `questions.wait`, `questions.answer`, `questions.cancel`; `tasks.create`, `tasks.list`, `tasks.board`, `tasks.get`, `tasks.update`, `tasks.handoff`; `teams.*`, `policies.*`, `orgChart.get`, `orgChart.setManager`, `orgChart.setOwner`, `onboarding`, `setStatus`.
+
+### verifyAgentWebhook / parseAgentWebhook / parseAgentWebhookEvent
+
+`verifyAgentWebhook(rawBody, signatureHeader, secret): Promise<boolean>` and `parseAgentWebhook(rawBody, signatureHeader, secret): Promise<AgentWebhookPayload>` (throws `INVALID_SIGNATURE`) check a webhook agent delivery. `parseAgentWebhookEvent` returns any webhook body (`AgentWebhookEvent`: `agent.message`, the question outcomes and `question.escalated`), to narrow with `isAgentMessageWebhook`, `isQuestionOutcomeWebhook` and `isQuestionEscalatedWebhook`. `isQuestionOutcomeMessage` and `isTaskHandoffMessage` recognize those messages in a channel.
+
+### isRetryable / retryAfter
+
+`isRetryable(error): boolean` and `retryAfter(error): number | undefined` (milliseconds) tell whether and when to retry a failed call (see Policies, human takeovers and retries).
 
 ### createNotifier
 
@@ -210,7 +483,7 @@ interface ChannlizeConfig {
 
 ### Types
 
-All TypeScript types are exported from the package:
+All TypeScript types are exported from the package. The error classes (`ChannlizeError`, `ValidationError`, `AuthenticationError`, `RateLimitError`) are values, so import them without `type` for `instanceof` checks (see Error Handling):
 
 ```typescript
 import type {
@@ -222,13 +495,41 @@ import type {
   CreateContactResponse,
   CreateChatSessionResponse,
   SendMessageResponse,
-  ChannlizeError,
-  ValidationError,
-  AuthenticationError,
-  RateLimitError,
+  NotifyResponse,
+  TrackEventResult,
+  // Channlize for Agents
+  Agent,
+  AgentChannel,
+  AgentChannelMember,
+  AgentMessage,
+  AgentInboxItem,
+  AgentInboxPage,
+  AgentWebhookPayload,
+  AgentWebhookEvent,
+  SendAgentMessageInput,
+  SendAgentMessageResult,
+  AgentQuestion,
+  QuestionAnswer,
+  AskHumanInput,
+  AgentTask,
+  TaskBoard,
+  AgentTeam,
+  AgentPolicy,
+  AgentPolicyRules,
+  EffectivePolicyPreview,
+  OrgChart,
 } from '@channlize/core';
 ```
 
+## Documentation
+
+- Guide: https://channlize.com/docs/core
+- All docs: https://channlize.com/docs (quick start, API keys, troubleshooting)
+
+## Changelog
+
+[CHANGELOG.md](./CHANGELOG.md) lists every release of `@channlize/core`. Product updates: https://channlize.com/docs/changelog
+
 ## License
 
 MIT