agentcassette 0.1.0

package/dist/index.js

@@ -0,0 +1,881 @@
+import { createHash } from 'crypto';
+import { stat, readFile, mkdir, writeFile, rename, readdir, rm } from 'fs/promises';
+import { resolve, dirname, join } from 'path';
+
+// src/core/canonical.ts
+var ISO_TIMESTAMP = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:?\d{2})\b/giu;
+var UNIX_TIMESTAMP = /\b1[5-9]\d{8}(?:\d{3})?\b/gu;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (Array.isArray(value)) return value.map(asJsonValue);
+  if (isRecord(value)) {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== void 0) result[key] = asJsonValue(item);
+    }
+    return result;
+  }
+  return String(value);
+}
+function stableStringify(value) {
+  return JSON.stringify(sortValue(asJsonValue(value)));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (isRecord(value)) {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      const item = value[key];
+      if (item !== void 0) result[key] = sortValue(item);
+    }
+    return result;
+  }
+  return value;
+}
+function normalizeSemanticText(text) {
+  return text.normalize("NFKC").replace(ISO_TIMESTAMP, "<timestamp>").replace(UNIX_TIMESTAMP, "<timestamp>").replace(/\s+/gu, " ").trim();
+}
+function textPart(text) {
+  return { type: "text", text };
+}
+function normalizeRole(value) {
+  if (value === "system" || value === "assistant" || value === "tool") return value;
+  if (value === "model") return "assistant";
+  if (value === "function") return "tool";
+  return "user";
+}
+function contentToText(content) {
+  return content.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "json") return stableStringify(part.value);
+    return `[image:${part.source}]`;
+  }).join("\n");
+}
+function unknownToContent(value) {
+  if (typeof value === "string") return [textPart(value)];
+  if (value === null || value === void 0) return [];
+  if (Array.isArray(value)) {
+    return value.flatMap((part) => {
+      if (typeof part === "string") return [textPart(part)];
+      if (!isRecord(part)) return [{ type: "json", value: asJsonValue(part) }];
+      if (typeof part.text === "string") return [textPart(part.text)];
+      if (part.type === "text" && typeof part.text === "string") return [textPart(part.text)];
+      if (part.type === "image_url" && isRecord(part.image_url) && typeof part.image_url.url === "string") {
+        return [{ type: "image", source: part.image_url.url }];
+      }
+      return [{ type: "json", value: asJsonValue(part) }];
+    });
+  }
+  return [{ type: "json", value: asJsonValue(value) }];
+}
+function messageFromUnknown(value) {
+  if (!isRecord(value)) return { role: "user", content: unknownToContent(value) };
+  const message = {
+    role: normalizeRole(value.role),
+    content: unknownToContent(value.content)
+  };
+  if (typeof value.name === "string") message.name = value.name;
+  if (typeof value.tool_call_id === "string") message.toolCallId = value.tool_call_id;
+  if (typeof value.toolCallId === "string") message.toolCallId = value.toolCallId;
+  return message;
+}
+
+// src/core/diff.ts
+function structuredDiff(expected, actual) {
+  const entries = [];
+  walk(expected, actual, "$", entries);
+  return entries;
+}
+function walk(expected, actual, path, entries) {
+  if (Object.is(expected, actual)) return;
+  if (expected === void 0) {
+    entries.push({ path, kind: "added", actual: toDiffValue(actual) });
+    return;
+  }
+  if (actual === void 0) {
+    entries.push({ path, kind: "removed", expected: toDiffValue(expected) });
+    return;
+  }
+  if (Array.isArray(expected) && Array.isArray(actual)) {
+    const length = Math.max(expected.length, actual.length);
+    for (let index = 0; index < length; index += 1) {
+      walk(expected[index], actual[index], `${path}[${index}]`, entries);
+    }
+    return;
+  }
+  if (isPlainObject(expected) && isPlainObject(actual)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(expected), ...Object.keys(actual)]);
+    for (const key of [...keys].sort()) walk(expected[key], actual[key], `${path}.${key}`, entries);
+    return;
+  }
+  const kind = typeof expected === typeof actual ? "changed" : "type-changed";
+  entries.push({ path, kind, expected: toDiffValue(expected), actual: toDiffValue(actual) });
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toDiffValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (Array.isArray(value)) return value.map(toDiffValue);
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== void 0) result[key] = toDiffValue(item);
+    }
+    return result;
+  }
+  return String(value);
+}
+var CassetteDivergenceError = class extends Error {
+  report;
+  constructor(report) {
+    super(formatDivergence(report));
+    this.name = "CassetteDivergenceError";
+    this.report = report;
+  }
+};
+function formatDivergence(report) {
+  const lines = [
+    `Agent cassette diverged at turn ${report.turn + 1} in "${report.cassette}".`,
+    `Expected fingerprint: ${report.expectedFingerprint}`,
+    `Actual fingerprint:   ${report.actualFingerprint}`,
+    "",
+    "Structured request diff:"
+  ];
+  if (report.diff.length === 0) {
+    lines.push("  Requests differ under the configured fingerprint, but their stored structures are equal.");
+  } else {
+    for (const item of report.diff.slice(0, 30)) {
+      const expected = item.expected === void 0 ? "<missing>" : stableStringify(item.expected);
+      const actual = item.actual === void 0 ? "<missing>" : stableStringify(item.actual);
+      lines.push(`  ${item.path} (${item.kind})`, `    expected: ${expected}`, `    actual:   ${actual}`);
+    }
+    if (report.diff.length > 30) lines.push(`  \u2026and ${report.diff.length - 30} more differences.`);
+  }
+  lines.push("", "Fix the changed request, re-record this cassette intentionally, or provide a custom fingerprint when the change is non-behavioral.");
+  return lines.join("\n");
+}
+
+// src/core/events.ts
+function eventsForTurn(request, response) {
+  const events = [{ type: "messages.sent", messages: request.messages }];
+  for (const message of request.messages) {
+    if (message.role === "tool") events.push({ type: "tool.result.returned", message });
+  }
+  for (const call of response.toolCalls) events.push({ type: "tool.call.proposed", call });
+  if (response.content.length > 0) events.push({ type: "output.final", content: response.content });
+  return events;
+}
+var defaultFingerprint = (request) => {
+  const finalUser = [...request.messages].reverse().find((message) => message.role === "user");
+  const shape = request.messages.map((message) => ({
+    role: message.role,
+    content: message.content.map((part) => part.type),
+    ...message.name === void 0 ? {} : { name: message.name },
+    ...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId }
+  }));
+  const tools = request.tools.map((tool) => ({
+    name: tool.name,
+    ...tool.description === void 0 ? {} : { description: normalizeSemanticText(tool.description) },
+    inputSchema: tool.inputSchema
+  }));
+  const semanticFinalUserTurn = finalUser ? normalizeSemanticText(contentToText(finalUser.content)) : "";
+  const decisionHistory = request.messages.flatMap((message, index) => {
+    if (message.role === "system" || message === finalUser) return [];
+    return [{
+      index,
+      role: message.role,
+      content: normalizeSemanticText(contentToText(message.content)),
+      toolCalls: message.toolCalls ?? [],
+      ...message.name === void 0 ? {} : { name: message.name },
+      ...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId }
+    }];
+  });
+  const canonical = stableStringify({ tools, shape, decisionHistory, semanticFinalUserTurn });
+  return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+};
+function explainDefaultFingerprint(request) {
+  const finalUser = [...request.messages].reverse().find((message) => message.role === "user");
+  return {
+    conversationRoles: request.messages.map((message) => message.role),
+    finalUserTurn: finalUser ? normalizeSemanticText(contentToText(finalUser.content)) : "",
+    toolNames: request.tools.map((tool) => tool.name)
+  };
+}
+
+// src/core/redaction.ts
+var SECRET_KEY = /(?:api[-_]?key|authorization|password|passwd|secret|access[-_]?token|refresh[-_]?token|cookie)/iu;
+var BEARER_TOKEN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
+var EMAIL = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/giu;
+var PHONE_CANDIDATE = /(?<!\d)(?:\+?\d[\d ().-]{7,}\d)(?!\d)/gu;
+var defaultRedactionRules = [
+  {
+    name: "secret-key",
+    match: ({ key }) => key !== void 0 && SECRET_KEY.test(key)
+  }
+];
+function redact(value, options = {}) {
+  const rules = [
+    ...options.includeDefaults === false ? [] : defaultRedactionRules,
+    ...options.rules ?? []
+  ];
+  return visit(value, "$", void 0, rules, options.includeDefaults !== false);
+}
+function visit(value, path, key, rules, redactDefaultStrings) {
+  const json = asJsonValue(value);
+  const context = key === void 0 ? { path, value: json } : { path, key, value: json };
+  const rule = rules.find((candidate) => {
+    try {
+      return candidate.match(context);
+    } catch {
+      return false;
+    }
+  });
+  if (rule) return rule.replacement ?? "[REDACTED]";
+  if (typeof value === "string" && redactDefaultStrings) {
+    return value.replace(BEARER_TOKEN, "Bearer [REDACTED]").replace(EMAIL, "[REDACTED_EMAIL]").replace(PHONE_CANDIDATE, (candidate) => countDigits(candidate) >= 10 ? "[REDACTED_PHONE]" : candidate);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => visit(item, `${path}[${index}]`, void 0, rules, redactDefaultStrings));
+  }
+  if (isRecord(value)) {
+    const result = {};
+    for (const [childKey, item] of Object.entries(value)) {
+      result[childKey] = visit(item, `${path}.${childKey}`, childKey, rules, redactDefaultStrings);
+    }
+    return result;
+  }
+  return value;
+}
+function countDigits(value) {
+  return value.replace(/\D/gu, "").length;
+}
+var FileCassetteStore = class {
+  directory;
+  constructor(directory = ".agentcassette/cassettes") {
+    this.directory = resolve(directory);
+  }
+  async exists(name) {
+    try {
+      await stat(this.pathFor(name));
+      return true;
+    } catch (error) {
+      if (hasCode(error, "ENOENT")) return false;
+      throw error;
+    }
+  }
+  async read(name) {
+    const source = await readFile(this.pathFor(name), "utf8");
+    return parseCassette(source, name);
+  }
+  async write(cassette) {
+    const destination = this.pathFor(cassette.name);
+    await mkdir(dirname(destination), { recursive: true });
+    const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(cassette, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    await rename(temporary, destination);
+  }
+  async list() {
+    try {
+      const entries = await readdir(this.directory, { withFileTypes: true });
+      return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -5)).filter(isValidCassetteName).sort();
+    } catch (error) {
+      if (hasCode(error, "ENOENT")) return [];
+      throw error;
+    }
+  }
+  async remove(name) {
+    await rm(this.pathFor(name), { force: true });
+  }
+  pathFor(name) {
+    if (!isValidCassetteName(name)) {
+      throw new Error("Cassette names must start with a lowercase letter or digit and contain only lowercase letters, digits, dots, underscores, or hyphens.");
+    }
+    return join(this.directory, `${name}.json`);
+  }
+};
+var MemoryCassetteStore = class {
+  cassettes = /* @__PURE__ */ new Map();
+  async exists(name) {
+    return this.cassettes.has(name);
+  }
+  async read(name) {
+    const cassette = this.cassettes.get(name);
+    if (!cassette) throw new Error(`Cassette "${name}" does not exist.`);
+    return structuredClone(cassette);
+  }
+  async write(cassette) {
+    this.cassettes.set(cassette.name, structuredClone(cassette));
+  }
+  async list() {
+    return [...this.cassettes.keys()].sort();
+  }
+  async remove(name) {
+    this.cassettes.delete(name);
+  }
+};
+function parseCassette(source, expectedName) {
+  const value = JSON.parse(source);
+  if (!isCassette(value)) throw new Error(`Invalid agentcassette file${expectedName ? `: ${expectedName}` : ""}.`);
+  if (expectedName !== void 0 && value.name !== expectedName) {
+    throw new Error(`Cassette identity mismatch: expected "${expectedName}", file contains "${value.name}".`);
+  }
+  return value;
+}
+function isValidCassetteName(name) {
+  return /^[a-z0-9][a-z0-9._-]*$/u.test(name);
+}
+function isCassette(value) {
+  if (!isObject(value)) return false;
+  return value.schemaVersion === 1 && typeof value.name === "string" && isValidCassetteName(value.name) && typeof value.createdAt === "string" && typeof value.updatedAt === "string" && (value.metadata === void 0 || isMetadata(value.metadata)) && Array.isArray(value.turns) && value.turns.every((turn, index) => isTurn(turn, index));
+}
+function isTurn(value, index) {
+  return isObject(value) && value.index === index && typeof value.fingerprint === "string" && isRequest(value.request) && Array.isArray(value.events) && value.events.every(isEvent) && isResponse(value.response);
+}
+function isMetadata(value) {
+  return isObject(value) && (value.provider === void 0 || typeof value.provider === "string") && (value.testFile === void 0 || typeof value.testFile === "string") && (value.tags === void 0 || Array.isArray(value.tags) && value.tags.every((tag) => typeof tag === "string")) && (value.fingerprint === void 0 || value.fingerprint === "default" || value.fingerprint === "custom");
+}
+function isEvent(value) {
+  if (!isObject(value)) return false;
+  if (value.type === "messages.sent") return Array.isArray(value.messages) && value.messages.every(isMessage);
+  if (value.type === "tool.result.returned") return isMessage(value.message);
+  if (value.type === "tool.call.proposed") return isToolCall(value.call);
+  return value.type === "output.final" && Array.isArray(value.content) && value.content.every(isContentPart);
+}
+function isRequest(value) {
+  return isObject(value) && Array.isArray(value.messages) && value.messages.every(isMessage) && Array.isArray(value.tools) && value.tools.every((tool) => isObject(tool) && typeof tool.name === "string" && isJsonValue(tool.inputSchema)) && (value.model === void 0 || typeof value.model === "string");
+}
+function isResponse(value) {
+  return isObject(value) && Array.isArray(value.content) && value.content.every(isContentPart) && Array.isArray(value.toolCalls) && value.toolCalls.every(isToolCall) && (value.sequence === void 0 || Array.isArray(value.sequence) && value.sequence.every(isResponseItem)) && (value.id === void 0 || typeof value.id === "string") && (value.model === void 0 || typeof value.model === "string") && (value.finishReason === void 0 || typeof value.finishReason === "string") && (value.usage === void 0 || isObject(value.usage) && typeof value.usage.inputTokens === "number" && typeof value.usage.outputTokens === "number" && typeof value.usage.totalTokens === "number" && (value.usage.costUsd === void 0 || typeof value.usage.costUsd === "number"));
+}
+function isMessage(value) {
+  return isObject(value) && (value.role === "system" || value.role === "user" || value.role === "assistant" || value.role === "tool") && Array.isArray(value.content) && value.content.every(isContentPart) && (value.name === void 0 || typeof value.name === "string") && (value.toolCallId === void 0 || typeof value.toolCallId === "string") && (value.toolCalls === void 0 || Array.isArray(value.toolCalls) && value.toolCalls.every(isToolCall));
+}
+function isContentPart(value) {
+  if (!isObject(value)) return false;
+  if (value.type === "text") return typeof value.text === "string";
+  if (value.type === "image") return typeof value.source === "string";
+  return value.type === "json" && isJsonValue(value.value);
+}
+function isResponseItem(value) {
+  return isObject(value) && (value.type === "content" && isContentPart(value.part) || value.type === "toolCall" && isToolCall(value.call));
+}
+function isToolCall(value) {
+  return isObject(value) && typeof value.name === "string" && isJsonValue(value.arguments) && (value.id === void 0 || typeof value.id === "string");
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  return isObject(value) && Object.values(value).every(isJsonValue);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// src/core/client.ts
+async function createCassetteClient(options) {
+  validateOptions(options);
+  const store = options.store ?? new FileCassetteStore();
+  const requestedMode = options.mode ?? "auto";
+  const mode = requestedMode === "auto" ? await store.exists(options.name) ? "replay" : "record" : requestedMode;
+  const fingerprint = options.fingerprint ?? defaultFingerprint;
+  const replayTurns = options.replayTurns ?? Number.POSITIVE_INFINITY;
+  let cassette = mode === "replay" ? await store.read(options.name) : newCassette(options.name, options.adapter.provider, options.metadata, options.fingerprint === void 0);
+  let position = 0;
+  let queue = Promise.resolve();
+  const invoke = async (input) => {
+    const normalizedRequest = redacted(options.adapter.normalizeRequest(input), options.redaction);
+    const actualFingerprint = fingerprint(normalizedRequest);
+    const shouldReplay = mode === "replay" && position < replayTurns;
+    if (shouldReplay) {
+      const expected = cassette.turns[position];
+      if (!expected) {
+        throw new CassetteDivergenceError({
+          cassette: cassette.name,
+          turn: position,
+          expectedFingerprint: "<end-of-cassette>",
+          actualFingerprint,
+          expected: emptyRequest(),
+          actual: normalizedRequest,
+          diff: structuredDiff(emptyRequest(), normalizedRequest)
+        });
+      }
+      if (expected.fingerprint !== actualFingerprint) {
+        throw new CassetteDivergenceError({
+          cassette: cassette.name,
+          turn: position,
+          expectedFingerprint: expected.fingerprint,
+          actualFingerprint,
+          expected: expected.request,
+          actual: normalizedRequest,
+          diff: structuredDiff(expected.request, normalizedRequest)
+        });
+      }
+      position += 1;
+      if (options.onReplay) {
+        await options.onReplay({ cassette: cassette.name, turn: expected.index, response: structuredClone(expected.response) });
+      }
+      return options.adapter.replayResponse(structuredClone(expected.response));
+    }
+    const client = options.client;
+    if (!client) {
+      const reason = mode === "record" ? "record mode" : `partial replay after turn ${replayTurns}`;
+      throw new Error(`A real client boundary is required for ${reason}.`);
+    }
+    const liveResponse = await client(input);
+    const normalizedResponse = withCalculatedCost(
+      redacted(options.adapter.normalizeResponse(liveResponse), options.redaction),
+      normalizedRequest,
+      options.calculateCost
+    );
+    if (mode === "record") {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      cassette.turns.push({
+        index: position,
+        fingerprint: actualFingerprint,
+        request: normalizedRequest,
+        events: eventsForTurn(normalizedRequest, normalizedResponse),
+        response: normalizedResponse
+      });
+      cassette.updatedAt = now;
+      await store.write(cassette);
+    }
+    position += 1;
+    return liveResponse;
+  };
+  const wrapped = ((input) => {
+    const result = queue.then(() => invoke(input));
+    queue = result.then(() => void 0, () => void 0);
+    return result;
+  });
+  Object.defineProperties(wrapped, {
+    cassetteName: { value: options.name, enumerable: true },
+    mode: { value: mode, enumerable: true },
+    turn: { get: () => position, enumerable: true }
+  });
+  return wrapped;
+}
+function validateOptions(options) {
+  if (!options.name.trim()) throw new Error("Cassette name cannot be empty.");
+  if (options.replayTurns !== void 0 && (!Number.isInteger(options.replayTurns) || options.replayTurns < 0)) {
+    throw new Error("replayTurns must be a non-negative integer.");
+  }
+}
+function redacted(value, options) {
+  return redact(value, options ?? {});
+}
+function withCalculatedCost(response, request, calculator) {
+  if (!calculator) return response;
+  const cost = calculator({ request, response });
+  if (cost === void 0) return response;
+  if (!Number.isFinite(cost) || cost < 0) throw new Error("calculateCost must return a non-negative finite number or undefined.");
+  const usage = response.usage ?? { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  return { ...response, usage: { ...usage, costUsd: cost } };
+}
+function newCassette(name, provider, metadata, usesDefaultFingerprint) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const mergedMetadata = {
+    ...metadata,
+    provider,
+    fingerprint: usesDefaultFingerprint ? "default" : "custom"
+  };
+  return {
+    schemaVersion: 1,
+    name,
+    createdAt: now,
+    updatedAt: now,
+    turns: [],
+    metadata: mergedMetadata
+  };
+}
+function emptyRequest() {
+  return { messages: [], tools: [] };
+}
+
+// src/providers/common.ts
+function records(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseJson(value) {
+  if (typeof value !== "string") return asJsonValue(value);
+  try {
+    return asJsonValue(JSON.parse(value));
+  } catch {
+    return value;
+  }
+}
+function normalizeTools(value, style) {
+  const source = style === "google" ? records(value).flatMap((group) => records(group.functionDeclarations ?? group.function_declarations)) : records(value);
+  return source.flatMap((item) => {
+    const fn = style === "openai" && isRecord(item.function) ? item.function : item;
+    const name = stringValue(fn.name);
+    if (!name) return [];
+    const schema = fn.parameters ?? fn.parametersJsonSchema ?? fn.parameters_json_schema ?? fn.input_schema ?? fn.inputSchema ?? {};
+    const tool = { name, inputSchema: asJsonValue(schema) };
+    const description = stringValue(fn.description);
+    if (description !== void 0) tool.description = description;
+    return [tool];
+  });
+}
+function normalizeUsage(value, inputKeys, outputKeys, totalKeys = []) {
+  if (!isRecord(value)) return void 0;
+  const inputTokens = firstNumber(value, inputKeys) ?? 0;
+  const outputTokens = firstNumber(value, outputKeys) ?? 0;
+  const totalTokens = firstNumber(value, totalKeys) ?? inputTokens + outputTokens;
+  if (inputTokens === 0 && outputTokens === 0 && totalTokens === 0) return void 0;
+  return { inputTokens, outputTokens, totalTokens };
+}
+function firstNumber(record, keys) {
+  for (const key of keys) {
+    const result = numberValue(record[key]);
+    if (result !== void 0) return result;
+  }
+  return void 0;
+}
+function contentParts(value) {
+  return unknownToContent(value);
+}
+function contentToProviderText(content) {
+  if (content.length === 0) return null;
+  return content.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "json") return JSON.stringify(part.value);
+    return `[image:${part.source}]`;
+  }).join("\n");
+}
+
+// src/providers/anthropic.ts
+function anthropic() {
+  return {
+    provider: "anthropic",
+    normalizeRequest: (request) => normalizeAnthropicRequest(request),
+    normalizeResponse: (response) => normalizeAnthropicResponse(response),
+    replayResponse: (response) => replayAnthropicResponse(response)
+  };
+}
+function normalizeAnthropicRequest(value) {
+  const request = isRecord(value) ? value : {};
+  const messages = [];
+  if (request.system !== void 0) messages.push({ role: "system", content: unknownToContent(request.system) });
+  for (const source of records(request.messages)) {
+    const role = normalizeRole(source.role);
+    if (!Array.isArray(source.content)) {
+      messages.push({ role, content: unknownToContent(source.content) });
+      continue;
+    }
+    for (const block of source.content) {
+      if (!isRecord(block)) {
+        messages.push({ role, content: unknownToContent(block) });
+        continue;
+      }
+      if (block.type === "tool_result") {
+        const message = { role: "tool", content: unknownToContent(block.content) };
+        const id = stringValue(block.tool_use_id);
+        if (id !== void 0) message.toolCallId = id;
+        messages.push(message);
+        continue;
+      }
+      if (block.type === "tool_use" && typeof block.name === "string") {
+        const call = { name: block.name, arguments: asJsonValue(block.input) };
+        const id = stringValue(block.id);
+        if (id !== void 0) call.id = id;
+        messages.push({ role: "assistant", content: [], toolCalls: [call] });
+        continue;
+      }
+      messages.push({ role, content: block.type === "text" ? unknownToContent(block.text) : unknownToContent(block) });
+    }
+  }
+  const normalized = { messages, tools: normalizeTools(request.tools, "anthropic") };
+  const model = stringValue(request.model);
+  if (model !== void 0) normalized.model = model;
+  return normalized;
+}
+function normalizeAnthropicResponse(value) {
+  const response = isRecord(value) ? value : {};
+  const content = [];
+  const toolCalls = [];
+  const sequence = [];
+  for (const block of records(response.content)) {
+    if (block.type === "text" && typeof block.text === "string") {
+      const part = textPart(block.text);
+      content.push(part);
+      sequence.push({ type: "content", part });
+    }
+    if (block.type === "tool_use" && typeof block.name === "string") {
+      const call = { name: block.name, arguments: asJsonValue(block.input) };
+      const id2 = stringValue(block.id);
+      if (id2 !== void 0) call.id = id2;
+      toolCalls.push(call);
+      sequence.push({ type: "toolCall", call });
+    }
+  }
+  const normalized = { content, toolCalls, sequence };
+  const id = stringValue(response.id);
+  if (id !== void 0) normalized.id = id;
+  const model = stringValue(response.model);
+  if (model !== void 0) normalized.model = model;
+  const finishReason = stringValue(response.stop_reason);
+  if (finishReason !== void 0) normalized.finishReason = finishReason;
+  const usage = normalizeUsage(response.usage, ["input_tokens"], ["output_tokens"]);
+  if (usage !== void 0) normalized.usage = usage;
+  return normalized;
+}
+function replayAnthropicResponse(response) {
+  return {
+    id: response.id ?? "msg_agentcassette_replay",
+    model: response.model,
+    type: "message",
+    role: "assistant",
+    content: response.sequence ? response.sequence.map((item, index) => item.type === "content" ? anthropicContentBlock(item.part) : {
+      type: "tool_use",
+      id: item.call.id ?? `toolu_replay_${index}`,
+      name: item.call.name,
+      input: item.call.arguments
+    }) : [
+      ...response.content.map(anthropicContentBlock),
+      ...response.toolCalls.map((call, index) => ({
+        type: "tool_use",
+        id: call.id ?? `toolu_replay_${index}`,
+        name: call.name,
+        input: call.arguments
+      }))
+    ],
+    stop_reason: response.finishReason ?? (response.toolCalls.length > 0 ? "tool_use" : "end_turn"),
+    stop_sequence: null,
+    usage: response.usage ? {
+      input_tokens: response.usage.inputTokens,
+      output_tokens: response.usage.outputTokens
+    } : void 0
+  };
+}
+function anthropicContentBlock(part) {
+  return part.type === "text" ? { type: "text", text: part.text } : { type: "text", text: JSON.stringify(part.type === "json" ? part.value : part.source) };
+}
+
+// src/providers/google.ts
+function google() {
+  return {
+    provider: "google",
+    normalizeRequest: (request) => normalizeGoogleRequest(request),
+    normalizeResponse: (response) => normalizeGoogleResponse(response),
+    replayResponse: (response) => replayGoogleResponse(response)
+  };
+}
+function normalizeGoogleRequest(value) {
+  const request = isRecord(value) ? value : {};
+  const config = isRecord(request.config) ? request.config : {};
+  const messages = [];
+  const system = request.systemInstruction ?? request.system_instruction ?? config.systemInstruction ?? config.system_instruction;
+  if (system !== void 0) {
+    const content = isRecord(system) ? googleTextParts(system.parts) : unknownToContent(system);
+    messages.push({ role: "system", content });
+  }
+  for (const source of records(request.contents)) {
+    const role = normalizeRole(source.role);
+    if (!Array.isArray(source.parts)) {
+      messages.push({ role, content: unknownToContent(source.parts) });
+      continue;
+    }
+    for (const part of source.parts) appendGooglePart(messages, role, part);
+  }
+  const normalized = {
+    messages,
+    tools: normalizeTools(request.tools ?? config.tools, "google")
+  };
+  const model = stringValue(request.model);
+  if (model !== void 0) normalized.model = model;
+  return normalized;
+}
+function normalizeGoogleResponse(value) {
+  const response = isRecord(value) ? value : {};
+  const candidate = records(response.candidates)[0];
+  const candidateContent = candidate && isRecord(candidate.content) ? candidate.content : {};
+  const content = [];
+  const toolCalls = [];
+  for (const part of records(candidateContent.parts)) {
+    if (typeof part.text === "string") content.push(textPart(part.text));
+    const fn = part.functionCall ?? part.function_call;
+    if (isRecord(fn) && typeof fn.name === "string") {
+      toolCalls.push({ name: fn.name, arguments: asJsonValue(fn.args) });
+    }
+  }
+  const normalized = { content, toolCalls };
+  const id = stringValue(response.responseId ?? response.response_id);
+  if (id !== void 0) normalized.id = id;
+  const model = stringValue(response.modelVersion ?? response.model_version);
+  if (model !== void 0) normalized.model = model;
+  const finishReason = candidate ? stringValue(candidate.finishReason ?? candidate.finish_reason) : void 0;
+  if (finishReason !== void 0) normalized.finishReason = finishReason;
+  const usage = normalizeUsage(response.usageMetadata ?? response.usage_metadata, ["promptTokenCount", "prompt_token_count"], ["candidatesTokenCount", "candidates_token_count"], ["totalTokenCount", "total_token_count"]);
+  if (usage !== void 0) normalized.usage = usage;
+  return normalized;
+}
+function appendGooglePart(messages, role, value) {
+  if (!isRecord(value)) {
+    messages.push({ role, content: unknownToContent(value) });
+    return;
+  }
+  if (typeof value.text === "string") {
+    messages.push({ role, content: [textPart(value.text)] });
+    return;
+  }
+  const functionCall = value.functionCall ?? value.function_call;
+  if (isRecord(functionCall) && typeof functionCall.name === "string") {
+    messages.push({
+      role: "assistant",
+      content: [],
+      toolCalls: [{ name: functionCall.name, arguments: asJsonValue(functionCall.args) }]
+    });
+    return;
+  }
+  const functionResponse = value.functionResponse ?? value.function_response;
+  if (isRecord(functionResponse)) {
+    const message = {
+      role: "tool",
+      content: [{ type: "json", value: asJsonValue(functionResponse.response) }]
+    };
+    const name = stringValue(functionResponse.name);
+    if (name !== void 0) message.name = name;
+    messages.push(message);
+    return;
+  }
+  messages.push({ role, content: [{ type: "json", value: asJsonValue(value) }] });
+}
+function googleTextParts(value) {
+  return records(value).flatMap((part) => typeof part.text === "string" ? [textPart(part.text)] : [{ type: "json", value: asJsonValue(part) }]);
+}
+function replayGoogleResponse(response) {
+  return {
+    responseId: response.id,
+    modelVersion: response.model,
+    candidates: [{
+      content: {
+        role: "model",
+        parts: [
+          ...response.content.map((part) => part.type === "text" ? { text: part.text } : { text: JSON.stringify(part.type === "json" ? part.value : part.source) }),
+          ...response.toolCalls.map((call) => ({ functionCall: { name: call.name, args: call.arguments } }))
+        ]
+      },
+      finishReason: response.finishReason ?? "STOP"
+    }],
+    usageMetadata: response.usage ? {
+      promptTokenCount: response.usage.inputTokens,
+      candidatesTokenCount: response.usage.outputTokens,
+      totalTokenCount: response.usage.totalTokens
+    } : void 0
+  };
+}
+
+// src/providers/openai.ts
+function openAI() {
+  return {
+    provider: "openai",
+    normalizeRequest: (request) => normalizeOpenAIRequest(request),
+    normalizeResponse: (response) => normalizeOpenAIResponse(response),
+    replayResponse: (response) => replayOpenAIResponse(response)
+  };
+}
+var openAICompatible = openAI;
+function normalizeOpenAIRequest(value) {
+  const request = isRecord(value) ? value : {};
+  const normalized = {
+    messages: (Array.isArray(request.messages) ? request.messages : []).map((source) => {
+      const message = messageFromUnknown(source);
+      if (isRecord(source)) {
+        const toolCalls = openAIToolCalls(source.tool_calls ?? source.toolCalls);
+        if (toolCalls.length > 0) message.toolCalls = toolCalls;
+      }
+      return message;
+    }),
+    tools: normalizeTools(request.tools, "openai")
+  };
+  const model = stringValue(request.model);
+  if (model !== void 0) normalized.model = model;
+  return normalized;
+}
+function normalizeOpenAIResponse(value) {
+  const response = isRecord(value) ? value : {};
+  const choice = records(response.choices)[0];
+  const message = choice && isRecord(choice.message) ? choice.message : {};
+  const toolCalls = openAIToolCalls(message.tool_calls ?? message.toolCalls);
+  const normalized = {
+    content: contentParts(message.content),
+    toolCalls
+  };
+  const id = stringValue(response.id);
+  if (id !== void 0) normalized.id = id;
+  const model = stringValue(response.model);
+  if (model !== void 0) normalized.model = model;
+  const finishReason = choice ? stringValue(choice.finish_reason ?? choice.finishReason) : void 0;
+  if (finishReason !== void 0) normalized.finishReason = finishReason;
+  const usage = normalizeUsage(response.usage, ["prompt_tokens", "input_tokens"], ["completion_tokens", "output_tokens"], ["total_tokens"]);
+  if (usage !== void 0) normalized.usage = usage;
+  return normalized;
+}
+function replayOpenAIResponse(response) {
+  return {
+    id: response.id ?? "agentcassette-replay",
+    object: "chat.completion",
+    created: 0,
+    model: response.model,
+    choices: [{
+      index: 0,
+      message: {
+        role: "assistant",
+        content: contentToProviderText(response.content),
+        tool_calls: response.toolCalls.map((call, index) => ({
+          id: call.id ?? `call_replay_${index}`,
+          type: "function",
+          function: { name: call.name, arguments: JSON.stringify(call.arguments) }
+        }))
+      },
+      finish_reason: response.finishReason ?? (response.toolCalls.length > 0 ? "tool_calls" : "stop")
+    }],
+    usage: response.usage ? {
+      prompt_tokens: response.usage.inputTokens,
+      completion_tokens: response.usage.outputTokens,
+      total_tokens: response.usage.totalTokens
+    } : void 0
+  };
+}
+function openAIToolCalls(value) {
+  return records(value).flatMap((item) => {
+    const fn = isRecord(item.function) ? item.function : item;
+    const name = stringValue(fn.name);
+    if (!name) return [];
+    const call = { name, arguments: parseJson(fn.arguments) };
+    const id = stringValue(item.id);
+    if (id !== void 0) call.id = id;
+    return [call];
+  });
+}
+
+// src/providers/semantic.ts
+function semantic() {
+  return {
+    provider: "semantic",
+    normalizeRequest: (request) => structuredClone(request),
+    normalizeResponse: (response) => structuredClone(response),
+    replayResponse: (response) => structuredClone(response)
+  };
+}
+
+export { CassetteDivergenceError, FileCassetteStore, MemoryCassetteStore, anthropic, createCassetteClient, defaultFingerprint, defaultRedactionRules, explainDefaultFingerprint, google, normalizeAnthropicRequest, normalizeAnthropicResponse, normalizeGoogleRequest, normalizeGoogleResponse, normalizeOpenAIRequest, normalizeOpenAIResponse, openAI, openAICompatible, parseCassette, redact, semantic, structuredDiff };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map