@channlize/mcp 0.3.0 → 0.5.0

package/dist/server.js

@@ -33,21 +33,108 @@ var import_stdio = require("@modelcontextprotocol/server/stdio");
 // src/api.ts
 var import_core = require("@channlize/core");
 var ToolError = class extends Error {
-  constructor(message, statusCode, code) {
-    super(message);
+  constructor(message2, statusCode, code, retryAt) {
+    super(message2);
     this.statusCode = statusCode;
     this.code = code;
+    this.retryAt = retryAt;
     this.name = "ToolError";
   }
   statusCode;
   code;
+  retryAt;
 };
-function hintFor(status, apiMessage) {
+function scopeFor(apiMessage) {
+  const perm = /permission:\s*([\w:*-]+)/i.exec(apiMessage)?.[1] ?? "";
+  switch (perm) {
+    case "inbox:read":
+      return "inbox:read (or read)";
+    case "inbox:write":
+      return "inbox:write";
+    case "routing:read":
+      return "routing:write, inbox:read (or read)";
+    case "routing:write":
+      return "routing:write";
+    case "analytics:read":
+      return "analytics:read (or read)";
+    case "agents:send":
+      return "agents:send";
+    case "agents:read":
+      return "agents:read";
+    case "agents:ask_human":
+      return "agents:ask_human";
+    case "agents:admin":
+      return "agents:admin (an unbound key)";
+    default:
+      return /write|notify/.test(apiMessage) ? "write" : "read";
+  }
+}
+function retryText(retryAt) {
+  return retryAt ? ` Retry after ${retryAt}, not before.` : "";
+}
+function agentHint(code, body = {}) {
+  const retryAt = typeof body.retryAt === "string" ? body.retryAt : void 0;
+  switch (code) {
+    case "AGENT_KEY_REQUIRED":
+      return "Agent tools need an agent key or a multi-agent key: create one under SDK & Integration \u2192 API keys and pick the agents.";
+    case "AGENT_NOT_ALLOWED":
+      return "The key can't act as that agent: pass one of the key's agents as agentId (list_agents), or fix CHANNLIZE_AGENT_ID.";
+    case "NOT_A_CHANNEL_MEMBER":
+      return "Only channel members can post (observers only read): use list_agent_channels, or ask an admin to add the agent to the channel.";
+    case "AGENT_PAUSED":
+    case "AGENT_RETIRED":
+      return "Only active agents can act: ask an admin to reactivate it in the dashboard.";
+    case "AGENT_RATE_LIMITED":
+      return "The agent is sending too fast: wait a minute before sending again.";
+    case "AGENT_THREAD_PAUSED": {
+      const why = body.reason === "ping_pong" ? " (two agents were going back and forth)" : body.reason === "duplicate_content" ? " (the same message kept being posted)" : "";
+      return `The loop guard paused this thread${why}: stop sending in it until a person replies or resumes it. Don't rephrase and retry.`;
+    }
+    case "HUMAN_TAKEOVER":
+      return `A person took over this thread: don't post in it until the takeover ends or they hand it back.${retryText(retryAt)}`;
+    case "POLICY_RATE_LIMITED":
+    case "POLICY_BUDGET_EXHAUSTED":
+    case "POLICY_OUTSIDE_WORKING_HOURS":
+      return `The agent's policy refuses this for now: wait, don't retry in a loop.${retryText(retryAt)}`;
+    case "POLICY_CHANNEL_NOT_ALLOWED":
+    case "POLICY_DM_NOT_ALLOWED":
+    case "POLICY_ASK_HUMAN_NOT_ALLOWED":
+    case "POLICY_URGENCY_NOT_ALLOWED":
+    case "POLICY_MAX_DEPTH":
+      return "The agent's policy forbids this: retrying won't help. Pick another channel, agent or urgency, or ask an admin to change the policy.";
+    case "TASK_CLOSED":
+      return "The task is closed (completed, failed, canceled or rejected) and cannot change: create a new task instead.";
+    case "ALREADY_ASSIGNED":
+      return "The task is already assigned to that agent.";
+    case "AGENT_NOT_IN_CHANNEL":
+      return "The other agent isn't a member of the task's channel: pick a member (list_agent_channels), or ask an admin to add it.";
+    case "NOT_TASK_PARTICIPANT":
+      return "Only the task's assignee or creator can change it or hand it off.";
+    case "QUESTION_CLOSED":
+      return "The question is already closed (answered, expired or canceled): the first answer wins. Read it with get_answer.";
+    case "APPROVAL_ROLE_REQUIRED":
+      return "This approval needs a person with the required role: an agent cannot answer it.";
+    case "AGENT_ADMIN_KEY_REQUIRED":
+      return "This needs an unbound agents:admin key (not a key bound to agents): create one under SDK & Integration \u2192 API keys.";
+    case "INVALID_ANSWER":
+      return "Answer with one of the question's option ids (approve / deny for approvals), or text when free text is allowed.";
+    default:
+      return void 0;
+  }
+}
+function hintFor(status, apiMessage, code, body) {
+  const agent = agentHint(code, body);
+  if (agent) return `${apiMessage}. ${agent}`;
+  if (status === 400 && /agent_id is required/i.test(apiMessage)) {
+    return `${apiMessage}. Pass agentId (from list_agents), or set CHANNLIZE_AGENT_ID / --agent-id on the MCP server.`;
+  }
   switch (status) {
     case 401:
       return `${apiMessage}. The server API key is invalid, revoked or expired: create a new one under SDK & Integration \u2192 API keys and update CHANNLIZE_SERVER_API_KEY.`;
     case 403:
-      return /permission/i.test(apiMessage) ? `${apiMessage}. This needs a server API key with the ${/write|notify/.test(apiMessage) ? "write" : "read"} scope: create one under SDK & Integration \u2192 API keys.` : apiMessage;
+      return /permission/i.test(apiMessage) ? `${apiMessage}. This needs a server API key with the ${scopeFor(
+        apiMessage
+      )} scope: create one under SDK & Integration \u2192 API keys.` : apiMessage;
     case 404:
       return `${apiMessage}. Check the ID (and CHANNLIZE_PROJECT_ID): it must belong to the key's organization.`;
     case 429:
@@ -60,9 +147,15 @@ function toToolError(err) {
   if (err instanceof ToolError) return err;
   if (err instanceof import_core.ChannlizeError) {
     return new ToolError(
-      err.statusCode ? hintFor(err.statusCode, err.message) : err.message,
+      err.statusCode ? hintFor(
+        err.statusCode,
+        err.message.replace(/\.$/, ""),
+        err.code,
+        err.details
+      ) : err.message,
       err.statusCode,
-      err.code
+      err.code,
+      err.retryAt
     );
   }
   return new ToolError(err instanceof Error ? err.message : String(err));
@@ -80,6 +173,10 @@ var ChannlizeApi = class {
   get hasWidgetKey() {
     return !!this.config.widgetKey;
   }
+  /** The default agent for the agent tools (`CHANNLIZE_AGENT_ID`). */
+  get agentId() {
+    return this.config.agentId;
+  }
   requireServerKey() {
     if (!this.config.serverApiKey) {
       throw new ToolError(
@@ -88,9 +185,10 @@ var ChannlizeApi = class {
     }
     return this.config.serverApiKey;
   }
-  async request(method, path, options = {}) {
+  async request(method, path2, options = {}) {
     const key = this.requireServerKey();
-    const url2 = new URL(`${this.config.baseUrl}${path}`);
+    const timeout = options.timeout ?? this.config.timeout;
+    const url2 = new URL(`${this.config.baseUrl}${path2}`);
     for (const [k, v] of Object.entries(options.query ?? {})) {
       if (v !== void 0 && v !== "") url2.searchParams.set(k, String(v));
     }
@@ -104,14 +202,15 @@ var ChannlizeApi = class {
           ...options.body !== void 0 ? { "Content-Type": "application/json" } : {},
           ...options.headers
         },
+        // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- `method` is dynamic; GET calls never pass a body.
         body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
-        signal: AbortSignal.timeout(this.config.timeout)
+        signal: AbortSignal.timeout(timeout)
       });
     } catch (err) {
       const e = err;
       if (e.name === "TimeoutError" || e.name === "AbortError") {
         throw new ToolError(
-          `Channlize API timed out after ${this.config.timeout} ms (${method} ${url2.pathname}). Retry, or raise CHANNLIZE_TIMEOUT.`,
+          `Channlize API timed out after ${timeout} ms (${method} ${url2.pathname}). Retry, or raise CHANNLIZE_TIMEOUT.`,
           408,
           "TIMEOUT"
         );
@@ -121,30 +220,34 @@ var ChannlizeApi = class {
       );
     }
     const text = await res.text();
-    let data = void 0;
+    let data2 = void 0;
     if (text) {
       try {
-        data = JSON.parse(text);
+        data2 = JSON.parse(text);
       } catch {
-        data = void 0;
+        data2 = void 0;
       }
     }
     if (!res.ok) {
-      const body = data ?? {};
-      const raw = Array.isArray(body.message) ? body.message.join(", ") : body.message;
-      const apiMessage = raw || (typeof body.error === "string" && /\s/.test(body.error) ? body.error : "") || `HTTP ${res.status} ${res.statusText}`.trim();
+      const { message: message2, code, body } = (0, import_core.parseApiError)(
+        res.status,
+        data2,
+        res.statusText
+      );
+      const retryAt = typeof body.retryAt === "string" ? body.retryAt : void 0;
       throw new ToolError(
-        hintFor(res.status, apiMessage.replace(/\.$/, "")),
+        hintFor(res.status, message2.replace(/\.$/, ""), code, body),
         res.status,
-        body.code ?? (typeof body.error === "string" ? body.error : void 0)
+        code,
+        retryAt
       );
     }
-    if (data === void 0) {
+    if (data2 === void 0) {
       throw new ToolError(
         `Unexpected non-JSON response from ${method} ${url2.pathname}`
       );
     }
-    return data;
+    return data2;
   }
   /**
    * `CHANNLIZE_PROJECT_ID`, or the first project of the key's organization
@@ -198,17 +301,14 @@ var ChannlizeApi = class {
 };
 
 // src/config.ts
-var DEFAULT_BASE_URL = "https://api.channlize.com";
-var DEFAULT_TIMEOUT = 1e4;
+var import_core2 = require("@channlize/core");
 var ConfigError = class extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message2) {
+    super(message2);
     this.name = "ConfigError";
   }
 };
-function keyKind(key) {
-  return key.startsWith("wk_") ? "widget" : "server";
-}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function clean(value) {
   const v = value?.trim();
   return v ? v : void 0;
@@ -217,18 +317,18 @@ function resolveConfig(config) {
   let serverApiKey = clean(config.serverApiKey);
   let widgetKey = clean(config.widgetKey);
   const apiKey = clean(config.apiKey);
-  if (serverApiKey && keyKind(serverApiKey) === "widget") {
+  if (serverApiKey && (0, import_core2.keyKind)(serverApiKey) === "widget") {
     throw new ConfigError(
       "CHANNLIZE_SERVER_API_KEY / --server-api-key holds a widget key (wk_\u2026). Widget keys are public and only work for the visitor tools: pass it as CHANNLIZE_WIDGET_KEY / --widget-key, and create a server API key (ch_live_\u2026) under SDK & Integration \u2192 API keys in the Channlize dashboard."
     );
   }
-  if (widgetKey && keyKind(widgetKey) === "server") {
+  if (widgetKey && (0, import_core2.keyKind)(widgetKey) === "server") {
     throw new ConfigError(
       "CHANNLIZE_WIDGET_KEY / --widget-key holds a server API key. Pass server keys (ch_live_\u2026) as CHANNLIZE_SERVER_API_KEY / --server-api-key; widget keys start with wk_."
     );
   }
   if (apiKey) {
-    if (keyKind(apiKey) === "widget") widgetKey ??= apiKey;
+    if ((0, import_core2.keyKind)(apiKey) === "widget") widgetKey ??= apiKey;
     else serverApiKey ??= apiKey;
   }
   if (!serverApiKey && !widgetKey) {
@@ -236,13 +336,13 @@ function resolveConfig(config) {
       "A Channlize key is required. Set CHANNLIZE_SERVER_API_KEY (or --server-api-key) to a server API key (ch_live_\u2026) from SDK & Integration \u2192 API keys in the Channlize dashboard. Use a read-scoped key for read-only access, or add the write scope to send events, logs and conversations."
     );
   }
-  const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+  const timeout = config.timeout ?? import_core2.DEFAULT_TIMEOUT;
   if (!Number.isFinite(timeout) || timeout <= 0) {
     throw new ConfigError(
       `Invalid timeout "${config.timeout}": use milliseconds, e.g. 10000`
     );
   }
-  const baseUrl = (clean(config.baseUrl) ?? DEFAULT_BASE_URL).replace(
+  const baseUrl = (clean(config.baseUrl) ?? import_core2.DEFAULT_BASE_URL).replace(
     /\/+$/,
     ""
   );
@@ -250,26 +350,35 @@ function resolveConfig(config) {
     new URL(baseUrl);
   } catch {
     throw new ConfigError(
-      `Invalid base URL "${config.baseUrl}": use e.g. ${DEFAULT_BASE_URL}`
+      `Invalid base URL "${config.baseUrl}": use e.g. ${import_core2.DEFAULT_BASE_URL}`
+    );
+  }
+  const agentId2 = clean(config.agentId);
+  if (agentId2 && !UUID.test(agentId2)) {
+    throw new ConfigError(
+      `Invalid agent ID "${agentId2}": CHANNLIZE_AGENT_ID / --agent-id takes the agent's ID (a UUID, shown in the dashboard under Agents), not its slug.`
     );
   }
   return {
     serverApiKey,
     widgetKey,
     projectId: clean(config.projectId),
+    agentId: agentId2,
     baseUrl,
     timeout
   };
 }
 function configFromEnv(env = process.env) {
-  const timeout = clean(env.CHANNLIZE_TIMEOUT);
+  const { timeout, serverApiKey, widgetKey, apiKey, projectId, baseUrl } = (0, import_core2.readChannlizeEnv)(env);
   return {
-    serverApiKey: clean(env.CHANNLIZE_SERVER_API_KEY),
-    widgetKey: clean(env.CHANNLIZE_WIDGET_KEY),
-    apiKey: clean(env.CHANNLIZE_API_KEY),
-    projectId: clean(env.CHANNLIZE_PROJECT_ID),
-    baseUrl: clean(env.CHANNLIZE_BASE_URL),
-    timeout: timeout ? Number(timeout) : void 0
+    serverApiKey,
+    widgetKey,
+    apiKey,
+    projectId,
+    baseUrl,
+    timeout: timeout ? Number(timeout) : void 0,
+    // Read here rather than from core, so older @channlize/core versions work.
+    agentId: clean(env.CHANNLIZE_AGENT_ID)
   };
 }
 
@@ -450,12 +559,12 @@ function registerServerPrompts(server) {
     },
     ({ status, limit }) => user(`Triage my Channlize support inbox.
 
-1. Call list_conversations with status "${status || "open"}" and limit ${Number(limit) || 10}.
+1. Call list_conversations with status ["${status || "open"}"] and limit ${Number(limit) || 10}.
 2. For each conversation, call get_conversation to read the thread.
 3. Return a table sorted by urgency: subject, customer, how long it has waited, current priority, a suggested priority (low / normal / high / urgent) and a one-line reason.
 4. Under the table, draft a short, friendly reply for each conversation that needs one, and flag anything that looks like a bug, an outage or a billing problem.
 
-Replies and status or priority changes are made by the team in the Slack thread or the Channlize dashboard, so present the drafts for me to send; don't invent facts about my product.`)
+Present the drafts for me to review; don't invent facts about my product. Only if I confirm, and the key has the inbox:write scope, send them with reply_to_conversation, or post them for the team with add_internal_note; tag, assign or close with the matching tools.`)
   );
   server.registerPrompt(
     "summarize-conversation",
@@ -466,8 +575,8 @@ Replies and status or priority changes are made by the team in the Slack thread
         conversationId: z.string().describe("Conversation ID")
       })
     },
-    ({ conversationId }) => user(
-      `Call get_conversation with conversationId "${conversationId}". Summarize it in five bullet points or fewer: what the customer wants, what has been answered, what is still open, and the customer's mood. Then suggest the next step and draft a reply if one is needed.`
+    ({ conversationId: conversationId2 }) => user(
+      `Call get_conversation with conversationId "${conversationId2}". Summarize it in five bullet points or fewer: what the customer wants, what has been answered, what is still open, and the customer's mood. Then suggest the next step and draft a reply if one is needed.`
     )
   );
   server.registerPrompt(
@@ -598,15 +707,1240 @@ function registerResources(server, api) {
 }
 
 // src/tools.ts
+var z4 = __toESM(require("zod/v4"));
+var import_core3 = require("@channlize/core");
+
+// src/agents.ts
 var z2 = __toESM(require("zod/v4"));
-var STATUSES = ["open", "pending", "resolved", "closed"];
-var PRIORITIES = ["low", "normal", "high", "urgent"];
-var SEVERITIES = ["info", "warning", "error"];
-var EVENT_KEY = /^[a-z0-9][a-z0-9._-]*$/;
-function ok(data) {
+function defineTool(tool) {
+  return tool;
+}
+var AGENT_TASK_STATUSES = [
+  "open",
+  "working",
+  "input_required",
+  "completed",
+  "failed",
+  "canceled",
+  "rejected"
+];
+var uuid = (what) => z2.string().uuid().describe(what);
+var agentId = uuid(
+  "The agent to act as (from list_agents). Needed with a multi-agent key unless the server has a default agent (CHANNLIZE_AGENT_ID); leave it out with an agent key."
+).optional();
+var channelId = uuid("Agent channel ID (from list_agent_channels)");
+var threadId = uuid(
+  "Reply in this thread: the id of any message in it (thread_id or id from read_agent_inbox)"
+).optional();
+var mentions = z2.array(z2.string().uuid()).max(50).optional().describe("Agent IDs to mention (from list_agents)");
+var data = z2.record(z2.string(), z2.unknown()).optional().describe("Structured data for the recipients (JSON object)");
+var usage = {
+  tokens: z2.number().int().min(0).optional().describe("Tokens you used for this message (reporting)"),
+  cost: z2.number().min(0).optional().describe("What this message cost you, in USD (reporting)")
+};
+var message = z2.looseObject({
+  id: z2.string(),
+  channel_id: z2.string(),
+  thread_id: z2.string().nullable(),
+  type: z2.string(),
+  text: z2.string(),
+  sender: z2.looseObject({ kind: z2.string() }),
+  task_status: z2.string().nullable().optional()
+});
+var sendOutput = z2.object({
+  message,
+  deliveries: z2.array(
+    z2.looseObject({ id: z2.string(), agent_id: z2.string(), status: z2.string() })
+  )
+});
+var dueAt = z2.string().max(40).optional().describe("Due date: an ISO date (2026-11-30) or date-time");
+var task = z2.looseObject({
+  id: z2.string(),
+  channel_id: z2.string(),
+  text: z2.string(),
+  board_status: z2.string(),
+  assignee_agent_id: z2.string().nullable(),
+  due_at: z2.string().nullable()
+});
+var deliveries = z2.array(
+  z2.looseObject({ id: z2.string(), agent_id: z2.string(), status: z2.string() })
+);
+var question = z2.looseObject({
+  id: z2.string(),
+  kind: z2.string(),
+  question: z2.string(),
+  status: z2.string(),
+  answer: z2.looseObject({}).nullable()
+});
+var questionId = uuid("The question ID (from ask_human or list_questions)");
+var BOARD_STATUSES = [
+  "open",
+  "in_progress",
+  "blocked",
+  "done",
+  "failed"
+];
+var QUESTION_WAIT_MAX_SECONDS = 25;
+var READ = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var SEND = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: true
+};
+function actingAs(api, id2) {
+  return id2 ?? api.agentId;
+}
+function requireAgent(api, id2) {
+  const agent = actingAs(api, id2);
+  if (!agent) {
+    throw new ToolError(
+      "Pass agentId (from list_agents), or set CHANNLIZE_AGENT_ID / --agent-id on the MCP server."
+    );
+  }
+  return agent;
+}
+async function send(api, body) {
+  const r = await api.request(
+    "POST",
+    "/v1/agents/messages",
+    { body }
+  );
+  return { message: r.message, deliveries: r.deliveries ?? [] };
+}
+var enc = encodeURIComponent;
+function outcomeMessage(status, q) {
+  const answer = q.answer ?? {};
+  const choice = answer.option_label ?? answer.option_id;
+  const comment = answer.comment ? `: ${String(answer.comment)}` : "";
+  switch (status) {
+    case "answered":
+      if (q.kind === "approval") {
+        return answer.approved ? `Approved${comment}. Go ahead.` : `Denied${comment}. Don't do it.`;
+      }
+      return `Answered: ${[choice, answer.text].filter(Boolean).join(" / ") || "(empty)"}.`;
+    case "expired_default":
+      return `Nobody answered by the deadline: the default option applies (${String(choice ?? "none")}).`;
+    case "expired":
+      return "Nobody answered by the deadline and there is no default: decide whether to ask again or drop it. For an approval, treat it as not approved.";
+    case "canceled":
+      return "The question was canceled.";
+    default:
+      return `Status: ${status}.`;
+  }
+}
+var AGENT_TOOLS = [
+  defineTool({
+    name: "send_agent_message",
+    title: "Send agent message",
+    description: "Post a message to an agent channel as your agent. Every other agent in the channel receives it (webhook, inbox or A2A), people see it in Slack and the dashboard, and it counts as one Event. Reply in a thread with threadId; mention agents with mentions. Needs the agents:send scope, and the agent must be a member of the channel.",
+    scope: "agents:send",
+    endpoint: "POST /v1/agents/messages",
+    inputSchema: z2.object({
+      agentId,
+      channelId,
+      text: z2.string().min(1).max(4e4).describe("Message text"),
+      threadId,
+      mentions,
+      data,
+      ...usage
+    }),
+    outputSchema: sendOutput,
+    annotations: SEND,
+    handler: (api, a) => send(api, {
+      agent_id: actingAs(api, a.agentId),
+      channel_id: a.channelId,
+      type: "message",
+      text: a.text,
+      thread_id: a.threadId,
+      mentions: a.mentions,
+      data: a.data,
+      tokens: a.tokens,
+      cost: a.cost
+    })
+  }),
+  defineTool({
+    name: "create_task",
+    title: "Create task",
+    description: "Hand a task to an agent of a channel: creates a task (board status open) that starts its own thread, optionally assigned to a member agent (assigneeAgentId, who is mentioned) and with a due date. The returned taskId is for update_task, update_task_status and handoff_task. Your policy may refuse the channel or the assignee (POLICY_* errors). Needs the agents:send scope.",
+    scope: "agents:send",
+    endpoint: "POST /v1/agents/tasks",
+    inputSchema: z2.object({
+      agentId,
+      channelId,
+      text: z2.string().min(1).max(4e4).describe("What should be done, with enough context to do it"),
+      assigneeAgentId: uuid(
+        "The agent that should do it: a member of the channel (from list_agents)"
+      ).optional(),
+      dueAt,
+      threadId,
+      mentions,
+      data
+    }),
+    // `message` is the task too (a task is its `task` message plus board fields).
+    outputSchema: z2.object({ taskId: z2.string(), task, message, deliveries }),
+    annotations: SEND,
+    handler: async (api, a) => {
+      const r = await api.request(
+        "POST",
+        "/v1/agents/tasks",
+        {
+          body: {
+            agent_id: actingAs(api, a.agentId),
+            channel_id: a.channelId,
+            text: a.text,
+            assignee_agent_id: a.assigneeAgentId,
+            due_at: a.dueAt,
+            thread_id: a.threadId,
+            mentions: a.mentions,
+            data: a.data
+          }
+        }
+      );
+      return {
+        taskId: String(r.task.id),
+        task: r.task,
+        message: r.task,
+        deliveries: r.deliveries ?? []
+      };
+    }
+  }),
+  defineTool({
+    name: "update_task_status",
+    title: "Update task status",
+    description: "Report progress on a task (from create_task or a task in your inbox): working, input_required, completed, failed, canceled or rejected, with an optional note and result data. It is posted in the task thread and moves the task on the board (working \u2192 in_progress, input_required \u2192 blocked, completed \u2192 done; canceled and rejected show as failed). completed, failed, canceled and rejected are final: a closed task cannot be reopened (TASK_CLOSED). To change the due date, use update_task. Needs the agents:send scope.",
+    scope: "agents:send",
+    endpoint: "POST /v1/agents/messages",
+    inputSchema: z2.object({
+      agentId,
+      channelId,
+      taskId: uuid("The task message ID"),
+      status: z2.enum(AGENT_TASK_STATUSES).describe("The new status of the task"),
+      text: z2.string().max(4e4).optional().describe("What changed, e.g. the result or what input is needed"),
+      data,
+      ...usage
+    }),
+    outputSchema: sendOutput,
+    annotations: SEND,
+    handler: (api, a) => send(api, {
+      agent_id: actingAs(api, a.agentId),
+      channel_id: a.channelId,
+      type: "status",
+      text: a.text ?? "",
+      task_id: a.taskId,
+      task_status: a.status,
+      data: a.data,
+      tokens: a.tokens,
+      cost: a.cost
+    })
+  }),
+  defineTool({
+    name: "update_task",
+    title: "Update task",
+    description: "Move a task on the board (open, in_progress, blocked, done, failed) and/or change its due date, with a note: posted as a status update in the task thread, recorded in the task's history and shown on its Slack card. Only the task's assignee or creator can change it (NOT_TASK_PARTICIPANT), and a closed task can't change (TASK_CLOSED). To cancel or reject, or to attach result data, use update_task_status. Needs the agents:send scope.",
+    scope: "agents:send",
+    endpoint: "PATCH /v1/agents/tasks/:taskId",
+    inputSchema: z2.object({
+      agentId,
+      taskId: uuid("The task ID"),
+      status: z2.enum(BOARD_STATUSES).optional().describe("The board column"),
+      dueAt: z2.string().max(40).nullable().optional().describe("New due date (ISO date or date-time); null clears it"),
+      note: z2.string().max(2e3).optional().describe("What changed, shown with the update")
+    }),
+    outputSchema: z2.object({ task, changed: z2.boolean() }),
+    annotations: SEND,
+    handler: async (api, a) => {
+      if (a.status === void 0 && a.dueAt === void 0) {
+        throw new ToolError("Pass status or dueAt.");
+      }
+      const r = await api.request(
+        "PATCH",
+        `/v1/agents/tasks/${enc(a.taskId)}`,
+        {
+          body: {
+            agent_id: actingAs(api, a.agentId),
+            status: a.status,
+            due_at: a.dueAt,
+            note: a.note
+          }
+        }
+      );
+      return { task: r.task, changed: Boolean(r.changed) };
+    }
+  }),
+  defineTool({
+    name: "handoff_task",
+    title: "Hand off task",
+    description: "Hand a task you are assigned to (or created) to another member agent of its channel, with the reason: the new and the previous assignee get a status message (data.handoff), and it's recorded in the task's history. Use it when another agent is better placed, then stop working on the task. Errors: ALREADY_ASSIGNED, AGENT_NOT_IN_CHANNEL, TASK_CLOSED, NOT_TASK_PARTICIPANT, POLICY_DM_NOT_ALLOWED. Needs the agents:send scope.",
+    scope: "agents:send",
+    endpoint: "POST /v1/agents/tasks/:taskId/handoff",
+    inputSchema: z2.object({
+      agentId,
+      taskId: uuid("The task ID"),
+      toAgentId: uuid("The new assignee (from list_agents or get_org_chart)"),
+      reason: z2.string().max(2e3).optional().describe("Why, and what the new assignee needs to know")
+    }),
+    outputSchema: z2.object({ task, deliveries }),
+    annotations: SEND,
+    handler: async (api, a) => {
+      const r = await api.request(
+        "POST",
+        `/v1/agents/tasks/${enc(a.taskId)}/handoff`,
+        {
+          body: {
+            agent_id: actingAs(api, a.agentId),
+            to_agent_id: a.toAgentId,
+            reason: a.reason
+          }
+        }
+      );
+      return {
+        task: r.task,
+        deliveries: r.deliveries ?? []
+      };
+    }
+  }),
+  defineTool({
+    name: "list_tasks",
+    title: "List tasks",
+    description: "List a channel's tasks, newest first, with their board status (open, in_progress, blocked, done, failed), assignee, due date and last handoff. Filter by assignee (your own agent id for your work) or status. channelId is required unless the key is an agents:admin key. Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents/tasks",
+    inputSchema: z2.object({
+      agentId,
+      channelId: channelId.optional(),
+      assigneeAgentId: uuid("Only tasks assigned to this agent").optional(),
+      status: z2.enum(BOARD_STATUSES).optional(),
+      limit: z2.number().int().min(1).max(500).default(50).describe("How many to return (1-500, default 50)")
+    }),
+    outputSchema: z2.object({ tasks: z2.array(task) }),
+    annotations: READ,
+    handler: async (api, a) => {
+      const r = await api.request(
+        "GET",
+        "/v1/agents/tasks",
+        {
+          query: {
+            agent_id: actingAs(api, a.agentId),
+            channel_id: a.channelId,
+            assignee_agent_id: a.assigneeAgentId,
+            status: a.status,
+            limit: a.limit
+          }
+        }
+      );
+      return { tasks: r.tasks ?? [] };
+    }
+  }),
+  defineTool({
+    name: "get_task_board",
+    title: "Get task board",
+    description: "A channel's task board: tasks grouped by column (open, in_progress, blocked, done, failed), counts per column, and the agents on it. Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents/tasks/board",
+    inputSchema: z2.object({
+      agentId,
+      channelId,
+      assigneeAgentId: uuid("Only tasks assigned to this agent").optional()
+    }),
+    outputSchema: z2.object({
+      channel_id: z2.string(),
+      columns: z2.record(z2.string(), z2.array(task)),
+      counts: z2.record(z2.string(), z2.number()),
+      agents: z2.array(z2.looseObject({ id: z2.string() })),
+      truncated: z2.boolean()
+    }),
+    annotations: READ,
+    handler: async (api, a) => await api.request("GET", "/v1/agents/tasks/board", {
+      query: {
+        agent_id: actingAs(api, a.agentId),
+        channel_id: a.channelId,
+        assignee_agent_id: a.assigneeAgentId
+      }
+    })
+  }),
+  defineTool({
+    name: "ask_human",
+    title: "Ask a human",
+    description: "Ask people a question, or for an approval (kind approval: Approve / Deny), when you can't or shouldn't decide alone. It's posted in Slack (the channel's linked Slack channel, else the escalation channel) with a button per option, and escalates (manager, owner, supervisors, escalation channel) until someone answers or the deadline passes; with a defaultOption, the default applies at the deadline. Returns at once with the questionId: then call get_answer, which waits for the answer. Don't act on what you asked about before the answer. Counts as one Event. Your policy may refuse (POLICY_ASK_HUMAN_NOT_ALLOWED, POLICY_URGENCY_NOT_ALLOWED). Needs the agents:ask_human scope.",
+    scope: "agents:ask_human",
+    endpoint: "POST /v1/agents/questions",
+    inputSchema: z2.object({
+      agentId,
+      kind: z2.enum(["question", "approval"]).default("question").describe("question (default) or approval (answered Approve / Deny)"),
+      question: z2.string().min(1).max(3e3).describe("The question, with what people need to answer it"),
+      options: z2.array(
+        z2.object({
+          id: z2.string().min(1).max(100),
+          label: z2.string().min(1).max(75)
+        })
+      ).max(10).optional().describe("Up to 10 answers to pick from (ignored for approvals)"),
+      freeText: z2.boolean().optional().describe("Allow a typed answer (always on without options)"),
+      urgency: z2.enum(["low", "normal", "high", "urgent"]).optional().describe("How fast it escalates (default normal)"),
+      deadline: z2.string().max(40).optional().describe("ISO date-time, at most 30 days away"),
+      defaultOption: z2.string().max(100).optional().describe("Option id applied at the deadline when nobody answered"),
+      channelId: channelId.optional().describe("Post it in this agent channel (from list_agent_channels)"),
+      threadId,
+      context: z2.record(z2.string(), z2.unknown()).optional().describe("Facts shown with the question (JSON object)"),
+      amount: z2.number().min(0).optional().describe("Approvals: the amount at stake"),
+      currency: z2.string().regex(/^[A-Za-z]{3}$/).optional().describe("Approvals: ISO 4217 currency code"),
+      resource: z2.record(z2.string(), z2.unknown()).optional().describe("Approvals: what is being approved (JSON object)"),
+      requiredRoles: z2.array(z2.string().min(1).max(40)).max(10).optional().describe('Approvals: roles that may answer, e.g. ["admin"]')
+    }),
+    outputSchema: z2.object({ questionId: z2.string(), question }),
+    annotations: SEND,
+    handler: async (api, a) => {
+      const r = await api.request(
+        "POST",
+        "/v1/agents/questions",
+        {
+          body: {
+            agent_id: actingAs(api, a.agentId),
+            kind: a.kind,
+            question: a.question,
+            options: a.options,
+            free_text: a.freeText,
+            urgency: a.urgency,
+            deadline: a.deadline,
+            default_option: a.defaultOption,
+            channel_id: a.channelId,
+            thread_id: a.threadId,
+            context: a.context,
+            amount: a.amount,
+            currency: a.currency,
+            resource: a.resource,
+            required_roles: a.requiredRoles
+          }
+        }
+      );
+      return {
+        questionId: String(r.question.id),
+        question: r.question
+      };
+    }
+  }),
+  defineTool({
+    name: "get_answer",
+    title: "Get answer",
+    description: `Wait for the answer to a question from ask_human: holds up to waitSeconds (default and maximum ${QUESTION_WAIT_MAX_SECONDS}) and returns as soon as it closes. status is answered (answer.option_id / answer.text; approvals have answer.approved), expired_default (the default option applied), expired (no answer by the deadline) or canceled. When waiting is true nobody has answered yet: call get_answer again, or do other work and come back. Needs the agents:ask_human scope (or agents:read).`,
+    scope: "agents:ask_human",
+    endpoint: "GET /v1/agents/questions/:id/wait",
+    inputSchema: z2.object({
+      agentId,
+      questionId,
+      waitSeconds: z2.number().int().min(0).max(QUESTION_WAIT_MAX_SECONDS).default(QUESTION_WAIT_MAX_SECONDS).describe(
+        `Seconds to wait for an answer (0-${QUESTION_WAIT_MAX_SECONDS}, default ${QUESTION_WAIT_MAX_SECONDS}); 0 only checks`
+      )
+    }),
+    outputSchema: z2.object({
+      questionId: z2.string(),
+      status: z2.string(),
+      waiting: z2.boolean(),
+      answer: z2.looseObject({}).nullable(),
+      message: z2.string(),
+      question
+    }),
+    annotations: READ,
+    handler: async (api, a) => {
+      const r = await api.request(
+        "GET",
+        `/v1/agents/questions/${enc(a.questionId)}/wait`,
+        {
+          query: {
+            agent_id: actingAs(api, a.agentId),
+            timeout: a.waitSeconds
+          },
+          // The API holds the request for up to waitSeconds.
+          timeout: (a.waitSeconds + 10) * 1e3
+        }
+      );
+      const status = String(r.question.status);
+      const waiting = status === "open";
+      return {
+        questionId: a.questionId,
+        status,
+        waiting,
+        answer: r.question.answer ?? null,
+        message: waiting ? `Still waiting: nobody has answered yet. Call get_answer again with questionId ${a.questionId}, or check back later; don't act on the question meanwhile.` : outcomeMessage(status, r.question),
+        question: r.question
+      };
+    }
+  }),
+  defineTool({
+    name: "list_questions",
+    title: "List questions",
+    description: "List your questions and the ones escalated to you as a manager agent, newest first. Filter with status open to find what still needs an answer (answer_escalated_question). Needs the agents:read scope (or agents:ask_human).",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents/questions",
+    inputSchema: z2.object({
+      agentId,
+      status: z2.enum(["open", "answered", "expired_default", "expired", "canceled"]).optional(),
+      kind: z2.enum(["question", "approval"]).optional(),
+      channelId: channelId.optional(),
+      cursor: z2.string().max(300).optional().describe("nextCursor of the previous call"),
+      limit: z2.number().int().min(1).max(200).default(20).describe("How many to return (1-200, default 20)")
+    }),
+    outputSchema: z2.object({
+      questions: z2.array(question),
+      nextCursor: z2.string().nullable()
+    }),
+    annotations: READ,
+    handler: async (api, a) => {
+      const r = await api.request("GET", "/v1/agents/questions", {
+        query: {
+          agent_id: actingAs(api, a.agentId),
+          status: a.status,
+          kind: a.kind,
+          channel_id: a.channelId,
+          cursor: a.cursor,
+          limit: a.limit
+        }
+      });
+      return {
+        questions: r.questions ?? [],
+        nextCursor: r.next_cursor ?? null
+      };
+    }
+  }),
+  defineTool({
+    name: "cancel_question",
+    title: "Cancel question",
+    description: "Cancel one of your open questions when it no longer matters (you found the answer, the work was dropped): its Slack post is updated and escalation stops. Only the agent that asked can cancel, and a closed question can't be (QUESTION_CLOSED). Needs the agents:ask_human scope.",
+    scope: "agents:ask_human",
+    endpoint: "DELETE /v1/agents/questions/:id",
+    inputSchema: z2.object({ agentId, questionId }),
+    outputSchema: z2.object({ question }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    handler: async (api, a) => {
+      const r = await api.request(
+        "DELETE",
+        `/v1/agents/questions/${enc(a.questionId)}`,
+        { query: { agent_id: actingAs(api, a.agentId) } }
+      );
+      return { question: r.question };
+    }
+  }),
+  defineTool({
+    name: "answer_escalated_question",
+    title: "Answer escalated question",
+    description: "Answer a question another agent asked, when it was escalated to you as its manager agent (a question.escalated delivery, or list_questions with status open). Pick an optionId (approve / deny for approvals, with a comment), or give text when free text is allowed. The first answer wins (QUESTION_CLOSED after), approvals that require a role need a person (APPROVAL_ROLE_REQUIRED), and you can't answer your own question. Needs the agents:send scope.",
+    scope: "agents:send",
+    endpoint: "POST /v1/agents/questions/:id/answer",
+    inputSchema: z2.object({
+      agentId,
+      questionId,
+      optionId: z2.string().min(1).max(100).optional().describe("One of the question options (approve / deny for approvals)"),
+      text: z2.string().max(3e3).optional().describe("A typed answer, when the question allows free text"),
+      comment: z2.string().max(2e3).optional().describe("Why (shown with the answer; say why on a deny)")
+    }),
+    outputSchema: z2.object({ question }),
+    annotations: SEND,
+    handler: async (api, a) => {
+      if (!a.optionId && !a.text) throw new ToolError("Pass optionId or text.");
+      const r = await api.request(
+        "POST",
+        `/v1/agents/questions/${enc(a.questionId)}/answer`,
+        {
+          body: {
+            agent_id: actingAs(api, a.agentId),
+            option_id: a.optionId,
+            text: a.text,
+            comment: a.comment
+          }
+        }
+      );
+      return { question: r.question };
+    }
+  }),
+  defineTool({
+    name: "get_org_chart",
+    title: "Get org chart",
+    description: "The organization's agents with their manager (an agent or a person), owner and teams, the teams, and the reporting tree. Use it to find who to hand a task off to, or who manages an agent. Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents/org-chart",
+    inputSchema: z2.object({
+      teamId: uuid("Only this team").optional(),
+      channelId: uuid("Only the agents of this channel").optional(),
+      includeRetired: z2.boolean().optional().describe("Include retired agents (default false)")
+    }),
+    outputSchema: z2.object({
+      agents: z2.array(z2.looseObject({ id: z2.string() })),
+      users: z2.array(z2.looseObject({ id: z2.string() })),
+      teams: z2.array(z2.looseObject({ id: z2.string() })),
+      tree: z2.array(z2.looseObject({}))
+    }),
+    annotations: READ,
+    handler: async (api, a) => await api.request("GET", "/v1/agents/org-chart", {
+      query: {
+        team_id: a.teamId,
+        channel_id: a.channelId,
+        include_retired: a.includeRetired ? "true" : void 0
+      }
+    })
+  }),
+  defineTool({
+    name: "get_effective_policy",
+    title: "Get effective policy",
+    description: "The policy in force for an agent (in a channel): the merged rules (allowed channels, direct messages, asking humans, rate, budgets, working hours, thread depth, humans-win minutes), which policy set each, current usage, working hours now, and with a channel whether it may post and read there now. Read-only. Needs an unbound key with the agents:admin scope: a key bound to agents gets 403 AGENT_ADMIN_KEY_REQUIRED.",
+    scope: "agents:admin",
+    endpoint: "GET /v1/agents/policies/preview",
+    inputSchema: z2.object({
+      agentId: uuid(
+        "The agent (from list_agents). Default: the server agent (CHANNLIZE_AGENT_ID)"
+      ).optional(),
+      channelId: channelId.optional()
+    }),
+    outputSchema: z2.looseObject({
+      agent_id: z2.string(),
+      channel_id: z2.string().nullable(),
+      rules: z2.looseObject({}),
+      working_hours: z2.looseObject({}),
+      usage: z2.looseObject({}),
+      checks: z2.looseObject({}).nullable()
+    }),
+    annotations: READ,
+    handler: async (api, a) => await api.request("GET", "/v1/agents/policies/preview", {
+      query: {
+        agent_id: requireAgent(api, a.agentId),
+        channel_id: a.channelId
+      }
+    })
+  }),
+  defineTool({
+    name: "read_agent_inbox",
+    title: "Read agent inbox",
+    description: "Read your agent's unacknowledged messages, oldest first: messages, tasks and task status updates from other agents and people, each with its channel, thread and sender. Messages stay until ack_agent_messages acknowledges them, so read, handle, then ack. Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents/:id/inbox",
+    inputSchema: z2.object({
+      agentId,
+      cursor: z2.string().max(200).optional().describe("Read after this cursor (nextCursor of the previous call)"),
+      limit: z2.number().int().min(1).max(200).default(20).describe("How many to return (1-200, default 20)")
+    }),
+    outputSchema: z2.object({
+      agentId: z2.string(),
+      messages: z2.array(
+        z2.looseObject({
+          delivery_id: z2.string(),
+          cursor: z2.string(),
+          message
+        })
+      ),
+      nextCursor: z2.string().nullable(),
+      hasMore: z2.boolean()
+    }),
+    annotations: READ,
+    handler: async (api, a) => {
+      const id2 = requireAgent(api, a.agentId);
+      const r = await api.request("GET", `/v1/agents/${enc(id2)}/inbox`, {
+        query: { cursor: a.cursor, limit: a.limit }
+      });
+      return {
+        agentId: id2,
+        messages: r.messages ?? [],
+        nextCursor: r.next_cursor ?? null,
+        hasMore: Boolean(r.has_more)
+      };
+    }
+  }),
+  defineTool({
+    name: "ack_agent_messages",
+    title: "Acknowledge agent messages",
+    description: "Acknowledge inbox messages you handled so read_agent_inbox stops returning them: upTo acks everything up to and including that delivery or message ID, ids acks just those. Acking twice is harmless. Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "POST /v1/agents/:id/inbox/ack",
+    inputSchema: z2.object({
+      agentId,
+      upTo: z2.string().uuid().optional().describe("Ack everything up to and including this delivery_id"),
+      ids: z2.array(z2.string().uuid()).min(1).max(500).optional().describe("Ack these delivery (or message) IDs")
+    }),
+    outputSchema: z2.object({ acked: z2.number() }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: async (api, a) => {
+      if (!a.upTo === !a.ids) {
+        throw new ToolError("Pass either upTo or ids.");
+      }
+      const id2 = requireAgent(api, a.agentId);
+      const r = await api.request(
+        "POST",
+        `/v1/agents/${enc(id2)}/inbox/ack`,
+        { body: a.upTo ? { up_to: a.upTo } : { ids: a.ids } }
+      );
+      return { acked: Number(r.acked ?? 0) };
+    }
+  }),
+  defineTool({
+    name: "list_agents",
+    title: "List agents",
+    description: "List the organization's agents: id, slug, name, role, description, status (active, paused, retired) and how they receive messages. Use the ids for mentions and agentId. Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents",
+    inputSchema: z2.object({
+      includeRetired: z2.boolean().optional().describe("Include retired agents (default false)")
+    }),
+    outputSchema: z2.object({
+      agents: z2.array(
+        z2.looseObject({
+          id: z2.string(),
+          slug: z2.string(),
+          name: z2.string(),
+          status: z2.string()
+        })
+      )
+    }),
+    annotations: READ,
+    handler: async (api, a) => {
+      const r = await api.request("GET", "/v1/agents", {
+        query: { include_retired: a.includeRetired || void 0 }
+      });
+      return { agents: r.agents ?? [] };
+    }
+  }),
+  defineTool({
+    name: "list_agent_channels",
+    title: "List agent channels",
+    description: "List the agent channels your key's agents are members or observers of: id, slug, name, description and whether they are archived. Post with send_agent_message (members only). Needs the agents:read scope.",
+    scope: "agents:read",
+    endpoint: "GET /v1/agents/channels",
+    inputSchema: z2.object({
+      includeArchived: z2.boolean().optional().describe("Include archived channels (default false)")
+    }),
+    outputSchema: z2.object({
+      channels: z2.array(
+        z2.looseObject({
+          id: z2.string(),
+          slug: z2.string(),
+          name: z2.string(),
+          archived: z2.boolean()
+        })
+      )
+    }),
+    annotations: READ,
+    handler: async (api, a) => {
+      const r = await api.request(
+        "GET",
+        "/v1/agents/channels",
+        { query: { include_archived: a.includeArchived || void 0 } }
+      );
+      return { channels: r.channels ?? [] };
+    }
+  })
+];
+var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
+
+// src/inbox.ts
+var z3 = __toESM(require("zod/v4"));
+function defineTool2(tool) {
+  return tool;
+}
+var CONVERSATION_STATUSES = [
+  "open",
+  "pending",
+  "resolved",
+  "closed"
+];
+var CONVERSATION_PRIORITIES = [
+  "low",
+  "normal",
+  "high",
+  "urgent"
+];
+var CONVERSATION_SORTS = [
+  "recent",
+  "oldest",
+  "newest",
+  "priority"
+];
+var loose = z3.looseObject({});
+var id = (what) => z3.string().uuid().describe(`${what} ID`);
+var conversationId = id(
+  "Conversation (from list_conversations or search_conversations)"
+);
+var person = z3.looseObject({
+  id: z3.string(),
+  name: z3.string().nullable().optional(),
+  email: z3.string().nullable().optional()
+}).nullable();
+var conversationSummary = z3.looseObject({
+  id: z3.string(),
+  subject: z3.string().nullable().optional(),
+  status: z3.string(),
+  priority: z3.string().optional(),
+  source: z3.string().nullable().optional(),
+  tags: z3.array(z3.string()).optional(),
+  customer: person.optional(),
+  assignee: person.optional(),
+  triage: z3.record(z3.string(), z3.unknown()).nullable().optional(),
+  needsReply: z3.boolean().optional(),
+  lastActivityAt: z3.string().nullable().optional()
+});
+var page = {
+  total: z3.number(),
+  limit: z3.number(),
+  offset: z3.number(),
+  hasMore: z3.boolean()
+};
+var listOutput = z3.object({
+  conversations: z3.array(conversationSummary),
+  ...page
+});
+var changeOutput = z3.object({
+  conversation: z3.looseObject({ id: z3.string(), status: z3.string() }),
+  changes: z3.array(z3.string())
+});
+var slackOutcome = z3.string().describe(
+  "Slack mirror: queued, posted, no_thread (not in Slack), not_connected or failed"
+);
+var tags = z3.array(z3.string().trim().min(1).max(50)).max(20);
+var paging = {
+  limit: z3.number().int().min(1).max(100).default(20).describe("How many to return (1-100, default 20)"),
+  offset: z3.number().int().min(0).default(0).describe("Skip this many")
+};
+function oneOrMany(values) {
+  return z3.union([z3.enum(values), z3.array(z3.enum(values)).max(10)]).optional();
+}
+var asList = (v) => v === void 0 ? void 0 : Array.isArray(v) ? v.join(",") : v;
+var listFilters = {
+  status: oneOrMany(CONVERSATION_STATUSES).describe(
+    'Only these statuses: "open" or a list like ["open", "pending"]'
+  ),
+  priority: oneOrMany(CONVERSATION_PRIORITIES).describe(
+    'Only these priorities: "urgent" or a list'
+  ),
+  assignee: z3.string().max(255).optional().describe('A teammate (user ID or email), "unassigned" or "assigned"'),
+  projectId: id("Project").optional(),
+  updatedSince: z3.iso.datetime({ offset: true }).optional().describe("Updated or with a new message since (ISO 8601)"),
+  tag: z3.string().max(50).optional().describe("Carrying this tag"),
+  source: z3.string().max(32).optional().describe("Entry point, e.g. live_chat, contact_form, api, email"),
+  intent: z3.string().max(64).optional().describe("AI triage intent (triaged conversations only)"),
+  urgency: z3.string().max(64).optional().describe("AI triage urgency (triaged conversations only)"),
+  sort: z3.enum(CONVERSATION_SORTS).optional().describe(
+    "recent (last activity, default), oldest, newest (created) or priority"
+  )
+};
+async function list(api, a) {
+  const r = await api.request("GET", "/v1/conversations", {
+    query: {
+      status: asList(a.status),
+      priority: asList(a.priority),
+      assignee: a.assignee,
+      projectId: a.projectId,
+      updatedSince: a.updatedSince,
+      tag: a.tag,
+      source: a.source,
+      intent: a.intent,
+      urgency: a.urgency,
+      sort: a.sort,
+      q: a.q,
+      limit: a.limit,
+      offset: a.offset
+    }
+  });
   return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-    structuredContent: data
+    conversations: r.conversations ?? [],
+    total: Number(r.total ?? 0),
+    limit: Number(r.limit ?? a.limit),
+    offset: Number(r.offset ?? a.offset),
+    hasMore: Boolean(r.hasMore)
+  };
+}
+var path = (cid, rest = "") => `/v1/conversations/${encodeURIComponent(cid)}${rest}`;
+async function patch(api, cid, body) {
+  const r = await api.request(
+    "PATCH",
+    path(cid),
+    { body }
+  );
+  return {
+    conversation: r.conversation,
+    changes: r.changes ?? []
+  };
+}
+var READ2 = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var CHANGE = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+var ROUTING_FIELDS = [
+  "source",
+  "project",
+  "widget",
+  "connection",
+  "page_url",
+  "page_domain",
+  "customer_email",
+  "customer_email_domain",
+  "message",
+  "subject",
+  "tags",
+  "priority",
+  "language"
+];
+var ROUTING_OPERATORS = [
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "ends_with",
+  "matches"
+];
+var routingConditions = z3.object({
+  match: z3.enum(["all", "any"]).describe("all = every condition holds, any = one is enough"),
+  conditions: z3.array(
+    z3.object({
+      field: z3.enum(ROUTING_FIELDS),
+      operator: z3.enum(ROUTING_OPERATORS),
+      value: z3.union([z3.string(), z3.array(z3.string())]).describe(
+        "A value, or a list (positive operators: any matches; negative: none does). Case-insensitive; matches uses * and ? wildcards."
+      )
+    })
+  ).max(50).describe("Empty = matches every new conversation (catch-all)")
+}).describe(
+  'Which new conversations the rule catches, tested on the first message, e.g. { "match": "any", "conditions": [{ "field": "message", "operator": "contains", "value": ["refund", "invoice"] }] }'
+);
+var ruleFields = {
+  name: z3.string().trim().min(1).max(255).describe("Rule name"),
+  targetChannelId: z3.string().regex(/^[A-Z0-9]{2,30}$/, "a Slack channel ID like C0123ABCD").describe("Slack channel ID to post matching conversations to"),
+  conditions: routingConditions,
+  projectId: id("Project (default: the oldest project)").optional(),
+  widgetId: id("Widget").nullable().optional(),
+  integrationId: id("Integration (default: the Slack workspace)").optional(),
+  assignToUserId: id("Teammate to assign matching conversations to").nullable().optional(),
+  isActive: z3.boolean().optional().describe("Default true"),
+  priority: z3.number().int().min(-1e6).max(1e6).optional().describe("Higher runs first (default: after every rule)")
+};
+var rule = z3.looseObject({
+  id: z3.string(),
+  name: z3.string(),
+  priority: z3.number(),
+  is_active: z3.boolean(),
+  target_channel_id: z3.string()
+});
+var INBOX_TOOLS = [
+  defineTool2({
+    name: "list_conversations",
+    title: "List conversations",
+    description: "List support conversations, most recent activity first, filtered by status, priority, assignee, project, tag, source, last update or AI triage (intent/urgency). Each row has the customer, assignee, needsReply (the customer spoke last) and a preview of the latest message. Use get_conversation for the thread. Needs the inbox:read (or read) scope.",
+    scope: "inbox:read",
+    endpoint: "GET /v1/conversations",
+    inputSchema: z3.object({ ...listFilters, ...paging }),
+    outputSchema: listOutput,
+    annotations: READ2,
+    handler: (api, a) => list(api, a)
+  }),
+  defineTool2({
+    name: "search_conversations",
+    title: "Search conversations",
+    description: "Find conversations whose subject, customer name or email, or any message contains the text (case-insensitive), with the same filters as list_conversations. Needs the inbox:read (or read) scope.",
+    scope: "inbox:read",
+    endpoint: "GET /v1/conversations?q=",
+    inputSchema: z3.object({
+      query: z3.string().trim().min(1).max(200).describe("Text to look for"),
+      ...listFilters,
+      ...paging
+    }),
+    outputSchema: listOutput,
+    annotations: READ2,
+    handler: (api, { query, ...a }) => list(api, { ...a, q: query })
+  }),
+  defineTool2({
+    name: "get_conversation",
+    title: "Get conversation",
+    description: "Read one conversation with its full thread: customer, agent, system and bot messages in order, internal notes included (isInternal: true, never seen by the customer), plus status, priority, tags, assignee, customer, triage and its Slack thread. Needs the inbox:read (or read) scope.",
+    scope: "inbox:read",
+    endpoint: "GET /v1/conversations/:id",
+    inputSchema: z3.object({ conversationId }),
+    outputSchema: z3.object({
+      conversation: z3.looseObject({
+        id: z3.string(),
+        status: z3.string(),
+        messages: z3.array(loose)
+      })
+    }),
+    annotations: READ2,
+    handler: async (api, { conversationId: cid }) => {
+      const r = await api.request("GET", path(cid));
+      return { conversation: r.conversation };
+    }
+  }),
+  defineTool2({
+    name: "reply_to_conversation",
+    title: "Reply to conversation",
+    description: 'Send a reply to the customer, as this API key (shown as "<key name> (agent)"). It reaches the customer like a dashboard reply (chat widget, email, SMS, ...) and is mirrored to the Slack thread; an open conversation becomes pending. Confirm the text with the user before sending. For a note only the team sees, use add_internal_note. Needs the inbox:write scope.',
+    scope: "inbox:write",
+    endpoint: "POST /v1/conversations/:id/reply",
+    inputSchema: z3.object({
+      conversationId,
+      content: z3.string().trim().min(1).max(1e4).describe("Reply text, as the customer will read it")
+    }),
+    outputSchema: z3.object({
+      message: z3.looseObject({ id: z3.string() }),
+      conversationStatus: z3.string(),
+      slack: slackOutcome
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    handler: async (api, { conversationId: cid, content }) => {
+      const r = await api.request("POST", path(cid, "/reply"), {
+        body: { content }
+      });
+      return {
+        message: r.message,
+        conversationStatus: String(r.conversationStatus ?? ""),
+        slack: String(r.slack ?? "")
+      };
+    }
+  }),
+  defineTool2({
+    name: "add_internal_note",
+    title: "Add internal note",
+    description: "Add an internal note to a conversation: posted in its Slack thread for the team and kept in the conversation, never sent to the customer. Use it for findings, handoffs and suggested replies. Needs the inbox:write scope.",
+    scope: "inbox:write",
+    endpoint: "POST /v1/conversations/:id/notes",
+    inputSchema: z3.object({
+      conversationId,
+      content: z3.string().trim().min(1).max(1e4).describe("Note text")
+    }),
+    outputSchema: z3.object({
+      note: z3.looseObject({ id: z3.string() }),
+      slack: slackOutcome
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    handler: async (api, { conversationId: cid, content }) => {
+      const r = await api.request("POST", path(cid, "/notes"), {
+        body: { content }
+      });
+      return { note: r.note, slack: String(r.slack ?? "") };
+    }
+  }),
+  defineTool2({
+    name: "assign_conversation",
+    title: "Assign conversation",
+    description: "Assign a conversation to a teammate (by user ID or email; owners, admins and agents, not viewers), or unassign it with null. The teammate is notified, and the change shows in the timeline and Slack. Needs the inbox:write scope.",
+    scope: "inbox:write",
+    endpoint: "PATCH /v1/conversations/:id",
+    inputSchema: z3.object({
+      conversationId,
+      assignee: z3.string().min(1).max(255).nullable().describe("User ID or email of the teammate, or null to unassign")
+    }),
+    outputSchema: changeOutput,
+    annotations: CHANGE,
+    handler: (api, { conversationId: cid, assignee }) => patch(
+      api,
+      cid,
+      assignee === null ? { assigneeId: null } : assignee.includes("@") ? { assigneeEmail: assignee } : { assigneeId: assignee }
+    )
+  }),
+  defineTool2({
+    name: "tag_conversation",
+    title: "Tag conversation",
+    description: "Add or remove tags on a conversation, or replace them all with `set`. Tags are lowercased; at most 20. Needs the inbox:write scope.",
+    scope: "inbox:write",
+    endpoint: "PATCH /v1/conversations/:id",
+    inputSchema: z3.object({
+      conversationId,
+      add: tags.optional().describe("Tags to add"),
+      remove: tags.optional().describe("Tags to remove"),
+      set: tags.optional().describe("Replace every tag with these ([] clears them)")
+    }),
+    outputSchema: changeOutput,
+    annotations: CHANGE,
+    handler: (api, { conversationId: cid, add, remove, set }) => {
+      if (!add?.length && !remove?.length && !set) {
+        throw new ToolError("Pass tags to add, remove, or set.");
+      }
+      return patch(api, cid, {
+        ...set ? { tags: set } : {},
+        ...add?.length ? { addTags: add } : {},
+        ...remove?.length ? { removeTags: remove } : {}
+      });
+    }
+  }),
+  defineTool2({
+    name: "close_conversation",
+    title: "Close conversation",
+    description: "Close a conversation (or mark it resolved). Nothing is sent to the customer; the change shows in the timeline and the Slack root post. Reply first if the customer should hear back. Needs the inbox:write scope.",
+    scope: "inbox:write",
+    endpoint: "PATCH /v1/conversations/:id",
+    inputSchema: z3.object({
+      conversationId,
+      status: z3.enum(["closed", "resolved"]).default("closed").describe("closed (default) or resolved")
+    }),
+    outputSchema: changeOutput,
+    annotations: CHANGE,
+    handler: (api, { conversationId: cid, status }) => patch(api, cid, { status })
+  }),
+  defineTool2({
+    name: "reopen_conversation",
+    title: "Reopen conversation",
+    description: "Reopen a closed or resolved conversation (status open). Needs the inbox:write scope.",
+    scope: "inbox:write",
+    endpoint: "PATCH /v1/conversations/:id",
+    inputSchema: z3.object({ conversationId }),
+    outputSchema: changeOutput,
+    annotations: CHANGE,
+    handler: (api, { conversationId: cid }) => patch(api, cid, { status: "open" })
+  }),
+  defineTool2({
+    name: "get_analytics_summary",
+    title: "Get analytics summary",
+    description: "Support KPIs for a period (default the last 30 days): conversations started and resolved, median first-response and resolution times, messages in and out, each with the previous period; plus the inbox right now (open, pending, unassigned, urgent, awaiting a reply). Needs the analytics:read (or read) scope.",
+    scope: "analytics:read",
+    endpoint: "GET /v1/analytics/summary",
+    inputSchema: z3.object({
+      days: z3.number().int().min(1).max(366).optional().describe("Period length in days, ending today (default 30)"),
+      from: z3.iso.date().optional().describe("First day, YYYY-MM-DD"),
+      to: z3.iso.date().optional().describe("Last day, YYYY-MM-DD"),
+      tz: z3.string().max(64).optional().describe("IANA time zone for day boundaries (default UTC)"),
+      projectId: id("Project").optional()
+    }),
+    outputSchema: z3.looseObject({ range: loose, kpis: loose, inbox: loose }),
+    annotations: READ2,
+    handler: async (api, args) => api.request(
+      "GET",
+      "/v1/analytics/summary",
+      { query: args }
+    )
+  }),
+  defineTool2({
+    name: "list_routing_rules",
+    title: "List routing rules",
+    description: "List the routing rules in evaluation order (highest priority first): which new conversations each one sends to which Slack channel, and who it assigns. Needs the routing:write, inbox:read or read scope.",
+    scope: "routing:read",
+    endpoint: "GET /v1/routing-rules",
+    inputSchema: z3.object({}),
+    outputSchema: z3.object({ rules: z3.array(rule) }),
+    annotations: READ2,
+    handler: async (api) => {
+      const r = await api.request(
+        "GET",
+        "/v1/routing-rules"
+      );
+      return { rules: r.routing_rules ?? [] };
+    }
+  }),
+  defineTool2({
+    name: "create_routing_rule",
+    title: "Create routing rule",
+    description: "Create a routing rule: new conversations whose first message matches `conditions` are posted to `targetChannelId` instead of the default channel (and optionally assigned). It runs after the existing rules unless `priority` is given. Confirm with the user first. Needs the routing:write scope.",
+    scope: "routing:write",
+    endpoint: "POST /v1/routing-rules",
+    inputSchema: z3.object(ruleFields),
+    outputSchema: z3.object({ rule }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    handler: async (api, body) => {
+      const r = await api.request(
+        "POST",
+        "/v1/routing-rules",
+        { body }
+      );
+      return { rule: r.routing_rule };
+    }
+  }),
+  defineTool2({
+    name: "update_routing_rule",
+    title: "Update routing rule",
+    description: "Change a routing rule (from list_routing_rules); omitted fields keep their value, and `conditions` replaces the whole condition group. Use isActive: false to pause a rule. Needs the routing:write scope.",
+    scope: "routing:write",
+    endpoint: "PATCH /v1/routing-rules/:id",
+    inputSchema: z3.object({
+      ruleId: id("Routing rule"),
+      name: ruleFields.name.optional(),
+      targetChannelId: ruleFields.targetChannelId.optional(),
+      conditions: routingConditions.optional(),
+      projectId: ruleFields.projectId,
+      widgetId: ruleFields.widgetId,
+      integrationId: ruleFields.integrationId,
+      assignToUserId: ruleFields.assignToUserId,
+      isActive: ruleFields.isActive,
+      priority: ruleFields.priority
+    }),
+    outputSchema: z3.object({ rule }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: async (api, { ruleId, ...body }) => {
+      if (Object.values(body).every((v) => v === void 0)) {
+        throw new ToolError("Pass at least one field to change.");
+      }
+      const r = await api.request(
+        "PATCH",
+        `/v1/routing-rules/${encodeURIComponent(ruleId)}`,
+        { body }
+      );
+      return { rule: r.routing_rule };
+    }
+  }),
+  defineTool2({
+    name: "delete_routing_rule",
+    title: "Delete routing rule",
+    description: "Delete a routing rule for good. To stop it temporarily, use update_routing_rule with isActive: false instead. Confirm with the user first. Needs the routing:write scope.",
+    scope: "routing:write",
+    endpoint: "DELETE /v1/routing-rules/:id",
+    inputSchema: z3.object({ ruleId: id("Routing rule") }),
+    outputSchema: z3.object({ deleted: z3.boolean(), ruleId: z3.string() }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: async (api, { ruleId }) => {
+      await api.request(
+        "DELETE",
+        `/v1/routing-rules/${encodeURIComponent(ruleId)}`
+      );
+      return { deleted: true, ruleId };
+    }
+  })
+];
+var INBOX_TOOL_NAMES = INBOX_TOOLS.map((t) => t.name);
+
+// src/tools.ts
+function ok(data2) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data2, null, 2) }],
+    structuredContent: data2
   };
 }
 async function run(fn) {
@@ -620,25 +1954,15 @@ async function run(fn) {
     };
   }
 }
-var record2 = z2.record(z2.string(), z2.unknown());
-var loose = z2.looseObject({});
-var page = {
-  total: z2.number(),
-  limit: z2.number(),
-  offset: z2.number(),
-  hasMore: z2.boolean()
+var record4 = z4.record(z4.string(), z4.unknown());
+var loose2 = z4.looseObject({});
+var page2 = {
+  total: z4.number(),
+  limit: z4.number(),
+  offset: z4.number(),
+  hasMore: z4.boolean()
 };
-var conversationSummary = z2.looseObject({
-  id: z2.string(),
-  subject: z2.string().nullable().optional(),
-  status: z2.string(),
-  priority: z2.string().nullable().optional(),
-  customerEmail: z2.string().nullable().optional(),
-  customerName: z2.string().nullable().optional(),
-  tags: z2.array(z2.string()).nullable().optional(),
-  createdAt: z2.string().optional()
-});
-var READ = {
+var READ3 = {
   readOnlyHint: true,
   destructiveHint: false,
   idempotentHint: true,
@@ -650,9 +1974,9 @@ function registerServerTools(server, api) {
     {
       title: "Get project",
       description: "Show the Channlize project behind the server API key: name, ID, totals, the key's permissions and whether Slack is connected. Start here to check the setup.",
-      inputSchema: z2.object({}),
-      outputSchema: z2.object({ project: loose }),
-      annotations: READ
+      inputSchema: z4.object({}),
+      outputSchema: z4.object({ project: loose2 }),
+      annotations: READ3
     },
     () => run(async () => {
       const r = await api.request("GET", "/projects/me");
@@ -664,9 +1988,9 @@ function registerServerTools(server, api) {
     {
       title: "Get analytics",
       description: "Daily support activity for the last 30 days (UTC): conversations created and resolved, customer and agent messages.",
-      inputSchema: z2.object({}),
-      outputSchema: z2.object({ analytics: loose }),
-      annotations: READ
+      inputSchema: z4.object({}),
+      outputSchema: z4.object({ analytics: loose2 }),
+      annotations: READ3
     },
     () => run(async () => {
       const r = await api.request(
@@ -676,75 +2000,20 @@ function registerServerTools(server, api) {
       return { analytics: r.analytics };
     })
   );
-  server.registerTool(
-    "list_conversations",
-    {
-      title: "List conversations",
-      description: "List the organization's most recent support conversations (newest first, from the latest 50), optionally filtered by status or priority. Use get_conversation for the messages.",
-      inputSchema: z2.object({
-        status: z2.enum(STATUSES).optional().describe("Only conversations with this status"),
-        priority: z2.enum(PRIORITIES).optional().describe("Only conversations with this priority"),
-        limit: z2.number().int().min(1).max(50).default(20).describe("How many to return (1-50, default 20)")
-      }),
-      outputSchema: z2.object({
-        conversations: z2.array(conversationSummary),
-        returned: z2.number(),
-        matched: z2.number(),
-        scanned: z2.number()
-      }),
-      annotations: READ
-    },
-    ({ status, priority, limit }) => run(async () => {
-      const r = await api.request(
-        "GET",
-        "/conversations"
-      );
-      const all = r.conversations ?? [];
-      const matched = all.filter(
-        (c) => (!status || c.status === status) && (!priority || c.priority === priority)
-      );
-      const conversations = matched.slice(0, limit);
-      return {
-        conversations,
-        returned: conversations.length,
-        matched: matched.length,
-        scanned: all.length
-      };
-    })
-  );
-  server.registerTool(
-    "get_conversation",
-    {
-      title: "Get conversation",
-      description: "Read one conversation with its full message thread (customer, agent and system messages), status, priority and tags.",
-      inputSchema: z2.object({
-        conversationId: z2.string().uuid().describe("Conversation ID (from list_conversations)")
-      }),
-      outputSchema: z2.object({ conversation: loose }),
-      annotations: READ
-    },
-    ({ conversationId }) => run(async () => {
-      const conversation = await api.request(
-        "GET",
-        `/conversations/${encodeURIComponent(conversationId)}`
-      );
-      return { conversation };
-    })
-  );
   server.registerTool(
     "create_conversation",
     {
       title: "Create conversation",
       description: "Open a new support conversation on behalf of a customer. It is posted to Slack (the given channel, else routing rules, else the default channel). Needs the write scope. Repeating the same customer, subject and message within 30 seconds returns the existing conversation.",
-      inputSchema: z2.object({
-        customerEmail: z2.email().describe("Customer's email address"),
-        customerName: z2.string().max(255).optional().describe("Customer's name"),
-        subject: z2.string().min(1).max(500).describe("Subject line"),
-        message: z2.string().min(1).describe("First message, from the customer"),
-        channel: z2.string().optional().describe("Slack channel ID to post to, overriding routing rules"),
-        tags: z2.array(z2.string()).max(20).optional().describe("Tags")
+      inputSchema: z4.object({
+        customerEmail: z4.email().describe("Customer's email address"),
+        customerName: z4.string().max(255).optional().describe("Customer's name"),
+        subject: z4.string().min(1).max(500).describe("Subject line"),
+        message: z4.string().min(1).describe("First message, from the customer"),
+        channel: z4.string().optional().describe("Slack channel ID to post to, overriding routing rules"),
+        tags: z4.array(z4.string()).max(20).optional().describe("Tags")
       }),
-      outputSchema: z2.object({ conversation: loose }),
+      outputSchema: z4.object({ conversation: loose2 }),
       annotations: {
         readOnlyHint: false,
         destructiveHint: false,
@@ -764,12 +2033,12 @@ function registerServerTools(server, api) {
     {
       title: "List contacts",
       description: "List the customers who contacted the organization, with their conversation count. Paginate with limit/offset.",
-      inputSchema: z2.object({
-        limit: z2.number().int().min(1).max(100).default(50),
-        offset: z2.number().int().min(0).default(0)
+      inputSchema: z4.object({
+        limit: z4.number().int().min(1).max(100).default(50),
+        offset: z4.number().int().min(0).default(0)
       }),
-      outputSchema: z2.object({ contacts: z2.array(loose), ...page }),
-      annotations: READ
+      outputSchema: z4.object({ contacts: z4.array(loose2), ...page2 }),
+      annotations: READ3
     },
     ({ limit, offset }) => run(async () => {
       const r = await api.request("GET", "/contacts", {
@@ -789,11 +2058,11 @@ function registerServerTools(server, api) {
     {
       title: "Get contact",
       description: "Read one contact (customer) by ID.",
-      inputSchema: z2.object({
-        contactId: z2.string().uuid().describe("Contact ID (from list_contacts)")
+      inputSchema: z4.object({
+        contactId: z4.string().uuid().describe("Contact ID (from list_contacts)")
       }),
-      outputSchema: z2.object({ contact: loose }),
-      annotations: READ
+      outputSchema: z4.object({ contact: loose2 }),
+      annotations: READ3
     },
     ({ contactId }) => run(async () => {
       const contact = await api.request(
@@ -808,14 +2077,14 @@ function registerServerTools(server, api) {
     {
       title: "Create contact",
       description: "Add a customer by email, or return the existing one with that email. Needs the write scope.",
-      inputSchema: z2.object({
-        email: z2.email(),
-        name: z2.string().max(255).optional(),
-        company: z2.string().optional(),
-        phone: z2.string().optional(),
-        tags: z2.array(z2.string()).max(20).optional()
+      inputSchema: z4.object({
+        email: z4.email(),
+        name: z4.string().max(255).optional(),
+        company: z4.string().optional(),
+        phone: z4.string().optional(),
+        tags: z4.array(z4.string()).max(20).optional()
       }),
-      outputSchema: z2.object({ contact: loose }),
+      outputSchema: z4.object({ contact: loose2 }),
       annotations: {
         readOnlyHint: false,
         destructiveHint: false,
@@ -835,23 +2104,23 @@ function registerServerTools(server, api) {
     {
       title: "Send an Event to Slack",
       description: 'Post an Event to Slack: the event key (e.g. "user.subscribed") picks the channel and message template set under Events in the dashboard, and `data` fills its {{placeholders}}. An unknown key is saved as a disabled draft and answered with status "skipped". Needs the write scope. Pass an idempotencyKey so a retry never posts twice.',
-      inputSchema: z2.object({
-        event: z2.string().max(100).regex(
-          EVENT_KEY,
+      inputSchema: z4.object({
+        event: z4.string().max(100).regex(
+          import_core3.EVENT_KEY_PATTERN,
           "lowercase letters, digits, dots, underscores or dashes"
         ).describe("Event key, e.g. user.subscribed"),
-        data: record2.optional().describe(
+        data: record4.optional().describe(
           'Template fields, e.g. { "username": "ada", "plan": "Pro" }'
         ),
-        idempotencyKey: z2.string().min(1).max(255).optional().describe("Send at most once per key (retry-safe)"),
-        channel: z2.string().optional().describe("Slack channel ID instead of the event's channel")
+        idempotencyKey: z4.string().min(1).max(255).optional().describe("Send at most once per key (retry-safe)"),
+        channel: z4.string().optional().describe("Slack channel ID instead of the event's channel")
       }),
-      outputSchema: z2.looseObject({
-        id: z2.string(),
-        event: z2.string(),
-        status: z2.string(),
-        reason: z2.string().optional(),
-        duplicate: z2.boolean().optional()
+      outputSchema: z4.looseObject({
+        id: z4.string(),
+        event: z4.string(),
+        status: z4.string(),
+        reason: z4.string().optional(),
+        duplicate: z4.boolean().optional()
       }),
       annotations: {
         readOnlyHint: false,
@@ -860,9 +2129,9 @@ function registerServerTools(server, api) {
         openWorldHint: true
       }
     },
-    ({ event, data, idempotencyKey, channel }) => run(async () => {
+    ({ event, data: data2, idempotencyKey, channel }) => run(async () => {
       const client = await api.notifier();
-      const r = await client.notify(event, data, { idempotencyKey, channel });
+      const r = await client.notify(event, data2, { idempotencyKey, channel });
       return {
         id: r.id,
         event: r.event,
@@ -877,12 +2146,12 @@ function registerServerTools(server, api) {
     {
       title: "List Events",
       description: "List the Events configured on the project (key, name, Slack channel, message template, enabled), including disabled drafts created by unknown keys sent with notify_event.",
-      inputSchema: z2.object({}),
-      outputSchema: z2.object({
-        projectId: z2.string(),
-        definitions: z2.array(loose)
+      inputSchema: z4.object({}),
+      outputSchema: z4.object({
+        projectId: z4.string(),
+        definitions: z4.array(loose2)
       }),
-      annotations: READ
+      annotations: READ3
     },
     () => run(async () => {
       const projectId = await api.projectId();
@@ -898,15 +2167,15 @@ function registerServerTools(server, api) {
     {
       title: "List Event deliveries",
       description: "Recent notify_event deliveries on the project, newest first, with their status (queued, sent, failed, skipped) and the reason when not sent. Use it to check why an Event did not reach Slack.",
-      inputSchema: z2.object({
-        definitionId: z2.string().uuid().optional().describe("Only this Event (ID from list_event_definitions)"),
-        limit: z2.number().int().min(1).max(100).default(20)
+      inputSchema: z4.object({
+        definitionId: z4.string().uuid().optional().describe("Only this Event (ID from list_event_definitions)"),
+        limit: z4.number().int().min(1).max(100).default(20)
       }),
-      outputSchema: z2.object({
-        projectId: z2.string(),
-        deliveries: z2.array(loose)
+      outputSchema: z4.object({
+        projectId: z4.string(),
+        deliveries: z4.array(loose2)
       }),
-      annotations: READ
+      annotations: READ3
     },
     ({ definitionId, limit }) => run(async () => {
       const projectId = await api.projectId();
@@ -923,20 +2192,20 @@ function registerServerTools(server, api) {
     {
       title: "Query logs",
       description: "Search log tracking (trackEvent / trackServerEvent / track_log), newest first. Filter by severity, source, text (matches the name and properties) and time range; paginate with limit/offset. Covers all projects unless projectId is given.",
-      inputSchema: z2.object({
-        severity: z2.enum(SEVERITIES).optional(),
-        source: z2.enum(["client_sdk", "server_api", "system"]).optional().describe(
+      inputSchema: z4.object({
+        severity: z4.enum(import_core3.EVENT_SEVERITIES).optional(),
+        source: z4.enum(["client_sdk", "server_api", "system"]).optional().describe(
           "client_sdk = browser (widget key), server_api = server key"
         ),
-        search: z2.string().max(200).optional().describe("Text to look for"),
-        from: z2.iso.datetime({ offset: true }).optional().describe("ISO 8601 start"),
-        to: z2.iso.datetime({ offset: true }).optional().describe("ISO 8601 end"),
-        projectId: z2.string().uuid().optional(),
-        limit: z2.number().int().min(1).max(100).default(50),
-        offset: z2.number().int().min(0).default(0)
+        search: z4.string().max(200).optional().describe("Text to look for"),
+        from: z4.iso.datetime({ offset: true }).optional().describe("ISO 8601 start"),
+        to: z4.iso.datetime({ offset: true }).optional().describe("ISO 8601 end"),
+        projectId: z4.string().uuid().optional(),
+        limit: z4.number().int().min(1).max(100).default(50),
+        offset: z4.number().int().min(0).default(0)
       }),
-      outputSchema: z2.object({ events: z2.array(loose), ...page }),
-      annotations: READ
+      outputSchema: z4.object({ events: z4.array(loose2), ...page2 }),
+      annotations: READ3
     },
     (args) => run(async () => {
       const r = await api.request("GET", "/v1/events", { query: args });
@@ -954,12 +2223,12 @@ function registerServerTools(server, api) {
     {
       title: "Record a log",
       description: "Record a log line under Log tracking from a trusted server context (source server_api). Needs the write scope. For Slack messages about product events use notify_event instead.",
-      inputSchema: z2.object({
-        name: z2.string().min(1).max(255).describe("Log name, e.g. payment.failed"),
-        severity: z2.enum(SEVERITIES).default("info"),
-        properties: record2.optional().describe("Extra fields")
+      inputSchema: z4.object({
+        name: z4.string().min(1).max(255).describe("Log name, e.g. payment.failed"),
+        severity: z4.enum(import_core3.EVENT_SEVERITIES).default("info"),
+        properties: record4.optional().describe("Extra fields")
       }),
-      outputSchema: z2.object({ id: z2.string(), projectId: z2.string() }),
+      outputSchema: z4.object({ id: z4.string(), projectId: z4.string() }),
       annotations: {
         readOnlyHint: false,
         destructiveHint: false,
@@ -988,16 +2257,16 @@ function registerWidgetTools(server, api) {
     {
       title: "Submit contact form",
       description: "Submit the website contact form as a visitor (widget key). Creates a conversation that is posted to Slack. Useful to test the setup end to end.",
-      inputSchema: z2.object({
-        name: z2.string().min(1).describe("Visitor's name"),
-        email: z2.email().describe("Visitor's email"),
-        subject: z2.string().optional(),
-        message: z2.string().min(1),
-        pageUrl: z2.url().optional().describe("Page the form was sent from")
+      inputSchema: z4.object({
+        name: z4.string().min(1).describe("Visitor's name"),
+        email: z4.email().describe("Visitor's email"),
+        subject: z4.string().optional(),
+        message: z4.string().min(1),
+        pageUrl: z4.url().optional().describe("Page the form was sent from")
       }),
-      outputSchema: z2.looseObject({
-        conversationId: z2.string().optional(),
-        message: z2.string().optional()
+      outputSchema: z4.looseObject({
+        conversationId: z4.string().optional(),
+        message: z4.string().optional()
       }),
       annotations: VISITOR
     },
@@ -1011,12 +2280,12 @@ function registerWidgetTools(server, api) {
     {
       title: "Start chat session",
       description: "Start a live chat session as a website visitor (widget key). Returns the session ID for send_message.",
-      inputSchema: z2.object({
-        metadata: record2.optional().describe("Metadata to attach (e.g. user info)")
+      inputSchema: z4.object({
+        metadata: record4.optional().describe("Metadata to attach (e.g. user info)")
       }),
-      outputSchema: z2.looseObject({
-        sessionId: z2.string(),
-        status: z2.string()
+      outputSchema: z4.looseObject({
+        sessionId: z4.string(),
+        status: z4.string()
       }),
       annotations: VISITOR
     },
@@ -1034,13 +2303,13 @@ function registerWidgetTools(server, api) {
     {
       title: "Send chat message",
       description: "Send a visitor message in a chat session (widget key); it is posted to the Slack thread.",
-      inputSchema: z2.object({
-        sessionId: z2.string().min(1).describe("From create_chat_session"),
-        content: z2.string().min(1).max(5e3)
+      inputSchema: z4.object({
+        sessionId: z4.string().min(1).describe("From create_chat_session"),
+        content: z4.string().min(1).max(5e3)
       }),
-      outputSchema: z2.looseObject({
-        messageId: z2.string(),
-        sessionStatus: z2.string()
+      outputSchema: z4.looseObject({
+        messageId: z4.string(),
+        sessionStatus: z4.string()
       }),
       annotations: VISITOR
     },
@@ -1054,16 +2323,16 @@ function registerWidgetTools(server, api) {
     {
       title: "Read chat messages",
       description: "Read a chat session's messages, including agent replies from Slack (widget key).",
-      inputSchema: z2.object({
-        sessionId: z2.string().min(1),
-        limit: z2.number().int().min(1).max(100).default(50),
-        offset: z2.number().int().min(0).default(0)
+      inputSchema: z4.object({
+        sessionId: z4.string().min(1),
+        limit: z4.number().int().min(1).max(100).default(50),
+        offset: z4.number().int().min(0).default(0)
       }),
-      outputSchema: z2.object({
-        sessionId: z2.string(),
-        messages: z2.array(loose)
+      outputSchema: z4.object({
+        sessionId: z4.string(),
+        messages: z4.array(loose2)
       }),
-      annotations: { ...READ, openWorldHint: true }
+      annotations: { ...READ3, openWorldHint: true }
     },
     ({ sessionId, limit, offset }) => run(async () => {
       const messages = await api.widget().getChatMessages(sessionId, limit, offset);
@@ -1085,10 +2354,10 @@ function registerWidgetTools(server, api) {
     {
       title: "End chat session",
       description: "End a chat session as the visitor (widget key).",
-      inputSchema: z2.object({ sessionId: z2.string().min(1) }),
-      outputSchema: z2.looseObject({
-        sessionId: z2.string(),
-        status: z2.string()
+      inputSchema: z4.object({ sessionId: z4.string().min(1) }),
+      outputSchema: z4.looseObject({
+        sessionId: z4.string(),
+        status: z4.string()
       }),
       annotations: { ...VISITOR, idempotentHint: true }
     },
@@ -1098,6 +2367,27 @@ function registerWidgetTools(server, api) {
     })
   );
 }
+function registerAll(server, api, tools) {
+  for (const tool of tools) {
+    server.registerTool(
+      tool.name,
+      {
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        annotations: tool.annotations
+      },
+      (args) => run(async () => await tool.handler(api, args))
+    );
+  }
+}
+function registerInboxTools(server, api) {
+  registerAll(server, api, INBOX_TOOLS);
+}
+function registerAgentTools(server, api) {
+  registerAll(server, api, AGENT_TOOLS);
+}
 
 // src/http.ts
 var import_node_http = require("http");
@@ -1129,7 +2419,7 @@ async function toRequest(req, origin) {
 async function startHttpServer(factory, options = {}) {
   const host = options.host ?? "127.0.0.1";
   const port = options.port ?? 3333;
-  const path = options.path ?? "/mcp";
+  const path2 = options.path ?? "/mcp";
   const local = LOCAL_HOSTS.has(host);
   const handler = (0, import_server.createMcpHandler)(() => factory(), {
     onerror: (err) => console.error("[channlize-mcp]", err.message)
@@ -1141,8 +2431,8 @@ async function startHttpServer(factory, options = {}) {
         `http://${req.headers.host ?? `${host}:${port}`}`
       );
       const url2 = new URL(request.url);
-      if (url2.pathname !== path) {
-        res.writeHead(404, { "Content-Type": "text/plain" }).end(`Not found: use ${path}`);
+      if (url2.pathname !== path2) {
+        res.writeHead(404, { "Content-Type": "text/plain" }).end(`Not found: use ${path2}`);
         return;
       }
       const rejected = local ? (0, import_server.hostHeaderValidationResponse)(request, (0, import_server.localhostAllowedHostnames)()) ?? (0, import_server.originValidationResponse)(request, (0, import_server.localhostAllowedOrigins)()) : void 0;
@@ -1169,19 +2459,25 @@ async function startHttpServer(factory, options = {}) {
   const actualPort = typeof address === "object" && address ? address.port : port;
   const shownHost = host.includes(":") ? `[${host}]` : host;
   return {
-    url: `http://${shownHost}:${actualPort}${path}`,
+    url: `http://${shownHost}:${actualPort}${path2}`,
     server,
     close: () => new Promise((r) => server.close(() => r()))
   };
 }
 
 // src/index.ts
-var VERSION = true ? "0.3.0" : "0.0.0";
+var import_core4 = require("@channlize/core");
+var VERSION = true ? "0.5.0" : "0.0.0";
 var INSTRUCTIONS = `Channlize routes website conversations and app events to the team's Slack.
-- Inbox: list_conversations / get_conversation, then contacts. Replies and status changes happen in Slack or the dashboard.
+- Inbox: list_conversations / search_conversations, then get_conversation for the thread. reply_to_conversation sends to the customer as this key ("<key name> (agent)"), so confirm the text first; add_internal_note only reaches the team in Slack. assign_conversation, tag_conversation, close_conversation and reopen_conversation change it.
+- get_analytics_summary gives KPIs and the inbox right now; list/create/update/delete_routing_rule manage which Slack channel new conversations go to.
 - Events (notify_event) post a Slack message per event key; list_event_definitions and list_event_deliveries explain what was sent or skipped.
 - Logs: query_logs searches log tracking; track_log records one.
-- Write tools need a server API key with the write scope; a 403 means the key is read-only.`;
+- Agents (Channlize for Agents): talk to other agents and people in agent channels. list_agents, list_agent_channels and get_org_chart show who and where; send_agent_message posts; read_agent_inbox returns what was sent to your agent, and ack_agent_messages clears what you handled. With a multi-agent key, pass agentId (or set CHANNLIZE_AGENT_ID).
+- Tasks: create_task hands work to an agent (assignee, due date); update_task moves it on the board, update_task_status reports progress or the result, handoff_task passes it to a better-placed agent; list_tasks and get_task_board show the work.
+- Humans in the loop: ask_human asks people a question or for an approval, then get_answer waits (up to 25 s per call; call it again while it says still waiting). Don't act on what you asked about until it's answered; an expired approval is not an approval. cancel_question withdraws one; answer_escalated_question answers one escalated to you as a manager agent (list_questions).
+- Refusals: a POLICY_* error with a retry time means wait until then, without one the policy forbids it (don't retry). HUMAN_TAKEOVER means a person took over the thread: stay out of it until the time it gives. AGENT_THREAD_PAUSED means stop posting in that thread. get_effective_policy (agents:admin key) shows the rules.
+- Scopes: read / write for contacts, Events and logs; inbox:read, inbox:write, routing:write and analytics:read for the inbox tools; agents:send, agents:read and agents:ask_human for the agent tools. A 403 names the scope the key is missing.`;
 function buildServer(config, info = {}) {
   const api = new ChannlizeApi(resolveConfig(config));
   const server = new import_server2.McpServer(
@@ -1189,6 +2485,8 @@ function buildServer(config, info = {}) {
     { instructions: INSTRUCTIONS }
   );
   if (api.hasServerKey) {
+    registerInboxTools(server, api);
+    registerAgentTools(server, api);
     registerServerTools(server, api);
     registerServerPrompts(server);
   }
@@ -1237,6 +2535,8 @@ Keys (flags override environment variables):
   --api-key <key>         Either kind, by prefix       CHANNLIZE_API_KEY
   --project-id <id>       Project (default: the key's first project)
                                                        CHANNLIZE_PROJECT_ID
+  --agent-id <id>         Agent the agent tools act as (multi-agent keys)
+                                                       CHANNLIZE_AGENT_ID
 Options:
   --base-url <url>        API URL (default https://api.channlize.com)
                                                        CHANNLIZE_BASE_URL
@@ -1250,17 +2550,18 @@ Options:
 
 The server API key enables the inbox, contact, Events and log tools (read
 scope for reads, write scope to send). The widget key adds visitor tools
-(contact form, chat). Create keys in the Channlize dashboard under
-SDK & Integration \u2192 API keys.
+(contact form, chat). An agent key or a multi-agent key (agents:send,
+agents:read, agents:ask_human) enables the agent tools. Create keys in the
+Channlize dashboard under SDK & Integration \u2192 API keys.
 
 Claude Code:
   claude mcp add channlize --env CHANNLIZE_SERVER_API_KEY=ch_live_\u2026 -- npx -y @channlize/mcp
 
 Docs: https://github.com/channlize/sdk/tree/main/packages/mcp
 `;
-function fail(message) {
+function fail(message2) {
   console.error(
-    `channlize-mcp: ${message}
+    `channlize-mcp: ${message2}
 
 Run 'channlize-mcp --help' for usage.`
   );
@@ -1275,6 +2576,7 @@ async function main() {
         "widget-key": { type: "string" },
         "api-key": { type: "string" },
         "project-id": { type: "string" },
+        "agent-id": { type: "string" },
         "base-url": { type: "string" },
         timeout: { type: "string" },
         transport: { type: "string" },
@@ -1304,6 +2606,7 @@ async function main() {
     widgetKey: str("widget-key") ?? env.widgetKey,
     apiKey: str("api-key") ?? env.apiKey,
     projectId: str("project-id") ?? env.projectId,
+    agentId: str("agent-id") ?? env.agentId,
     baseUrl: str("base-url") ?? env.baseUrl,
     timeout: timeout !== void 0 ? Number(timeout) : env.timeout
   };