ChatKit

1. Chat providers: These are first-class integrations with third-party chat providers.
2. Vercel AI SDK chat provider: This managed provider exposes your agent through a Vercel AI SDK-compatible endpoint for custom clients.
3. Signals: These are events from third-party providers that Tilde delivers to your agent.

​

Set up ChatKit

pnpm add @ai-sdk/openai ai @trytilde/sdk @trytilde/sdk-vercel-ai-node

import { openai } from "@ai-sdk/openai";
import {
  chatKitEndpoint,
  convertToAiSdkMessages,
  createClient,
} from "@trytilde/sdk-vercel-ai-node";
import { consumeStream, convertToModelMessages, streamText } from "ai";

export const POST = chatKitEndpoint({
  client: createClient({
    apiKey: process.env.TILDE_API_KEY!,
    orgId: process.env.TILDE_ORG_ID!,
    teamId: process.env.TILDE_TEAM_ID!,
  }),
  webhookSigningKey: process.env.TILDE_WEBHOOK_SIGNING_KEY!,
  responseMode: "agentLoop",
  async handler(request, context) {
    const history = await context.session.history();
    const messages = await convertToAiSdkMessages({
      messages: [...history.items, ...context.messages],
      chatkit: context.chatkit,
    });
    const result = streamText({
      abortSignal: request.signal,
      messages: await convertToModelMessages(messages),
      model: openai("gpt-5.5"),
    });

    return result.toUIMessageStreamResponse({
      consumeSseStream: consumeStream,
      originalMessages: messages,
    });
  },
});

​

Choose how the endpoint responds

• agentLoop streams returned assistant text as the visible reply, preserving the existing endpoint pattern.
• tool treats returned assistant text as private reasoning. The agent must call context.session.tools.sendMessage (also available through context.$provider.tools) for visible replies.

​

Confirm an outbound message

​

Share a room with people and agents

​

Keep substantial work durable

• A goal records the outcome for one agent and session. A task records an independently deliverable piece of that goal, including dependencies and progress.
• A background job delegates one bounded objective to an explicit child agent. Jobs persist an optional model_id, hard duration/token/cost budgets, child session, transcript message IDs, artifacts, and terminal result.
• An AgentRun persists the model-loop objective, generation-fenced lease, steps, token/cost totals, loop counters, wake state, and tool-effect receipts.
• A routine stores recurring intent and its schedule. Prefer an event trigger when the same work can start from a Signal.

​

Compact model context without rewriting history

​

Test your agent in ChatKit workspace

​

Approve agent-requested capability changes

​

Search conversations

curl --get \
  --header "Authorization: Bearer $TILDE_API_KEY" \
  --data-urlencode "q=deployment rollback" \
  --data-urlencode "page_size=25" \
  "https://api.trytilde.ai/api/v1/team/$TILDE_TEAM_ID/chatkit/workspace/search"

curl --get \
  --header "Authorization: Bearer $TILDE_API_KEY" \
  --data-urlencode "q=customer reference" \
  --data-urlencode "session_id=$TILDE_SESSION_ID" \
  "https://api.trytilde.ai/api/v1/team/$TILDE_TEAM_ID/chatkit/workspace/search"

​

Audit coding-agent sessions

openbot plugin --cli codex --agent-id "$TILDE_CHATKIT_AGENT_ID"
openbot plugin --cli claude --agent-id "$TILDE_CHATKIT_AGENT_ID"
openbot plugin --cli cursor --agent-id "$TILDE_CHATKIT_AGENT_ID"
openbot plugin --cli opencode --agent-id "$TILDE_CHATKIT_AGENT_ID"
openbot plugin --cli gemini --agent-id "$TILDE_CHATKIT_AGENT_ID"

​

Provider-specific message metadata

import {
  chatKitEndpoint,
  createClient,
} from "@trytilde/sdk-vercel-ai-node";

