@channlize/mcp 0.1.1 → 0.4.0

package/dist/index.mjs

@@ -1,1721 +1,1206 @@
 // src/index.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { McpServer } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 
-// src/resources/index.ts
-var CONTACT_FORM_SCHEMA = `{
-  "name": "ContactFormData",
-  "description": "Data structure for submitting a contact form inquiry",
-  "type": "object",
-  "properties": {
-    "name": {
-      "type": "string",
-      "description": "Contact's full name",
-      "required": true
-    },
-    "email": {
-      "type": "string",
-      "format": "email",
-      "description": "Contact's email address",
-      "required": true
-    },
-    "subject": {
-      "type": "string",
-      "description": "Subject line for the inquiry"
-    },
-    "message": {
-      "type": "string",
-      "description": "Message content",
-      "required": true
-    },
-    "customFields": {
-      "type": "object",
-      "description": "Additional custom fields as key-value pairs",
-      "additionalProperties": true
-    },
-    "pageUrl": {
-      "type": "string",
-      "description": "URL of the page where form was submitted"
-    },
-    "userAgent": {
-      "type": "string",
-      "description": "User agent string of the submitter"
+// src/api.ts
+import {
+  ChannlizeClient,
+  ChannlizeError,
+  parseApiError
+} from "@channlize/core";
+var ToolError = class extends Error {
+  constructor(message, statusCode, code) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.name = "ToolError";
+  }
+  statusCode;
+  code;
+};
+function hintFor(status, apiMessage) {
+  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;
+    case 404:
+      return `${apiMessage}. Check the ID (and CHANNLIZE_PROJECT_ID): it must belong to the key's organization.`;
+    case 429:
+      return `${apiMessage}. Rate limited: wait a little before retrying.`;
+    default:
+      return apiMessage;
+  }
+}
+function toToolError(err) {
+  if (err instanceof ToolError) return err;
+  if (err instanceof ChannlizeError) {
+    return new ToolError(
+      err.statusCode ? hintFor(err.statusCode, err.message.replace(/\.$/, "")) : err.message,
+      err.statusCode,
+      err.code
+    );
+  }
+  return new ToolError(err instanceof Error ? err.message : String(err));
+}
+var ChannlizeApi = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  projectIdPromise;
+  widgetClient;
+  get hasServerKey() {
+    return !!this.config.serverApiKey;
+  }
+  get hasWidgetKey() {
+    return !!this.config.widgetKey;
+  }
+  requireServerKey() {
+    if (!this.config.serverApiKey) {
+      throw new ToolError(
+        "This tool needs a server API key (ch_live_\u2026): set CHANNLIZE_SERVER_API_KEY or pass --server-api-key."
+      );
     }
+    return this.config.serverApiKey;
   }
