Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import fs from "node:fs";
import path from "node:path";
import type { SqliteAdapter } from "../db/adapters/types";
import { parseStoredPayload } from "./parseStoredPayload";
/** Read-only surface shared by the dashboard and isolated export process. */
export interface CallLogReadDb {
prepare(sql: string): Pick<ReturnType<SqliteAdapter["prepare"]>, "get" | "all">;
}
export interface CallLogDetailEntry {
id: string;
timestamp: string | null;
model: string | null;
status: number;
detailState: string;
artifactRelPath: string | null;
error: unknown;
hasPipelineDetails: boolean;
}
interface DetailFileIo {
readFile(file: string): string | Promise<string>;
readdir(dir: string): string[] | Promise<string[]>;
}
const asyncIo: DetailFileIo = {
readFile: (file) => fs.promises.readFile(file, "utf8"),
readdir: (dir) => fs.promises.readdir(dir),
};
/** Dashboard compatibility: its existing detail path still reads synchronously. */
export const dashboardDetailIo: DetailFileIo = {
readFile: (file) => fs.readFileSync(file, "utf8"),
readdir: (dir) => fs.readdirSync(dir),
};
function hasTable(db: CallLogReadDb, table: string): boolean {
return Boolean(
db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table)
);
}
function legacyPipeline(db: CallLogReadDb, id: string): Record<string, unknown> | null {
if (!hasTable(db, "request_detail_logs")) return null;
const row = db
.prepare(
`SELECT * FROM request_detail_logs WHERE call_log_id = ? ORDER BY timestamp DESC LIMIT 1`
)
.get(id) as Record<string, unknown> | undefined;
if (!row) return null;
return {
clientRequest: parseStoredPayload(row.client_request),
providerRequest: parseStoredPayload(row.translated_request),
providerResponse: parseStoredPayload(row.provider_response),
clientResponse: parseStoredPayload(row.client_response),
};
}
async function legacyDisk(
entry: CallLogDetailEntry,
baseDir: string | null,
io: DetailFileIo
): Promise<Record<string, unknown> | null> {
if (!baseDir || !entry.timestamp) return null;
const date = new Date(entry.timestamp);
if (Number.isNaN(date.getTime())) return null;
const dateFolder = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
const dir = path.join(baseDir, dateFolder);
const time = `${String(date.getHours()).padStart(2, "0")}${String(date.getMinutes()).padStart(2, "0")}${String(date.getSeconds()).padStart(2, "0")}`;
const safeModel = (entry.model || "unknown").replace(/[/:]/g, "-");
try {
try {
return JSON.parse(
await io.readFile(path.join(dir, `${time}_${safeModel}_${entry.status}.json`))
) as Record<string, unknown>;
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") return null;
}
const files = (await io.readdir(dir)).filter(
(file) => file.startsWith(time) && file.endsWith(`_${entry.status}.json`)
);
return files.length
? (JSON.parse(await io.readFile(path.join(dir, files[0]))) as Record<string, unknown>)
: null;
} catch {
// Missing/corrupt historical files intentionally export summary-only records.
return null;
}
}
type ArtifactState = "missing" | "corrupt";
type DetailPayload = Record<string, unknown>;
interface ArtifactRead {
payload: DetailPayload | null;
detailState: string;
artifactRelPath: string | null;
pipelinePayloads: DetailPayload | null;
}
async function readArtifactPayload(
db: CallLogReadDb,
entry: CallLogDetailEntry,
baseDir: string | null,
io: DetailFileIo,
onArtifactState?: (relativePath: string, state: ArtifactState) => void
): Promise<ArtifactRead> {
const relPath = entry.artifactRelPath;
const unchanged: ArtifactRead = {
payload: null,
detailState: entry.detailState,
artifactRelPath: relPath,
pipelinePayloads: null,
};
if (!relPath || !baseDir) return unchanged;
try {
const payload = JSON.parse(await io.readFile(path.join(baseDir, relPath))) as DetailPayload;
if (!payload) return unchanged;
return {
payload,
detailState: "ready",
artifactRelPath: relPath,
pipelinePayloads: (payload.pipeline ?? legacyPipeline(db, entry.id)) as DetailPayload | null,
};
} catch (error) {
const state: ArtifactState =
(error as NodeJS.ErrnoException).code === "ENOENT" ? "missing" : "corrupt";
onArtifactState?.(relPath, state);
return {
payload: null,
detailState: state,
artifactRelPath: state === "missing" ? null : relPath,
pipelinePayloads: null,
};
}
}
/** Legacy inline error column: blank → null, JSON → parsed, plain text kept verbatim. */
function parseLegacyError(value: unknown): unknown {
if (typeof value !== "string" || !value.trim()) return null;
try {
return JSON.parse(value);
} catch {
return value; // Historical plain-text error.
}
}
function readLegacyInline(db: CallLogReadDb, id: string): DetailPayload | null {
if (!hasTable(db, "call_logs_v1_legacy")) return null;
const row = db
.prepare("SELECT request_body, response_body, error FROM call_logs_v1_legacy WHERE id = ?")
.get(id) as Record<string, unknown> | undefined;
if (!row) return null;
return {
requestBody: parseStoredPayload(row.request_body),
responseBody: parseStoredPayload(row.response_body),
error: parseLegacyError(row.error),
};
}
/** Body/error fields; an inline legacy row's error wins even when null (historical shape). */
function detailBodyFields(payload: DetailPayload | null, inline: boolean, entryError: unknown) {
return {
requestBody: payload?.requestBody ?? null,
responseBody: payload?.responseBody ?? null,
error: inline ? payload?.error : (payload?.error ?? entryError),
};
}
/**
* Pure detail resolution: artifact → legacy-inline → legacy-disk → none.
* Never updates SQLite. The dashboard owns missing/corrupt bookkeeping via onArtifactState;
* the export child deliberately supplies no callback and uses asynchronous filesystem IO.
*/
export async function resolveCallLogDetail<T extends CallLogDetailEntry>(
db: CallLogReadDb,
entry: T,
baseDir: string | null,
options: {
io?: DetailFileIo;
onArtifactState?: (relativePath: string, state: ArtifactState) => void;
} = {}
) {
const io = options.io ?? asyncIo;
const artifact = await readArtifactPayload(db, entry, baseDir, io, options.onArtifactState);
const artifactReady = artifact.payload !== null;
const inlinePayload =
!artifactReady && artifact.detailState === "legacy-inline"
? readLegacyInline(db, entry.id)
: null;
const inline = inlinePayload !== null;
const payload = artifact.payload ?? inlinePayload ?? (await legacyDisk(entry, baseDir, io));
const pipelinePayloads = artifact.pipelinePayloads || legacyPipeline(db, entry.id);
const hasPipelineDetails = artifactReady ? Boolean(payload?.pipeline) : Boolean(pipelinePayloads);
return {
...entry,
detailState: artifact.detailState,
artifactRelPath: artifact.artifactRelPath,
...detailBodyFields(payload, inline, entry.error),
pipelinePayloads,
hasPipelineDetails: hasPipelineDetails || entry.hasPipelineDetails,
active: false,
};
}