export const POST = chatKitEndpoint({
  client: createClient({
    apiKey: process.env.TILDE_API_KEY!,
    orgId: process.env.TILDE_ORG_ID!,
    teamId: process.env.TILDE_TEAM_ID!,
  }),
  webhookSigningKey: process.env.TILDE_WEBHOOK_SIGNING_KEY!,
  responseMode: "agentLoop",
  async handler(_request, context) {
    console.log({
      event: context.github?.event,
      owner: context.github?.owner,
      repo: context.github?.repo,
      pullNumber: context.github?.pull_number,
      issueNumber: context.github?.issue_number,
    });

    // ...rest of your agent code.
  },
});

import {
  chatKitEndpoint,
  createClient,
} from "@trytilde/sdk-vercel-ai-node";

export const POST = chatKitEndpoint({
  client: createClient({
    apiKey: process.env.TILDE_API_KEY!,
    orgId: process.env.TILDE_ORG_ID!,
    teamId: process.env.TILDE_TEAM_ID!,
  }),
  webhookSigningKey: process.env.TILDE_WEBHOOK_SIGNING_KEY!,
  responseMode: "agentLoop",
  async handler(_request, context) {
    console.log({
      teamId: context.slack?.team_id,
      channelId: context.slack?.channel_id,
      threadTimestamp: context.slack?.thread_ts,
      userId: context.slack?.user,
    });

    // ...rest of your agent code.
  },
});

​

Work with session context

const history = await context.session.history();
const messages = await convertToAiSdkMessages({
  messages: [...history.items, ...context.messages],
  chatkit: context.chatkit,
});

const receivingAgent = {
  id: context.agent?.id,
  name: context.agent?.displayName,
  avatarUrl: context.agent?.avatar?.url,
};

​

Handle unprocessed content

• fileUpload receives each unprocessed file part and its parent message.
• firecrawl maps page-monitoring and completed-check signals to typed message converters.
• github maps GitHub issue, pull request, and CI signal types to typed message converters.
• sentry maps a signal type, such as sentry.issue.created, to a typed message converter.
• Return an AI SDK message or part to include it. Return null to omit it.
• Handlers can be asynchronous. If a handler throws, message conversion fails.

import type { Client } from "@trytilde/sdk";
import {
  type ChatKitEndpointContext,
  convertToAiSdkMessages,
  createChatKitAttachmentFilePartHandler,
} from "@trytilde/sdk-vercel-ai-node";

async function convertTurn(
  client: Client,
  context: ChatKitEndpointContext,
) {
  const history = await context.session.history();

  return convertToAiSdkMessages({
    messages: [...history.items, ...context.messages],
    chatkit: context.chatkit,
    onUnprocessed: {
      fileUpload: createChatKitAttachmentFilePartHandler(client, context),
    },
  });
}

import {
  type ChatKitEndpointContext,
  convertToAiSdkMessages,
  type GitHubSignalByType,
} from "@trytilde/sdk-vercel-ai-node";
import type { UIMessage } from "ai";

type PullRequestOpened =
  GitHubSignalByType["github.pull_request.opened"];

function pullRequestOpenedMessage(
  signal: PullRequestOpened,
): UIMessage {
  const { repository, pull_request } = signal.data;

  return {
    id: signal.id,
    role: "user",
    parts: [{
      type: "text",
      text: `Review ${repository.full_name}#${pull_request.number}: ${pull_request.title}`,
    }],
  };
}

async function messagesForGitHubTurn(
  context: ChatKitEndpointContext,
) {
  const history = await context.session.history();

  return convertToAiSdkMessages({
    messages: [...history.items, ...context.messages],
    chatkit: context.chatkit,
    onUnprocessed: {
      github: {
        "github.pull_request.opened": pullRequestOpenedMessage,
      },
    },
  });
}

import {
  type ChatKitEndpointContext,
  convertToAiSdkMessages,
  type FirecrawlSignalByType,
} from "@trytilde/sdk-vercel-ai-node";
import type { UIMessage } from "ai";

type PageChanged =
  FirecrawlSignalByType["firecrawl.monitor.page.changed"];

function pageChangedMessage(signal: PageChanged): UIMessage {
  const { monitor, page } = signal.data;

  return {
    id: signal.id,
    role: "user",
    parts: [{
      type: "text",
      text: `Review changes to ${page.url} from monitor ${monitor.id}.`,
    }],
  };
}