-}`;
-var CHAT_SESSION_SCHEMA = `{
-  "name": "ChatSession",
-  "description": "Real-time chat session structure",
-  "type": "object",
-  "properties": {
-    "id": {
-      "type": "string",
-      "description": "Unique session identifier"
-    },
-    "status": {
-      "type": "string",
-      "enum": ["active", "closed", "waiting"],
-      "description": "Current session status"
-    },
-    "messages": {
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/ChatMessage"
-      },
-      "description": "Array of messages in this session"
-    },
-    "metadata": {
-      "type": "object",
-      "description": "Custom metadata for the session"
-    },
-    "createdAt": {
-      "type": "string",
-      "format": "date-time",
-      "description": "Session creation timestamp"
-    },
-    "updatedAt": {
-      "type": "string",
-      "format": "date-time",
-      "description": "Last update timestamp"
+  async request(method, path, options = {}) {
+    const key = this.requireServerKey();
+    const url2 = new URL(`${this.config.baseUrl}${path}`);
+    for (const [k, v] of Object.entries(options.query ?? {})) {
+      if (v !== void 0 && v !== "") url2.searchParams.set(k, String(v));
     }
-  },
-  "definitions": {
-    "ChatMessage": {
-      "type": "object",
-      "properties": {
-        "id": { "type": "string" },
-        "content": { "type": "string" },
-        "timestamp": { "type": "string", "format": "date-time" },
-        "author": { "type": "string", "enum": ["user", "agent"] },
-        "authorData": {
-          "type": "object",
-          "properties": {
-            "name": { "type": "string" },
-            "email": { "type": "string" },
-            "avatarUrl": { "type": "string" }
-          }
+    let res;
+    try {
+      res = await fetch(url2, {
+        method,
+        headers: {
+          Authorization: `Bearer ${key}`,
+          Accept: "application/json",
+          ...options.body !== void 0 ? { "Content-Type": "application/json" } : {},
+          ...options.headers
         },
-        "attachments": {
-          "type": "array",
-          "items": { "$ref": "#/definitions/FileAttachment" }
-        }
+        // 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)
+      });
+    } 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.`,
+          408,
+          "TIMEOUT"
+        );
       }
-    },
-    "FileAttachment": {
-      "type": "object",
-      "properties": {
-        "id": { "type": "string" },
-        "name": { "type": "string" },
-        "size": { "type": "number" },
-        "type": { "type": "string" },
-        "url": { "type": "string" }
+      throw new ToolError(
+        `Could not reach the Channlize API at ${this.config.baseUrl}: ${e.message}`
+      );
+    }
+    const text = await res.text();
+    let data = void 0;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = void 0;
       }
     }
+    if (!res.ok) {
+      const { message, code } = parseApiError(res.status, data, res.statusText);
+      throw new ToolError(
+        hintFor(res.status, message.replace(/\.$/, "")),
+        res.status,
+        code
+      );
+    }
+    if (data === void 0) {
+      throw new ToolError(
+        `Unexpected non-JSON response from ${method} ${url2.pathname}`
+      );
+    }
+    return data;
   }
-}`;
-var API_REFERENCE = `# Channlize API Reference
-
-## Overview
-Channlize is a developer-first support platform that routes customer conversations directly into Slack.
-
-Base URL: \`http://api.channlize.com\` (default) or your configured API endpoint
-
-## Authentication
-All API requests require a Widget Key (API key) in the request body or as a header.
-
-## Endpoints
-
-### Contact Forms
-
-**POST /public/contact**
-Submit a contact form inquiry.
-
-Request Body:
-\`\`\`json
-{
-  "widgetKey": "your-widget-key",
-  "name": "John Doe",
-  "email": "john@example.com",
-  "subject": "Support Request",
-  "message": "I need help with...",
-  "pageUrl": "https://example.com/contact",
-  "userAgent": "Mozilla/5.0..."
-}
-\`\`\`
-
-Response:
-\`\`\`json
-{
-  "success": true,
-  "conversationId": "3f0c\u2026",
-  "message": "Thank you for contacting us! We will get back to you soon."
-}
-\`\`\`
-
-### Chat Sessions
-
-**POST /v1/chat/sessions**
-Create a new chat session.
+  /**
+   * `CHANNLIZE_PROJECT_ID`, or the first project of the key's organization
+   * (`GET /projects/me`), looked up once.
+   */
+  projectId() {
+    if (this.config.projectId) return Promise.resolve(this.config.projectId);
+    this.projectIdPromise ??= this.request(
+      "GET",
+      "/projects/me"
+    ).then((r) => {
+      if (!r.project?.id) {
+        throw new ToolError(
+          "Could not find a project for this key: set CHANNLIZE_PROJECT_ID."
+        );
+      }
+      return r.project.id;
+    }).catch((err) => {
+      this.projectIdPromise = void 0;
+      throw err;
+    });
+    return this.projectIdPromise;
+  }
+  /** `@channlize/core` client bound to the widget key (visitor tools). */
+  widget() {
+    if (!this.config.widgetKey) {
+      throw new ToolError(
+        "This tool needs the public widget key (wk_\u2026): set CHANNLIZE_WIDGET_KEY or pass --widget-key."
+      );
+    }
+    this.widgetClient ??= new ChannlizeClient({
+      apiKey: this.config.widgetKey,
+      projectId: this.config.projectId ?? "",
+      baseUrl: this.config.baseUrl,
+      timeout: this.config.timeout
+    });
+    return this.widgetClient;
+  }
+  /** `@channlize/core` client for `notify` (server key + project). */
+  async notifier() {
+    const serverApiKey = this.requireServerKey();
+    return new ChannlizeClient({
+      // core requires a widget key; notify only uses serverApiKey.
+      apiKey: this.config.widgetKey ?? "unused",
+      serverApiKey,
+      projectId: await this.projectId(),
+      baseUrl: this.config.baseUrl,
+      timeout: this.config.timeout
+    });
+  }
+};
 
-Request Body:
-\`\`\`json
-{
-  "metadata": {
-    "pageUrl": "https://example.com",
-    "userAgent": "Mozilla/5.0...",
-    "customField": "value"
+// src/config.ts
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_TIMEOUT,
+  keyKind,
+  readChannlizeEnv
+} from "@channlize/core";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
   }
+};
+function clean(value) {
+  const v = value?.trim();
+  return v ? v : void 0;
 }
-\`\`\`
-
-Response:
-\`\`\`json
-{
-  "data": {
-    "session": {
-      "id": "session_123",
-      "status": "active",
-      "messages": [],
-      "createdAt": "2025-01-15T10:00:00Z"
-    },
-    "sseEndpoint": "/v1/chat/sessions/session_123/events"
+function resolveConfig(config) {
+  let serverApiKey = clean(config.serverApiKey);
+  let widgetKey = clean(config.widgetKey);
+  const apiKey = clean(config.apiKey);
+  if (serverApiKey && 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") {
+    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;
+    else serverApiKey ??= apiKey;
+  }
+  if (!serverApiKey && !widgetKey) {
+    throw new ConfigError(
+      "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;
+  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(
+    /\/+$/,
+    ""
+  );
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new ConfigError(
+      `Invalid base URL "${config.baseUrl}": use e.g. ${DEFAULT_BASE_URL}`
+    );
   }
+  return {
+    serverApiKey,
+    widgetKey,
+    projectId: clean(config.projectId),
+    baseUrl,
+    timeout
+  };
+}
+function configFromEnv(env = process.env) {
+  const { timeout, ...rest } = readChannlizeEnv(env);
+  return { ...rest, timeout: timeout ? Number(timeout) : void 0 };
 }
-\`\`\`
 
-**POST /v1/chat/sessions/:sessionId/messages**
-Send a message in a chat session.
+// src/prompts.ts
+import * as z from "zod/v4";
 
-Request: FormData with 'content' field and optional file attachments
+// src/docs.ts
+var QUICK_START = `# Channlize quick start
 
-**GET /v1/chat/sessions/:sessionId/messages**
-Get messages for a session. Query params: limit, offset
+Channlize routes website conversations and app events to Slack.
 
-**POST /v1/chat/sessions/:sessionId/close**
-Close a chat session.
+## Keys
+- **Widget key** (\`wk_\u2026\`): public, safe in browser code. Used by the chat widget,
+  contact form and browser log tracking (\`apiKey\` in the SDK config).
+- **Server API key** (\`ch_live_\u2026\`): secret, server only (\`serverApiKey\`). Scopes:
+  \`read\` (conversations, contacts, logs, Events) and \`write\` (notify, server logs,
+  create conversations/contacts). Create both under SDK & Integration \u2192 API keys.
+- **Project ID**: shown next to each widget key.
 
-## Error Responses
+## Install
+\`\`\`bash
+npm install @channlize/core     # any JS runtime
+npm install @channlize/react    # React components and hooks
+\`\`\`
 
-Status codes:
-- 400: Validation error
-- 401: Authentication failed
-- 429: Rate limit exceeded
-- 500: Server error
+## Browser
+\`\`\`ts
+import { ChannlizeClient } from '@channlize/core';
 
-Error format:
-\`\`\`json
-{
-  "error": "Error message",
-  "code": "ERROR_CODE",
-  "field": "fieldName" // for validation errors
-}
+const client = new ChannlizeClient({ apiKey: 'wk_\u2026', projectId: '<project-id>' });
+await client.submitContactForm({ name: 'Ada', email: 'ada@example.com', message: 'Hi!' });
+await client.trackEvent('checkout.started', { properties: { cartId: 'c_1' } });
+\`\`\`
+
+## Server
+\`\`\`ts
+import { createNotifier } from '@channlize/core';
+
+// Reads CHANNLIZE_SERVER_API_KEY (or CHANNLIZE_API_KEY) and CHANNLIZE_PROJECT_ID.
+const notify = createNotifier();
+await notify('user.subscribed', { username: 'ada', plan: 'Pro' });
 \`\`\`
-`;
-var QUICK_START = `# Channlize Quick Start
 
-## Installation
+Errors are \`ChannlizeError\` (\`statusCode\`, \`code\`), with subclasses
+\`ValidationError\` (400), \`AuthenticationError\` (401) and \`RateLimitError\` (429).
+`;
+var REACT_COMPONENTS = `# @channlize/react
 
 \`\`\`bash
-# For React applications
 npm install @channlize/react
-
-# For non-React applications
-npm install @channlize/core
 \`\`\`
 
-## React Setup
-
-1. Wrap your app with ChannlizeProvider:
+## Floating chat widget (all-in-one)
+\`ChannlizeChat\` includes the provider, launcher button and chat window.
 
 \`\`\`tsx
-import { ChannlizeProvider } from '@channlize/react';
+'use client';
+import { ChannlizeChat } from '@channlize/react';
 
-function App() {
+export function SupportWidget() {
   return (
-    <ChannlizeProvider
+    <ChannlizeChat
       config={{
-        apiKey: 'your-widget-key',
-        projectId: 'your-project-id',
+        apiKey: process.env.NEXT_PUBLIC_CHANNLIZE_WIDGET_KEY!, // wk_\u2026, public
+        projectId: process.env.NEXT_PUBLIC_CHANNLIZE_PROJECT_ID!,
       }}
-    >
-      <YourApp />
-    </ChannlizeProvider>
-  );
-}
-\`\`\`
-
-2. Use the Form component:
-
-\`\`\`tsx
-import { Form } from '@channlize/react';
-
-function ContactPage() {
-  return (
-    <Form
-      onSuccess={() => console.log('Form submitted!')}
-      submitText="Send Message"
+      position="bottom-right"
+      primaryColor="#2563eb"
+      theme="auto"
+      chatProps={{ title: 'Acme Support', greeting: 'Hi there!', welcomeMessage: 'Ask us anything.' }}
     />
   );
 }
 \`\`\`
 
-3. Add live chat:
+Key props: \`position\` ('bottom-right' | 'bottom-left' | 'top-right' | 'top-left'),
+\`primaryColor\`, \`theme\` ('auto' | 'light' | 'dark'), \`defaultOpen\`, \`showOnMobile\`,
+\`offset\`, \`zIndex\`, \`onOpen\`, \`onClose\`, and \`chatProps\` (SupportChat props).
 
+## Provider + inline components
 \`\`\`tsx
-import { Chat } from '@channlize/react';
+import { ChannlizeProvider, SupportChat, ContactForm } from '@channlize/react';
 
-function SupportPage() {
-  return (
-    <Chat
-      autoStart={true}
-      title="Customer Support"
-      placeholder="How can we help?"
-    />
-  );
-}
+<ChannlizeProvider config={{ apiKey: 'wk_\u2026', projectId: '<project-id>' }}>
+  <SupportChat title="Need help?" greeting="Hi!" suggestions={['Pricing', 'Billing']} />
+  <ContactForm submitText="Send" successMessage="Thanks! We'll reply by email." />
+</ChannlizeProvider>
 \`\`\`
 
-## Core SDK Usage
+SupportChat props include \`title\`, \`greeting\`, \`welcomeMessage\`, \`suggestions\`,
+\`placeholder\`, \`allowAttachments\`, \`allowEndChat\`, \`theme\`, \`primaryColor\`,
+\`locale\`, \`maxLength\`, \`labels\` and the \`useChatSession\` options
+(\`autoConnect\`, \`metadata\`, \`persistSession\`, \`onMessage\`, \`onError\`).
+
+ContactForm props: \`customFields\`, \`onSuccess\`, \`onError\`, \`className\`, \`styles\`,
+\`submitText\`, \`successMessage\`.
+
+## Hooks (inside ChannlizeProvider)
+- \`useChatSession(options)\` \u2192 \`{ session, messages, isConnecting, isConnected, error,
+  sendMessage, startSession, endSession, reconnect }\`
+- \`useContactForm({ onSuccess, onError })\` \u2192 \`{ submit, isSubmitting, isSuccess, error, reset }\`
+- \`useChannlizeAnalytics()\` \u2192 \`{ track(name, { properties, severity }) }\` (log tracking)
+- \`useChannlize()\` \u2192 \`{ client, config }\`
+
+## Next.js App Router
+Components use state and effects: render them from a \`'use client'\` file. The widget
+key is public (\`NEXT_PUBLIC_\u2026\` is fine); never put the server API key in a
+\`NEXT_PUBLIC_\` variable.
+`;
+var EVENTS = `# Events: notify Slack from code
 
-For non-React applications:
+Each event key (e.g. \`user.subscribed\`) has a Slack channel and a message template
+with \`{{field}}\` placeholders, set under Events in the dashboard. A key that isn't set
+up yet is saved as a disabled draft the first time it is sent (\`status: 'skipped'\`),
+so you can ship code first and configure it after. Server only: needs a server API key
+with the \`write\` scope.
 
-\`\`\`typescript
-import { ChannlizeClient } from '@channlize/core';
+\`\`\`ts
+import { createNotifier } from '@channlize/core';
 
-const client = new ChannlizeClient({
-  apiKey: 'your-widget-key',
-  projectId: 'your-project-id',
-});
+type AppEvents = {
+  'user.subscribed': { username: string; plan: string };
+  'invoice.paid': { amount: string; customer: string };
+};
 
-// Submit contact form
-await client.submitContactForm({
-  name: 'John Doe',
-  email: 'john@example.com',
-  message: 'I need help!',
-});
+// Env: CHANNLIZE_SERVER_API_KEY (or CHANNLIZE_API_KEY), CHANNLIZE_PROJECT_ID.
+const notify = createNotifier<AppEvents>();
 
-// Create chat session
-const { session } = await client.createChatSession();
+const res = await notify('user.subscribed', { username: 'ada', plan: 'Pro' });
+// res.status: 'queued' | 'skipped' (see res.reason); res.duplicate on a repeated key
 
-// Send message
-await client.sendMessage(session.id, 'Hello!');
+// Retry-safe: an idempotency key already used posts nothing.
+await notify('invoice.paid', { amount: '$49', customer: 'ada@example.com' }, { idempotencyKey: 'inv_123' });
 \`\`\`
 
-## Configuration
-
-- \`apiKey\`: Your Channlize widget key (required)
-- \`projectId\`: Your project ID (required)
-- \`baseUrl\`: API base URL (optional, defaults to api.channlize.com)
-- \`timeout\`: Request timeout in ms (optional, defaults to 10000)
-`;
-var REACT_COMPONENTS = `# Channlize React Components
-
-## ChannlizeProvider
-
-Wrap your app to provide Channlize configuration to all components.
+To type keys app-wide instead, augment the interface:
+\`\`\`ts
+declare module '@channlize/core' {
+  interface ChannlizeEvents {
+    'user.subscribed': { username: string; plan: string };
+  }
+}
+\`\`\`
 
-\`\`\`tsx
-<ChannlizeProvider config={{ apiKey, projectId }}>
-  {children}
-</ChannlizeProvider>
+Over HTTP:
+\`\`\`bash
+curl -X POST https://api.channlize.com/v1/notify \\
+  -H "Authorization: Bearer $CHANNLIZE_SERVER_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -H "Idempotency-Key: signup-42" \\
+  -d '{"projectId":"<project-id>","event":"user.subscribed","data":{"username":"ada"}}'
 \`\`\`
 
-## Form
+Log tracking is separate: \`client.trackEvent\` (browser) / \`trackServerEvent\` (server)
+record log lines shown under Log tracking.
+`;
 
-A complete contact form with validation and submission handling.
+// src/prompts.ts
+function user(text) {
+  return {
+    messages: [
+      { role: "user", content: { type: "text", text } }
+    ]
+  };
+}
+function registerServerPrompts(server) {
+  server.registerPrompt(
+    "triage-conversations",
+    {
+      title: "Triage open conversations",
+      description: "Review open support conversations, rank them by urgency and draft a reply for each.",
+      argsSchema: z.object({
+        status: z.string().optional().describe(
+          "Status to triage: open (default), pending, resolved or closed"
+        ),
+        limit: z.string().optional().describe("How many conversations (default 10)")
+      })
+    },
+    ({ status, limit }) => user(`Triage my Channlize support inbox.
 
-### Props
-- \`customFields?: Array<CustomField>\` - Additional form fields
-- \`onSuccess?: () => void\` - Success callback
-- \`onError?: (error: Error) => void\` - Error callback
-- \`className?: string\` - CSS class name
-- \`styles?: FormStyles\` - Custom styles object
-- \`submitText?: string\` - Submit button text
-- \`successMessage?: string\` - Success message text
+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.
 
-### Example
-\`\`\`tsx
-<Form
-  customFields={[
+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.`)
+  );
+  server.registerPrompt(
+    "summarize-conversation",
     {
-      name: 'department',
-      label: 'Department',
-      type: 'select',
-      options: ['Sales', 'Support'],
-      required: true,
+      title: "Summarize a conversation",
+      description: "Summarize one conversation and suggest the next step.",
+      argsSchema: z.object({
+        conversationId: z.string().describe("Conversation ID")
+      })
     },
-  ]}
-  onSuccess={() => alert('Sent!')}
-  styles={{
-    button: { background: '#007bff', color: 'white' },
-  }}
-/>
-\`\`\`
+    ({ 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.`
+    )
+  );
+  server.registerPrompt(
+    "check-events",
+    {
+      title: "Check Events delivery",
+      description: "Check that Events reach Slack: list them and explain failed or skipped deliveries.",
+      argsSchema: z.object({})
+    },
+    () => user(`Check my Channlize Events setup.
 
-## Chat
+1. Call list_event_definitions and list the Events, flagging disabled drafts and Events without a Slack channel.
+2. Call list_event_deliveries (limit 50) and group the deliveries by status.
+3. For each failed or skipped delivery, explain the reason and how to fix it (enable the Event, pick a channel under Events in the dashboard, invite the Slack app to the channel, or connect Slack).`)
+  );
+}
+function registerGuidePrompts(server) {
+  server.registerPrompt(
+    "setup-events",
+    {
+      title: "Add Events to my app",
+      description: "Add Channlize Events (notify Slack from server code) to the current codebase.",
+      argsSchema: z.object({
+        events: z.string().optional().describe('Events to add, e.g. "signup, subscription upgrade"')
+      })
+    },
+    ({ events }) => user(`Add Channlize Events to this codebase${events ? ` for: ${events}` : ""}.
 
-Real-time chat widget with message history and file attachments.
+Find where these things happen on the server, then call notify there with a typed event map and an idempotency key derived from the record ID. Never call it from browser code. Read the server key from CHANNLIZE_SERVER_API_KEY and the project from CHANNLIZE_PROJECT_ID, and add both to the env example file. Don't let a notify failure break the request: catch and log it.
 
-### Props
-- \`autoStart?: boolean\` - Auto-start chat session
-- \`metadata?: Record<string, unknown>\` - Session metadata
-- \`onMessage?: (message: ChatMessage) => void\` - New message callback
-- \`onError?: (error: Error) => void\` - Error callback
-- \`className?: string\` - CSS class name
-- \`styles?: ChatStyles\` - Custom styles object
-- \`title?: string\` - Chat header title
-- \`placeholder?: string\` - Input placeholder text
-- \`maxHeight?: string\` - Maximum container height
+Reference:
 
-### Example
-\`\`\`tsx
-<Chat
-  autoStart={true}
-  title="Need Help?"
-  placeholder="Type your message..."
-  onMessage={(msg) => console.log('New:', msg)}
-  styles={{
-    container: { width: '400px', height: '500px' },
-    header: { background: '#007bff', color: 'white' },
-  }}
-/>
-\`\`\`
+${EVENTS}`)
+  );
+  server.registerPrompt(
+    "setup-live-chat",
+    {
+      title: "Add the chat widget",
+      description: "Add the Channlize live chat widget to a React or Next.js app.",
+      argsSchema: z.object({
+        framework: z.string().optional().describe("e.g. Next.js App Router, Vite, Remix")
+      })
+    },
+    ({ framework }) => user(`Add the Channlize chat widget to this ${framework || "React"} app: install @channlize/react, render ChannlizeChat once in the root layout (from a 'use client' component on Next.js), read the widget key and project ID from public env variables, and match primaryColor to the app's brand color.
 
-## Hooks
+Reference:
 
-### useContactForm()
-Hook for managing contact form state.
+${REACT_COMPONENTS}`)
+  );
+  server.registerPrompt(
+    "integrate-contact-form",
+    {
+      title: "Add a contact form",
+      description: "Add a Channlize contact form page to a React app.",
+      argsSchema: z.object({
+        styling: z.string().optional().describe("Styling approach, e.g. Tailwind or CSS modules")
+      })
+    },
+    ({ styling }) => user(`Add a contact page to this app using Channlize. Use the ContactForm component (or useContactForm with a custom form${styling ? ` styled with ${styling}` : ""}) inside ChannlizeProvider, show a clear success state, and surface errors from onError.
 
-\`\`\`tsx
-const { submit, isSubmitting, isSuccess, error, reset } = useContactForm({
-  onSuccess: (response) => console.log('Submitted:', response),
-  onError: (error) => console.error('Failed:', error),
-});
-\`\`\`
+Reference:
 
-### useChatSession()
-Hook for managing chat sessions.
+${REACT_COMPONENTS}`)
+  );
+}
 
-\`\`\`tsx
-const {
-  session,
-  messages,
-  isConnecting,
-  isConnected,
-  error,
-  sendMessage,
-  startSession,
-  endSession,
-} = useChatSession({
-  autoConnect: false,
-  metadata: { page: 'support' },
-  onMessage: (message) => console.log('New message:', message),
+// src/resources.ts
+var markdown = (uri, text) => ({
+  contents: [{ uri, mimeType: "text/markdown", text }]
 });
-\`\`\`
-
-## Styling
-
-All components accept \`styles\` prop for custom styling or \`className\` for CSS classes.
-
-CSS class names:
-- \`.channlize-form\`
-- \`.channlize-field\`
-- \`.channlize-error\`
-- \`.channlize-chat-container\`
-- \`.channlize-chat-header\`
-- \`.channlize-chat-messages\`
-- \`.channlize-message\`
-- \`.channlize-message-user\`
-- \`.channlize-message-agent\`
-`;
-var resources = [
-  {
-    uri: "channlize://schema/contact-form",
-    name: "Contact Form Schema",
-    description: "JSON schema for contact form data structure",
-    mimeType: "application/json",
-    getText: () => CONTACT_FORM_SCHEMA
-  },
-  {
-    uri: "channlize://schema/chat-session",
-    name: "Chat Session Schema",
-    description: "JSON schema for chat session data structure",
-    mimeType: "application/json",
-    getText: () => CHAT_SESSION_SCHEMA
-  },
-  {
-    uri: "channlize://docs/api-reference",
-    name: "API Reference",
-    description: "Complete Channlize API reference documentation",
-    mimeType: "text/markdown",
-    getText: () => API_REFERENCE
-  },
-  {
-    uri: "channlize://docs/quick-start",
-    name: "Quick Start Guide",
-    description: "Quick start guide for using Channlize SDK",
-    mimeType: "text/markdown",
-    getText: () => QUICK_START
-  },
-  {
-    uri: "channlize://docs/react-components",
-    name: "React Components Documentation",
-    description: "Documentation for Channlize React components and hooks",
-    mimeType: "text/markdown",
-    getText: () => REACT_COMPONENTS
+function registerResources(server, api) {
+  server.registerResource(
+    "quick-start",
+    "channlize://docs/quick-start",
+    {
+      title: "Channlize quick start",
+      description: "Keys, install, and first calls from the browser and the server.",
+      mimeType: "text/markdown"
+    },
+    (uri) => markdown(uri.href, QUICK_START)
+  );
+  server.registerResource(
+    "react-components",
+    "channlize://docs/react-components",
+    {
+      title: "@channlize/react components and hooks",
+      description: "ChannlizeChat, SupportChat, ContactForm, hooks and Next.js notes.",
+      mimeType: "text/markdown"
+    },
+    (uri) => markdown(uri.href, REACT_COMPONENTS)
+  );
+  server.registerResource(
+    "events",
+    "channlize://docs/events",
+    {
+      title: "Events: notify Slack from code",
+      description: "createNotifier / notify with typed events, idempotency and curl.",
+      mimeType: "text/markdown"
+    },
+    (uri) => markdown(uri.href, EVENTS)
+  );
+  if (api.hasServerKey) {
+    server.registerResource(
+      "project",
+      "channlize://project",
+      {
+        title: "Current Channlize project",
+        description: "The key's project: ID, name, totals, permissions and Slack connection.",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const r = await api.request(
+          "GET",
+          "/projects/me"
+        );
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(r.project, null, 2)
+            }
+          ]
+        };
+      }
+    );
   }
-];
-function getResource(uri) {
-  return resources.find((r) => r.uri === uri);
-}
-function listResources() {
-  return resources;
 }
 
-// src/tools/index.ts
-import { ChannlizeClient } from "@channlize/core";
-function createClient(context) {
-  return new ChannlizeClient({
-    apiKey: context.config.apiKey,
-    projectId: context.config.projectId || "",
-    baseUrl: context.config.baseUrl,
-    timeout: context.config.timeout
-  });
+// src/tools.ts
+import * as z2 from "zod/v4";
+import { EVENT_KEY_PATTERN, EVENT_SEVERITIES } from "@channlize/core";
+var STATUSES = ["open", "pending", "resolved", "closed"];
+var PRIORITIES = ["low", "normal", "high", "urgent"];
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
 }
-var tools = [
-  {
-    name: "submit_contact_form",
-    description: "Submit a contact form inquiry to Channlize. This creates a new conversation thread in Slack where the team can respond.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "Contact's full name"
-        },
-        email: {
-          type: "string",
-          description: "Contact's email address"
-        },
-        subject: {
-          type: "string",
-          description: "Subject line for the inquiry (optional)"
-        },
-        message: {
-          type: "string",
-          description: "The message content"
-        },
-        customFields: {
-          type: "object",
-          description: "Additional custom fields as key-value pairs (optional)",
-          additionalProperties: true
-        },
-        pageUrl: {
-          type: "string",
-          description: "URL of the page where form was submitted (optional)"
-        },
-        userAgent: {
-          type: "string",
-          description: "User agent string of the submitter (optional)"
-        }
-      },
-      required: ["name", "email", "message"]
+async function run(fn) {
+  try {
+    return ok(await fn());
+  } catch (err) {
+    const e = toToolError(err);
+    return {
+      content: [{ type: "text", text: e.message }],
+      isError: true
+    };
+  }
+}
+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 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 = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+function registerServerTools(server, api) {
+  server.registerTool(
+    "get_project",
+    {
+      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
     },
-    handler: async (args, context) => {
-      const client = createClient(context);
-      const response = await client.submitContactForm({
-        name: args.name,
-        email: args.email,
-        subject: args.subject,
-        message: args.message,
-        customFields: args.customFields,
-        pageUrl: args.pageUrl,
-        userAgent: args.userAgent
-      });
+    () => run(async () => {
+      const r = await api.request("GET", "/projects/me");
+      return { project: r.project };
+    })
+  );
+  server.registerTool(
+    "get_analytics",
+    {
+      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
+    },
+    () => run(async () => {
+      const r = await api.request(
+        "GET",
+        "/projects/analytics"
+      );
+      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 {
-        success: response.success ?? true,
-        conversationId: response.conversationId,
-        message: response.message || "Contact form submitted successfully"
+        conversations,
+        returned: conversations.length,
+        matched: matched.length,
+        scanned: all.length
       };
-    }
-  },
-  {
-    name: "create_chat_session",
-    description: "Create a new chat session for real-time messaging. Returns a session ID that can be used to send and receive messages.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        metadata: {
-          type: "object",
-          description: "Custom metadata to attach to the session (e.g., page URL, user info)",
-          additionalProperties: true
-        }
+    })
+  );
+  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")
+      }),
+      outputSchema: z2.object({ conversation: loose }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
       }
     },
