summarizeSourceText

async function summarizeSourceText(
  input: SummarizeSourceTextInput
): Promise<SummarizeSourceTextOutput>

interface SummarizeSourceTextInput {
  sourceText: string;
}

const SummarizeSourceTextInputSchema = z.object({
  sourceText: z.string().describe('The source text to summarize.'),
});

interface SummarizeSourceTextOutput {
  summary: string;
}

const SummarizeSourceTextOutputSchema = z.object({
  summary: z.string().describe('A concise summary of the source text.'),
});

import { summarizeSourceText } from '@/ai/flows/summarize-source-text';

const result = await summarizeSourceText({
  sourceText: `
    Artificial intelligence (AI) has made remarkable progress in recent years, 
    with applications ranging from natural language processing to computer vision. 
    Machine learning algorithms, particularly deep learning neural networks, have 
    enabled computers to perform tasks that were once thought to require human 
    intelligence. These advancements have led to practical applications in 
    healthcare, autonomous vehicles, and many other fields. However, challenges 
    remain in areas such as AI safety, bias in algorithms, and the ethical 
    implications of AI deployment.
  `
});

console.log(result.summary);
/* Output:
"AI has advanced significantly through machine learning and deep learning, 
enabling applications in healthcare and autonomous vehicles. Despite progress, 
challenges in AI safety, algorithmic bias, and ethical concerns persist."
*/

const articleText = `
  [Long news article about climate policy...]
`;

const result = await summarizeSourceText({ sourceText: articleText });
console.log(result.summary);
// Concise summary of the article's main points

const abstractText = `
  This study examines the effects of remote work on employee productivity 
  and well-being across 500 organizations. Data was collected through surveys 
  and performance metrics over a 12-month period. Results indicate that...
`;

const result = await summarizeSourceText({ sourceText: abstractText });
console.log(result.summary);
// Brief summary of research findings

const longText = `
  First paragraph about introduction...
  
  Second paragraph with main arguments...
  
  Third paragraph with supporting evidence...
  
  Final paragraph with conclusions...
`;

const result = await summarizeSourceText({ sourceText: longText });
console.log(result.summary);
// Condensed version hitting key points from all paragraphs

Summarize the following text in a concise manner:

{{{sourceText}}}

// Summarize multiple documents
const documents = await fetchDocuments();

const summaries = await Promise.all(
  documents.map(doc => 
    summarizeSourceText({ sourceText: doc.content })
  )
);

// Create summary index
const index = documents.map((doc, i) => ({
  title: doc.title,
  summary: summaries[i].summary
}));

// Used internally in generateArgumentBlueprint
const scrapedContent = await webScraper({ url: 'https://example.com/article' });
const summary = await summarizeSourceText({ sourceText: scrapedContent.text });

// Use summary as context for argument analysis

const emailThread = getEmailThread();
const fullText = emailThread.map(email => email.body).join('\n\n');

const result = await summarizeSourceText({ sourceText: fullText });
console.log('Thread Summary:', result.summary);

// Generate previews for blog posts or articles
function generatePreview(article: Article) {
  const result = await summarizeSourceText({ 
    sourceText: article.content 
  });
  
  return {
    ...article,
    preview: result.summary
  };
}

const meetingTranscript = getMeetingTranscript();

const result = await summarizeSourceText({ 
  sourceText: meetingTranscript 
});

// Share concise summary with team
sendSummaryEmail(result.summary);

// Good: Single article or document section
const text = 'Up to ~10,000 words';

// Caution: May hit token limits
const veryLongText = 'Entire book or multiple long documents';

function chunkText(text: string, maxChunkSize: number): string[] {
  // Split into sentences and group into chunks
  // Implementation details...
}

async function summarizeLongDocument(document: string) {
  const chunks = chunkText(document, 5000);
  
  // Summarize each chunk
  const chunkSummaries = await Promise.all(
    chunks.map(chunk => summarizeSourceText({ sourceText: chunk }))
  );
  
  // Summarize the summaries for final condensed version
  const finalSummary = await summarizeSourceText({ 
    sourceText: chunkSummaries.map(s => s.summary).join('\n\n')
  });
  
  return finalSummary;
}

try {
  await summarizeSourceText({ sourceText: '' });
} catch (error) {
  // Schema validation may accept but AI may return minimal summary
}

try {
  const hugeText = '...text exceeding token limits...';
  await summarizeSourceText({ sourceText: hugeText });
} catch (error) {
  // May throw token limit error
  console.error('Text too long for single summarization');
}

try {
  await summarizeSourceText({ sourceText: article });
} catch (error) {
  console.error('AI summarization failed:', error);
  // Fallback to truncated original or error handling
}

// Summarize before analyzing for fallacies
const summary = await summarizeSourceText({ sourceText: longArticle });
const fallacies = await identifyLogicalFallacies({ 
  argumentText: summary.summary 
});

// Used in argument blueprint generation for source processing
const scrapedContent = await webScraper({ url });
const summary = await summarizeSourceText({ 
  sourceText: scrapedContent.text 
});
// Use summary in blueprint analysis...