pi-meta-oauth 0.4.2 → 0.4.4

package/extensions/media/responses.ts

@@ -0,0 +1,186 @@
+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 };
+}

package/extensions/media-output.ts

@@ -0,0 +1,127 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export const DEFAULT_MEDIA_MAX_CHARS = 20_000;
+export const MAX_MEDIA_MAX_CHARS = 50_000;
+export const DEFAULT_MEDIA_MAX_OUTPUT_TOKENS = 8_000;
+export const MIN_MEDIA_MAX_OUTPUT_TOKENS = 4_000;
+export const MAX_MEDIA_MAX_OUTPUT_TOKENS = 32_000;
+const MAX_INLINE_BYTES = 50 * 1024;
+const MAX_INLINE_LINES = 2_000;
+
+export interface MediaOutputDetails {
+	path?: string;
+	chars: number;
+	lines: number;
+	truncated: boolean;
+	incomplete: boolean;
+}
+
+function clampInteger(value: number | undefined, fallback: number, minimum: number, maximum: number): number {
+	if (value === undefined) return fallback;
+	return Math.max(minimum, Math.min(maximum, Math.trunc(value)));
+}
+
+export function mediaMaxChars(value: number | undefined): number {
+	return clampInteger(value, DEFAULT_MEDIA_MAX_CHARS, 1_000, MAX_MEDIA_MAX_CHARS);
+}
+
+export function mediaMaxOutputTokens(value: number | undefined): number {
+	return clampInteger(
+		value,
+		DEFAULT_MEDIA_MAX_OUTPUT_TOKENS,
+		MIN_MEDIA_MAX_OUTPUT_TOKENS,
+		MAX_MEDIA_MAX_OUTPUT_TOKENS,
+	);
+}
+
+function inlineSlice(text: string, maxChars: number): string {
+	let slice = text.split("\n").slice(0, MAX_INLINE_LINES).join("\n").slice(0, maxChars);
+	if (Buffer.byteLength(slice, "utf8") <= MAX_INLINE_BYTES) return slice;
+	const bytes = Buffer.from(slice, "utf8").subarray(0, MAX_INLINE_BYTES);
+	slice = new TextDecoder().decode(bytes);
+	return slice.endsWith("\uFFFD") ? slice.slice(0, -1) : slice;
+}
+
+function responseReason(response: unknown): string | undefined {
+	if (!response || typeof response !== "object") return undefined;
+	const record = response as Record<string, unknown>;
+	const details = record.incomplete_details;
+	if (details && typeof details === "object") {
+		const reason = (details as Record<string, unknown>).reason;
+		if (typeof reason === "string") return reason;
+	}
+	for (const key of ["finish_reason", "stop_reason"]) {
+		if (typeof record[key] === "string") return record[key] as string;
+	}
+	return record.status === "incomplete" ? "incomplete" : undefined;
+}
+
+export function responseHitOutputLimit(response: unknown): boolean {
+	const reason = responseReason(response)?.toLowerCase();
+	return reason === "max_output_tokens" || reason === "length" || reason === "max_tokens";
+}
+
+function outputFilePath(identity: string, text: string): string {
+	const hash = createHash("sha256").update(`${identity}\0${text.length}\0${text.slice(0, 1024)}`).digest("hex").slice(0, 16);
+	return join(tmpdir(), `pi-meta-media-${hash}.txt`);
+}
+
+async function saveFullOutput(identity: string, text: string): Promise<string | undefined> {
+	const basePath = outputFilePath(identity, text);
+	try {
+		await mkdir(tmpdir(), { recursive: true });
+		try {
+			await writeFile(basePath, text, { encoding: "utf8", flag: "wx", mode: 0o600 });
+			return basePath;
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			const uniquePath = `${basePath}.${randomBytes(4).toString("hex")}`;
+			await writeFile(uniquePath, text, { encoding: "utf8", flag: "wx", mode: 0o600 });
+			return uniquePath;
+		}
+	} catch {
+		return undefined;
+	}
+}
+
+export async function prepareMediaOutput(options: {
+	text: string;
+	identity: string;
+	maxChars?: number;
+	response?: unknown;
+}): Promise<{ text: string; details: MediaOutputDetails }> {
+	const { text, identity, response } = options;
+	const slice = inlineSlice(text, mediaMaxChars(options.maxChars));
+	const truncated = slice.length < text.length;
+	const lines = text.length === 0 ? 0 : text.split("\n").length;
+	const incomplete = responseHitOutputLimit(response);
+	const savedPath = truncated ? await saveFullOutput(identity, text) : undefined;
+	const notes: string[] = [];
+	if (truncated) {
+		const continuation =
+			lines <= 1
+				? `full content saved to: ${savedPath}. Open that file directly; it is a single line so read offset/limit cannot page through it.`
+				: `full content saved to: ${savedPath} (${lines} lines). Use the read tool with offset/limit to continue (offset is a 1-based line number).`;
+		notes.push(
+			savedPath
+				? `content truncated at ${slice.length} of ${text.length} characters; ${continuation}`
+				: `content truncated at ${slice.length} of ${text.length} characters; the full content could not be saved, so continuation is unavailable.`,
+		);
+	}
+	if (incomplete) {
+		notes.push("Muse exhausted max_output_tokens, so the analysis may be incomplete. Retry with a larger budget or a narrower prompt.");
+	}
+	return {
+		text: `${slice}${notes.length > 0 ? `\n\n[${notes.join(" ")}]` : ""}`,
+		details: {
+			...(savedPath ? { path: savedPath } : {}),
+			chars: text.length,
+			lines,
+			truncated,
+			incomplete,
+		},
+	};
+}