-    handler: async (args, context) => {
-      const client = createClient(context);
-      const response = await client.createChatSession(args.metadata);
-      return {
-        success: true,
-        session: {
-          id: response.session.id,
-          status: response.session.status,
-          createdAt: response.session.createdAt,
-          messageCount: response.session.messages?.length || 0
-        },
-        sseEndpoint: response.sseEndpoint,
-        message: "Chat session created successfully"
-      };
-    }
-  },
-  {
-    name: "send_message",
-    description: "Send a message in an existing chat session. The message will be delivered to the Slack thread and the user can see agent replies in real-time.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sessionId: {
-          type: "string",
-          description: "The chat session ID"
-        },
-        content: {
-          type: "string",
-          description: "The message content to send"
-        }
-      },
-      required: ["sessionId", "content"]
+    (args) => run(async () => {
+      const conversation = await api.request("POST", "/conversations", {
+        body: args
+      });
+      return { conversation };
+    })
+  );
+  server.registerTool(
+    "list_contacts",
+    {
+      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)
+      }),
+      outputSchema: z2.object({ contacts: z2.array(loose), ...page }),
+      annotations: READ
     },
-    handler: async (args, context) => {
-      const client = createClient(context);
-      const response = await client.sendMessage(args.sessionId, args.content);
+    ({ limit, offset }) => run(async () => {
+      const r = await api.request("GET", "/contacts", {
+        query: { limit, offset }
+      });
       return {
-        success: true,
-        message: {
-          id: response.message.id,
-          content: response.message.content,
-          timestamp: response.message.timestamp,
-          author: response.message.author
-        },
-        sessionStatus: response.session.status,
-        deliveryMessage: "Message sent successfully"
+        contacts: r.contacts ?? [],
+        total: Number(r.total ?? 0),
+        limit: Number(r.limit ?? limit),
+        offset: Number(r.offset ?? offset),
+        hasMore: Boolean(r.hasMore)
       };
-    }
-  },
-  {
-    name: "get_chat_messages",
-    description: "Retrieve messages from a chat session. Useful for viewing conversation history.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sessionId: {
-          type: "string",
-          description: "The chat session ID"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of messages to retrieve (default: 50)",
-          default: 50
-        },
-        offset: {
-          type: "number",
-          description: "Number of messages to skip (default: 0)",
-          default: 0
-        }
-      },
-      required: ["sessionId"]
+    })
+  );
+  server.registerTool(
+    "get_contact",
+    {
+      title: "Get contact",
+      description: "Read one contact (customer) by ID.",
+      inputSchema: z2.object({
+        contactId: z2.string().uuid().describe("Contact ID (from list_contacts)")
+      }),
+      outputSchema: z2.object({ contact: loose }),
+      annotations: READ
     },
-    handler: async (args, context) => {
-      const client = createClient(context);
-      const messages = await client.getChatMessages(
-        args.sessionId,
-        args.limit || 50,
-        args.offset || 0
+    ({ contactId }) => run(async () => {
+      const contact = await api.request(
+        "GET",
+        `/contacts/${encodeURIComponent(contactId)}`
       );
+      return { contact };
+    })
+  );
+  server.registerTool(
+    "create_contact",
+    {
+      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()
+      }),
+      outputSchema: z2.object({ contact: loose }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    (args) => run(async () => {
+      const contact = await api.request("POST", "/contacts", {
+        body: args
+      });
+      return { contact };
+    })
+  );
+  server.registerTool(
+    "notify_event",
+    {
+      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_PATTERN,
+          "lowercase letters, digits, dots, underscores or dashes"
+        ).describe("Event key, e.g. user.subscribed"),
+        data: record2.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")
+      }),
+      outputSchema: z2.looseObject({
+        id: z2.string(),
+        event: z2.string(),
+        status: z2.string(),
+        reason: z2.string().optional(),
+        duplicate: z2.boolean().optional()
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    ({ event, data, idempotencyKey, channel }) => run(async () => {
+      const client = await api.notifier();
+      const r = await client.notify(event, data, { idempotencyKey, channel });
       return {
-        success: true,
-        sessionId: args.sessionId,
-        messageCount: messages.length,
-        messages: messages.map((msg) => ({
-          id: msg.id,
-          content: msg.content,
-          timestamp: msg.timestamp,
-          author: msg.author,
-          authorData: msg.authorData,
-          hasAttachments: (msg.attachments?.length || 0) > 0
-        }))
+        id: r.id,
+        event: r.event,
+        status: r.status,
+        ...r.reason ? { reason: r.reason } : {},
+        ...r.duplicate ? { duplicate: true } : {}
       };
-    }
-  },
-  {
-    name: "close_chat_session",
-    description: "Close an active chat session. This marks the conversation as complete and stops real-time updates.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sessionId: {
-          type: "string",
-          description: "The chat session ID to close"
-        }
-      },
-      required: ["sessionId"]
+    })
+  );
+  server.registerTool(
+    "list_event_definitions",
+    {
+      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)
+      }),
+      annotations: READ
+    },
+    () => run(async () => {
+      const projectId = await api.projectId();
+      const r = await api.request(
+        "GET",
+        `/v1/projects/${encodeURIComponent(projectId)}/event-definitions`
+      );
+      return { projectId, definitions: r.definitions ?? [] };
+    })
+  );
+  server.registerTool(
+    "list_event_deliveries",
+    {
+      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)
+      }),
+      outputSchema: z2.object({
+        projectId: z2.string(),
+        deliveries: z2.array(loose)
+      }),
+      annotations: READ
+    },
+    ({ definitionId, limit }) => run(async () => {
+      const projectId = await api.projectId();
+      const r = await api.request(
+        "GET",
+        `/v1/projects/${encodeURIComponent(projectId)}/event-deliveries`,
+        { query: { definitionId, limit } }
+      );
+      return { projectId, deliveries: r.deliveries ?? [] };
+    })
+  );
+  server.registerTool(
+    "query_logs",
+    {
+      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(EVENT_SEVERITIES).optional(),
+        source: z2.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)
+      }),
+      outputSchema: z2.object({ events: z2.array(loose), ...page }),
+      annotations: READ
     },
