@daniel156161/prism 0.2.60 → 0.2.78

package/src/prism-extensions/integrations/obsidian-memory.ts

@@ -3,9 +3,10 @@ import * as path from "node:path"
 import { execFile as execFileCallback } from "node:child_process"
 import { promisify } from "node:util"
 import { createRequire } from "node:module"
-import { getObsidianCliTimeoutMs, getPrismSessionDbPath, getPrismSessionsDir, getPrismSettingsPath, getVaultPath, readVaultPathFromSettings, getObsidianVaultName, obsidianCliEnv } from "../core/shared-config.js"
+import { getObsidianCliTimeoutMs, getPrismSessionDbPath, getPrismSessionsDir, getPrismSettingsPath, getVaultPath, readSettings, readVaultPathFromSettings, getObsidianVaultName, obsidianCliEnv } from "../core/shared-config.js"
 import { excerpt, fileExists as exists, listMarkdownFiles as listVaultMarkdownFiles, readCappedFile, schema, scoreContent, slugify, todayDate, CONTEXT_SEARCH_LIMIT, MAX_ALWAYS_CONTEXT_BYTES, MAX_FILE_BYTES, MAX_READ_RENDER_LINES, MAX_SEARCH_FILES } from "../core/vault.js"
 import { fuzzyFilter } from "../core/fuzzy.js"
+import { descriptionFromMarkdown, formatNewObsidianNoteBody, sanitizeObsidianDescription } from "./obsidian-formatting.js"
 
 const _require = createRequire(import.meta.url)
 import { renderCollapsibleTextResult, stripLeadingPathHeader, stripLeadingSearchTerms } from "../ui/collapsed-text-rendering.js"
@@ -31,6 +32,23 @@ function shouldUseObsidianCli(): boolean {
   return !!cliVaultName()
 }
 
