pi-meta-oauth 0.4.4 → 0.6.0

package/extensions/media/mime.ts

@@ -1,178 +0,0 @@
-import { extname } from "node:path";
-
-export interface ResponsesContentBlock {
-	type: string;
-	[key: string]: unknown;
-}
-
-type SupportedMime =
-	| "video/mp4"
-	| "audio/mpeg"
-	| "audio/wav"
-	| "application/pdf"
-	| "image/png"
-	| "image/jpeg"
-	| "image/gif"
-	| "image/webp"
-	| "image/x-icon"
-	| "text/plain"
-	| "application/json"
-	| "application/jsonl";
-
-const EXT_TO_MIME: Record<string, SupportedMime> = {
-	".mp4": "video/mp4",
-	".m4v": "video/mp4",
-	".mp3": "audio/mpeg",
-	".wav": "audio/wav",
-	".pdf": "application/pdf",
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".gif": "image/gif",
-	".webp": "image/webp",
-	".ico": "image/x-icon",
-	".txt": "text/plain",
-	".json": "application/json",
-	".jsonl": "application/jsonl",
-};
-
-export function mimeForPath(path: string): SupportedMime | undefined {
-	const ext = extname(path).toLowerCase();
-	return EXT_TO_MIME[ext];
-}
-
-export function mimeForDataUrl(dataUrl: string): string | undefined {
-	const m = dataUrl.match(/^data:([^;,\s]+)[;,]/);
-	return m?.[1]?.toLowerCase();
-}
-
-export function isVideoMime(m: string | undefined): boolean {
-	return m === "video/mp4";
-}
-
-export function isAudioMime(m: string | undefined): boolean {
-	return (
-		m === "audio/mpeg" ||
-		m === "audio/mp3" ||
-		m === "audio/wav" ||
-		m === "audio/x-wav"
-	);
-}
-
-export function isPdfMime(m: string | undefined): boolean {
-	return m === "application/pdf";
-}
-
-export function isImageMime(m: string | undefined): boolean {
-	return typeof m === "string" && m.startsWith("image/");
-}
-
-export function filenameForMime(
-	mime: string | undefined,
-	fallback = "file.bin",
-): string {
-	switch (mime) {
-		case "video/mp4":
-			return "video.mp4";
-		case "audio/mpeg":
-		case "audio/mp3":
-			return "audio.mp3";
-		case "audio/wav":
-		case "audio/x-wav":
-			return "audio.wav";
-		case "application/pdf":
-			return "document.pdf";
-		default:
-			return fallback;
-	}
-}
-
-export function audioFormatForMime(mime: string | undefined): "wav" | "mp3" {
-	return mime === "audio/wav" || mime === "audio/x-wav" ? "wav" : "mp3";
-}
-
-export function base64FromDataUrl(dataUrl: string): string {
-	const comma = dataUrl.indexOf(",");
-	return comma === -1 ? "" : dataUrl.slice(comma + 1);
-}
-
-export function base64ByteLength(base64: string): number {
-	const normalized = base64.replace(/\s/g, "");
-	if (!normalized) return 0;
-	const padding = normalized.endsWith("==")
-		? 2
-		: normalized.endsWith("=")
-			? 1
-			: 0;
-	return Math.max(0, Math.floor((normalized.length * 3) / 4) - padding);
-}
-
-export function isRemoteMediaSource(source: string): boolean {
-	return source.startsWith("https://") || source.startsWith("data:");
-}
-
-export function mediaPathFromUrl(url: string): string {
-	if (url.startsWith("data:")) return url;
-	try {
-		return new URL(url).pathname;
-	} catch {
-		const withoutHash = url.split("#")[0] ?? url;
-		return withoutHash.split("?")[0] ?? withoutHash;
-	}
-}
-
-export function mimeForSource(source: string): string | undefined {
-	if (source.startsWith("data:")) return mimeForDataUrl(source);
-	if (source.startsWith("https://")) {
-		try {
-			return mimeForPath(new URL(source).pathname);
-		} catch {
-			return undefined;
-		}
-	}
-	return mimeForPath(source);
-}
-
-/** Build a generic Meta Responses input_file block. */
-export function inputFileFromSource(
-	source: string,
-	filename?: string,
-): ResponsesContentBlock {
-	if (source.startsWith("https://")) {
-		return { type: "input_file", file_url: source };
-	}
-	if (source.startsWith("data:")) {
-		const mime = mimeForDataUrl(source);
-		return {
-			type: "input_file",
-			file_data: source,
-			filename: filename ?? filenameForMime(mime),
-		};
-	}
-	return { type: "input_file", file_id: source };
-}
-
-/** Build the typed content block required by Meta for each media kind. */
-export function mediaInputFromSource(
-	source: string,
-	filename?: string,
-	expectedMime?: string,
-): ResponsesContentBlock {
-	if (!source.startsWith("data:") && !source.startsWith("https://")) {
-		return { type: "input_file", file_id: source };
-	}
-	const mime = expectedMime ?? mimeForSource(source);
-	if (isVideoMime(mime)) {
-		return { type: "input_video", video_url: source };
-	}
-	if (isAudioMime(mime) && source.startsWith("data:")) {
-		return {
-			type: "input_audio",
-			input_audio: {
-				data: base64FromDataUrl(source),
-				format: audioFormatForMime(mime),
-			},
-		};
-	}
-	return inputFileFromSource(source, filename);
-}