-    handler: async (args, context) => {
-      const client = createClient(context);
-      const session = await client.closeChatSession(args.sessionId);
+    (args) => run(async () => {
+      const r = await api.request("GET", "/v1/events", { query: args });
       return {
-        success: true,
-        sessionId: session.id,
-        status: session.status,
-        closedAt: session.updatedAt,
-        message: "Chat session closed successfully"
+        events: r.events ?? [],
+        total: Number(r.total ?? 0),
+        limit: Number(r.limit ?? args.limit),
+        offset: Number(r.offset ?? args.offset),
+        hasMore: Boolean(r.hasMore)
       };
-    }
-  }
-];
-function getTool(name) {
-  return tools.find((t) => t.name === name);
-}
-function listTools() {
-  return tools;
-}
-
-// src/prompts/index.ts
-var prompts = [
-  {
-    name: "integrate-contact-form",
-    description: "Guide for adding a Channlize contact form to a React application",
-    arguments: [
-      {
-        name: "framework",
-        description: "The React framework being used (e.g., Next.js, Vite, CRA)",
-        required: false
-      },
-      {
-        name: "styling",
-        description: "The styling approach (e.g., Tailwind, CSS Modules, styled-components)",
-        required: false
-      }
-    ],
-    getPrompt: (args) => {
-      const framework = args?.framework || "React";
-      const styling = args?.styling || "CSS";
-      return `# Integrating Channlize Contact Form in ${framework}
-
-## Step 1: Install Dependencies
-
-\`\`\`bash
-npm install @channlize/react
-\`\`\`
-
-## Step 2: Configure Provider
-
-Wrap your application with the ChannlizeProvider at the root level:
-
-\`\`\`tsx
-import { ChannlizeProvider } from '@channlize/react';
-
-function App() {
-  return (
-    <ChannlizeProvider
-      config={{
-        apiKey: process.env.NEXT_PUBLIC_CHANNLIZE_API_KEY, // Your widget key
-        projectId: process.env.NEXT_PUBLIC_CHANNLIZE_PROJECT_ID,
-        baseUrl: process.env.NEXT_PUBLIC_CHANNLIZE_API_URL, // Optional
-      }}
-    >
-      <YourAppContent />
-    </ChannlizeProvider>
+    })
   );
-}
-\`\`\`
-
-## Step 3: Add Form Component
-
-Create a contact page or component:
-
-\`\`\`tsx
-import { Form } from '@channlize/react';
-
-export default function ContactPage() {
-  return (
-    <div className="container mx-auto py-8">
-      <h1>Contact Us</h1>
-      <Form
-        onSuccess={() => {
-          alert('Thank you! We will get back to you soon.');
-        }}
-        onError={(error) => {
-          console.error('Failed to submit:', error);
-        }}
-        customFields={[
-          {
-            name: 'department',
-            label: 'Department',
-            type: 'select',
-            options: ['Sales', 'Support', 'Billing'],
-            required: true,
-          },
-        ]}
-        ${styling === "Tailwind" ? `className="max-w-2xl"` : ""}
-        styles={{
-          form: { maxWidth: '600px', margin: '0 auto' },
-          button: { 
-            background: '#007bff', 
-            color: 'white',
-            padding: '0.75rem 1.5rem',
-            borderRadius: '0.5rem',
-          },
-        }}
-        submitText="Send Message"
-        successMessage="Thank you! We'll respond shortly."
-      />
-    </div>
-  );
-}
-\`\`\`
-
-## Step 4: Environment Variables
-
-Add to your \`.env.local\` or \`.env\`:
-
-\`\`\`
-NEXT_PUBLIC_CHANNLIZE_API_KEY=your_widget_key_here
-NEXT_PUBLIC_CHANNLIZE_PROJECT_ID=your_project_id_here
-NEXT_PUBLIC_CHANNLIZE_API_URL=http://api.channlize.com  # Optional
-\`\`\`
-
-## Step 5: Customize (Optional)
-
-### Custom Fields
-Add custom fields to gather specific information:
-
-\`\`\`tsx
-customFields={[
-  {
-    name: 'company',
-    label: 'Company Name',
-    type: 'text',
-    required: false,
-  },
-  {
-    name: 'priority',
-    label: 'Priority',
-    type: 'select',
-    options: ['Low', 'Medium', 'High'],
-    required: true,
-  },
-]}
-\`\`\`
-
-### Custom Styling with ${styling}
-${styling === "Tailwind" ? "Use Tailwind classes with the className prop or override styles." : "Apply custom styles using the styles prop or external CSS."}
-
-## Tips
-
-- Messages are sent to your configured Slack channel instantly
-- Email fallback is automatic if Slack delivery fails
-- Form includes built-in validation and error handling
-- All fields support accessibility features (ARIA labels, keyboard navigation)
-
-## Next Steps
-
-- Set up Slack workspace integration in your Channlize dashboard
-- Configure channel routing rules
-- Add webhooks for custom workflows
-`;
-    }
-  },
-  {
-    name: "setup-live-chat",
-    description: "Guide for implementing the Channlize live chat widget in a React application",
-    arguments: [
-      {
-        name: "placement",
-        description: 'Where to place the chat widget (e.g., "page", "popup", "sidebar")',
-        required: false
+  server.registerTool(
+    "track_log",
+    {
+      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(EVENT_SEVERITIES).default("info"),
+        properties: record2.optional().describe("Extra fields")
+      }),
+      outputSchema: z2.object({ id: z2.string(), projectId: z2.string() }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
       }
-    ],
-    getPrompt: (args) => {
-      const placement = args?.placement || "page";
-      return `# Setting Up Channlize Live Chat Widget
-
-## Step 1: Install Dependencies
-
-\`\`\`bash
-npm install @channlize/react
-\`\`\`
-
-## Step 2: Configure Provider
-
-Ensure your app is wrapped with ChannlizeProvider:
-
-\`\`\`tsx
-import { ChannlizeProvider } from '@channlize/react';
-
-function App() {
-  return (
-    <ChannlizeProvider
-      config={{
-        apiKey: process.env.NEXT_PUBLIC_CHANNLIZE_API_KEY,
-        projectId: process.env.NEXT_PUBLIC_CHANNLIZE_PROJECT_ID,
-      }}
-    >
-      <YourAppContent />
-    </ChannlizeProvider>
-  );
-}
-\`\`\`
-
-## Step 3: Add Chat Component
-
-${placement === "popup" ? `
-### Popup Widget (Bottom-Right Corner)
-
-\`\`\`tsx
-import { useState } from 'react';
-import { Chat } from '@channlize/react';
-
-export function ChatWidget() {
-  const [isOpen, setIsOpen] = useState(false);
-
-  return (
-    <>
-      {/* Floating Button */}
-      {!isOpen && (
-        <button
-          onClick={() => setIsOpen(true)}
-          style={{
-            position: 'fixed',
-            bottom: '20px',
-            right: '20px',
-            width: '60px',
-            height: '60px',
-            borderRadius: '50%',
-            background: '#007bff',
-            color: 'white',
-            border: 'none',
-            fontSize: '24px',
-            cursor: 'pointer',
-            boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
-            zIndex: 1000,
-          }}
-        >
-          \u{1F4AC}
-        </button>
-      )}
-
-      {/* Chat Window */}
-      {isOpen && (
-        <div
-          style={{
-            position: 'fixed',
-            bottom: '20px',
-            right: '20px',
-            zIndex: 1000,
-            boxShadow: '0 4px 24px rgba(0,0,0,0.15)',
-            borderRadius: '12px',
-            overflow: 'hidden',
-          }}
-        >
-          <Chat
-            autoStart={true}
-            title="Customer Support"
-            placeholder="Type your message..."
-            onMessage={(message) => {
-              console.log('New message:', message);
-            }}
-            styles={{
-              container: {
-                width: '380px',
-                height: '600px',
-                display: 'flex',
-                flexDirection: 'column',
-                background: 'white',
-              },
-              header: {
-                background: '#007bff',
-                color: 'white',
-                padding: '1rem',
-                display: 'flex',
-                alignItems: 'center',
-              },
-            }}
-          />
-          <button
-            onClick={() => setIsOpen(false)}
-            style={{
-              position: 'absolute',
-              top: '10px',
-              right: '10px',
-              background: 'rgba(255,255,255,0.2)',
-              border: 'none',
-              color: 'white',
-              cursor: 'pointer',
-              fontSize: '20px',
-              width: '30px',
-              height: '30px',
-              borderRadius: '50%',
-            }}
-          >
-            \xD7
-          </button>
-        </div>
-      )}
-    </>
-  );
-}
-\`\`\`
-` : `
-### Embedded Chat
-
-\`\`\`tsx
-import { Chat } from '@channlize/react';
-
-export default function SupportPage() {
-  return (
-    <div className="container mx-auto py-8">
-      <h1>Customer Support</h1>
-      <Chat
-        autoStart={true}
-        title="Live Chat Support"
-        placeholder="How can we help you today?"
-        onMessage={(message) => {
-          // Handle incoming messages
-          console.log('New message:', message);
-        }}
-        onError={(error) => {
-          console.error('Chat error:', error);
-        }}
-        styles={{
-          container: {
-            width: '100%',
-            maxWidth: '800px',
-            height: '600px',
-            margin: '0 auto',
-            border: '1px solid #e0e0e0',
-            borderRadius: '12px',
-          },
-          header: {
-            background: '#007bff',
-            color: 'white',
-          },
-        }}
-        maxHeight="600px"
-      />
-    </div>
-  );
-}
-\`\`\`
-`}
-
-## Step 4: Advanced Features
-
-### Custom Metadata
-Pass context about the user or page:
-
-\`\`\`tsx
-<Chat
-  metadata={{
-    userId: user?.id,
-    userName: user?.name,
-    currentPage: window.location.pathname,
-    plan: 'pro',
-  }}
-/>
-\`\`\`
-
-### Event Handlers
-React to chat events:
-
-\`\`\`tsx
-<Chat
-  onMessage={(message) => {
-    // Track analytics
-    analytics.track('chat_message_received', {
-      author: message.author,
-      timestamp: message.timestamp,
-    });
-  }}
-  onError={(error) => {
-    // Report errors
-    errorReporting.log(error);
-  }}
-/>
-\`\`\`
-
-## Real-Time Features
-
-- Messages are delivered instantly via Server-Sent Events (SSE)
-- Agent presence indicators show when team is active
-- File attachments supported (images, documents)
-- Automatic reconnection on connection loss
-- Message history persisted across sessions
-
-## Tips
-
-- Chat sessions are automatically created on first message
-- Sessions remain active until explicitly closed
-- Messages are threaded in Slack for team collaboration
-- Supports multiple concurrent chat sessions per project
-
-## Next Steps
-
-- Configure Slack notifications for new chats
-- Set up auto-responses for common questions
-- Integrate with your analytics platform
-- Add custom routing based on user context
-`;
-    }
-  },
-  {
-    name: "customize-styling",
-    description: "Guide for theming and customizing Channlize components",
-    getPrompt: () => `# Customizing Channlize Component Styling
-
-Channlize components are designed to be highly customizable to match your brand.
-
-## Styling Approaches
-
-### 1. Inline Styles with \`styles\` Prop
-
-The most direct way to customize appearance:
-
-\`\`\`tsx
-<Form
-  styles={{
-    form: {
-      maxWidth: '600px',
-      margin: '0 auto',
-      padding: '2rem',
-      background: '#f9fafb',
-      borderRadius: '8px',
-    },
-    field: {
-      marginBottom: '1.5rem',
-    },
-    label: {
-      display: 'block',
-      marginBottom: '0.5rem',
-      fontWeight: '600',
-      color: '#374151',
-    },
-    input: {
-      width: '100%',
-      padding: '0.75rem',
-      border: '1px solid #d1d5db',
-      borderRadius: '6px',
-      fontSize: '1rem',
-    },
-    textarea: {
-      width: '100%',
-      padding: '0.75rem',
-      border: '1px solid #d1d5db',
-      borderRadius: '6px',
-      fontSize: '1rem',
-      minHeight: '120px',
-    },
-    button: {
-      background: '#3b82f6',
-      color: 'white',
-      padding: '0.75rem 2rem',
-      border: 'none',
-      borderRadius: '6px',
-      fontSize: '1rem',
-      fontWeight: '600',
-      cursor: 'pointer',
-      transition: 'background 0.2s',
-    },
-    error: {
-      color: '#ef4444',
-      fontSize: '0.875rem',
-      marginTop: '0.5rem',
-    },
-    success: {
-      background: '#ecfdf5',
-      border: '1px solid #10b981',
-      padding: '1.5rem',
-      borderRadius: '6px',
-      color: '#065f46',
-    },
-  }}
-/>
-\`\`\`
-
-### 2. CSS Classes with \`className\` Prop
-
-Use your existing CSS or CSS-in-JS solution:
-
-\`\`\`tsx
-<Form className="custom-form" />
-\`\`\`
-
-\`\`\`css
-/* styles.css */
-.channlize-form {
-  max-width: 600px;
-  margin: 0 auto;
-}
-
-.channlize-field {
-  margin-bottom: 1.5rem;
-}
-
-.channlize-field label {
-  font-weight: 600;
-  color: var(--primary-text);
-}
-
-.channlize-field input,
-.channlize-field textarea,
-.channlize-field select {
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  padding: 0.75rem;
-}
-
-.channlize-form button[type="submit"] {
-  background: var(--primary-color);
-  color: white;
-}
-\`\`\`
-
-### 3. Tailwind CSS
-
-Combine with Tailwind utility classes:
-
-\`\`\`tsx
-<Form
-  className="max-w-2xl mx-auto p-8"
-  styles={{
-    input: {
-      // Tailwind styles as objects don't work well
-      // Use className on wrapper or global CSS
     },
-  }}
-/>
-\`\`\`
-
-\`\`\`css
-/* globals.css with @layer */
-@layer components {
-  .channlize-field input {
-    @apply w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500;
-  }
-  
-  .channlize-field textarea {
-    @apply w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500;
-  }
-  
-  .channlize-form button[type="submit"] {
-    @apply bg-blue-600 hover:bg-blue-700 text-white font-semibold py-3 px-6 rounded-lg transition;
-  }
+    ({ name, severity, properties }) => run(async () => {
+      const projectId = await api.projectId();
+      const r = await api.request("POST", "/v1/events", {
+        body: { projectId, name, severity, properties }
+      });
+      return { id: r.id, projectId };
+    })
+  );
 }
-\`\`\`
-
-## Styling Chat
-
-\`\`\`tsx
-<Chat
-  styles={{
-    container: {
-      border: '1px solid #e5e7eb',
-      borderRadius: '12px',
-      overflow: 'hidden',
-      boxShadow: '0 4px 12px rgba(0,0,0,0.1)',
-    },
-    header: {
-      background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
-      color: 'white',
-      padding: '1rem',
-    },
-    messages: {
-      background: '#f9fafb',
-      padding: '1rem',
+var VISITOR = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: true
+};
+function registerWidgetTools(server, api) {
+  server.registerTool(
+    "submit_contact_form",
+    {
+      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")
+      }),
+      outputSchema: z2.looseObject({
+        conversationId: z2.string().optional(),
+        message: z2.string().optional()
+      }),
+      annotations: VISITOR
     },
-    messageUser: {
-      background: '#3b82f6',
-      color: 'white',
-      padding: '0.75rem',
-      borderRadius: '12px 12px 4px 12px',
-      maxWidth: '70%',
-      marginLeft: 'auto',
+    (args) => run(async () => {
+      const r = await api.widget().submitContactForm(args);
+      return { conversationId: r.conversationId, message: r.message };
+    })
+  );
+  server.registerTool(
+    "create_chat_session",
+    {
+      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)")
+      }),
+      outputSchema: z2.looseObject({
+        sessionId: z2.string(),
+        status: z2.string()
+      }),
+      annotations: VISITOR
     },
-    messageAgent: {
-      background: 'white',
-      color: '#1f2937',
-      padding: '0.75rem',
-      borderRadius: '12px 12px 12px 4px',
-      maxWidth: '70%',
-      border: '1px solid #e5e7eb',
+    ({ metadata }) => run(async () => {
+      const r = await api.widget().createChatSession(metadata);
+      return {
+        sessionId: r.session.id,
+        status: r.session.status,
+        createdAt: String(r.session.createdAt)
+      };
+    })
+  );
+  server.registerTool(
+    "send_message",
+    {
+      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)
+      }),
+      outputSchema: z2.looseObject({
+        messageId: z2.string(),
+        sessionStatus: z2.string()
+      }),
+      annotations: VISITOR
     },
-    input: {
-      border: '1px solid #d1d5db',
-      borderRadius: '6px',
-      padding: '0.75rem',
-      fontSize: '1rem',
+    ({ sessionId, content }) => run(async () => {
+      const r = await api.widget().sendMessage(sessionId, content);
+      return { messageId: r.message.id, sessionStatus: r.session.status };
+    })
+  );
+  server.registerTool(
+    "get_chat_messages",
+    {
+      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)
+      }),
+      outputSchema: z2.object({
+        sessionId: z2.string(),
+        messages: z2.array(loose)
+      }),
+      annotations: { ...READ, openWorldHint: true }
     },
-    button: {
-      background: '#3b82f6',
-      color: 'white',
-      padding: '0.75rem 1.5rem',
-      borderRadius: '6px',
-      border: 'none',
-      cursor: 'pointer',
+    ({ sessionId, limit, offset }) => run(async () => {
+      const messages = await api.widget().getChatMessages(sessionId, limit, offset);
+      return {
+        sessionId,
+        messages: messages.map((m) => ({
+          id: m.id,
+          author: m.author,
+          authorName: m.authorData?.name,
+          content: m.content,
+          timestamp: String(m.timestamp),
+          attachments: m.attachments?.length ?? 0
+        }))
+      };
+    })
+  );
+  server.registerTool(
+    "close_chat_session",
+    {
+      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()
+      }),
+      annotations: { ...VISITOR, idempotentHint: true }
     },
-  }}
-/>
-\`\`\`
-
-## CSS Class Reference
-
-All Channlize components use semantic CSS classes:
-
-**Form:**
-- \`.channlize-form\` - Form container
-- \`.channlize-form-success\` - Success message container
-- \`.channlize-field\` - Field wrapper
-- \`.channlize-error\` - Error message
-
-**Chat:**
-- \`.channlize-chat-container\` - Main container
-- \`.channlize-chat-header\` - Header section
-- \`.channlize-chat-messages\` - Messages container
-- \`.channlize-message\` - Individual message
-- \`.channlize-message-user\` - User message
-- \`.channlize-message-agent\` - Agent message
-- \`.channlize-chat-input-container\` - Input area
-
-## Dark Mode Example
-
-\`\`\`tsx
-const darkStyles = {
-  form: {
-    background: '#1f2937',
-    color: '#f9fafb',
-  },
-  input: {
-    background: '#374151',
-    color: '#f9fafb',
-    border: '1px solid #4b5563',
-  },
-  button: {
-    background: '#3b82f6',
-    color: 'white',
-  },
-};
-
-<Form styles={darkStyles} />
-\`\`\`
-`
-  },
-  {
-    name: "handle-webhooks",
-    description: "Guide for integrating Channlize webhooks into custom workflows",
-    getPrompt: () => `# Integrating Channlize Webhooks
-
-Channlize can send webhook events to your backend for custom workflows and integrations.
-
-## Available Webhook Events
-
-- \`conversation.created\` - New contact form or chat session started
-- \`message.created\` - New message in a conversation
-- \`conversation.closed\` - Conversation marked as closed
-- \`agent.assigned\` - Agent assigned to conversation
-
-## Setting Up Webhooks
-
-### 1. Configure Webhook URL
-
-In your Channlize dashboard:
-1. Navigate to Project Settings \u2192 Webhooks
-2. Add your webhook endpoint URL
-3. Select which events to receive
-4. Save your secret key for verification
-
-### 2. Create Webhook Handler (Next.js API Route)
-
-\`\`\`typescript
-// app/api/webhooks/channlize/route.ts
-import { NextRequest, NextResponse } from 'next/server';
-import crypto from 'crypto';
-
-const WEBHOOK_SECRET = process.env.CHANNLIZE_WEBHOOK_SECRET!;
-
-function verifySignature(payload: string, signature: string): boolean {
-  const hmac = crypto.createHmac('sha256', WEBHOOK_SECRET);
-  const digest = hmac.update(payload).digest('hex');
-  return crypto.timingSafeEqual(
-    Buffer.from(signature),
-    Buffer.from(digest)
+    ({ sessionId }) => run(async () => {
+      const s = await api.widget().closeChatSession(sessionId);
+      return { sessionId: s.id ?? sessionId, status: s.status };
+    })
   );
 }
 
-export async function POST(req: NextRequest) {
-  const signature = req.headers.get('x-channlize-signature');
-  const payload = await req.text();
-
-  if (!signature || !verifySignature(payload, signature)) {
-    return NextResponse.json(
-      { error: 'Invalid signature' },
-      { status: 401 }
-    );
-  }
-
-  const event = JSON.parse(payload);
-
-  // Handle different event types
-  switch (event.type) {
-    case 'conversation.created':
-      await handleNewConversation(event.data);
-      break;
-
-    case 'message.created':
-      await handleNewMessage(event.data);
-      break;
-
-    case 'conversation.closed':
-      await handleConversationClosed(event.data);
-      break;
-
-    default:
-      console.log('Unhandled event type:', event.type);
-  }
-
-  return NextResponse.json({ received: true });
-}
-
-async function handleNewConversation(data: any) {
-  // Example: Log to analytics
-  await analytics.track('support_conversation_started', {
-    conversationId: data.conversation.id,
-    type: data.conversation.type, // 'contact_form' or 'chat'
-    customerEmail: data.conversation.email,
-  });
-
-  // Example: Notify sales team for high-value customers
-  if (data.conversation.metadata?.customerTier === 'enterprise') {
-    await notifySalesTeam({
-      conversationId: data.conversation.id,
-      customerEmail: data.conversation.email,
-      message: data.conversation.initialMessage,
-    });
-  }
-}
-
-async function handleNewMessage(data: any) {
-  // Example: Auto-tag based on content
-  const message = data.message.content.toLowerCase();
-  
-  if (message.includes('bug') || message.includes('error')) {
-    await tagConversation(data.conversation.id, 'bug');
-  }
-  
-  if (message.includes('billing') || message.includes('payment')) {
-    await tagConversation(data.conversation.id, 'billing');
-    await assignToDepartment(data.conversation.id, 'billing');
+// src/http.ts
+import { createServer } from "http";
+import {
+  createMcpHandler,
+  hostHeaderValidationResponse,
+  localhostAllowedHostnames,
+  localhostAllowedOrigins,
+  originValidationResponse
+} from "@modelcontextprotocol/server";
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+async function toRequest(req, origin) {
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (Array.isArray(v)) v.forEach((x) => headers.append(k, x));
+    else if (v !== void 0) headers.set(k, v);
   }
-
-  // Example: Sentiment analysis
-  const sentiment = await analyzeSentiment(message);
-  if (sentiment === 'negative') {
-    await escalateConversation(data.conversation.id, 'high');
+  let body;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    body = new Uint8Array(Buffer.concat(chunks));
   }
-}
-
-async function handleConversationClosed(data: any) {
-  // Example: Send satisfaction survey
-  await sendSurveyEmail({
-    to: data.conversation.email,
-    conversationId: data.conversation.id,
-    resolutionTime: data.metrics.resolutionTime,
+  const controller = new AbortController();
+  req.on("close", () => {
+    if (!req.complete) controller.abort();
   });
-
-  // Example: Update CRM
-  await updateCRM({
-    email: data.conversation.email,
-    lastInteraction: new Date(),
-    supportTicketId: data.conversation.id,
-    resolved: true,
+  return new Request(new URL(req.url ?? "/", origin), {
+    method: req.method,
+    headers,
+    body,
+    signal: controller.signal
   });
 }
-\`\`\`
-
-### 3. Express.js Example
-
-\`\`\`typescript
-import express from 'express';
-import crypto from 'crypto';
-
-const app = express();
-
-// Raw body needed for signature verification
-app.use('/webhooks/channlize', express.raw({ type: 'application/json' }));
-
-app.post('/webhooks/channlize', (req, res) => {
-  const signature = req.headers['x-channlize-signature'];
-  const payload = req.body.toString();
-
-  // Verify signature
-  const hmac = crypto.createHmac('sha256', process.env.CHANNLIZE_WEBHOOK_SECRET);
-  const digest = hmac.update(payload).digest('hex');
-
-  if (signature !== digest) {
-    return res.status(401).json({ error: 'Invalid signature' });
-  }
-
-  const event = JSON.parse(payload);
-
-  // Handle event
-  handleEvent(event);
-
-  res.json({ received: true });
-});
-\`\`\`
-
-## Webhook Event Payload Examples
-
-### conversation.created
-
-\`\`\`json
-{
-  "type": "conversation.created",
-  "timestamp": "2025-01-15T10:00:00Z",
-  "data": {
-    "conversation": {
-      "id": "conv_123",
-      "type": "contact_form",
-      "status": "open",
-      "email": "customer@example.com",
-      "name": "John Doe",
-      "initialMessage": "I need help with...",
-      "metadata": {
-        "pageUrl": "https://example.com/contact",
-        "userAgent": "Mozilla/5.0..."
-      },
-      "createdAt": "2025-01-15T10:00:00Z"
-    }
-  }
-}
-\`\`\`
-
-### message.created
-
-\`\`\`json
-{
-  "type": "message.created",
-  "timestamp": "2025-01-15T10:05:00Z",
-  "data": {
-    "message": {
-      "id": "msg_456",
-      "conversationId": "conv_123",
-      "content": "Thanks for reaching out!",
-      "author": "agent",
-      "authorData": {
-        "name": "Sarah",
-        "email": "sarah@example.com"
-      },
-      "timestamp": "2025-01-15T10:05:00Z"
-    },
-    "conversation": {
-      "id": "conv_123",
-      "status": "open"
+async function startHttpServer(factory, options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 3333;
+  const path = options.path ?? "/mcp";
+  const local = LOCAL_HOSTS.has(host);
+  const handler = createMcpHandler(() => factory(), {
+    onerror: (err) => console.error("[channlize-mcp]", err.message)
+  });
+  const server = createServer(async (req, res) => {
+    try {
+      const request = await toRequest(
+        req,
+        `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}`);
+        return;
+      }
+      const rejected = local ? hostHeaderValidationResponse(request, localhostAllowedHostnames()) ?? originValidationResponse(request, localhostAllowedOrigins()) : void 0;
+      const response = rejected ?? await handler.fetch(request);
+      res.writeHead(response.status, Object.fromEntries(response.headers));
+      if (response.body) {
+        for await (const chunk of response.body) {
+          res.write(chunk);
+        }
+      }
+      res.end();
+    } catch (err) {
+      console.error("[channlize-mcp]", err.message);
+      if (!res.headersSent)
+        res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Internal server error");
     }
-  }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => resolve());
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  const shownHost = host.includes(":") ? `[${host}]` : host;
+  return {
+    url: `http://${shownHost}:${actualPort}${path}`,
+    server,
+    close: () => new Promise((r) => server.close(() => r()))
+  };
 }