+function booleanSetting(value: unknown): boolean | undefined {
+  if (typeof value === "boolean") return value
+  if (typeof value !== "string") return undefined
+  const normalized = value.trim().toLowerCase()
+  if (["1", "true", "yes", "on"].includes(normalized)) return true
+  if (["0", "false", "no", "off"].includes(normalized)) return false
+  return undefined
+}
+
+function shouldInjectObsidianCandidates(env: NodeJS.ProcessEnv = process.env): boolean {
+  const envValue = booleanSetting(env.PRISM_OBSIDIAN_INJECT_CANDIDATES ?? env.PI_OBSIDIAN_INJECT_CANDIDATES)
+  if (envValue !== undefined) return envValue
+  const settings = readSettings(undefined, env)
+  const settingsValue = booleanSetting(settings?.obsidian?.injectCandidates ?? settings?.obsidianInjectCandidates)
+  return settingsValue ?? true
+}
+
 async function obsidianCli(command: string, args: string[] = []): Promise<string> {
   const name = cliVaultName()
   if (!name) throw new Error("PRISM_OBSIDIAN_VAULT_NAME is not configured")
@@ -154,22 +172,16 @@ export function inferType(relPath: string): string {
   return "note"
 }
 
+export const sanitizeDescription = sanitizeObsidianDescription
+
 export function inferDescriptionFromMemoryText(text: string, fallback = ""): string {
-  const clean = stripFrontmatter(String(text ?? ""))
-    .replace(/```[\s\S]*?```/g, " ")
-    .replace(/^#{1,6}\s+(?:Update|Fix)\s+\d{4}-\d{2}-\d{2}.*$/gmi, "")
-    .replace(/^#{1,6}\s+/gm, "")
-    .replace(/^[-*+]\s+/gm, "")
-    .replace(/`+/g, "")
-    .replace(/\s+/g, " ")
-    .trim()
-  return compactLine(clean || fallback, 220)
+  return descriptionFromMarkdown(stripFrontmatter(String(text ?? "")), fallback)
 }
 
 export function buildFrontmatter(relPath: string, description?: string): string {
   const tags = inferTags(relPath)
   const name = noteName(relPath)
-  const summary = description?.trim() ? description.trim() : name
+  const summary = sanitizeDescription(description?.trim() ? description : name)
   return [
     "---",
     `name: ${yamlString(name)}`,
@@ -193,7 +205,7 @@ export function upsertFrontmatterStatusAndUpdated(text: string, date = todayDate
   const parsed = splitLeadingFrontmatter(text)
   if (!parsed) return text
   let frontmatter = parsed.frontmatter.replace(/\r\n/g, "\n").replace(/\n?---\n?$/, "")
-  const summary = description?.trim()
+  const summary = sanitizeDescription(description ?? "")
   if (summary) {
     const current = frontmatter.match(/^description:\s*(.*?)\s*$/m)?.[1]?.replace(/^['"]|['"]$/g, "") ?? ""
     if (/^description:\s*.*$/m.test(frontmatter)) {
@@ -250,23 +262,17 @@ export function normalizeUpdateHeadings(text: string): string {
   const lines = String(text ?? "").split("\n")
   const out: string[] = []
   for (const line of lines) {
-    const titled = line.match(/^(#{2,6})\s+(Update|Fix)\s+(\d{4}-\d{2}-\d{2})\s+[—-]\s+(.+?)\s*$/)
-    if (titled) {
-      const [, level, kind, date, title] = titled
+    const dated = line.match(/^(#{2,6})\s+(Update|Fix|Recherche)\s+(\d{4}-\d{2}-\d{2})(?:\s*(?:[—–:-]\s*)?(.+?))?\s*$/)
+    if (dated) {
+      const [, level, kind, date, rawTitle] = dated
+      const title = rawTitle?.trim() ?? ""
       if (!seenDates.has(date)) {
         out.push(`## Update ${date}`)
         seenDates.add(date)
       }
-      const cleanTitle = kind === "Update" ? title.trim() : `${kind} ${title.trim()}`
-      out.push(`${level.length === 2 ? "###" : level} ${cleanTitle}`)
-      continue
-    }
-    const plain = line.match(/^##\s+Update\s+(\d{4}-\d{2}-\d{2})\s*$/)
-    if (plain) {
-      const [, date] = plain
-      if (!seenDates.has(date)) {
-        out.push(`## Update ${date}`)
-        seenDates.add(date)
+      if (title) {
+        const cleanTitle = kind === "Update" ? title : `${kind} ${title}`
+        out.push(`${level.length === 2 ? "###" : level} ${cleanTitle}`)
       }
       continue
     }
@@ -275,8 +281,9 @@ export function normalizeUpdateHeadings(text: string): string {
   return out.join("\n").replace(/\n{3,}/g, "\n\n")
 }
 
-export function buildMemoryAppendEntry(text: string, heading?: string, date = todayDate()): string {
+export function buildMemoryAppendEntry(text: string, heading?: string, date = todayDate(), existingNote = true): string {
   const clean = stripFrontmatter(String(text ?? "")).trim()
+  if (!existingNote) return formatNewObsidianNoteBody(clean)
   if (/^##\s+Update\s+\d{4}-\d{2}-\d{2}(?:\s+[—-]\s+.+?)?\s*$/m.test(clean)) return clean
   const title = typeof heading === "string" && heading.trim() ? heading.trim() : ""
   const dateHeading = title ? `## Update ${date} — ${title}` : `## Update ${date}`
@@ -313,7 +320,10 @@ export async function appendMemoryWithResult(relPath: string, text: string, head
   if (!vault && !useCli) requireVaultPath()
   const rel = normalizeVaultRelativePath(relPath || DEFAULT_MEMORY_NOTE)
   const abs = vault ? absoluteVaultPath(vault, rel).abs : rel
-  const entry = buildMemoryAppendEntry(text, heading)
+  const existingNote = useCli
+    ? await obsidianCliRead(rel).then(() => true).catch(() => false)
+    : await exists(abs)
+  const entry = buildMemoryAppendEntry(text, heading, todayDate(), existingNote)
   const description = inferDescriptionFromMemoryText(entry, noteName(rel))
 
   if (useCli) {
@@ -340,19 +350,24 @@ export async function appendMemory(relPath: string, text: string, heading?: stri
   return (await appendMemoryWithResult(relPath, text, heading)).abs
 }
 
+function capMemoryText(content: string): string {
+  const buf = Buffer.from(content, "utf-8")
+  const text = buf.subarray(0, MAX_FILE_BYTES).toString("utf-8")
+  return buf.length > MAX_FILE_BYTES ? `${text}\n\n[truncated: ${buf.length} bytes]` : text
+}
+
 export async function readMemory(relPath = DEFAULT_MEMORY_NOTE): Promise<string> {
   const vault = getVaultPath()
-  const useCli = shouldUseObsidianCli() && !vault
+  const useCli = shouldUseObsidianCli()
   if (!vault && !useCli) requireVaultPath()
   const rel = normalizeVaultRelativePath(relPath, DEFAULT_MEMORY_NOTE)
   const abs = vault ? absoluteVaultPath(vault, rel).abs : rel
-  if (useCli) {
-    const content = await obsidianCliRead(rel)
-    const buf = Buffer.from(content, "utf-8")
-    const text = buf.subarray(0, MAX_FILE_BYTES).toString("utf-8")
-    return buf.length > MAX_FILE_BYTES ? `${text}\n\n[truncated: ${buf.length} bytes]` : text
+  if (vault) {
+    try { return readCappedFile(abs) } catch (error) {
+      if (!useCli) throw error
+    }
   }
-  return readCappedFile(abs)
+  return capMemoryText(await obsidianCliRead(rel))
 }
 
 export function listMarkdownFiles(vault: string, subdir = ""): Promise<string[]> {
@@ -424,8 +439,13 @@ function formatSearchResults(results: SearchVaultResult[]): string {
 
 export async function searchMemory(query: string, limit = 10, subdir = ""): Promise<string> {
   if (shouldUseObsidianCli()) {
-    const output = await obsidianCliSearch(query, limit, subdir)
-    if (!isEmptyCliSearch(output)) return output.trim()
+    try {
+      const output = await obsidianCliSearch(query, limit, subdir)
+      if (!isEmptyCliSearch(output)) return output.trim()
+    } catch {
+      // If the desktop-backed Obsidian CLI is broken or unavailable, keep memory
+      // search working through the configured filesystem vault path.
+    }
     // The Obsidian CLI's search:context matches AND across all query terms, so a
     // multi-term natural-language query returns nothing as soon as a single term is
     // missing from a note. Fall back to the local OR-based ranking (same scoring the
@@ -446,20 +466,42 @@ export async function listMemoryNotes(subdir = ""): Promise<string[]> {
   return listMarkdownFiles(requireVaultPath(), subdir)
 }
 
-async function readAlwaysContext(vault: string): Promise<string[]> {
-  const files = await listMarkdownFiles(vault, ALWAYS_CONTEXT_DIR)
+async function readAlwaysContext(vault: string | undefined): Promise<string[]> {
   const sections: string[] = []
   let totalBytes = 0
-  for (const rel of files) {
-    const { abs } = absoluteVaultPath(vault, rel)
-    const stat = await fs.stat(abs).catch(() => undefined)
-    if (!stat || stat.size > MAX_FILE_BYTES) continue
-    if (totalBytes + stat.size > MAX_ALWAYS_CONTEXT_BYTES) break
-    const content = await fs.readFile(abs, "utf-8")
+
+  async function addSection(rel: string, content: string): Promise<void> {
+    const bytes = Buffer.byteLength(content, "utf-8")
+    if (bytes > MAX_FILE_BYTES || totalBytes + bytes > MAX_ALWAYS_CONTEXT_BYTES) return
     const body = stripFrontmatter(content).trim().replace(/^#(?!#)\s+/m, "## ")
-    totalBytes += Buffer.byteLength(content, "utf-8")
+    totalBytes += bytes
     sections.push(`## ${rel}\n${body}`)
   }
+
+  if (vault) {
+    try {
+      const files = await listMarkdownFiles(vault, ALWAYS_CONTEXT_DIR)
+      for (const rel of files) {
+        const { abs } = absoluteVaultPath(vault, rel)
+        const stat = await fs.stat(abs).catch(() => undefined)
+        if (!stat || stat.size > MAX_FILE_BYTES) continue
+        if (totalBytes + stat.size > MAX_ALWAYS_CONTEXT_BYTES) break
+        await addSection(rel, await fs.readFile(abs, "utf-8"))
+      }
+      if (sections.length > 0 || !shouldUseObsidianCli()) return sections
+    } catch {
+      if (!shouldUseObsidianCli()) return sections
+    }
+  }
+
+  if (shouldUseObsidianCli()) {
+    const files = await obsidianCliListMarkdown(ALWAYS_CONTEXT_DIR).catch(() => [])
+    for (const rel of files) {
+      if (totalBytes >= MAX_ALWAYS_CONTEXT_BYTES) break
+      const content = await obsidianCliRead(rel).catch(() => "")
+      if (content) await addSection(rel, content)
+    }
+  }
   return sections
 }
 
@@ -717,9 +759,10 @@ export default async function obsidianMemoryExtension(pi: ExtensionAPI): Promise
   })
 
   pi.on("before_agent_start", async (event: any) => {
-    if (!vault) return
+    if (!vault && !shouldUseObsidianCli()) return
     const alwaysContext = await readAlwaysContext(vault)
-    const results = await searchVault(vault, event.prompt, CONTEXT_SEARCH_LIMIT, process.env.PI_OBSIDIAN_CONTEXT_DIR ?? "")
+    const injectCandidates = shouldInjectObsidianCandidates()
+    const results = injectCandidates && vault ? await searchVault(vault, event.prompt, CONTEXT_SEARCH_LIMIT, process.env.PI_OBSIDIAN_CONTEXT_DIR ?? "").catch(() => []) : []
     if (alwaysContext.length === 0 && results.length === 0) return
 
     const out: { systemPrompt?: string; message?: any } = {}

package/src/prism-extensions/integrations/research-tools.ts

@@ -5,6 +5,7 @@ import { fuzzyFilter } from "../core/fuzzy.js"
 import { clearPrismManifestRoutingTier, setPrismManifestRoutingTier } from "../core/manifest-routing.js"
 import { renderCollapsibleTextResult } from "../ui/collapsed-text-rendering.js"
 import { formatBracketedToolCall, renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
+import { fetchYouTubeContent, isYouTubeUrl } from "./youtube.js"
 
 export function formatResearchToolCall(toolName: "web_search" | "web_fetch", args: any, theme: ThemeLike): string {
   const displayName = toolName === "web_search" ? "web search" : "web fetch"
@@ -331,6 +332,7 @@ export async function webSearch(query: string, limit = 10): Promise<string> {
 export async function webFetch(url: string, maxChars = 20_000): Promise<string> {
   const safeUrl = validateHttpUrl(url)
   const safeMaxChars = clampLimit(maxChars, 20_000, 1_000, 100_000)
+  if (isYouTubeUrl(safeUrl)) return fetchYouTubeContent(safeUrl, safeMaxChars)
   const response = await fetch(safeUrl, { headers: { "User-Agent": "Mozilla/5.0 (compatible; prism-research/1.0)" }, signal: AbortSignal.timeout(15_000) })
   const text = await response.text()
   if (!response.ok) throw new Error(`Fetch failed for ${safeUrl}: HTTP ${response.status}`)
@@ -390,8 +392,8 @@ export default function researchToolsExtension(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "web_fetch",
     label: "web fetch",
-    description: "Fetch readable text from a web page for citation-backed research.",
-    promptSnippet: "Fetch readable text from a web page.",
+    description: "Fetch readable text from a web page for citation-backed research. For YouTube URLs, extracts structured video metadata (title, channel, description, duration, views, publish date) and transcript when available.",
+    promptSnippet: "Fetch readable text from a web page. For YouTube URLs, extracts structured video metadata (title, channel, description, duration, views, publish date) and transcript when available.",
     parameters: Type.Object({ url: Type.String(), maxChars: Type.Optional(Type.Number()) }),
     async execute(_id: string, params: any) {
       return { content: [{ type: "text", text: await webFetch(params.url, params.maxChars || 20_000) }], details: { url: params.url } }

package/src/prism-extensions/integrations/youtube.ts

@@ -0,0 +1,292 @@
+import { decodeHtml } from "./research-tools.js"
+
+// ---------------------------------------------------------------------------
+// YouTube URL detection & video ID extraction
+// ---------------------------------------------------------------------------
+
+const YT_HOSTS = /^(?:www\.)?(?:youtube\.com|youtu\.be|m\.youtube\.com|music\.youtube\.com)$/i
+const YT_SHORT_HOST = /^(?:www\.)?youtu\.be$/i
+
+export function isYouTubeUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url)
+    return YT_HOSTS.test(parsed.hostname) && (YT_SHORT_HOST.test(parsed.hostname) || /^\/(?:watch|shorts|embed|v)(?:[/?]|$)/.test(parsed.pathname) || parsed.pathname.startsWith("/live/"))
+  } catch {
+    return false
+  }
+}
+
+export function extractVideoId(url: string): string | undefined {
+  try {
+    const parsed = new URL(url)
+    if (YT_SHORT_HOST.test(parsed.hostname)) return parsed.pathname.slice(1).split(/[/?#]/)[0] || undefined
+    const v = parsed.searchParams.get("v")
+    if (v) return v
+    const pathMatch = parsed.pathname.match(/^\/(?:embed|v|shorts|live)\/([a-zA-Z0-9_-]{11})/)
+    return pathMatch?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Metadata extraction from page HTML
+// ---------------------------------------------------------------------------
+
+export interface YouTubeMetadata {
+  videoId: string
+  title: string
+  channel: string
+  channelUrl?: string
+  description: string
+  duration: number // seconds
+  viewCount?: number
+  publishDate?: string
+  category?: string
+  keywords?: string[]
+  isLive?: boolean
+  thumbnail?: string
+}
+
+export function parsePlayerResponse(html: string): any | undefined {
+  const match = html.match(/var ytInitialPlayerResponse\s*=\s*(\{.*?\});\s*(?:var |<\/script>)/)
+  if (!match) return undefined
+  try {
+    return JSON.parse(match[1])
+  } catch {
+    return undefined
+  }
+}
+
+export function extractMetadata(player: any): YouTubeMetadata | undefined {
+  const details = player?.videoDetails
+  if (!details?.videoId) return undefined
+
+  const micro = player.microformat?.playerMicroformatRenderer
+
+  return {
+    videoId: details.videoId,
+    title: details.title ?? "Unknown",
+    channel: micro?.ownerChannelName ?? details.author ?? "Unknown",
+    channelUrl: details.channelId ? `https://www.youtube.com/channel/${details.channelId}` : undefined,
+    description: details.shortDescription ?? "",
+    duration: Number(details.lengthSeconds) || 0,
+    viewCount: details.viewCount ? Number(details.viewCount) : undefined,
+    publishDate: micro?.publishDate ?? micro?.uploadDate,
+    category: micro?.category,
+    keywords: details.keywords,
+    isLive: details.isLiveContent === true,
+    thumbnail: details.thumbnail?.thumbnails?.at(-1)?.url,
+  }
+}
+
+export function extractMetadataFromHtml(html: string): YouTubeMetadata | undefined {
+  const player = parsePlayerResponse(html)
+  return player ? extractMetadata(player) : undefined
+}
+
+// ---------------------------------------------------------------------------
+// Caption track extraction from page HTML
+// ---------------------------------------------------------------------------
+
+export interface CaptionTrack {
+  url: string
+  language: string
+  languageCode: string
+  kind?: string // "asr" = auto-generated
+}
+
+export function extractCaptionTracks(player: any): CaptionTrack[] {
+  const tracks = player?.captions?.playerCaptionsTracklistRenderer?.captionTracks
+  if (!Array.isArray(tracks)) return []
+  return tracks.map((t: any) => ({
+    url: (t.baseUrl ?? "").replace(/\\u0026/g, "&"),
+    language: t.name?.simpleText ?? t.languageCode ?? "unknown",
+    languageCode: t.languageCode ?? "",
+    kind: t.kind,
+  })).filter((t: CaptionTrack) => t.url)
+}
+
+// ---------------------------------------------------------------------------
+// Transcript parsing (XML srv1 format → plain text)
+// ---------------------------------------------------------------------------
+
+export function parseTranscriptXml(xml: string): string {
+  const segments: string[] = []
+  for (const match of xml.matchAll(/<text[^>]*start="([^"]*)"[^>]*>([\s\S]*?)<\/text>/g)) {
+    const startSec = parseFloat(match[1])
+    const text = decodeHtml(match[2]).replace(/<[^>]+>/g, "").trim()
+    if (!text) continue
+    const minutes = Math.floor(startSec / 60)
+    const seconds = Math.floor(startSec % 60)
+    const timestamp = `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`
+    segments.push(`[${timestamp}] ${text}`)
+  }
+  return segments.join("\n")
+}
+
+// ---------------------------------------------------------------------------
+// Transcript fetching via yt-dlp (best-effort)
+// ---------------------------------------------------------------------------
+
+async function ytDlpAvailable(): Promise<boolean> {
+  try {
+    const { execFile } = await import("node:child_process")
+    const { promisify } = await import("node:util")
+    const execFileAsync = promisify(execFile)
+    await execFileAsync("yt-dlp", ["--version"], { timeout: 5_000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function fetchTranscriptYtDlp(videoId: string, lang = "en"): Promise<string> {
+  const { execFile } = await import("node:child_process")
+  const { promisify } = await import("node:util")
+  const { mkdtemp, readFile, rm } = await import("node:fs/promises")
+  const { join } = await import("node:path")
+  const { tmpdir } = await import("node:os")
+  const execFileAsync = promisify(execFile)
+
+  const tmpDir = await mkdtemp(join(tmpdir(), "yt-transcript-"))
+  const outTemplate = join(tmpDir, "sub")
+
+  try {
+    await execFileAsync("yt-dlp", [
+      "--write-auto-sub",
+      "--write-sub",
+      "--sub-lang", lang,
+      "--sub-format", "srv1",
+      "--skip-download",
+      "--no-warnings",
+      "--no-check-certificates",
+      "-o", outTemplate,
+      `https://www.youtube.com/watch?v=${videoId}`,
+    ], { timeout: 30_000 })
+
+    // Try manual subs first, then auto subs
+    const { readdir } = await import("node:fs/promises")
+    const files = await readdir(tmpDir)
+    const subFile = files.find((f) => f.endsWith(".srv1"))
+    if (!subFile) return ""
+
+    const xml = await readFile(join(tmpDir, subFile), "utf-8")
+    return parseTranscriptXml(xml)
+  } catch {
+    return ""
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Direct caption fetch (fallback when yt-dlp not available)
+// ---------------------------------------------------------------------------
+
+export async function fetchTranscriptDirect(captionUrl: string): Promise<string> {
+  try {
+    const response = await fetch(captionUrl, {
+      headers: { "User-Agent": "Mozilla/5.0 (compatible; prism-research/1.0)" },
+      signal: AbortSignal.timeout(10_000),
+    })
+    const text = await response.text()
+    if (!text || !response.ok) return ""
+    return parseTranscriptXml(text)
+  } catch {
+    return ""
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Duration formatting
+// ---------------------------------------------------------------------------
+
+export function formatDuration(seconds: number): string {
+  if (seconds <= 0) return "unknown"
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = seconds % 60
+  if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`
+  return `${m}:${String(s).padStart(2, "0")}`
+}
+
+// ---------------------------------------------------------------------------
+// Format the final YouTube result
+// ---------------------------------------------------------------------------
+
+export function formatYouTubeResult(meta: YouTubeMetadata, transcript: string, maxChars: number): string {
+  const lines: string[] = []
+
+  lines.push(`# ${meta.title}`)
+  lines.push("")
+  lines.push(`**Channel:** ${meta.channel}`)
+  if (meta.publishDate) lines.push(`**Published:** ${meta.publishDate}`)
+  lines.push(`**Duration:** ${formatDuration(meta.duration)}`)
+  if (meta.viewCount != null) lines.push(`**Views:** ${meta.viewCount.toLocaleString("en-US")}`)
+  if (meta.category) lines.push(`**Category:** ${meta.category}`)
+  if (meta.isLive) lines.push(`**Live:** yes`)
+  lines.push(`**URL:** https://www.youtube.com/watch?v=${meta.videoId}`)
+
+  if (meta.description) {
+    lines.push("")
+    lines.push("## Description")
+    lines.push(meta.description)
+  }
+
+  if (transcript) {
+    lines.push("")
+    lines.push("## Transcript")
+    lines.push(transcript)
+  }
+
+  let result = lines.join("\n")
+  if (result.length > maxChars) result = `${result.slice(0, maxChars - 20)}\n\n[truncated]`
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point for web_fetch YouTube handling
+// ---------------------------------------------------------------------------
+
+export async function fetchYouTubeContent(url: string, maxChars = 20_000): Promise<string> {
+  const videoId = extractVideoId(url)
+  if (!videoId) throw new Error(`Could not extract video ID from URL: ${url}`)
+
+  // Fetch the page for metadata
+  const response = await fetch(`https://www.youtube.com/watch?v=${videoId}`, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0",
+      "Accept-Language": "en-US,en;q=0.5",
+      "Cookie": "CONSENT=YES+cb",
+    },
+    signal: AbortSignal.timeout(15_000),
+  })
+  if (!response.ok) throw new Error(`YouTube fetch failed: HTTP ${response.status}`)
+  const html = await response.text()
+
+  const player = parsePlayerResponse(html)
+  const meta = player ? extractMetadata(player) : undefined
+  if (!meta) throw new Error(`Could not extract video metadata from YouTube page for ${videoId}`)
+
+  // Try to get transcript
+  let transcript = ""
+
+  // 1. Try direct caption fetch from page (fast, works when YouTube allows it)
+  const captionTracks = player ? extractCaptionTracks(player) : []
+  if (captionTracks.length > 0) {
+    // Prefer manual English, then any manual, then auto English, then first available
+    const preferred = captionTracks.find((t) => t.languageCode === "en" && t.kind !== "asr")
+      ?? captionTracks.find((t) => t.kind !== "asr")
+      ?? captionTracks.find((t) => t.languageCode === "en")
+      ?? captionTracks[0]
+    transcript = await fetchTranscriptDirect(preferred.url)
+  }
+
+  // 2. Fall back to yt-dlp if direct fetch returned nothing
+  if (!transcript && await ytDlpAvailable()) {
+    transcript = await fetchTranscriptYtDlp(videoId, "en")
+  }
+
+  return formatYouTubeResult(meta, transcript, maxChars)
+}

package/src/prism-extensions/providers/manifest-provider.ts

@@ -1,9 +1,11 @@
-import { createAssistantMessageEventStream } from "@earendil-works/pi-ai"
+import { calculateCost, createAssistantMessageEventStream } from "@earendil-works/pi-ai"
+import { getBuiltinModel as getTypedBuiltinModel } from "@earendil-works/pi-ai/providers/all"
 import { getPrismManifestRoutingTier } from "../core/manifest-routing.js"
 export { DEFAULT_MANIFEST_BASE_URL, DEFAULT_MANIFEST_CONTEXT_WINDOW, DEFAULT_MANIFEST_MAX_TOKENS, DEFAULT_MANIFEST_MODEL, applyManifestTierHeader, buildManifestRequestHeaders, normalizeManifestBaseUrl, normalizeManifestTier, readManifestProviderSettings, resolveManifestProviderConfig } from "./manifest-config.js"
 import { DEFAULT_MANIFEST_MODEL, type ManifestProviderConfig, applyManifestTierHeader, buildManifestRequestHeaders, normalizeManifestTier, resolveManifestProviderConfig } from "./manifest-config.js"
 
 type ExtensionAPI = any
+const getBuiltinModel = getTypedBuiltinModel as (provider: string, modelId: string) => any
 
 function sanitizeManifestSystemText(text: string): string {
   // Manifest may route to Anthropic. Its OpenAI-to-Anthropic bridge currently rejects some
@@ -180,6 +182,23 @@ export function manifestResponseSummary(headers: Record<string, string | undefin
   return `Manifest: ${parts.join(" · ")}`
 }
 
+export function applyManifestResponseCost(message: any, headers: Record<string, string | undefined>): any {
+  if (message?.role !== "assistant" || message.provider !== "manifest" || !message.usage) return message
+  const provider = headers["x-manifest-provider"]?.trim()
+  const responseModel = headers["x-manifest-model"]?.trim()
+  if (!provider || !responseModel) return message
+
+  const model = getBuiltinModel(provider, responseModel) ?? getBuiltinModel(provider, responseModel.split("/").pop() ?? responseModel)
+  if (!model?.cost) return { ...message, responseModel: `${provider}/${responseModel}` }
+
+  const usage = {
+    ...message.usage,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  }
+  calculateCost(model, usage)
+  return { ...message, responseModel: `${provider}/${responseModel}`, usage }
+}
+
 function registerManifestProvider(pi: ExtensionAPI, config: ManifestProviderConfig): void {
   if (!config.baseUrl) return
   pi.registerProvider("manifest", {
@@ -207,6 +226,7 @@ function registerManifestProvider(pi: ExtensionAPI, config: ManifestProviderConf
 export default function manifestProviderExtension(pi: ExtensionAPI): void {
   let config = resolveManifestProviderConfig()
   let lastSummary: string | undefined
+  let lastHeaders: Record<string, string | undefined> = {}
   registerManifestProvider(pi, config)
 
   pi.on?.("before_provider_headers", (event: any, ctx: any) => {
@@ -221,10 +241,17 @@ export default function manifestProviderExtension(pi: ExtensionAPI): void {
 
   pi.on?.("after_provider_response", (event: any, ctx: any) => {
     if (ctx.model?.provider !== "manifest") return
-    lastSummary = manifestResponseSummary(event.headers ?? {})
+    lastHeaders = event.headers ?? {}
+    lastSummary = manifestResponseSummary(lastHeaders)
     if (lastSummary) ctx.ui?.setStatus?.("manifest", lastSummary)
   })
 
+  pi.on?.("message_end", (event: any, ctx: any) => {
+    if (ctx.model?.provider !== "manifest") return
+    const message = applyManifestResponseCost(event.message, lastHeaders)
+    return message === event.message ? undefined : { message }
+  })
+
   pi.registerCommand?.("manifest", {
     description: "Show or set Manifest routing override: status | tier <custom-tier|auto>",
     handler: async (args: string, ctx: any) => {