async function messagesForFirecrawlTurn(
  context: ChatKitEndpointContext,
) {
  const history = await context.session.history();

  return convertToAiSdkMessages({
    messages: [...history.items, ...context.messages],
    chatkit: context.chatkit,
    onUnprocessed: {
      firecrawl: {
        "firecrawl.monitor.page.changed": pageChangedMessage,
      },
    },
  });
}

import {
  type ChatKitEndpointContext,
  convertToAiSdkMessages,
  type SentrySignalByType,
} from "@trytilde/sdk-vercel-ai-node";
import type { UIMessage } from "ai";

type IssueCreated =
  SentrySignalByType["sentry.issue.created"];

function issueCreatedMessage(signal: IssueCreated): UIMessage {
  const { issue } = signal.data.data;

  return {
    id: signal.id,
    role: "user",
    parts: [{
      type: "text",
      text: `Investigate ${issue.shortId ?? issue.id}: ${issue.title}`,
    }],
  };
}

async function messagesForSentryTurn(
  context: ChatKitEndpointContext,
) {
  const history = await context.session.history();

  return convertToAiSdkMessages({
    messages: [...history.items, ...context.messages],
    chatkit: context.chatkit,
    onUnprocessed: {
      sentry: {
        "sentry.issue.created": issueCreatedMessage,
      },
    },
  });
}

​

Choose how new turns are handled

​

Let agents invoke other agents through MCP

• message accepts Vercel AI SDK-compatible UI message parts, persists the inbound ChatKit message, and immediately returns a ticket and session ID.
• wait_for_response accepts that ticket, subscribes to the live ChatKit session, streams response deltas through MCP progress notifications (or logging notifications when the caller did not supply a progress token), and returns the final canonical ChatKit message.
• Reuse the returned session ID to continue the same child-agent conversation. Omit it to create a new session.
• Queue status notifications include the target agent’s concurrency policy and whether multiple messages were batched into the turn.

​

Trigger work from events via Signals

import {
  chatKitEndpoint,
  convertToAiSdkMessages,
  createClient,
  type SentrySignalByType,
} from "@trytilde/sdk-vercel-ai-node";
import type { UIMessage } from "ai";

type IssueCreatedSignal = SentrySignalByType["sentry.issue.created"];

function sentryIssueCreatedMessage(signal: IssueCreatedSignal): UIMessage {
  const { issue } = signal.data.data;

  return {
    id: signal.id,
    role: "user",
    parts: [
      {
        type: "text",
        text: `Investigate Sentry issue ${issue.shortId ?? issue.id}: ${issue.title}`,
      },
    ],
  };
}

export const POST = chatKitEndpoint({
  client: createClient({
    apiKey: process.env.TILDE_API_KEY!,
    orgId: process.env.TILDE_ORG_ID!,
    teamId: process.env.TILDE_TEAM_ID!,
  }),
  webhookSigningKey: process.env.TILDE_WEBHOOK_SIGNING_KEY!,
  responseMode: "agentLoop",
  async handler(_request, context) {
    const history = await context.session.history();
    const messages = await convertToAiSdkMessages({
      messages: [...history.items, ...context.messages],
      chatkit: context.chatkit,
      onUnprocessed: {
        sentry: {
          "sentry.issue.created": sentryIssueCreatedMessage,
        },
      },
    });

    // ...rest of your agent code.
  },
});

​

ChatKit and memory

​

Configure realtime voice

• Text agent with speech: Tilde transcribes incoming audio, invokes your normal chatKitEndpoint callback, and speaks its streamed text response.
• Telnyx Conversation Relay: Telnyx handles recognition and speech synthesis for incoming phone calls. Tilde receives caller text, invokes your normal callback, and streams its response text to Telnyx. This profile is phone-only.
• OpenAI Realtime: the realtime model generates spoken responses directly. Tilde records the final transcripts without invoking your text endpoint again.

​

Change resources through native tools

​

Recover missing conversation context