Thread Interface

readonly id: string

readonly channelId: string

readonly adapter: Adapter

readonly isDM: boolean

readonly channel: Channel<TState>

const channelName = await thread.channel.fetchMetadata();
console.log(channelName.name);

readonly state: Promise<TState | null>

interface MyState {
  aiMode?: boolean;
  userName?: string;
}

const state = await thread.state; // Type: MyState | null
if (state?.aiMode) {
  // AI mode is enabled
}

recentMessages: Message[]

readonly messages: AsyncIterable<Message>

// Get the 10 most recent messages
const recent: Message[] = [];
for await (const msg of thread.messages) {
  recent.push(msg);
  if (recent.length >= 10) break;
}

readonly allMessages: AsyncIterable<Message>

// Process all messages from the beginning
for await (const message of thread.allMessages) {
  console.log(message.text);
}

post(
  message: string | PostableMessage | CardJSXElement
): Promise<SentMessage>

// Simple string
await thread.post("Hello!");

// Markdown
await thread.post({ markdown: "**Bold** and _italic_" });

// With emoji
import { emoji } from "chat";
await thread.post(`${emoji.thumbs_up} Great job!`);

// JSX Card (with @jsxImportSource chat)
await thread.post(
  <Card title="Welcome!">
    <Text>Hello world</Text>
  </Card>
);

// Stream from AI SDK
import { generateText } from "ai";
const result = await generateText({ prompt: message.text });
await thread.post(result.textStream);

postEphemeral(
  user: string | Author,
  message: AdapterPostableMessage | CardJSXElement,
  options: PostEphemeralOptions
): Promise<EphemeralMessage | null>

// Always send (DM fallback on Discord/Teams)
await thread.postEphemeral(
  user, 
  'Only you can see this!', 
  { fallbackToDM: true }
);

// Only send if native ephemeral supported (Slack/GChat)
const result = await thread.postEphemeral(
  user, 
  'Secret!', 
  { fallbackToDM: false }
);
if (!result) {
  // Platform doesn't support native ephemeral
}

setState(
  state: Partial<TState>,
  options?: { replace?: boolean }
): Promise<void>

interface MyState {
  aiMode?: boolean;
  userName?: string;
  count?: number;
}

// Merge with existing state
await thread.setState({ aiMode: true });

// Replace entire state
await thread.setState({ userName: "Alice" }, { replace: true });

async subscribe(): Promise<void>

chat.onNewMention(async (thread, message) => {
  await thread.subscribe();
  await thread.post("I'm now watching this thread!");
});

async unsubscribe(): Promise<void>

await thread.unsubscribe();

async isSubscribed(): Promise<boolean>

if (await thread.isSubscribed()) {
  console.log("Already subscribed");
} else {
  await thread.subscribe();
}

async startTyping(status?: string): Promise<void>

await thread.startTyping("Thinking...");
// Perform long-running operation
await thread.post("Here's the answer!");

async refresh(): Promise<void>

await thread.refresh();
const latest = thread.recentMessages[thread.recentMessages.length - 1];

mentionUser(userId: string): string

const mention = thread.mentionUser(message.author.userId);
await thread.post(`Hey ${mention}, check this out!`);

createSentMessageFromMessage(
  message: Message
): SentMessage

chat.onNewMention(async (thread, message) => {
  await thread.post("Hello! How can I help?");
});

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

chat.onSubscribedMessage(async (thread, message) => {
  const result = await generateText({
    model: openai("gpt-4"),
    prompt: message.text,
  });
  
  // Stream the response
  await thread.post(result.textStream);
});

interface ConversationState {
  mode: "help" | "chat" | "search";
  history: string[];
}

chat.onNewMention(async (thread, message) => {
  await thread.setState({ 
    mode: "chat", 
    history: [message.text] 
  });
  await thread.subscribe();
});

chat.onSubscribedMessage(async (thread, message) => {
  const state = await thread.state;
  const history = state?.history || [];
  
  // Update history
  await thread.setState({ 
    history: [...history, message.text] 
  });
});

// Get recent messages for context
const recentMessages: string[] = [];
for await (const msg of thread.messages) {
  recentMessages.push(msg.text);
  if (recentMessages.length >= 5) break;
}

const context = recentMessages.reverse().join("\n");