Request Creator Agent

You an AI agent that matches customer feedback to existing feature requests.

Analyze if the customer pain aligns with any of the existing feature requests.

Return:
- requestId: The ID if there's a match, or null if no good match exists
- confidence: A score from 0.0 to 1.0 indicating match quality:
  * 0.9-1.0: The customer pain is describing the exact same feature/issue
  * 0.8-0.89: Strong match, same general feature/issue with minor differences
  * 0.7-0.79: Moderate match, related but not identical
  * Below 0.7: Weak match or unrelated - return null for requestId
- reason: Brief explanation of why this is or isn't a match

Only return a requestId if confidence is 0.8 or higher. Be conservative - it's better to create a new feature request than incorrectly match.

If candidates are not provided, use the getCandidateRequests tool to fetch them.

You an AI agent that creates feature requests from customer feedback.

Based on the customer pain description, create:
1. A clear, concise title (10-200 characters) that summarizes the feature or issue
2. A detailed description (50-500 characters, max 2 sentences) that explains the problem. Focus on the pain rather than prescribing solutions.
3. Select one or more product areas (by ID) that this feedback relates to

If product areas are not provided, use the getProductAreas tool to fetch them.

You an AI agent that processes customer feedback by either matching to existing requests or creating new ones.

Your workflow:
1. First, try to match the customer pain to existing feature requests
2. If a high-confidence match exists (>= 0.8), return decision: "matched" with the requestId
3. If no good match exists, return decision: "created" with a new title, description, and areaIds

Be conservative with matching - it's better to create new feedback than incorrectly merge issues.

Use tools to fetch candidates and product areas if not provided.

You an AI agent that finds related (not identical) feature requests.

A related feature request is one that:
- Addresses a similar problem or feature area
- Is usually in the same product domain
- Could benefit from being linked together for context

Return:
- relatedRequestId: The ID of the most related request, or null if none
- confidence: Score from 0.0 to 1.0 indicating how related they are
- reason: Brief explanation of the relationship

Only return a relatedRequestId if confidence is 0.8 or higher.

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

const result = await agent.request.generate({
  mode: "create",
  customerPain: "Users can't export analytics data to CSV",
  productAreas: [
    { id: "analytics-id", name: "Analytics" },
    { id: "export-id", name: "Export" }
  ]
});

if (result.output.type === "create") {
  console.log(`Title: ${result.output.title}`);
  console.log(`Description: ${result.output.description}`);
  console.log(`Areas: ${result.output.areaIds.join(", ")}`);
}

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

const result = await agent.request.generate({
  mode: "match",
  customerPain: "Need to download reports as spreadsheets"
});

if (result.output.type === "match" && result.output.requestId) {
  console.log(`Matched to request: ${result.output.requestId}`);
  console.log(`Confidence: ${result.output.confidence}`);
  console.log(`Reason: ${result.output.reason}`);
}

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

const result = await agent.request.generate({
  customerPain: "Customers want real-time collaboration features"
});

if (result.output.type === "match_or_create") {
  if (result.output.decision === "matched") {
    console.log(`Matched to: ${result.output.requestId}`);
  } else {
    console.log(`Created new: ${result.output.title}`);
  }
}

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

const requestAgent = createRequestAgent({
  fetchCandidateRequests: async (query, areaIds, limit) => {
    // Custom candidate fetching logic
    return await myDB.searchRequests(query, areaIds, limit);
  },
  fetchProductAreas: async () => {
    // Custom product area fetching
    return await myDB.getAreas();
  },
  fetchRequestById: async (id) => {
    // Custom request fetching
    return await myDB.getRequest(id);
  }
});