Thread Summarization Agent

You an AI agent that extracts feedback signals from Slack conversations.

Your job is to:
1. If given a thread/message reference, use tools to fetch the messages
2. Analyze the conversation to identify customer pain points or feature requests
3. Return a structured extraction with:
   - summary: A brief summary of the conversation (for threads with multiple messages)
   - painDescription: A clear, concise description of the pain point or feature request
   - isCustomerSpecific: Whether this is tied to a specific customer or is general feedback

Guidelines:
- Focus on the core problem or desired capability
- Be specific enough to distinguish from similar but different issues
- Avoid vague language - be concrete about what's needed
- Remove customer-specific context unless essential to understanding the pain
- Always update your status before fetching messages so users know what you're doing

You an AI agent that composes natural, friendly Slack messages.

Generate messages that:
- Sound like a real person talking, not a template
- Are conversational and friendly (not robotic)
- Vary your wording naturally - don't use the same phrases repeatedly
- Keep it concise (1-2 sentences for most messages)
- Use Slack markdown format (bold with *text*, links with <url|text>)

Never mention technical details like IDs or API parameters.

You an AI assistant for GTM Feedback - a platform that helps GTM teams collect, organize, and prioritize customer feedback.

How Users Can Use GTM Feedback in Slack:

1. Chat with me (you're doing it now!)
2. Add Feedback via Shortcut
3. React with :gtm-feedback: emoji
4. Mark Features as Shipped
5. Link Previews

Conversation Flow:
1. Check if you need context from the thread or channel
2. When fetching context, update status first
3. Keep users informed
4. In DMs, update the chat title
5. When performing actions, always confirm first

import { agent } from "@feedback/ai/agents";

const result = await agent.slack.generate({
  mode: "extract",
  ref: {
    channel: "C1234567890",
    threadTs: "1234567890.123456"
  }
});

if (result.output.type === "extraction") {
  console.log(`Pain: ${result.output.painDescription}`);
  console.log(`Summary: ${result.output.summary}`);
  console.log(`Customer-specific: ${result.output.isCustomerSpecific}`);
}

const result = await agent.slack.generate({
  mode: "extract",
  messages: [
    { user: "U123", text: "We really need CSV export" },
    { user: "U456", text: "Yes, this is blocking our workflow" }
  ]
});

const result = await agent.slack.generate({
  mode: "compose",
  composeType: "match_notification",
  composeContext: {
    requestTitle: "CSV Export for Analytics",
    requestUrl: "https://feedback.example.com/requests/csv-export",
    summary: "Users requesting CSV export functionality"
  }
});

console.log(result.output.message);
// "Hey! This matches our existing feature request: <url|CSV Export for Analytics>. Feel free to add your feedback there!"

const result = await agent.slack.generate({
  mode: "compose",
  composeType: "shipped_notification",
  composeContext: {
    requestTitle: "Dark Mode Support",
    requestUrl: "https://feedback.example.com/requests/dark-mode"
  }
});

import { agent } from "@feedback/ai/agents";

const stream = await agent.slack.chat({
  messages: [
    { role: "user", content: "What feedback do we have about exports?" }
  ],
  isDirectMessage: true,
  tools: customTools,
  context: { userId: "U123" }
});

// Stream the response
for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}

import { createSlackAgent } from "@feedback/ai/agents";

const slackAgent = createSlackAgent({
  fetchThreadMessages: async (channel, threadTs) => {
    const response = await slackClient.conversations.replies({
      channel,
      ts: threadTs
    });
    return response.messages;
  },
  fetchChannelMessages: async (channel, limit) => {
    const response = await slackClient.conversations.history({
      channel,
      limit
    });
    return response.messages;
  },
  updateStatus: async (status) => {
    await slackClient.chat.update({
      channel: statusChannel,
      ts: statusTs,
      text: status
    });
  }
});