-\`\`\`
-
-## Use Cases
-
-1. **CRM Integration**: Sync conversations to Salesforce, HubSpot, etc.
-2. **Analytics**: Track support metrics in your data warehouse
-3. **Auto-routing**: Assign conversations based on content analysis
-4. **Notifications**: Alert teams via SMS, PagerDuty for urgent issues
-5. **AI Enhancement**: Feed messages to AI for sentiment/intent analysis
-6. **Billing**: Track support usage for metered billing
 
-## Security Best Practices
-
-- Always verify webhook signatures
-- Use HTTPS endpoints only
-- Rotate webhook secrets periodically
-- Implement rate limiting on webhook endpoints
-- Log all webhook events for audit trail
-`
+// src/index.ts
+import {
+  ChannlizeError as ChannlizeError2,
+  ValidationError,
+  AuthenticationError,
+  RateLimitError
+} from "@channlize/core";
+var VERSION = true ? "0.4.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.
+- 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.`;
+function buildServer(config, info = {}) {
+  const api = new ChannlizeApi(resolveConfig(config));
+  const server = new McpServer(
+    { name: info.name ?? "channlize", version: info.version ?? VERSION },
+    { instructions: INSTRUCTIONS }
+  );
+  if (api.hasServerKey) {
+    registerServerTools(server, api);
+    registerServerPrompts(server);
   }
-];
-function getPrompt(name) {
-  return prompts.find((p) => p.name === name);
+  if (api.hasWidgetKey) registerWidgetTools(server, api);
+  registerResources(server, api);
+  registerGuidePrompts(server);
+  return server;
 }
-function listPrompts() {
-  return prompts;
-}
-
-// src/index.ts
 var ChannlizeMCPServer = class {
   server;
   config;
+  info;
   constructor(options = {}) {
-    this.config = options.config;
-    this.server = new Server(
-      {
-        name: options.name || "channlize-mcp",
-        version: options.version || "0.1.0"
-      },
-      {
-        capabilities: {
-          resources: {},
-          tools: {},
-          prompts: {}
-        }
-      }
-    );
-    this.setupHandlers();
-  }
-  setupHandlers() {
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      const resources2 = listResources();
-      return {
-        resources: resources2.map((r) => ({
-          uri: r.uri,
-          name: r.name,
-          description: r.description,
-          mimeType: r.mimeType
-        }))
-      };
-    });
-    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      const resource = getResource(request.params.uri);
-      if (!resource) {
-        throw new Error(`Resource not found: ${request.params.uri}`);
-      }
-      return {
-        contents: [
-          {
-            uri: resource.uri,
-            mimeType: resource.mimeType,
-            text: resource.getText()
-          }
-        ]
-      };
-    });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      const tools2 = listTools();
-      return {
-        tools: tools2.map((t) => ({
-          name: t.name,
-          description: t.description,
-          inputSchema: t.inputSchema
-        }))
-      };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const tool = getTool(request.params.name);
-      if (!tool) {
-        throw new Error(`Tool not found: ${request.params.name}`);
-      }
-      if (!this.config?.apiKey) {
-        throw new Error(
-          "Channlize API key required. Please configure the MCP server with your API credentials."
-        );
-      }
-      const context = {
-        config: this.config
-      };
-      try {
-        const result = await tool.handler(
-          request.params.arguments || {},
-          context
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result, null, 2)
-            }
-          ]
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: false,
-                  error: error.message || "Unknown error",
-                  code: error.code,
-                  statusCode: error.statusCode
-                },
-                null,
-                2
-              )
-            }
-          ],
-          isError: true
-        };
-      }
-    });
-    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-      const prompts2 = listPrompts();
-      return {
-        prompts: prompts2.map((p) => ({
-          name: p.name,
-          description: p.description,
-          arguments: p.arguments
-        }))
-      };
-    });
-    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const prompt = getPrompt(request.params.name);
-      if (!prompt) {
-        throw new Error(`Prompt not found: ${request.params.name}`);
-      }
-      const args = request.params.arguments;
-      const text = prompt.getPrompt(args);
-      return {
-        description: prompt.description,
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text
-            }
-          }
-        ]
-      };
-    });
+    this.config = resolveConfig(options.config ?? {});
+    this.info = { name: options.name, version: options.version };
+    this.server = buildServer(this.config, this.info);
   }
-  /**
-   * Set or update the Channlize configuration
-   */
-  setConfig(config) {
-    this.config = config;
-  }
-  /**
-   * Get the underlying MCP server instance
-   */
+  /** The underlying `McpServer`. */
   getServer() {
     return this.server;
   }
-  /**
-   * Start the server with stdio transport
-   */
+  /** Serve over stdio (what desktop and IDE clients launch). */
   async runStdio() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
+    await this.server.connect(new StdioServerTransport());
   }
   /**
-   * Close the server
+   * Serve Streamable HTTP at `http://<host>:<port>/mcp` (default
+   * 127.0.0.1:3333). Each request gets a fresh server; nothing is shared.
    */
+  async runHttp(options = {}) {
+    return startHttpServer(() => buildServer(this.config, this.info), options);
+  }
   async close() {
     await this.server.close();
   }
@@ -1725,14 +1210,19 @@ function createMCPServer(options) {
 }
 var index_default = ChannlizeMCPServer;
 export {
+  AuthenticationError,
+  ChannlizeError2 as ChannlizeError,
   ChannlizeMCPServer,
+  ConfigError,
+  RateLimitError,
+  ToolError,
+  VERSION,
+  ValidationError,
+  buildServer,
+  configFromEnv,
   createMCPServer,
   index_default as default,
-  getPrompt,
-  getResource,
-  getTool,
-  listPrompts,
-  listResources,
-  listTools
+  keyKind,
+  resolveConfig
 };
 //# sourceMappingURL=index.mjs.map