package/extensions/media/payload.ts

@@ -1,303 +0,0 @@
-import { STORE_SAFE_INLINE_BYTES } from "./limits.ts";
-import { uploadInlineMedia } from "./files.ts";
-import {
-	base64ByteLength,
-	base64FromDataUrl,
-	filenameForMime,
-	isAudioMime,
-	isImageMime,
-	isPdfMime,
-	isVideoMime,
-	mediaInputFromSource,
-	mediaPathFromUrl,
-	mimeForDataUrl,
-} from "./mime.ts";
-
-function record(value: unknown): Record<string, unknown> | undefined {
-	return value !== null && typeof value === "object"
-		? (value as Record<string, unknown>)
-		: undefined;
-}
-
-function isInputImageBlock(b: Record<string, unknown>): boolean {
-	return b.type === "input_image" && typeof b.image_url === "string";
-}
-
-function rewriteBlock(
-	block: Record<string, unknown>,
-): Record<string, unknown> | null {
-	if (!isInputImageBlock(block)) return null;
-	const url = block.image_url as string;
-	const mime = mimeForDataUrl(url);
-	const lowerPath = mediaPathFromUrl(url).toLowerCase();
-	const isHttps = url.startsWith("https://");
-	const isHttpsVideo =
-		isHttps && (lowerPath.endsWith(".mp4") || lowerPath.endsWith(".m4v"));
-	const isHttpsAudio =
-		isHttps && (lowerPath.endsWith(".mp3") || lowerPath.endsWith(".wav"));
-	const isHttpsPdf = isHttps && lowerPath.endsWith(".pdf");
-	const isHttpsImage =
-		isHttps &&
-		(lowerPath.endsWith(".png") ||
-			lowerPath.endsWith(".jpg") ||
-			lowerPath.endsWith(".jpeg") ||
-			lowerPath.endsWith(".gif") ||
-			lowerPath.endsWith(".webp"));
-
-	if (isHttpsImage || isImageMime(mime)) return null;
-
-	if (isVideoMime(mime) || isHttpsVideo) {
-		return mediaInputFromSource(url, "video.mp4", "video/mp4") as Record<
-			string,
-			unknown
-		>;
-	}
-	if (isAudioMime(mime) || isHttpsAudio) {
-		const effectiveMime =
-			typeof mime === "string"
-				? mime
-				: lowerPath.endsWith(".wav")
-					? "audio/wav"
-					: "audio/mpeg";
-		return mediaInputFromSource(
-			url,
-			filenameForMime(effectiveMime, "audio.bin"),
-			effectiveMime,
-		) as Record<string, unknown>;
-	}
-	if (isPdfMime(mime) || isHttpsPdf) {
-		return mediaInputFromSource(
-			url,
-			"document.pdf",
-			"application/pdf",
-		) as Record<string, unknown>;
-	}
-	return null;
-}
-
-function rewriteBlocks(
-	blocks: Record<string, unknown>[],
-	onlyImageUrls = false,
-): { blocks: Record<string, unknown>[]; rewritten: boolean } {
-	let rewritten = false;
-	const next = blocks.map((block) => {
-		if (
-			onlyImageUrls &&
-			!(block.type === "input_image" && typeof block.image_url === "string")
-		) {
-			return block;
-		}
-		const replacement = rewriteBlock(block);
-		if (replacement) {
-			rewritten = true;
-			return replacement;
-		}
-		return block;
-	});
-	return { blocks: next, rewritten };
-}
-
-/** Rewrite smuggled media image_url blocks into Meta-supported typed blocks. */
-export function rewriteResponsesPayload(payload: unknown): {
-	rewritten: boolean;
-	payload: unknown;
-} {
-	if (!payload || typeof payload !== "object")
-		return { rewritten: false, payload };
-	const p = payload as Record<string, unknown>;
-	const input = p.input;
-	if (!Array.isArray(input)) return { rewritten: false, payload };
-	let rewritten = false;
-	const newInput = input.map((entry) => {
-		if (!entry || typeof entry !== "object") return entry;
-		const e = { ...(entry as Record<string, unknown>) };
-		if (Array.isArray(e.content)) {
-			const result = rewriteBlocks(e.content as Record<string, unknown>[]);
-			if (result.rewritten) {
-				rewritten = true;
-				e.content = result.blocks;
-			}
-		}
-		if (
-			(e.type === "function_call_output" ||
-				e.type === "custom_tool_call_output") &&
-			Array.isArray(e.output)
-		) {
-			const result = rewriteBlocks(
-				e.output as Record<string, unknown>[],
-				true,
-			);
-			if (result.rewritten) {
-				rewritten = true;
-				e.output = result.blocks;
-			}
-		}
-		return e;
-	});
-	if (!rewritten) return { rewritten: false, payload };
-	return { rewritten: true, payload: { ...p, input: newInput } };
-}
-
-function inlineFromBlock(
-	block: Record<string, unknown>,
-): { base64: string; mime: string; filename: string } | undefined {
-	if (
-		block.type === "input_video" &&
-		typeof block.video_url === "string" &&
-		block.video_url.startsWith("data:")
-	) {
-		return {
-			base64: base64FromDataUrl(block.video_url),
-			mime: mimeForDataUrl(block.video_url) ?? "video/mp4",
-			filename: "video.mp4",
-		};
-	}
-	if (block.type === "input_audio") {
-		const audio = record(block.input_audio);
-		if (typeof audio?.data === "string") {
-			const format = audio.format === "wav" ? "wav" : "mp3";
-			return {
-				base64: audio.data.startsWith("data:")
-					? base64FromDataUrl(audio.data)
-					: audio.data,
-				mime: format === "wav" ? "audio/wav" : "audio/mpeg",
-				filename: `audio.${format}`,
-			};
-		}
-	}
-	if (
-		block.type === "input_file" &&
-		typeof block.file_data === "string" &&
-		block.file_data.startsWith("data:")
-	) {
-		const mime = mimeForDataUrl(block.file_data) ?? "application/octet-stream";
-		return {
-			base64: base64FromDataUrl(block.file_data),
-			mime,
-			filename:
-				typeof block.filename === "string" && block.filename
-					? block.filename
-					: filenameForMime(mime),
-		};
-	}
-	if (
-		block.type === "input_image" &&
-		typeof block.image_url === "string" &&
-		block.image_url.startsWith("data:")
-	) {
-		const mime = mimeForDataUrl(block.image_url) ?? "image/png";
-		return {
-			base64: base64FromDataUrl(block.image_url),
-			mime,
-			filename: filenameForMime(mime, "image.bin"),
-		};
-	}
-	return undefined;
-}
-
-function isMediaBlock(block: Record<string, unknown>): boolean {
-	return (
-		block.type === "input_file" ||
-		block.type === "input_image" ||
-		block.type === "input_video" ||
-		block.type === "input_audio"
-	);
-}
-
-export function payloadContainsMedia(payload: unknown): boolean {
-	if (!payload || typeof payload !== "object") return false;
-	const input = (payload as Record<string, unknown>).input;
-	if (!Array.isArray(input)) return false;
-	for (const entry of input as Record<string, unknown>[]) {
-		if (!entry || typeof entry !== "object") continue;
-		const groups = [entry.content, entry.output];
-		for (const group of groups) {
-			if (!Array.isArray(group)) continue;
-			for (const block of group as Record<string, unknown>[]) {
-				if (block && typeof block === "object" && isMediaBlock(block))
-					return true;
-			}
-		}
-	}
-	return false;
-}
-
-async function promoteBlocks(
-	blocks: Record<string, unknown>[],
-	apiKey: string,
-	uploadThresholdBytes: number,
-	signal?: AbortSignal,
-): Promise<{
-	blocks: Record<string, unknown>[];
-	uploaded: number;
-	needsStoreFalse: boolean;
-}> {
-	let uploaded = 0;
-	let needsStoreFalse = false;
-	const next: Record<string, unknown>[] = [];
-	for (const block of blocks) {
-		const inline = inlineFromBlock(block);
-		if (inline) {
-			needsStoreFalse = true;
-			if (base64ByteLength(inline.base64) > uploadThresholdBytes) {
-				const id = await uploadInlineMedia(
-					apiKey,
-					inline.base64,
-					inline.mime,
-					inline.filename,
-					signal,
-				);
-				uploaded += 1;
-				next.push({ type: "input_file", file_id: id });
-				continue;
-			}
-		} else if (isMediaBlock(block)) {
-			needsStoreFalse = true;
-		}
-		next.push(block);
-	}
-	return { blocks: next, uploaded, needsStoreFalse };
-}
-
-export async function maybeUploadLargeInlineBlocks(
-	payload: unknown,
-	apiKey: string | undefined,
-	uploadThresholdBytes = STORE_SAFE_INLINE_BYTES,
-	signal?: AbortSignal,
-): Promise<{ payload: unknown; uploaded: number }> {
-	if (!apiKey) return { payload, uploaded: 0 };
-	if (!payload || typeof payload !== "object") return { payload, uploaded: 0 };
-	const p = payload as Record<string, unknown>;
-	const input = p.input;
-	if (!Array.isArray(input)) return { payload, uploaded: 0 };
-	let uploaded = 0;
-	let needsStoreFalse = false;
-	const newInput: unknown[] = [];
-
-	for (const entry of input as Record<string, unknown>[]) {
-		if (!entry || typeof entry !== "object") {
-			newInput.push(entry);
-			continue;
-		}
-		const nextEntry = { ...entry };
-		for (const key of ["content", "output"] as const) {
-			if (!Array.isArray(nextEntry[key])) continue;
-			const promoted = await promoteBlocks(
-				nextEntry[key] as Record<string, unknown>[],
-				apiKey,
-				uploadThresholdBytes,
-				signal,
-			);
-			nextEntry[key] = promoted.blocks;
-			uploaded += promoted.uploaded;
-			needsStoreFalse ||= promoted.needsStoreFalse;
-		}
-		newInput.push(nextEntry);
-	}
-
-	if (!needsStoreFalse && uploaded === 0) return { payload, uploaded: 0 };
-	return {
-		payload: { ...p, input: newInput, store: false },
-		uploaded,
-	};
-}

