@nijaru/pi-provider-compaction 0.0.2 → 0.0.4

package/dist/index.js

@@ -0,0 +1,1983 @@
+// index.ts
+import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
+import { normalizeContext as normalizeContext2 } from "@earendil-works/pi-ai";
+import { compact, convertToLlm } from "@earendil-works/pi-coding-agent";
+
+// policy.ts
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir,
+  hasTrustRequiringProjectResources,
+  ProjectTrustStore
+} from "@earendil-works/pi-coding-agent";
+import { closeSync, constants as fsConstants, fstatSync, openSync, readSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+var COMPACTION_MODEL_FLAG = "compaction-model";
+var PROJECT_POLICY = "compaction-policy.json";
+var AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
+var MAX_POLICY_BYTES = 64 * 1024;
+var MAX_MODEL_SELECTORS = 8;
+var MAX_SELECTOR_LENGTH = 512;
+function normalizeSelector(value) {
+  if (typeof value !== "string")
+    return;
+  const selector = value.trim();
+  if (selector.length === 0 || selector.length > MAX_SELECTOR_LENGTH)
+    return;
+  return selector;
+}
+function parsePolicySelectors(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  if (!("models" in value) || !Array.isArray(value.models))
+    return;
+  const selectors = [];
+  for (const model of value.models) {
+    const selector = normalizeSelector(model);
+    if (selector === undefined || selectors.includes(selector))
+      continue;
+    selectors.push(selector);
+    if (selectors.length === MAX_MODEL_SELECTORS)
+      break;
+  }
+  return selectors;
+}
+function readPolicySelectors(configPath) {
+  let fd;
+  try {
+    fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_POLICY_BYTES)
+      return;
+    const buffer = Buffer.allocUnsafe(MAX_POLICY_BYTES + 1);
+    let bytesRead = 0;
+    while (bytesRead < buffer.length) {
+      const count = readSync(fd, buffer, bytesRead, buffer.length - bytesRead, null);
+      if (count === 0)
+        break;
+      bytesRead += count;
+    }
+    if (bytesRead > MAX_POLICY_BYTES)
+      return;
+    return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
+  } catch {
+    return;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function activeAgentDir(ctx) {
+  const override = process.env[AGENT_DIR_OVERRIDE]?.trim();
+  if (override)
+    return resolve(override);
+  try {
+    const sessionDir = ctx.sessionManager?.getSessionDir();
+    if (sessionDir) {
+      const resolvedCwd = resolve(ctx.cwd);
+      const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+      const suffix = `${sep}${join("sessions", safePath)}`;
+      const resolvedSessionDir = resolve(sessionDir);
+      if (resolvedSessionDir.endsWith(suffix)) {
+        return resolvedSessionDir.slice(0, -suffix.length);
+      }
+    }
+  } catch {}
+  return getAgentDir();
+}
+function isProjectPolicyTrusted(ctx, agentDir) {
+  try {
+    if (!ctx.isProjectTrusted())
+      return false;
+    return hasTrustRequiringProjectResources(ctx.cwd) || new ProjectTrustStore(agentDir).get(ctx.cwd) === true;
+  } catch {
+    return false;
+  }
+}
+function readCompactionModelFlagFromArgv(argv = process.argv.slice(2)) {
+  let value;
+  const prefix = `--${COMPACTION_MODEL_FLAG}=`;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--")
+      break;
+    if (arg === `--${COMPACTION_MODEL_FLAG}`) {
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
+        value = next;
+        i++;
+      } else {
+        value = true;
+      }
+    } else if (arg.startsWith(prefix)) {
+      value = arg.slice(prefix.length);
+    }
+  }
+  return value;
+}
+function resolveCompactionModelPolicy(pi, ctx, argv = process.argv.slice(2)) {
+  const argvRaw = readCompactionModelFlagFromArgv(argv);
+  if (typeof argvRaw === "string" && argvRaw.trim()) {
+    const selector = normalizeSelector(argvRaw);
+    return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
+  }
+  try {
+    const rawFlag = pi.getFlag(COMPACTION_MODEL_FLAG);
+    if (typeof rawFlag === "string" && rawFlag.trim()) {
+      const selector = normalizeSelector(rawFlag);
+      return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
+    }
+  } catch {}
+  const agentDir = activeAgentDir(ctx);
+  const candidates = [];
+  if (isProjectPolicyTrusted(ctx, agentDir)) {
+    candidates.push({ path: join(ctx.cwd, CONFIG_DIR_NAME, PROJECT_POLICY), source: "project-policy" });
+  }
+  candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
+  for (const candidate of candidates) {
+    const selectors = readPolicySelectors(candidate.path);
+    if (selectors !== undefined) {
+      return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
+    }
+  }
+  return { hasSelectors: false };
+}
+
+// provider.ts
+function optionsWithObserver(model, context, options, observe) {
+  const handler = observe(model, context, options ?? {});
+  if (!handler)
+    return options;
+  return {
+    ...options,
+    onPayload: async (payload, requestModel) => {
+      const replacement = await options?.onPayload?.(payload, requestModel);
+      const prepared = replacement === undefined ? payload : replacement;
+      try {
+        return await handler(prepared);
+      } catch {
+        return prepared;
+      }
+    }
+  };
+}
+function decorateProvider(base, observe) {
+  const stream = (model, context, options) => base.stream(model, context, optionsWithObserver(model, context, options, observe));
+  const streamSimple = (model, context, options) => base.streamSimple(model, context, optionsWithObserver(model, context, options, observe));
+  const bound = new Map;
+  return new Proxy(base, {
+    get(target, key) {
+      if (key === "stream")
+        return stream;
+      if (key === "streamSimple")
+        return streamSimple;
+      const value = Reflect.get(target, key, target);
+      if (typeof value !== "function")
+        return value;
+      if (!bound.has(key))
+        bound.set(key, value.bind(target));
+      return bound.get(key);
+    }
+  });
+}
+function installObserver(pi, ctx, observe) {
+  const model = ctx.model;
+  if (!model)
+    return;
+  const registry = ctx.modelRegistry;
+  const id = model.provider;
+  const native = registry.getRegisteredNativeProvider(id);
+  if (native) {
+    const guarded = (...args) => {
+      const handler = observe(...args);
+      return handler ? (payload) => registry.getRegisteredNativeProvider(id) === wrapper ? handler(payload) : payload : undefined;
+    };
+    const wrapper = decorateProvider(native, guarded);
+    pi.registerProvider(wrapper);
+    return () => {
+      if (registry.getRegisteredNativeProvider(id) === wrapper)
+        pi.registerProvider(native);
+    };
+  }
+  const original = registry.getRegisteredProviderConfig(id);
+  if (!original?.streamSimple || original.refreshModels || original.oauth?.modifyModels)
+    return;
+  if (original.api !== model.api)
+    return;
+  const delegate = original.streamSimple.bind(original);
+  const guarded = (...args) => {
+    const handler = observe(...args);
+    return handler ? (payload) => registry.getRegisteredProviderConfig(id)?.streamSimple === wrapper ? handler(payload) : payload : undefined;
+  };
+  const wrapper = (requestModel, context, options) => delegate(requestModel, context, optionsWithObserver(requestModel, context, options, guarded));
+  pi.registerProvider(id, { ...original, api: original?.api ?? model.api, streamSimple: wrapper });
+  return () => {
+    const current = registry.getRegisteredProviderConfig(id);
+    if (current?.streamSimple !== wrapper || registry.getRegisteredNativeProvider(id))
+      return;
+    const restored = { ...current };
+    if (original?.streamSimple)
+      restored.streamSimple = original.streamSimple;
+    else
+      delete restored.streamSimple;
+    if (!original?.api && restored.api === model.api)
+      delete restored.api;
+    pi.unregisterProvider(id);
+    if (Object.keys(restored).length)
+      pi.registerProvider(id, restored);
+  };
+}
+
+// replay.ts
+import { getCurrentSystemPrompt, getCurrentTools as getCurrentTools2, getDeclaredTools, normalizeContext, resolveTranscript as resolveTranscript2 } from "@earendil-works/pi-ai";
+
+// node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
+class UnsupportedStrictJsonSchemaError extends Error {
+}
+var UNSUPPORTED_STRICT_SCHEMA_KEYS = [
+  "$ref",
+  "$defs",
+  "definitions",
+  "allOf",
+  "oneOf",
+  "patternProperties",
+  "dependentSchemas",
+  "dependencies",
+  "unevaluatedProperties",
+  "propertyNames",
+  "contains",
+  "prefixItems",
+  "not",
+  "if",
+  "then",
+  "else"
+];
+function isJsonSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStructuredSchema(schema) {
+  if (!isJsonSchemaObject(schema))
+    return false;
+  const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+  return types.includes("object") || types.includes("array") || schema.properties !== undefined || schema.items !== undefined;
+}
+function schemaAllowsNull(schema) {
+  if (!isJsonSchemaObject(schema))
+    return false;
+  if (schema.type === "null" || Array.isArray(schema.type) && schema.type.includes("null"))
+    return true;
+  if (schema.const === null || Array.isArray(schema.enum) && schema.enum.includes(null))
+    return true;
+  return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
+}
+function makeJsonSchemaNodeStrict(schema) {
+  if (!isJsonSchemaObject(schema)) {
+    throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
+  }
+  for (const key of UNSUPPORTED_STRICT_SCHEMA_KEYS) {
+    if (schema[key] !== undefined) {
+      throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
+    }
+  }
+  if (schema.anyOf !== undefined) {
+    if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
+      throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
+    }
+    for (const variant of schema.anyOf) {
+      if (isStructuredSchema(variant)) {
+        throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
+      }
+      makeJsonSchemaNodeStrict(variant);
+    }
+  }
+  if (schema.items !== undefined) {
+    if (Array.isArray(schema.items)) {
+      throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
+    }
+    makeJsonSchemaNodeStrict(schema.items);
+  }
+  const isObjectSchema = schema.type === "object";
+  if (schema.properties !== undefined && !isObjectSchema) {
+    throw new UnsupportedStrictJsonSchemaError("properties require type object");
+  }
+  if (!isObjectSchema)
+    return;
+  if (schema.additionalProperties !== undefined && schema.additionalProperties !== false) {
+    throw new UnsupportedStrictJsonSchemaError("schema-valued or true additionalProperties is unsupported");
+  }
+  if (schema.properties !== undefined && !isJsonSchemaObject(schema.properties)) {
+    throw new UnsupportedStrictJsonSchemaError("object properties must be a schema map");
+  }
+  if (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))) {
+    throw new UnsupportedStrictJsonSchemaError("object required must be a string array");
+  }
+  const properties = schema.properties ?? {};
+  const propertyNames = Object.keys(properties);
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  if ([...required].some((key) => !propertyNames.includes(key))) {
+    throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
+  }
+  for (const [key, property] of Object.entries(properties)) {
+    makeJsonSchemaNodeStrict(property);
+    if (!required.has(key) && !schemaAllowsNull(property)) {
+      properties[key] = { anyOf: [property, { type: "null" }] };
+    }
+  }
+  schema.required = propertyNames;
+  schema.additionalProperties = false;
+}
+function makeStrictJsonSchema(schema) {
+  const cloned = structuredClone(schema);
+  if (!isJsonSchemaObject(cloned)) {
+    throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+  }
+  makeJsonSchemaNodeStrict(cloned);
+  if (cloned.type !== "object") {
+    throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+  }
+  return cloned;
+}
+function getJsonSchemaToolParameters(tool, strict) {
+  return strict === true ? makeStrictJsonSchema(tool.parameters) : tool.parameters;
+}
+function getGrammarToolInput(toolName, arguments_, inputProperty) {
+  const input = arguments_[inputProperty];
+  if (typeof input !== "string") {
+    throw new Error(`Grammar tool call "${toolName}" requires argument "${inputProperty}" to be a string.`);
+  }
+  return input;
+}
+function inferGrammarInputProperty(tool) {
+  const schema = tool.parameters;
+  if (schema.type !== "object") {
+    throw new Error("grammar constrained sampling requires an object parameter schema");
+  }
+  if (!Array.isArray(schema.required) || schema.required.length !== 1 || typeof schema.required[0] !== "string") {
+    throw new Error("grammar constrained sampling requires exactly one required string property");
+  }
+  const inputProperty = schema.required[0];
+  if (!schema.properties?.[inputProperty]) {
+    throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+  }
+  if (schema.properties[inputProperty]?.type !== "string") {
+    throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+  }
+  return inputProperty;
+}
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+  const config = tool.constrainedSampling;
+  if (!config || config.type !== "json_schema")
+    return;
+  if (supportsStrictMode) {
+    try {
+      makeStrictJsonSchema(tool.parameters);
+      return true;
+    } catch (error) {
+      if (!(error instanceof UnsupportedStrictJsonSchemaError))
+        throw error;
+      if (config.strict !== "require")
+        return;
+      throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but ${error.message}.`);
+    }
+  }
+  if (config.strict === "require") {
+    throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+  }
+  return;
+}
+function resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools) {
+  const config = tool.constrainedSampling;
+  if (!config || config.type !== "grammar") {
+    return;
+  }
+  if (!supportsOpenAIGrammarTools) {
+    return;
+  }
+  const larkDefinition = config.variants.openai_lark;
+  const regexDefinition = config.variants.openai_regex;
+  const hasLarkDefinition = typeof larkDefinition === "string" && larkDefinition.trim().length > 0;
+  const hasRegexDefinition = typeof regexDefinition === "string" && regexDefinition.trim().length > 0;
+  if (!hasLarkDefinition && !hasRegexDefinition) {
+    throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+  }
+  try {
+    return {
+      format: hasLarkDefinition ? "lark" : "regex",
+      definition: hasLarkDefinition ? larkDefinition : regexDefinition,
+      inputProperty: inferGrammarInputProperty(tool)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+  }
+}
+function createGrammarToolInputProperties(tools, supportsOpenAIGrammarTools) {
+  const properties = new Map;
+  for (const tool of tools ?? []) {
+    const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+    if (grammar) {
+      properties.set(tool.name, grammar.inputProperty);
+    }
+  }
+  return properties;
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/text.js
+function contentText(content, separator = `
+`) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((block) => block.type === "text").map((block) => block.text).join(separator);
+}
+function getSystemMessageText(message) {
+  const parts = [contentText(message.content)];
+  for (const text of Object.values(message.sections ?? {})) {
+    if (text !== null)
+      parts.push(text);
+  }
+  return parts.filter((part) => part.length > 0).join(`
+
+`);
+}
+function renderSystemMessageUpdate(message) {
+  const parts = [];
+  const text = contentText(message.content);
+  if (text.length > 0)
+    parts.push(text);
+  for (const [name, value] of Object.entries(message.sections ?? {})) {
+    parts.push(value === null ? `Removed system prompt section "${name}".` : `Updated system prompt section "${name}":
+
+${value}`);
+  }
+  return parts.join(`
+
+`);
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/transcript.js
+function isSystemMessage(message) {
+  return message.role === "system";
+}
+function getInitialSystemMessage(messages) {
+  const first = messages[0];
+  return first && isSystemMessage(first) ? first : undefined;
+}
+function getCurrentTools(messages) {
+  const tools = new Map;
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    for (const tool of message.toolsRemoved ?? [])
+      tools.delete(tool.name);
+    for (const tool of message.toolsAdded ?? [])
+      tools.set(tool.name, tool);
+  }
+  return [...tools.values()];
+}
+function getCurrentSystemMessage(messages) {
+  const content = [];
+  const sections = new Map;
+  let timestamp;
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    timestamp ??= message.timestamp;
+    const text = contentText(message.content);
+    if (text.length > 0)
+      content.push(text);
+    for (const [name, value] of Object.entries(message.sections ?? {})) {
+      if (value === null)
+        sections.delete(name);
+      else
+        sections.set(name, value);
+    }
+  }
+  const tools = getCurrentTools(messages);
+  if (timestamp === undefined && tools.length === 0)
+    return;
+  return {
+    role: "system",
+    content: content.join(`
+
+`),
+    ...sections.size > 0 ? { sections: Object.fromEntries(sections) } : {},
+    ...tools.length > 0 ? { toolsAdded: tools } : {},
+    timestamp: timestamp ?? 0
+  };
+}
+function collapseSystemMessages(context) {
+  const head = getCurrentSystemMessage(context.messages);
+  const messages = context.messages.filter((message) => message.role !== "system");
+  return { messages: head ? [head, ...messages] : messages };
+}
+function resolveTranscript(context, supportsMidConvoSystemMessages) {
+  return supportsMidConvoSystemMessages ? context : collapseSystemMessages(context);
+}
+function hasNonAdditiveToolChanges(messages) {
+  const declared = new Set;
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    if ((message.toolsRemoved?.length ?? 0) > 0)
+      return true;
+    for (const tool of message.toolsAdded ?? []) {
+      if (declared.has(tool.name))
+        return true;
+      declared.add(tool.name);
+    }
+  }
+  return false;
+}
+function resolveTranscriptTools(messages, supportsToolAdditions) {
+  const anchorsAdditions = supportsToolAdditions && !hasNonAdditiveToolChanges(messages);
+  return {
+    requestTools: anchorsAdditions ? getInitialSystemMessage(messages)?.toolsAdded ?? [] : getCurrentTools(messages),
+    anchorsAdditions
+  };
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/hash.js
+function shortHash(str) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0;i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/sanitize-unicode.js
+function sanitizeSurrogates(text) {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+
+// node_modules/@earendil-works/pi-ai/dist/api/transform-messages.js
+var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+  const result = [];
+  let previousWasPlaceholder = false;
+  for (const block of content) {
+    if (block.type === "image") {
+      if (!previousWasPlaceholder) {
+        result.push({ type: "text", text: placeholder });
+      }
+      previousWasPlaceholder = true;
+      continue;
+    }
+    result.push(block);
+    previousWasPlaceholder = block.text === placeholder;
+  }
+  return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+  if (model.input.includes("image")) {
+    return messages;
+  }
+  return messages.map((msg) => {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER)
+      };
+    }
+    if (msg.role === "toolResult") {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+      };
+    }
+    return msg;
+  });
+}
+function transformMessages(messages, model, normalizeToolCallId) {
+  const toolCallIdMap = new Map;
+  const normalizedMessages = messages.map((msg) => msg.content == null ? { ...msg, content: [] } : msg);
+  const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
+  const transformed = imageAwareMessages.map((msg) => {
+    if (msg.role === "system" || msg.role === "user") {
+      return msg;
+    }
+    if (msg.role === "toolResult") {
+      const normalizedId = toolCallIdMap.get(msg.toolCallId);
+      if (normalizedId && normalizedId !== msg.toolCallId) {
+        return { ...msg, toolCallId: normalizedId };
+      }
+      return msg;
+    }
+    if (msg.role === "assistant") {
+      const assistantMsg = msg;
+      const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+      const transformedContent = assistantMsg.content.flatMap((block) => {
+        if (block.type === "thinking") {
+          if (block.redacted) {
+            return isSameModel ? block : [];
+          }
+          if (isSameModel && block.thinkingSignature)
+            return block;
+          if (!block.thinking || block.thinking.trim() === "")
+            return [];
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.thinking
+          };
+        }
+        if (block.type === "text") {
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.text
+          };
+        }
+        if (block.type === "toolCall") {
+          const toolCall = block;
+          let normalizedToolCall = toolCall;
+          if (!isSameModel && toolCall.thoughtSignature) {
+            normalizedToolCall = { ...toolCall };
+            delete normalizedToolCall.thoughtSignature;
+          }
+          if (!isSameModel && normalizeToolCallId) {
+            const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+            if (normalizedId !== toolCall.id) {
+              toolCallIdMap.set(toolCall.id, normalizedId);
+              normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+            }
+          }
+          return normalizedToolCall;
+        }
+        return block;
+      });
+      return {
+        ...assistantMsg,
+        content: transformedContent
+      };
+    }
+    return msg;
+  });
+  const result = [];
+  let pendingToolCalls = [];
+  let existingToolResultIds = new Set;
+  const heldSystemMessages = [];
+  const closePendingToolCalls = () => {
+    if (pendingToolCalls.length > 0) {
+      for (const tc of pendingToolCalls) {
+        if (!existingToolResultIds.has(tc.id)) {
+          result.push({
+            role: "toolResult",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            content: [{ type: "text", text: "No result provided" }],
+            isError: true,
+            timestamp: Date.now()
+          });
+        }
+      }
+      pendingToolCalls = [];
+      existingToolResultIds = new Set;
+    }
+    result.push(...heldSystemMessages);
+    heldSystemMessages.length = 0;
+  };
+  for (let i = 0;i < transformed.length; i++) {
+    const msg = transformed[i];
+    if (msg.role === "assistant") {
+      closePendingToolCalls();
+      const assistantMsg = msg;
+      if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+        continue;
+      }
+      const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        pendingToolCalls = toolCalls;
+        existingToolResultIds = new Set;
+      }
+      result.push(msg);
+    } else if (msg.role === "toolResult") {
+      existingToolResultIds.add(msg.toolCallId);
+      result.push(msg);
+    } else if (msg.role === "system") {
+      if (pendingToolCalls.length > 0) {
+        heldSystemMessages.push(msg);
+      } else {
+        result.push(msg);
+      }
+    } else if (msg.role === "user") {
+      closePendingToolCalls();
+      result.push(msg);
+    } else {
+      result.push(msg);
+    }
+  }
+  closePendingToolCalls();
+  return result;
+}
+
+// node_modules/@earendil-works/pi-ai/dist/api/openai-responses-shared.js
+function parseTextSignature(signature) {
+  if (!signature)
+    return;
+  if (signature.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(signature);
+      if (parsed.v === 1 && typeof parsed.id === "string") {
+        if (parsed.phase === "commentary" || parsed.phase === "final_answer") {
+          return { id: parsed.id, phase: parsed.phase };
+        }
+        return { id: parsed.id };
+      }
+    } catch {}
+  }
+  return { id: signature };
+}
+function convertToolResultOutput(model, content) {
+  const textResult = content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+  const images = content.filter((c) => c.type === "image");
+  const hasText = textResult.length > 0;
+  if (images.length === 0 || !model.input.includes("image")) {
+    return sanitizeSurrogates(hasText ? textResult : images.length > 0 ? "(see attached image)" : "(no tool output)");
+  }
+  const output = [];
+  if (hasText) {
+    output.push({ type: "input_text", text: sanitizeSurrogates(textResult) });
+  }
+  for (const image of images) {
+    output.push({
+      type: "input_image",
+      detail: "auto",
+      image_url: `data:${image.mimeType};base64,${image.data}`
+    });
+  }
+  return output;
+}
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+  const normalizedContext = resolveTranscript(context, options?.supportsMidConvoSystemMessages);
+  const messages = [];
+  const normalizeIdPart = (part) => {
+    const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+    return normalized.replace(/_+$/, "");
+  };
+  const buildForeignResponsesItemId = (itemId) => {
+    const normalized = `fc_${shortHash(itemId)}`;
+    return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+  };
+  const normalizeToolCallId = (id, _targetModel, source) => {
+    if (!allowedToolCallProviders.has(model.provider))
+      return normalizeIdPart(id);
+    if (!id.includes("|"))
+      return normalizeIdPart(id);
+    const [callId, itemId] = id.split("|");
+    const normalizedCallId = normalizeIdPart(callId);
+    const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+    let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
+    if (!normalizedItemId.startsWith("fc_")) {
+      normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+    }
+    return `${normalizedCallId}|${normalizedItemId}`;
+  };
+  const transformedMessages = transformMessages(normalizedContext.messages, model, normalizeToolCallId);
+  const transcriptTools = resolveTranscriptTools(normalizedContext.messages, (options?.supportsAdditionalTools ?? false) || (options?.supportsToolSearch ?? false));
+  const appendSystemToolAdditions = (message, seed) => {
+    const tools = transcriptTools.anchorsAdditions ? message.toolsAdded ?? [] : [];
+    if (tools.length === 0)
+      return;
+    if (options?.supportsAdditionalTools) {
+      messages.push({
+        type: "additional_tools",
+        role: "developer",
+        tools: convertResponsesTools(tools, options.toolOptions)
+      });
+      return;
+    }
+    if (!options?.supportsToolSearch)
+      return;
+    const names = tools.map((tool) => tool.name);
+    const callId = `pi_tool_load_${shortHash(`${seed}:${names.join(",")}`)}`;
+    messages.push({
+      type: "tool_search_call",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      arguments: { query: names.join(" "), limit: names.length }
+    });
+    messages.push({
+      type: "tool_search_output",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      tools: convertResponsesTools(tools, { ...options.toolOptions, toolSearchResult: true })
+    });
+  };
+  const includeInitialSystemMessage = options?.includeSystemPrompt ?? true;
+  const compat = model.compat;
+  const instructionRole = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
+  let msgIndex = 0;
+  let sourceIndex = 0;
+  for (const msg of transformedMessages) {
+    const isLeadingSystemMessage = sourceIndex++ === 0 && msg.role === "system";
+    if (msg.role === "system") {
+      if (!isLeadingSystemMessage)
+        appendSystemToolAdditions(msg, `system:${msgIndex}`);
+      if (!isLeadingSystemMessage || includeInitialSystemMessage) {
+        const text = isLeadingSystemMessage ? getSystemMessageText(msg) : renderSystemMessageUpdate(msg);
+        if (text.length > 0) {
+          messages.push({ role: instructionRole, content: sanitizeSurrogates(text) });
+        }
+      }
+    } else if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        messages.push({
+          role: "user",
+          content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }]
+        });
+      } else {
+        const content = msg.content.map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "input_text",
+              text: sanitizeSurrogates(item.text)
+            };
+          }
+          return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${item.mimeType};base64,${item.data}`
+          };
+        });
+        if (content.length === 0)
+          continue;
+        messages.push({
+          role: "user",
+          content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const output = [];
+      const assistantMsg = msg;
+      const isSameProviderAndApi = assistantMsg.provider === model.provider && assistantMsg.api === model.api;
+      const isSameModel = isSameProviderAndApi && assistantMsg.model === model.id;
+      const isDifferentModel = isSameProviderAndApi && assistantMsg.model !== model.id;
+      let textBlockIndex = 0;
+      for (const block of msg.content) {
+        if (block.type === "thinking") {
+          if (block.thinkingSignature) {
+            const reasoningItem = JSON.parse(block.thinkingSignature);
+            output.push(reasoningItem);
+          }
+        } else if (block.type === "text") {
+          const textBlock = block;
+          const parsedSignature = parseTextSignature(textBlock.textSignature);
+          const fallbackMessageId = textBlockIndex === 0 ? `msg_pi_${msgIndex}` : `msg_pi_${msgIndex}_${textBlockIndex}`;
+          textBlockIndex++;
+          let msgId = parsedSignature?.id;
+          if (!msgId) {
+            msgId = fallbackMessageId;
+          } else if (msgId.length > 64) {
+            msgId = `msg_${shortHash(msgId)}`;
+          }
+          output.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: sanitizeSurrogates(textBlock.text), annotations: [] }],
+            status: "completed",
+            id: msgId,
+            phase: parsedSignature?.phase
+          });
+        } else if (block.type === "toolCall") {
+          const toolCall = block;
+          const [callId, itemIdRaw] = toolCall.id.split("|");
+          const customInputProperty = options?.grammarToolInputProperties?.get(toolCall.name);
+          let itemId = itemIdRaw;
+          if (isDifferentModel && itemId?.startsWith("fc_") || customInputProperty === undefined && !itemId?.startsWith("fc_")) {
+            itemId = undefined;
+          }
+          if (customInputProperty !== undefined) {
+            output.push({
+              type: "custom_tool_call",
+              id: itemId,
+              call_id: callId,
+              name: toolCall.name,
+              input: sanitizeSurrogates(getGrammarToolInput(toolCall.name, toolCall.arguments, customInputProperty)),
+              ...isSameModel && toolCall.namespace !== undefined ? { namespace: toolCall.namespace } : {}
+            });
+          } else {
+            output.push({
+              type: "function_call",
+              id: itemId,
+              call_id: callId,
+              name: toolCall.name,
+              arguments: JSON.stringify(toolCall.arguments),
+              ...isSameModel && toolCall.namespace !== undefined ? { namespace: toolCall.namespace } : {}
+            });
+          }
+        }
+      }
+      if (output.length === 0)
+        continue;
+      messages.push(...output);
+    } else if (msg.role === "toolResult") {
+      const [callId] = msg.toolCallId.split("|");
+      const output = convertToolResultOutput(model, msg.content);
+      if (options?.grammarToolInputProperties?.has(msg.toolName)) {
+        messages.push({
+          type: "custom_tool_call_output",
+          call_id: callId,
+          output
+        });
+      } else {
+        messages.push({
+          type: "function_call_output",
+          call_id: callId,
+          output
+        });
+      }
+    }
+    if (!isLeadingSystemMessage)
+      msgIndex++;
+  }
+  return messages;
+}
+function convertResponsesTools(tools, options) {
+  const defaultStrict = options?.strict === undefined ? false : options.strict;
+  const supportsStrictMode = options?.supportsStrictMode ?? true;
+  const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
+  return tools.map((tool) => {
+    const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+    if (grammar) {
+      return {
+        type: "custom",
+        name: tool.name,
+        description: tool.description,
+        format: {
+          type: "grammar",
+          syntax: grammar.format,
+          definition: grammar.definition
+        },
+        ...options?.toolSearchResult ? { defer_loading: true } : {}
+      };
+    }
+    const constrainedStrict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+    const strict = constrainedStrict ?? defaultStrict;
+    const functionTool = {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: getJsonSchemaToolParameters(tool, strict === true),
+      ...options?.toolSearchResult ? { defer_loading: true } : {}
+    };
+    if (supportsStrictMode) {
+      functionTool.strict = strict;
+    }
+    return functionTool;
+  });
+}
+
+// protocol.ts
+var RESPONSES_APIS = new Set([
+  "openai-responses",
+  "openai-codex-responses",
+  "azure-openai-responses"
+]);
+var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+var MAX_ITEM_BYTES = 2 * 1024 * 1024;
+var REMOTE_RETAINED_BYTES = 8 * 1024 * 1024;
+var REMOTE_RETAINED_CHARS = 64000 * 4;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function supportsResponsesApi(model) {
+  return model !== undefined && RESPONSES_APIS.has(String(model.api));
+}
+function resolveNativeProtocol(model) {
+  if (!supportsResponsesApi(model))
+    return;
+  return model.api === "openai-codex-responses" ? "remote-v2" : "responses-compact";
+}
+function isCompactionItem(value) {
+  return isObject(value) && value.type === "compaction" && typeof value.encrypted_content === "string" && value.encrypted_content.length > 0;
+}
+function byteLength(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function validateItemSize(item) {
+  if (byteLength(item) > MAX_ITEM_BYTES)
+    throw new Error("Native compaction output item exceeded 2 MiB");
+}
+function validContent(value) {
+  return typeof value === "string" || Array.isArray(value) && value.every((part) => {
+    if (!isObject(part))
+      return false;
+    if (part.type === "input_text" || part.type === "output_text" || part.type === "summary_text")
+      return typeof part.text === "string";
+    if (part.type === "input_image")
+      return typeof part.image_url === "string" || typeof part.file_id === "string";
+    if (part.type === "refusal")
+      return typeof part.refusal === "string";
+    return false;
+  });
+}
+function validateCompactedOutput(value) {
+  if (!isObject(value) || !Array.isArray(value.output) || value.output.length === 0) {
+    throw new Error("Responses Compact returned an invalid output window");
+  }
+  if (byteLength(value.output) > MAX_RESPONSE_BYTES)
+    throw new Error("Native compaction output exceeded 8 MiB");
+  const output = value.output.map((item) => {
+    if (!isObject(item))
+      throw new Error("Responses Compact returned a non-object output item");
+    validateItemSize(item);
+    const type = item.type ?? (typeof item.role === "string" ? "message" : undefined);
+    if (!["compaction", "message", "reasoning", "function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output", "tool_search_call", "tool_search_output", "additional_tools"].includes(String(type)))
+      throw new Error("Responses Compact returned an unsupported output item");
+    if (type === "message" && (!["user", "assistant", "system", "developer"].includes(String(item.role)) || !validContent(item.content)))
+      throw new Error("Responses Compact returned an invalid message item");
+    if (type === "compaction" && !isCompactionItem(item))
+      throw new Error("Responses Compact returned an invalid checkpoint");
+    if (type === "reasoning" && !(typeof item.encrypted_content === "string" || Array.isArray(item.summary) && validContent(item.summary)))
+      throw new Error("Responses Compact returned invalid reasoning");
+    if (String(type).includes("call") || type === "tool_search_output") {
+      if (typeof item.call_id !== "string" || !item.call_id)
+        throw new Error("Responses Compact returned an invalid tool id");
+      if (type === "function_call" && (typeof item.name !== "string" || typeof item.arguments !== "string"))
+        throw new Error("Responses Compact returned an invalid function call");
+      if (type === "custom_tool_call" && (typeof item.name !== "string" || typeof item.input !== "string"))
+        throw new Error("Responses Compact returned an invalid custom call");
+      if ((type === "function_call_output" || type === "custom_tool_call_output") && !validContent(item.output))
+        throw new Error("Responses Compact returned an invalid tool output");
+      if (type === "tool_search_call" && !isObject(item.arguments))
+        throw new Error("Responses Compact returned an invalid tool search");
+    }
+    if ((type === "additional_tools" || type === "tool_search_output") && (!Array.isArray(item.tools) || !item.tools.every(isObject)))
+      throw new Error("Responses Compact returned invalid tools");
+    return structuredClone(item);
+  });
+  const checkpoints = output.filter(isCompactionItem);
+  if (checkpoints.length !== 1) {
+    throw new Error(`Responses Compact returned ${checkpoints.length} compaction items; expected exactly one`);
+  }
+  return output;
+}
+async function readJsonBounded(response, signal) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    throw new Error("Native compaction response exceeded 8 MiB");
+  }
+  if (!response.body)
+    throw new Error("Native compaction response did not contain a body");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  const onAbort = () => void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => {
+    return;
+  });
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      if (signal.aborted)
+        throw new DOMException("Compaction aborted", "AbortError");
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      total += value.byteLength;
+      if (total > MAX_RESPONSE_BYTES)
+        throw new Error("Native compaction response exceeded 8 MiB");
+      chunks.push(value);
+    }
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    throw new Error("Native compaction response returned malformed JSON");
+  }
+}
+function requestUrl(input) {
+  return new URL(input instanceof Request ? input.url : String(input));
+}
+function responsesCompactUrl(input) {
+  const original = requestUrl(input);
+  if (!original.pathname.endsWith("/responses")) {
+    throw new Error("Provider request URL does not end with /responses");
+  }
+  const compact = new URL(original);
+  compact.pathname = `${compact.pathname}/compact`;
+  if (compact.origin !== original.origin)
+    throw new Error("Responses Compact URL changed origin");
+  return compact;
+}
+function mergedHeaders(input, init) {
+  const headers = new Headers(input instanceof Request ? input.headers : undefined);
+  new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+  headers.delete("content-encoding");
+  headers.delete("content-length");
+  headers.set("accept", "application/json");
+  headers.set("content-type", "application/json");
+  return headers;
+}
+function compactPayload(payload) {
+  const allowed = [
+    "model",
+    "input",
+    "instructions",
+    "previous_response_id",
+    "prompt_cache_key",
+    "prompt_cache_retention",
+    "service_tier"
+  ];
+  const result = {};
+  for (const key of allowed) {
+    if (Object.hasOwn(payload, key) && payload[key] !== undefined)
+      result[key] = structuredClone(payload[key]);
+  }
+  if (typeof result.model !== "string" || !Array.isArray(result.input)) {
+    throw new Error("Provider did not expose a valid Responses payload for compaction");
+  }
+  return result;
+}
+function errorResponse(error) {
+  return Response.json({ error: { message: error instanceof Error ? error.message : String(error), type: "invalid_request_error" } }, { status: 400 });
+}
+function rawUsage(response) {
+  if (!isObject(response.usage))
+    throw new Error("Native compaction response is missing usage");
+  return structuredClone(response.usage);
+}
+function syntheticCompletion(response, payload) {
+  const completed = {
+    id: typeof response.id === "string" ? response.id : "resp_pi_provider_compaction",
+    object: "response",
+    created_at: typeof response.created_at === "number" ? response.created_at : Math.floor(Date.now() / 1000),
+    status: "completed",
+    model: payload.model,
+    output: [],
+    parallel_tool_calls: false,
+    tool_choice: "auto",
+    tools: [],
+    usage: rawUsage(response)
+  };
+  const body = [
+    { type: "response.created", response: { ...completed, status: "in_progress" } },
+    { type: "response.completed", response: completed }
+  ].map((event) => `data: ${JSON.stringify(event)}
+
+`).join("");
+  return new Response(body, { status: 200, headers: { "content-type": "text/event-stream" } });
+}
+async function collectProviderUsage(stream, signal) {
+  let usage;
+  for await (const event of stream) {
+    if (signal.aborted)
+      throw new DOMException("Compaction aborted", "AbortError");
+    if (event.type === "error")
+      throw new Error(event.error.errorMessage ?? "Native compaction provider request failed");
+    if (event.type === "done")
+      usage = event.message.usage;
+  }
+  if (!usage)
+    throw new Error("Native compaction provider stream ended without usage");
+  return usage;
+}
+async function requestResponsesCompact(request) {
+  let preparedPayload;
+  let compacted;
+  let bridgeError;
+  let dispatches = 0;
+  const baseFetch = request.fetch ?? globalThis.fetch;
+  const bridgeFetch = async (input, init) => {
+    if (request.signal.aborted)
+      throw new DOMException("Compaction aborted", "AbortError");
+    dispatches += 1;
+    if (dispatches !== 1 || !preparedPayload) {
+      bridgeError = new Error("Responses Compact provider dispatched an unexpected additional request");
+      return errorResponse(bridgeError);
+    }
+    try {
+      const compactUrl = responsesCompactUrl(input);
+      const response = await baseFetch(compactUrl, {
+        ...init,
+        method: "POST",
+        headers: mergedHeaders(input, init),
+        body: JSON.stringify(compactPayload(preparedPayload)),
+        signal: request.signal
+      });
+      if (!response.ok)
+        return response;
+      const parsed = await readJsonBounded(response, request.signal);
+      if (!isObject(parsed))
+        throw new Error("Responses Compact returned a non-object response");
+      compacted = { response: parsed, output: validateCompactedOutput(parsed) };
+      return syntheticCompletion(parsed, preparedPayload);
+    } catch (error) {
+      bridgeError = error;
+      return errorResponse(error);
+    }
+  };
+  const stream = request.provider.stream(request.model, request.context, {
+    apiKey: request.apiKey,
+    headers: request.headers,
+    env: request.env,
+    signal: request.signal,
+    transport: "sse",
+    cacheRetention: "none",
+    maxRetries: 0,
+    fetch: bridgeFetch,
+    onPayload: (payload) => {
+      if (!isObject(payload))
+        throw new Error("Responses provider exposed a non-object payload");
+      if (request.preparedPayload && request.preparedPayload.model !== payload.model)
+        throw new Error("Native route model changed since capture");
+      preparedPayload = { ...structuredClone(request.preparedPayload ?? payload), input: structuredClone(request.input) };
+      return preparedPayload;
+    }
+  });
+  const usage = await collectProviderUsage(stream, request.signal).catch((error) => {
+    if (bridgeError)
+      throw bridgeError;
+    throw error;
+  });
+  if (bridgeError)
+    throw bridgeError;
+  if (!compacted || dispatches !== 1)
+    throw new Error("Responses Compact did not complete exactly one request");
+  return { output: compacted.output, usage };
+}
+async function collectCompactionSse(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let bytes = 0;
+  let pending = "";
+  let dataLines = [];
+  let completed = false;
+  const items = new Map;
+  const onAbort = () => void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => {
+    return;
+  });
+  signal.addEventListener("abort", onAbort, { once: true });
+  const dispatch = () => {
+    if (dataLines.length === 0)
+      return;
+    const data = dataLines.join(`
+`);
+    dataLines = [];
+    if (data === "[DONE]")
+      return;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      throw new Error("Remote V2 returned malformed SSE JSON");
+    }
+    if (!isObject(event))
+      return;
+    if (event.type === "response.completed")
+      completed = true;
+    const candidates = [];
+    if (event.type === "response.output_item.done")
+      candidates.push(event.item);
+    if (event.type === "response.completed" && isObject(event.response) && Array.isArray(event.response.output)) {
+      candidates.push(...event.response.output);
+    }
+    for (const candidate of candidates) {
+      if (!isCompactionItem(candidate))
+        continue;
+      validateItemSize(candidate);
+      items.set(JSON.stringify(candidate), structuredClone(candidate));
+    }
+  };
+  const processLine = (line) => {
+    if (line === "")
+      return dispatch();
+    if (line.startsWith(":"))
+      return;
+    if (line.startsWith("data:"))
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+  };
+  try {
+    while (true) {
+      if (signal.aborted)
+        throw new DOMException("Compaction aborted", "AbortError");
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      bytes += value.byteLength;
+      if (bytes > MAX_RESPONSE_BYTES)
+        throw new Error("Remote V2 stream exceeded 8 MiB");
+      pending += decoder.decode(value, { stream: true });
+      let newline = pending.indexOf(`
+`);
+      while (newline >= 0) {
+        const raw = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        processLine(raw.endsWith("\r") ? raw.slice(0, -1) : raw);
+        newline = pending.indexOf(`
+`);
+      }
+    }
+    pending += decoder.decode();
+    if (pending)
+      processLine(pending.endsWith("\r") ? pending.slice(0, -1) : pending);
+    dispatch();
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+  if (!completed)
+    throw new Error("Remote V2 stream ended without response.completed");
+  if (items.size !== 1)
+    throw new Error(`Remote V2 returned ${items.size} distinct compaction items; expected exactly one`);
+  return { item: [...items.values()][0] };
+}
+function retainedUserMessage(item) {
+  return (item.type === undefined || item.type === "message") && item.role === "user" && Array.isArray(item.content);
+}
+function buildRemoteV2History(input, item) {
+  validateItemSize(item);
+  let remainingBytes = REMOTE_RETAINED_BYTES - byteLength(item);
+  let remainingChars = REMOTE_RETAINED_CHARS;
+  const kept = [];
+  for (let index = input.length - 1;index >= 0; index--) {
+    const candidate = input[index];
+    if (!retainedUserMessage(candidate))
+      continue;
+    const bytes = byteLength(candidate);
+    if (bytes > remainingBytes)
+      continue;
+    const chars = JSON.stringify(candidate).length;
+    if (chars > remainingChars)
+      continue;
+    kept.push(structuredClone(candidate));
+    remainingBytes -= bytes;
+    remainingChars -= chars;
+    if (remainingBytes < 256 || remainingChars < 64)
+      break;
+  }
+  return [...kept.reverse(), structuredClone(item)];
+}
+async function requestRemoteV2(request) {
+  const baseFetch = request.fetch ?? globalThis.fetch;
+  let sentInput;
+  const controller = new AbortController;
+  const signal = AbortSignal.any([request.signal, controller.signal]);
+  const inspections = [];
+  const inspectedFetch = async (input, init) => {
+    const response = await baseFetch(input, init);
+    if (!response.ok || !response.body)
+      return response;
+    const [providerBody, inspectionBody] = response.body.tee();
+    inspections.push(collectCompactionSse(inspectionBody, signal).then((result) => ({ result }), (error) => ({ error })));
+    return new Response(providerBody, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+  const stream = request.provider.stream(request.model, request.context, {
+    apiKey: request.apiKey,
+    headers: request.headers,
+    env: request.env,
+    signal: request.signal,
+    transport: "sse",
+    cacheRetention: "none",
+    maxRetries: 0,
+    fetch: inspectedFetch,
+    onPayload: (payload) => {
+      if (!isObject(payload))
+        throw new Error("Codex provider exposed a non-object payload");
+      sentInput = structuredClone(request.input);
+      if (request.preparedPayload && request.preparedPayload.model !== payload.model)
+        throw new Error("Native route model changed since capture");
+      return { ...structuredClone(request.preparedPayload ?? payload), stream: true, input: [...sentInput, { type: "compaction_trigger" }] };
+    }
+  });
+  try {
+    const usage = await collectProviderUsage(stream, request.signal);
+    if (!sentInput || inspections.length !== 1)
+      throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+    const inspection = await inspections[0];
+    if ("error" in inspection)
+      throw inspection.error;
+    return { output: buildRemoteV2History(sentInput, inspection.result.item), usage };
+  } finally {
+    controller.abort();
+  }
+}
+async function requestProviderCompaction(request) {
+  const result = await (request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request));
+  return { ...result, output: validateCompactedOutput(result) };
+}
+
+// replay.ts
+var TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+var MAX_SNAPSHOT_BYTES = 8 * 1024 * 1024;
+var SNAPSHOT_TTL_MS = 5 * 60000;
+function equal(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function serializeInput(model, context, declarations = context) {
+  const compat = model.compat;
+  const flag = (name) => compat?.[name] === true;
+  const codex = model.api === "openai-codex-responses";
+  const normalized = resolveTranscript2(context, flag("supportsMidConvoSystemMessages"));
+  const tools = resolveTranscript2(declarations, flag("supportsMidConvoSystemMessages"));
+  return convertResponsesMessages(model, normalized, model.api === "azure-openai-responses" ? new Set([...TOOL_CALL_PROVIDERS, "azure-openai-responses"]) : TOOL_CALL_PROVIDERS, {
+    includeSystemPrompt: !codex,
+    grammarToolInputProperties: createGrammarToolInputProperties(getDeclaredTools(tools.messages), flag("supportsOpenAIGrammarTools")),
+    supportsMidConvoSystemMessages: flag("supportsMidConvoSystemMessages"),
+    supportsAdditionalTools: flag("supportsAdditionalTools"),
+    supportsToolSearch: flag("supportsToolSearch"),
+    toolOptions: {
+      ...codex ? { strict: null } : {},
+      supportsStrictMode: compat?.supportsStrictMode ?? model.api !== "openai-responses",
+      supportsOpenAIGrammarTools: flag("supportsOpenAIGrammarTools")
+    }
+  });
+}
+function capturePreparedRequest(model, context, canonical, payload, reject = () => {}) {
+  if (!isObject(payload) || !Array.isArray(payload.input) || !payload.input.every(isObject)) {
+    reject("unsupported payload shape");
+    return;
+  }
+  if (payload.previous_response_id || payload.conversation) {
+    reject("stateful request");
+    return;
+  }
+  if (Buffer.byteLength(JSON.stringify({ context, payload })) > MAX_SNAPSHOT_BYTES) {
+    reject("snapshot exceeds size limit");
+    return;
+  }
+  const expected = serializeInput(model, context);
+  if (!equal(expected, payload.input)) {
+    reject("prepared input differs from serializer");
+    return;
+  }
+  return { context: structuredClone(context), canonical: structuredClone(canonical), payload: structuredClone(payload), portableInput: expected, createdAt: Date.now() };
+}
+function promptCount(input) {
+  let count = 0;
+  while (input[count]?.role === "system" || input[count]?.role === "developer")
+    count++;
+  return count;
+}
+function closedTools(context) {
+  const pending = new Set;
+  for (const message of context.messages) {
+    if (message.role === "assistant") {
+      if (message.stopReason === "error" || message.stopReason === "aborted")
+        return false;
+      for (const block of message.content)
+        if (block.type === "toolCall") {
+          if (pending.has(block.id))
+            return false;
+          pending.add(block.id);
+        }
+    } else if (message.role === "toolResult") {
+      if (!pending.delete(message.toolCallId))
+        return false;
+    }
+  }
+  return pending.size === 0;
+}
+function mappedPrefix(snapshot, prefix) {
+  if (!equal(snapshot.canonical.messages.slice(0, prefix.messages.length), prefix.messages))
+    return;
+  const head = prefix.messages[0]?.role === "system" ? 1 : 0;
+  if (head && snapshot.context.messages[0]?.role !== "system")
+    return;
+  if (!equal(snapshot.context.messages.slice(head, prefix.messages.length), prefix.messages.slice(head)))
+    return;
+  return normalizeContext({ messages: snapshot.context.messages.slice(0, prefix.messages.length) });
+}
+function selectCoveredPrefix(model, snapshot, prefix, reject = () => {}) {
+  if (Date.now() - snapshot.createdAt > SNAPSHOT_TTL_MS) {
+    reject("snapshot expired");
+    return;
+  }
+  if (!closedTools(prefix)) {
+    reject("prefix has an incomplete tool exchange or failed assistant");
+    return;
+  }
+  const mapped = mappedPrefix(snapshot, prefix);
+  if (!mapped) {
+    reject("projected prefix differs from request context");
+    return;
+  }
+  const expected = serializeInput(model, mapped, snapshot.context);
+  if (!equal(snapshot.portableInput.slice(0, expected.length), expected)) {
+    reject("serialized prefix does not match prepared input");
+    return;
+  }
+  const start = promptCount(expected);
+  let end = expected.length;
+  if (snapshot.replacement) {
+    if (snapshot.replacement.index < start || snapshot.replacement.index >= end) {
+      reject("previous native slot is outside covered prefix");
+      return;
+    }
+    end += snapshot.replacement.count - 1;
+  }
+  if (end <= start) {
+    reject("empty covered prefix");
+    return;
+  }
+  return structuredClone(snapshot.payload.input.slice(start, end));
+}
+function substituteSummary(payload, index, summary, output) {
+  if (!isObject(payload) || !Array.isArray(payload.input) || !payload.input.every(isObject))
+    return;
+  if (!equal(payload.input[index], summary))
+    return;
+  if (payload.input.filter((item) => equal(item, summary)).length !== 1)
+    return;
+  return { ...payload, input: [...payload.input.slice(0, index), ...structuredClone(output), ...payload.input.slice(index + 1)] };
+}
+function summarySlot(model, snapshot, summaryPrefix) {
+  const mapped = mappedPrefix(snapshot, summaryPrefix);
+  if (!mapped)
+    return;
+  const prefix = serializeInput(model, mapped, snapshot.context);
+  const index = promptCount(prefix);
+  if (prefix.length !== index + 1 || !equal(snapshot.portableInput.slice(0, prefix.length), prefix))
+    return;
+  return index;
+}
+function requestPolicy(model, snapshot) {
+  return {
+    model,
+    system: getCurrentSystemPrompt(snapshot.context.messages),
+    currentTools: getCurrentTools2(snapshot.context.messages),
+    declarations: getDeclaredTools(resolveTranscript2(snapshot.context, model.compat?.supportsMidConvoSystemMessages).messages),
+    instructions: snapshot.payload.instructions,
+    tools: snapshot.payload.tools,
+    prompt: snapshot.portableInput.slice(0, promptCount(snapshot.portableInput))
+  };
+}
+
+// index.ts
+var NATIVE_COMPACTION_TYPE = "pi-provider-compaction/openai-responses";
+var NATIVE_COMPACTION_VERSION = 3;
+var NATIVE_COMPACTION_SUMMARY = "This context was compacted using the provider's native OpenAI Responses state.";
+var supportsNativeCompaction = supportsResponsesApi;
+var digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+var transcript = (messages) => normalizeContext2({ messages: convertToLlm(messages) });
+function readNativeCompactionDetails(value) {
+  if (!isObject(value) || value.type !== NATIVE_COMPACTION_TYPE || value.version !== 1 && value.version !== 2 && value.version !== 3)
+    return;
+  if (typeof value.provider !== "string" || typeof value.api !== "string" || typeof value.model !== "string")
+    return;
+  const protocol = value.version === 1 ? "responses-compact" : value.protocol;
+  if (protocol !== "responses-compact" && protocol !== "remote-v2")
+    return;
+  try {
+    const output = validateCompactedOutput(value);
+    if (value.version === 3) {
+      const coverage = value.coverage;
+      if (!isObject(coverage) || coverage.kind !== "summarized-prefix")
+        return;
+      for (const field of ["firstKeptEntryId", "sourceLeafId", "sourceHash", "policyHash", "inputHash", "runtimeId"]) {
+        if (typeof coverage[field] !== "string" || !coverage[field])
+          return;
+      }
+      if (!isObject(value.identity) || typeof value.identity.endpoint !== "string")
+        return;
+    }
+    return { ...structuredClone(value), protocol, output };
+  } catch {
+    return;
+  }
+}
+function latestCompaction(branch) {
+  for (let index = branch.length - 1;index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type === "compaction")
+      return entry;
+  }
+  return;
+}
+function header(headers, name) {
+  const value = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name)?.[1];
+  return typeof value === "string" && value ? value : undefined;
+}
+function identity(model, options) {
+  const azure = model.api === "azure-openai-responses";
+  const azureBase = options.env?.AZURE_OPENAI_BASE_URL || (options.env?.AZURE_OPENAI_RESOURCE_NAME ? `https://${options.env.AZURE_OPENAI_RESOURCE_NAME}.openai.azure.com/openai/v1` : undefined);
+  const url = new URL(azure ? azureBase ?? model.baseUrl : model.baseUrl);
+  url.username = "";
+  url.password = "";
+  url.search = "";
+  url.hash = "";
+  let accountId = header(options.headers, "chatgpt-account-id");
+  if (!accountId && model.api === "openai-codex-responses" && options.apiKey) {
+    try {
+      const token = JSON.parse(Buffer.from(options.apiKey.split(".")[1], "base64url").toString("utf8"));
+      const id = token["https://api.openai.com/auth"]?.chatgpt_account_id;
+      if (typeof id === "string")
+        accountId = id;
+    } catch {}
+  }
+  const map = options.env?.AZURE_OPENAI_DEPLOYMENT_NAME_MAP?.split(",").map((entry) => entry.split("=").map((part) => part.trim()));
+  return {
+    endpoint: url.toString().replace(/\/+$/, ""),
+    organization: header(options.headers, "openai-organization"),
+    project: header(options.headers, "openai-project"),
+    accountId,
+    azureApiVersion: azure ? options.env?.AZURE_OPENAI_API_VERSION ?? "v1" : undefined,
+    azureDeployment: azure ? map?.find(([id]) => id === model.id)?.[1] ?? model.id : undefined
+  };
+}
+function combineUsage(first, second) {
+  if (!first)
+    return second;
+  if (!second)
+    return first;
+  const result = structuredClone(first);
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"])
+    result[key] += second[key];
+  for (const key of ["reasoning", "cacheWrite1h"])
+    if (first[key] !== undefined || second[key] !== undefined)
+      result[key] = (first[key] ?? 0) + (second[key] ?? 0);
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"])
+    result.cost[key] += second.cost[key];
+  return result;
+}
+function supportedRouteOptions(model, options) {
+  if (model.api !== "azure-openai-responses")
+    return true;
+  const extra = options;
+  if (["azureBaseUrl", "azureResourceName", "azureApiVersion", "azureDeploymentName"].some((key) => extra[key] !== undefined))
+    return false;
+  return !["AZURE_OPENAI_BASE_URL", "AZURE_OPENAI_RESOURCE_NAME", "AZURE_OPENAI_API_VERSION", "AZURE_OPENAI_DEPLOYMENT_NAME_MAP"].some((key) => process.env[key] !== undefined && options.env?.[key] === undefined);
+}
+function pi_provider_compaction_default(pi) {
+  const secret = randomBytes(32);
+  const routeDigest = (value) => createHmac("sha256", secret).update(JSON.stringify(value)).digest("hex");
+  let runtimeId = randomUUID();
+  let ctx;
+  let snapshot;
+  let active;
+  let pending;
+  let uninstall;
+  let installedProvider;
+  let generation = 0;
+  let captureStatus = "no request observed";
+  let compactionStatus = "not attempted in this runtime";
+  const captureRejected = (reason) => {
+    captureStatus = reason;
+  };
+  const fallback = (reason) => {
+    compactionStatus = `portable: ${reason}`;
+  };
+  pi.registerCommand("provider-compaction-status", {
+    description: "Show content-free native compaction eligibility and last attempt",
+    handler: async (_args, context) => {
+      context.ui.notify(`Provider compaction
+Observer: ${installedProvider ? "installed" : "unavailable for current registration"}
+Capture: ${captureStatus}
+Last attempt: ${compactionStatus}`, "info");
+    }
+  });
+  const invalidate = () => {
+    generation++;
+    runtimeId = randomUUID();
+    snapshot = undefined;
+    active = undefined;
+    pending = undefined;
+    captureStatus = "invalidated by lifecycle/history/policy change";
+  };
+  const generic = (context) => resolveCompactionModelPolicy(pi, context).hasSelectors;
+  const route = (model, options) => routeDigest({ model, apiKey: options.apiKey, headers: options.headers, env: options.env });
+  const unchanged = (branch, length, hash) => branch.length >= length && digest(branch.slice(0, length)) === hash && !branch.slice(length).some((entry) => entry.type === "context_edit");
+  const observe = (model, context, options) => {
+    const owner = ctx;
+    if (!owner || options.sessionId !== owner.sessionManager.getSessionId())
+      return;
+    if (!supportsNativeCompaction(model)) {
+      captureRejected("unsupported API");
+      return;
+    }
+    if (!options.onPayload) {
+      captureRejected("no payload callback");
+      return;
+    }
+    if (generic(owner)) {
+      captureRejected("generic compaction model takes precedence");
+      return;
+    }
+    if (!supportedRouteOptions(model, options)) {
+      captureRejected("unsupported route overrides");
+      return;
+    }
+    const ticket = generation;
+    const branch = owner.sessionManager.getBranch();
+    const branchHash = digest(branch);
+    const canonical = transcript(owner.sessionManager.buildSessionProjection().messages);
+    const current = () => generation === ticket && ctx === owner && !options.signal?.aborted && supportedRouteOptions(model, options) && digest(owner.sessionManager.getBranch()) === branchHash;
+    return async (payload) => {
+      if (!current())
+        return payload;
+      snapshot = undefined;
+      const prepared = capturePreparedRequest(model, context, canonical, payload, captureRejected);
+      if (!prepared) {
+        active = undefined;
+        return payload;
+      }
+      const auth = await owner.modelRegistry.getApiKeyAndHeaders(model);
+      if (!current())
+        return payload;
+      const normalizedHeaders = (headers) => Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]).sort(([a], [b]) => String(a).localeCompare(String(b)));
+      if (!auth.ok || generic(owner) || auth.apiKey !== options.apiKey || (auth.baseUrl ?? model.baseUrl) !== model.baseUrl || !equal(normalizedHeaders(auth.headers), normalizedHeaders(options.headers)) || !equal(auth.env ?? {}, options.env ?? {})) {
+        active = undefined;
+        captureRejected("resolved auth/route differs from prepared request, or generic policy changed");
+        return payload;
+      }
+      const provider = owner.modelRegistry.getProvider(model.provider);
+      if (!provider) {
+        captureRejected("provider unavailable");
+        return payload;
+      }
+      const routeHash = route(model, options);
+      const policyHash = digest(requestPolicy(model, prepared));
+      const latest = latestCompaction(branch);
+      let result = payload;
+      if (active && latest?.id === active.entryId && latest.summary === active.summary && digest(latest.details) === active.detailsHash && unchanged(branch, active.branchLength, active.branchHash) && active.routeHash === routeHash && active.policyHash === policyHash) {
+        const details = readNativeCompactionDetails(latest.details);
+        const projection = owner.sessionManager.buildSessionProjection();
+        const contribution = projection.entries.find((entry) => entry.sourceEntry.id === latest.id);
+        const prefix = contribution ? transcript(contribution.messages) : undefined;
+        const slot = prefix ? summarySlot(model, prepared, prefix) : undefined;
+        if (details?.version === 3 && details.coverage?.runtimeId === runtimeId && details.coverage.firstKeptEntryId === latest.firstKeptEntryId && slot !== undefined) {
+          const replaced = substituteSummary(payload, slot, prepared.portableInput[slot], details.output);
+          if (replaced) {
+            result = replaced;
+            prepared.payload = structuredClone(replaced);
+            prepared.replacement = { index: slot, count: details.output.length };
+          } else
+            active = undefined;
+        } else
+          active = undefined;
+      } else
+        active = undefined;
+      captureStatus = "eligible prepared request captured";
+      snapshot = {
+        prepared,
+        model: structuredClone(model),
+        provider,
+        options: { apiKey: options.apiKey, headers: structuredClone(options.headers), env: structuredClone(options.env), fetch: options.fetch },
+        branchLength: branch.length,
+        branchHash,
+        routeHash,
+        authHash: routeDigest(auth),
+        policyHash,
+        sessionId: owner.sessionManager.getSessionId()
+      };
+      return result;
+    };
+  };
+  const install = (context) => {
+    ctx = context;
+    if (installedProvider === context.model?.provider)
+      return;
+    uninstall?.();
+    uninstall = undefined;
+    installedProvider = undefined;
+    if (!supportsNativeCompaction(context.model))
+      return;
+    uninstall = installObserver(pi, context, observe);
+    if (uninstall)
+      installedProvider = context.model.provider;
+    captureStatus = uninstall ? "awaiting prepared request" : "unsupported provider registration";
+  };
+  pi.on("session_start", (_event, context) => {
+    invalidate();
+    install(context);
+    const latest = latestCompaction(context.sessionManager.getBranch());
+    if (latest?.summary === NATIVE_COMPACTION_SUMMARY)
+      context.ui.notify("Legacy native compaction has no portable summary. Native replay is disabled; recover from earlier history or start a new session.", "warning");
+  });
+  pi.on("before_agent_start", (_event, context) => {
+    install(context);
+  });
+  pi.on("model_select", (_event, context) => {
+    invalidate();
+    install(context);
+  });
+  pi.on("session_tree", () => {
+    invalidate();
+  });
+  pi.on("session_shutdown", () => {
+    invalidate();
+    uninstall?.();
+    uninstall = undefined;
+    installedProvider = undefined;
+    ctx = undefined;
+  });
+  const removeInvalidation = pi.events.on("pi-provider-compaction:invalidate", invalidate);
+  pi.on("session_shutdown", () => {
+    if (typeof removeInvalidation === "function")
+      removeInvalidation();
+  });
+  pi.on("session_before_compact", async (event, context) => {
+    const capture = snapshot;
+    snapshot = undefined;
+    pending = undefined;
+    if (!capture) {
+      fallback(`no eligible snapshot (${captureStatus})`);
+      return;
+    }
+    if (!context.model || generic(context) || event.signal.aborted) {
+      fallback("missing model, generic model override, or aborted attempt");
+      return;
+    }
+    const protocol = resolveNativeProtocol(context.model);
+    if (!protocol || context.sessionManager.getSessionId() !== capture.sessionId) {
+      fallback("unsupported protocol or changed session");
+      return;
+    }
+    const ticket = generation;
+    const branch = context.sessionManager.getBranch();
+    const branchHash = digest(branch);
+    if (!equal(branch, event.branchEntries) || !unchanged(branch, capture.branchLength, capture.branchHash)) {
+      fallback("history changed since capture");
+      return;
+    }
+    const projection = context.sessionManager.buildSessionProjection();
+    const boundary = projection.entries.findIndex((entry) => entry.sourceEntry.id === event.preparation.firstKeptEntryId);
+    if (boundary < 0) {
+      fallback("retained boundary missing from projection");
+      return;
+    }
+    const prefix = transcript(projection.entries.slice(0, boundary).flatMap((entry) => entry.messages));
+    const input = selectCoveredPrefix(capture.model, capture.prepared, prefix, fallback);
+    if (!input)
+      return;
+    const current = () => ticket === generation && !event.signal.aborted && supportedRouteOptions(capture.model, capture.options) && !generic(context) && context.modelRegistry.getProvider(capture.model.provider) === capture.provider && digest(context.sessionManager.getBranch()) === branchHash;
+    const auth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
+    if (!current())
+      return { cancel: true };
+    if (!auth.ok || routeDigest(auth) !== capture.authHash) {
+      fallback("auth changed since capture");
+      return;
+    }
+    compactionStatus = "generating portable summary";
+    let portable;
+    try {
+      portable = await compact(event.preparation, capture.model, auth.apiKey, auth.headers, event.customInstructions, event.signal, context.thinkingLevel, capture.provider.streamSimple.bind(capture.provider), auth.env, undefined, undefined, capture.sessionId);
+    } catch {
+      return !current() ? { cancel: true } : undefined;
+    }
+    if (!current() || !portable.summary.trim() || portable.summary === NATIVE_COMPACTION_SUMMARY)
+      return { cancel: true };
+    try {
+      const freshAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
+      if (!current())
+        return { cancel: true };
+      if (!freshAuth.ok || routeDigest(freshAuth) !== capture.authHash) {
+        fallback("auth changed after portable generation");
+        return { compaction: portable };
+      }
+      compactionStatus = "requesting native checkpoint";
+      const native = await requestProviderCompaction({
+        provider: capture.provider,
+        model: capture.model,
+        context: capture.prepared.context,
+        input,
+        preparedPayload: capture.prepared.payload,
+        protocol,
+        apiKey: capture.options.apiKey,
+        headers: capture.options.headers,
+        env: capture.options.env,
+        signal: event.signal,
+        fetch: capture.options.fetch
+      });
+      if (!current())
+        return { cancel: true };
+      const finalAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
+      if (!current())
+        return { cancel: true };
+      if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) {
+        fallback("auth changed after native generation");
+        return { compaction: portable };
+      }
+      const details = {
+        ...isObject(portable.details) ? portable.details : {},
+        type: NATIVE_COMPACTION_TYPE,
+        version: 3,
+        provider: capture.model.provider,
+        api: capture.model.api,
+        model: capture.model.id,
+        protocol,
+        identity: identity(capture.model, capture.options),
+        output: native.output,
+        nativeUsage: native.usage,
+        portableUsage: portable.usage,
+        coverage: { kind: "summarized-prefix", firstKeptEntryId: portable.firstKeptEntryId, sourceLeafId: branch.at(-1).id, sourceHash: branchHash, policyHash: capture.policyHash, inputHash: digest(input), runtimeId }
+      };
+      pending = { details, capture, summary: portable.summary };
+      return { compaction: { ...portable, usage: combineUsage(native.usage, portable.usage), details } };
+    } catch {
+      if (!current())
+        return { cancel: true };
+      fallback("native acquisition or validation failed");
+      return { compaction: portable };
+    }
+  });
+  pi.on("session_compact", (event, context) => {
+    if (readNativeCompactionDetails(event.compactionEntry.details)?.version === 3)
+      compactionStatus = "native checkpoint committed";
+    else if (!compactionStatus.startsWith("portable:"))
+      fallback("another handler supplied the committed result");
+    if (compactionStatus.startsWith("portable:"))
+      pi.appendEntry("pi-provider-compaction:diagnostic", { status: compactionStatus });
+    active = undefined;
+    snapshot = undefined;
+    const candidate = pending;
+    pending = undefined;
+    if (!candidate || !equal(event.compactionEntry.details, candidate.details) || event.compactionEntry.summary !== candidate.summary)
+      return;
+    const branch = context.sessionManager.getBranch();
+    const coverage = candidate.details.coverage;
+    if (!coverage || event.compactionEntry.firstKeptEntryId !== coverage.firstKeptEntryId || event.compactionEntry.parentId !== coverage.sourceLeafId || branch.at(-1)?.id !== event.compactionEntry.id || digest(branch.slice(0, -1)) !== coverage.sourceHash)
+      return;
+    active = { entryId: event.compactionEntry.id, detailsHash: digest(candidate.details), summary: candidate.summary, branchLength: branch.length, branchHash: digest(branch), routeHash: candidate.capture.routeHash, policyHash: candidate.capture.policyHash };
+  });
+  pi.on("session_compact_failed", () => {
+    pending = undefined;
+    snapshot = undefined;
+    compactionStatus = "compaction failed or cancelled";
+  });
+}
+export {
+  NATIVE_COMPACTION_SUMMARY,
+  NATIVE_COMPACTION_TYPE,
+  NATIVE_COMPACTION_VERSION,
+  pi_provider_compaction_default as default,
+  readNativeCompactionDetails,
+  supportsNativeCompaction
+};