Generating Proposals

const { proposal, generation } = await pf.generate('blogPost', {
  input: 'Write a blog post about the future of AI in healthcare',
});

console.log(proposal.generatedObject);
// {
//   title: "AI in Healthcare: Transforming Patient Care",
//   content: "Artificial intelligence is revolutionizing...",
//   tags: ["ai", "healthcare", "technology"]
// }

console.log(generation.latencyMs);  // 1523

const { proposal } = await pf.generate('recipe', {
  input: 'Create a pasta recipe',
  subject: { userId: 'user_123' },
});

// Subject is stored with the proposal for analytics
console.log(proposal.subject);  // { userId: 'user_123' }

const { proposal } = await pf.generate('blogPost', {
  input: 'Write a blog post about TypeScript',
  metadata: {
    projectId: 'proj_456',
    requestedBy: 'content-team',
  },
});

// Metadata is stored with the proposal
console.log(proposal.metadata.projectId);  // 'proj_456'

const { proposal, suggestionMeta } = await pf.generate('blogPost', {
  input: 'Write about React hooks',
  generateSuggestionMeta: true,
});

console.log(suggestionMeta);
// {
//   description: "A comprehensive guide to React hooks...",
//   justification: "This post covers useState, useEffect, and custom hooks..."
// }

// Display to users to help them evaluate the proposal

const { proposal, suggestedResponses } = await pf.generate('recipe', {
  input: 'A quick pasta dinner',
  generateSuggestedResponses: true,
});

console.log(suggestedResponses);
// ["Make it spicier", "Add more vegetables", "Make it vegan", "Reduce cooking time"]

// Display as clickable pills in your UI
// When clicked, regenerate with that feedback:
const { proposal: improved } = await pf.regenerate(proposal.id, {
  feedback: 'Make it spicier',
});

// Generate a recipe, but portions MUST be 4
const { proposal } = await pf.generate('recipe', {
  input: 'A hearty pasta dinner',
  edits: { portions: 4 },  // Constraint: portions will be exactly 4
});

console.log(proposal.generatedObject);
// {
//   title: "Creamy Pasta Carbonara",
//   ingredients: [...scaled for 4 people],
//   portions: 4  // Guaranteed to be 4
// }

// Use the fastest model for quick suggestions
const { proposal } = await pf.generate('recipe', {
  input: 'A quick pasta dish',
  modelTier: 'fast',  // Optimized for speed and cost
});

// Use the highest quality model for important content
const { proposal: premium } = await pf.generate('blogPost', {
  input: 'Write a detailed technical analysis',
  modelTier: 'quality',  // Highest quality output
});

// Available model tiers:
// - 'fast': Optimized for speed and cost (e.g., Claude Haiku)
// - 'balanced': Good balance of quality and cost (e.g., Claude Sonnet) - default
// - 'quality': Highest quality output (e.g., Claude Opus)

// Model tier can also be set at schema or application level
// Priority: per-generation > schema > application > system default

interface GenerateInput {
  // Required: Natural language input
  input: string;

  // Optional: Fields that must have exact values (constraints)
  edits?: Record<string, unknown>;

  // Optional: Metadata to attach to the proposal
  metadata?: Record<string, unknown>;

  // Optional: Subject attribution for user analytics
  subject?: { userId?: string; tenantId?: string; [key: string]: unknown };

  // Optional: Generate AI description and justification
  generateSuggestionMeta?: boolean;

  // Optional: Generate 3-5 suggested feedback phrases
  generateSuggestedResponses?: boolean;

  // Optional: 'llm' (default) or 'mock' for testing without LLM costs
  generationMode?: 'llm' | 'mock';

  // Optional: Explicit expiration timestamp (defaults to 7 days)
  expiresAt?: string | Date;

  // Optional: Expiration duration in milliseconds
  expirationDurationMs?: number;

  // Optional: Model tier for quality/speed tradeoff
  // 'fast' | 'balanced' (default) | 'quality'
  modelTier?: ModelTier;
}

// Response structure
interface GenerateResponse<T> {
  proposal: Proposal<T>;
  generation: {
    id: string;
    model: string;
    modelTier: ModelTier;  // The tier used
    promptTokens: number;
    completionTokens: number;
    credits: number;  // Credits consumed
    latencyMs: number;
    edits?: Record<string, unknown>;  // Constraints used
  };
  suggestionMeta?: {
    description: string;
    justification: string;
  };
  suggestedResponses?: string[];
}

// Original proposal wasn't quite right
const { proposal: original } = await pf.generate('blogPost', {
  input: 'Write about TypeScript',
});

// Regenerate with feedback
const { proposal: improved } = await pf.proposals.regenerate(original.id, {
  feedback: 'Make it more beginner-friendly and add code examples',
});

// New proposal is linked to the original
console.log(improved.parentProposalId);  // original.id

// 1. Generate a recipe
const { proposal } = await pf.generate('recipe', {
  input: 'A pasta dish for dinner',
});
// → { title: 'Tomato Pasta', ingredients: [...], portions: 2 }

// 2. User wants 4 portions - reject with edits
await pf.proposals.decide(proposal.id, {
  action: 'reject',
  reason: 'Need more portions for the family',
  edits: { portions: 4 },  // This becomes a constraint
});

// 3. Regenerate - edits are automatically used as constraints
const { proposal: improved } = await pf.proposals.regenerate(proposal.id, {});
// → { title: 'Tomato Pasta', ingredients: [...scaled up], portions: 4 }
// portions is guaranteed to be 4, ingredients are scaled accordingly

// 4. User approves the improved version
await pf.proposals.decide(improved.id, { action: 'approve' });

const topics = [
  'Introduction to Docker',
  'Kubernetes for Beginners',
  'CI/CD Best Practices',
];

const results = await Promise.all(
  topics.map((topic) =>
    pf.generate('blogPost', { input: `Write a blog post about ${topic}` })
  )
);

// results is typed as GenerateResponse<BlogPost>[]
for (const { proposal } of results) {
  console.log(proposal.generatedObject.title);
}

// Generate mock data for testing (no LLM cost)
const { proposal, generation } = await pf.generate('blogPost', {
  input: 'Write about TypeScript',
  generationMode: 'mock',
});

// Mock proposals have model: 'mock'
console.log(generation.model);  // 'mock'

// Generated object contains schema-valid placeholder data
console.log(proposal.generatedObject);
// {
//   title: "Mock string value",
//   content: "Mock string value",
//   tags: ["Mock string value"]
// }

// Webhooks still fire, enabling end-to-end workflow testing

import { ProposeFlowError, RateLimitError } from '@proposeflow/sdk';

try {
  const { proposal } = await pf.generate('blogPost', {
    input: 'Write a blog post',
  });
} catch (error) {
  if (error instanceof RateLimitError) {
    // Wait and retry
    console.log(`Rate limited. Retry after ${error.retryAfter}ms`);
  } else if (error instanceof ProposeFlowError) {
    // Handle API errors
    console.error(`API Error: ${error.message}`, error.code);
  }
}