package/extensions/media/responses.ts

@@ -1,186 +0,0 @@
-import type { Usage } from "@earendil-works/pi-ai";
-import { META_API_BASE_URL, metaFallbackCost } from "../meta.ts";
-
-function record(value: unknown): Record<string, unknown> | undefined {
-	return value !== null && typeof value === "object"
-		? (value as Record<string, unknown>)
-		: undefined;
-}
-
-function tokenCount(...values: unknown[]): number | undefined {
-	for (const value of values) {
-		const numeric =
-			typeof value === "number"
-				? value
-				: typeof value === "string" && value.trim()
-					? Number(value)
-					: Number.NaN;
-		if (Number.isFinite(numeric)) return Math.max(0, Math.trunc(numeric));
-	}
-	return undefined;
-}
-
-function responsesErrorDetail(json: unknown, text: string, statusText: string): string {
-	const body = record(json);
-	if (body?.error !== undefined) {
-		return JSON.stringify(body.error).slice(0, 1000);
-	}
-	if (typeof body?.message === "string") {
-		return body.message.slice(0, 1000);
-	}
-	return text.slice(0, 1000) || statusText;
-}
-
-/** Convert a Meta Responses API usage block into Pi's nested-tool usage shape. */
-export function extractMetaResponseUsage(
-	response: unknown,
-	modelId = "muse-spark-1.2",
-): Usage | undefined {
-	const usage = record(record(response)?.usage);
-	if (!usage) return undefined;
-
-	const inputDetails = record(
-		usage.input_tokens_details ?? usage.inputTokensDetails,
-	);
-	const outputDetails = record(
-		usage.output_tokens_details ?? usage.outputTokensDetails,
-	);
-	const inputTotal = tokenCount(
-		usage.input_tokens,
-		usage.inputTokens,
-		usage.prompt_tokens,
-		usage.promptTokens,
-		usage.input,
-	);
-	const output = tokenCount(
-		usage.output_tokens,
-		usage.outputTokens,
-		usage.completion_tokens,
-		usage.completionTokens,
-		usage.output,
-	);
-	if (inputTotal === undefined && output === undefined) return undefined;
-
-	const reportedInput = inputTotal ?? 0;
-	const cacheRead = Math.min(
-		reportedInput,
-		tokenCount(inputDetails?.cached_tokens, inputDetails?.cachedTokens) ?? 0,
-	);
-	const cacheWrite = Math.min(
-		reportedInput - cacheRead,
-		tokenCount(
-			inputDetails?.cache_write_tokens,
-			inputDetails?.cacheWriteTokens,
-		) ?? 0,
-	);
-	const uncachedInput = Math.max(0, reportedInput - cacheRead - cacheWrite);
-	const outputTokens = output ?? 0;
-	const reasoning = Math.min(
-		outputTokens,
-		tokenCount(
-			outputDetails?.reasoning_tokens,
-			outputDetails?.reasoningTokens,
-		) ?? 0,
-	);
-	const totalTokens =
-		tokenCount(usage.total_tokens, usage.totalTokens) ??
-		uncachedInput + cacheRead + cacheWrite + outputTokens;
-	const rates = metaFallbackCost(modelId);
-	const cost = {
-		input: (uncachedInput * (rates?.input ?? 0)) / 1_000_000,
-		output: (outputTokens * (rates?.output ?? 0)) / 1_000_000,
-		cacheRead: (cacheRead * (rates?.cacheRead ?? 0)) / 1_000_000,
-		cacheWrite: (cacheWrite * (rates?.cacheWrite ?? 0)) / 1_000_000,
-		total: 0,
-	};
-	cost.total = cost.input + cost.output + cost.cacheRead + cost.cacheWrite;
-
-	return {
-		input: uncachedInput,
-		output: outputTokens,
-		cacheRead,
-		cacheWrite,
-		reasoning,
-		totalTokens,
-		cost,
-	};
-}
-
-export function formatMetaResponseUsage(usage: Usage): string {
-	const parts = [`${usage.input.toLocaleString()} input`];
-	if (usage.cacheRead)
-		parts.push(`${usage.cacheRead.toLocaleString()} cache read`);
-	if (usage.cacheWrite)
-		parts.push(`${usage.cacheWrite.toLocaleString()} cache write`);
-	parts.push(`${usage.output.toLocaleString()} output`);
-	if (usage.reasoning)
-		parts.push(`${usage.reasoning.toLocaleString()} reasoning`);
-	return `Video token usage: ${usage.totalTokens.toLocaleString()} total (${parts.join(", ")})`;
-}
-
-export function extractResponsesText(json: unknown): string {
-	if (!json || typeof json !== "object") return "";
-	const j = json as Record<string, unknown>;
-	if (typeof j.output_text === "string" && j.output_text.trim())
-		return j.output_text;
-	const output = j.output as unknown;
-	if (Array.isArray(output)) {
-		const texts: string[] = [];
-		for (const item of output as Record<string, unknown>[]) {
-			if (!item || typeof item !== "object" || item.type !== "message")
-				continue;
-			if (typeof item.content === "string" && item.content.trim())
-				texts.push(item.content);
-			if (Array.isArray(item.content)) {
-				for (const c of item.content as Record<string, unknown>[]) {
-					if (
-						(c.type === "output_text" || c.type === "text") &&
-						typeof c.text === "string" &&
-						c.text.trim()
-					)
-						texts.push(c.text);
-					if (
-						c.type === "refusal" &&
-						typeof c.refusal === "string" &&
-						c.refusal.trim()
-					)
-						texts.push(c.refusal);
-				}
-			}
-		}
-		if (texts.length) return texts.join("\n\n");
-	}
-	if (typeof j.text === "string" && j.text.trim()) return j.text;
-	return "";
-}
-
-export async function callMetaResponses(
-	apiKey: string,
-	payload: Record<string, unknown>,
-	signal?: AbortSignal,
-): Promise<{ text: string; raw: unknown }> {
-	payload.store = false;
-	const res = await fetch(`${META_API_BASE_URL}/responses`, {
-		method: "POST",
-		headers: {
-			Authorization: `Bearer ${apiKey}`,
-			"Content-Type": "application/json",
-			"x-api-version": "1.0.0",
-		},
-		body: JSON.stringify(payload),
-		signal,
-	});
-	const text = await res.text();
-	let json: unknown;
-	try {
-		json = text ? (JSON.parse(text) as unknown) : {};
-	} catch {
-		json = text;
-	}
-	if (!res.ok) {
-		throw new Error(
-			`Meta Responses failed (HTTP ${res.status}): ${responsesErrorDetail(json, text, res.statusText)}`,
-		);
-	}
-	return { text: extractResponsesText(json), raw: json };
-}