@nijaru/pi-provider-compaction 0.0.2 → 0.0.3

package/dist/index.js

@@ -0,0 +1,1583 @@
+// 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/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}.`);
+  }
+}
+
+// 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 === "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 insertSyntheticToolResults = () => {
+    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;
+    }
+  };
+  for (let i = 0;i < transformed.length; i++) {
+    const msg = transformed[i];
+    if (msg.role === "assistant") {
+      insertSyntheticToolResults();
+      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 === "user") {
+      insertSyntheticToolResults();
+      result.push(msg);
+    } else {
+      result.push(msg);
+    }
+  }
+  insertSyntheticToolResults();
+  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 messages = [];
+  const loadedToolNames = new Set;
+  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(context.messages, model, normalizeToolCallId);
+  const includeSystemPrompt = options?.includeSystemPrompt ?? true;
+  if (includeSystemPrompt && context.systemPrompt) {
+    const compat = model.compat;
+    const role = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
+    messages.push({
+      role,
+      content: sanitizeSurrogates(context.systemPrompt)
+    });
+  }
+  let msgIndex = 0;
+  for (const msg of transformedMessages) {
+    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;
+          }
+          const canReplayNamespace = isSameModel || options?.deferredTools?.has(toolCall.name) === true;
+          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)),
+              ...canReplayNamespace && 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),
+              ...canReplayNamespace && 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
+        });
+      }
+      const deferredTools = [];
+      for (const name of msg.addedToolNames ?? []) {
+        const tool = options?.deferredTools?.get(name);
+        if (!tool || loadedToolNames.has(name))
+          continue;
+        loadedToolNames.add(name);
+        deferredTools.push(tool);
+      }
+      if (deferredTools.length > 0 && options?.deferredToolsMode === "additional-tools") {
+        messages.push({
+          type: "additional_tools",
+          role: "developer",
+          tools: convertResponsesTools(deferredTools, options.toolOptions)
+        });
+      } else if (deferredTools.length > 0 && options?.deferredToolsMode === "tool-search") {
+        const names = deferredTools.map((tool) => tool.name);
+        const searchCallId = `pi_tool_load_${shortHash(`${msg.toolCallId}:${names.join(",")}`)}`;
+        messages.push({
+          type: "tool_search_call",
+          call_id: searchCallId,
+          execution: "client",
+          status: "completed",
+          arguments: { query: names.join(" "), limit: names.length }
+        });
+        messages.push({
+          type: "tool_search_output",
+          call_id: searchCallId,
+          execution: "client",
+          status: "completed",
+          tools: convertResponsesTools(deferredTools, {
+            ...options.toolOptions,
+            deferLoading: true
+          })
+        });
+      }
+    }
+    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?.deferLoading ? { 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?.deferLoading ? { defer_loading: true } : {}
+    };
+    if (supportsStrictMode) {
+      functionTool.strict = strict;
+    }
+    return functionTool;
+  });
+}
+
+// index.ts
+import { calculateCost } from "@earendil-works/pi-ai";
+import {
+  compact,
+  convertToLlm,
+  sessionEntryToContextMessages
+} 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 };
+}
+
+// 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 validateCompactedOutput(value) {
+  if (!isObject(value) || !Array.isArray(value.output) || value.output.length === 0) {
+    throw new Error("Responses Compact returned an invalid output window");
+  }
+  const output = value.output.map((item) => {
+    if (!isObject(item))
+      throw new Error("Responses Compact returned a non-object output item");
+    validateItemSize(item);
+    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.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");
+      preparedPayload = { ...structuredClone(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.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 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, request.signal));
+    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);
+      return { ...structuredClone(payload), input: [...sentInput, { type: "compaction_trigger" }] };
+    }
+  });
+  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];
+  return { output: buildRemoteV2History(sentInput, inspection.item), usage };
+}
+async function requestProviderCompaction(request) {
+  return request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request);
+}
+
+// index.ts
+var NATIVE_COMPACTION_TYPE = "pi-provider-compaction/openai-responses";
+var NATIVE_COMPACTION_VERSION = 2;
+var NATIVE_COMPACTION_SUMMARY = "This context was compacted using the provider's native OpenAI Responses state.";
+var TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+function supportsNativeCompaction(model) {
+  return supportsResponsesApi(model);
+}
+function readUsage(value) {
+  if (!isObject(value) || !isObject(value.cost))
+    return;
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+    if (typeof value[key] !== "number" || !Number.isFinite(value[key]))
+      return;
+  }
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
+    if (typeof value.cost[key] !== "number" || !Number.isFinite(value.cost[key]))
+      return;
+  }
+  return value;
+}
+function readIdentity(value) {
+  if (!isObject(value) || typeof value.endpoint !== "string" || !value.endpoint)
+    return;
+  for (const key of ["organization", "project", "accountId", "azureApiVersion", "azureDeployment"]) {
+    if (value[key] !== undefined && typeof value[key] !== "string")
+      return;
+  }
+  return {
+    endpoint: value.endpoint,
+    organization: value.organization,
+    project: value.project,
+    accountId: value.accountId,
+    azureApiVersion: value.azureApiVersion,
+    azureDeployment: value.azureDeployment
+  };
+}
+function readNativeCompactionDetails(value) {
+  if (!isObject(value) || value.type !== NATIVE_COMPACTION_TYPE)
+    return;
+  if (value.version !== 1 && value.version !== NATIVE_COMPACTION_VERSION)
+    return;
+  if (typeof value.provider !== "string" || typeof value.api !== "string" || typeof value.model !== "string")
+    return;
+  if (!Array.isArray(value.output) || !value.output.every(isObject) || !value.output.some(isCompactionItem))
+    return;
+  const protocol = value.version === 1 ? "responses-compact" : value.protocol === "responses-compact" || value.protocol === "remote-v2" ? value.protocol : undefined;
+  if (!protocol)
+    return;
+  const strings = (candidate) => candidate === undefined ? undefined : Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? [...candidate] : undefined;
+  return {
+    type: NATIVE_COMPACTION_TYPE,
+    version: value.version,
+    provider: value.provider,
+    api: value.api,
+    model: value.model,
+    protocol,
+    identity: value.version === 1 ? undefined : readIdentity(value.identity),
+    output: structuredClone(value.output),
+    nativeUsage: readUsage(value.nativeUsage ?? value.usage),
+    usage: readUsage(value.usage),
+    portableUsage: readUsage(value.portableUsage),
+    readFiles: strings(value.readFiles),
+    modifiedFiles: strings(value.modifiedFiles)
+  };
+}
+function identityEqual(left, right) {
+  if (!left)
+    return true;
+  if (!right)
+    return false;
+  return left.endpoint === right.endpoint && left.organization === right.organization && left.project === right.project && left.accountId === right.accountId && left.azureApiVersion === right.azureApiVersion && left.azureDeployment === right.azureDeployment;
+}
+function findLatestNativeCompaction(entries, model, identity) {
+  if (!supportsNativeCompaction(model))
+    return;
+  for (let index = entries.length - 1;index >= 0; index--) {
+    const entry = entries[index];
+    if (entry.type !== "compaction")
+      continue;
+    const details = readNativeCompactionDetails(entry.details);
+    if (!details)
+      return;
+    if (details.provider !== model.provider || details.api !== model.api || details.model !== model.id)
+      return;
+    if (!identityEqual(details.identity, identity))
+      return;
+    return { ...details, entryId: entry.id };
+  }
+  return;
+}
+function responseItemsFromMessages(model, messages) {
+  const input = convertResponsesMessages(model, { messages: convertToLlm(messages), tools: [] }, TOOL_CALL_PROVIDERS, { includeSystemPrompt: false });
+  return input.filter(isObject);
+}
+function responseItemsFromEntries(model, entries) {
+  return responseItemsFromMessages(model, entries.flatMap((entry) => sessionEntryToContextMessages(entry)));
+}
+function nativeRequestInput(model, branchEntries, activeEntries, previous) {
+  if (previous) {
+    const previousIndex = branchEntries.findIndex((entry) => entry.id === previous.entryId);
+    if (previousIndex >= 0) {
+      return [...structuredClone(previous.output), ...responseItemsFromEntries(model, branchEntries.slice(previousIndex + 1))];
+    }
+  }
+  return responseItemsFromEntries(model, activeEntries);
+}
+function authHeaders(apiKey, headers) {
+  const result = { "content-type": "application/json" };
+  let hasAuthorization = false;
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    if (value === null)
+      continue;
+    result[name] = value;
+    if (name.toLowerCase() === "authorization" && value.trim())
+      hasAuthorization = true;
+  }
+  if (!hasAuthorization && apiKey)
+    result.authorization = `Bearer ${apiKey}`;
+  return result;
+}
+async function compactOpenAIResponses(options) {
+  const endpoint = `${options.baseUrl.replace(/\/+$/, "")}/responses/compact`;
+  const body = { model: options.model.id, input: options.input };
+  if (options.instructions)
+    body.instructions = options.instructions;
+  const response = await (options.fetchImpl ?? fetch)(endpoint, {
+    method: "POST",
+    headers: authHeaders(options.apiKey, options.headers),
+    body: JSON.stringify(body),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`OpenAI Responses compact request failed (${response.status}${detail ? `: ${detail.slice(0, 400)}` : ""})`);
+  }
+  const result = await response.json();
+  if (!isObject(result) || !Array.isArray(result.output) || !result.output.every(isObject) || !result.output.some(isCompactionItem)) {
+    throw new Error("OpenAI Responses compact response did not contain opaque compaction state");
+  }
+  const usage = compactUsage(options.model, result);
+  return {
+    type: NATIVE_COMPACTION_TYPE,
+    version: NATIVE_COMPACTION_VERSION,
+    provider: options.model.provider,
+    api: options.model.api,
+    model: options.model.id,
+    protocol: "responses-compact",
+    output: structuredClone(result.output),
+    nativeUsage: usage,
+    usage
+  };
+}
+function compactUsage(model, result) {
+  const usage = result.usage;
+  if (!isObject(usage))
+    return;
+  const cached = nestedNumber(usage.input_tokens_details, "cached_tokens");
+  const cacheWrite = nestedNumber(usage.input_tokens_details, "cache_write_tokens");
+  const mapped = {
+    input: Math.max(0, readNumber(usage.input_tokens) - cached - cacheWrite),
+    output: readNumber(usage.output_tokens),
+    cacheRead: cached,
+    cacheWrite,
+    reasoning: nestedNumber(usage.output_tokens_details, "reasoning_tokens"),
+    totalTokens: readNumber(usage.total_tokens),
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+  try {
+    calculateCost(model, mapped);
+  } catch {}
+  return mapped;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function nestedNumber(value, key) {
+  return isObject(value) ? readNumber(value[key]) : 0;
+}
+function stableStringify(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableStringify).join(",")}]`;
+  if (isObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function itemMatches(left, right) {
+  const leftId = typeof left.id === "string" ? left.id : undefined;
+  const rightId = typeof right.id === "string" ? right.id : undefined;
+  if (leftId && rightId)
+    return leftId === rightId;
+  const leftCallId = typeof left.call_id === "string" ? left.call_id : undefined;
+  const rightCallId = typeof right.call_id === "string" ? right.call_id : undefined;
+  if (leftCallId && rightCallId)
+    return leftCallId === rightCallId && left.type === right.type;
+  if (left.type === "message" && right.type === "message") {
+    return left.role === right.role && stableStringify(left.content) === stableStringify(right.content);
+  }
+  return stableStringify(left) === stableStringify(right);
+}
+function findLastSubsequence(items, sequence) {
+  if (sequence.length === 0)
+    return -1;
+  for (let start = items.length - sequence.length;start >= 0; start--) {
+    if (sequence.every((item, offset) => itemMatches(items[start + offset], item)))
+      return start;
+  }
+  return -1;
+}
+function rewriteResponsesPayload(payload, details, postCompactionItems) {
+  if (!isObject(payload) || !Array.isArray(payload.input))
+    return payload;
+  const currentInput = payload.input.filter(isObject);
+  if (currentInput.length !== payload.input.length)
+    return payload;
+  const postStart = findLastSubsequence(currentInput, postCompactionItems);
+  if (postStart >= 0)
+    return { ...payload, input: [...structuredClone(details.output), ...currentInput.slice(postStart)] };
+  const retainedOutput = details.output.filter((item) => item.type !== "compaction");
+  const retainedStart = findLastSubsequence(currentInput, retainedOutput);
+  if (retainedStart >= 0) {
+    return { ...payload, input: [...structuredClone(details.output), ...currentInput.slice(retainedStart + retainedOutput.length)] };
+  }
+  return { ...payload, input: [...structuredClone(details.output), ...structuredClone(postCompactionItems)] };
+}
+function genericCompactionSelected(pi, ctx) {
+  return resolveCompactionModelPolicy(pi, ctx).hasSelectors;
+}
+function normalizedEndpoint(value) {
+  if (!value)
+    return "";
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+function headerValue(headers, name) {
+  const match = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name.toLowerCase());
+  return typeof match?.[1] === "string" && match[1] ? match[1] : undefined;
+}
+function codexAccountId(apiKey) {
+  if (!apiKey)
+    return;
+  const parts = apiKey.split(".");
+  if (parts.length !== 3)
+    return;
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    if (!isObject(payload))
+      return;
+    const auth = payload["https://api.openai.com/auth"];
+    return isObject(auth) && typeof auth.chatgpt_account_id === "string" ? auth.chatgpt_account_id : undefined;
+  } catch {
+    return;
+  }
+}
+function azureDeployment(modelId, env) {
+  const raw = env?.AZURE_OPENAI_DEPLOYMENT_NAME_MAP;
+  if (!raw)
+    return modelId;
+  for (const entry of raw.split(",")) {
+    const [candidate, deployment] = entry.split("=", 2).map((part) => part?.trim());
+    if (candidate === modelId && deployment)
+      return deployment;
+  }
+  return modelId;
+}
+function routeIdentity(model, auth) {
+  const azure = model.api === "azure-openai-responses";
+  return {
+    endpoint: normalizedEndpoint(auth.baseUrl ?? auth.env?.AZURE_OPENAI_BASE_URL ?? model.baseUrl),
+    organization: headerValue(auth.headers, "openai-organization"),
+    project: headerValue(auth.headers, "openai-project"),
+    accountId: model.api === "openai-codex-responses" ? codexAccountId(auth.apiKey) : undefined,
+    azureApiVersion: azure ? auth.env?.AZURE_OPENAI_API_VERSION || "v1" : undefined,
+    azureDeployment: azure ? azureDeployment(model.id, auth.env) : undefined
+  };
+}
+function activeTools(pi) {
+  const available = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
+  return pi.getActiveTools().flatMap((name) => {
+    const tool = available.get(name);
+    return tool ? [{ name: tool.name, description: tool.description, parameters: tool.parameters }] : [];
+  });
+}
+function providerContext(pi, ctx, activeEntries) {
+  const messages = activeEntries.flatMap((entry) => sessionEntryToContextMessages(entry));
+  return {
+    systemPrompt: ctx.getSystemPrompt(),
+    messages: convertToLlm(messages),
+    tools: activeTools(pi)
+  };
+}
+function cleanHeaders(headers) {
+  if (!headers)
+    return;
+  return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null));
+}
+function combineUsage(first, second) {
+  if (!first)
+    return second;
+  if (!second)
+    return first;
+  return {
+    input: first.input + second.input,
+    output: first.output + second.output,
+    cacheRead: first.cacheRead + second.cacheRead,
+    cacheWrite: first.cacheWrite + second.cacheWrite,
+    cacheWrite1h: first.cacheWrite1h !== undefined || second.cacheWrite1h !== undefined ? (first.cacheWrite1h ?? 0) + (second.cacheWrite1h ?? 0) : undefined,
+    reasoning: first.reasoning !== undefined || second.reasoning !== undefined ? (first.reasoning ?? 0) + (second.reasoning ?? 0) : undefined,
+    totalTokens: first.totalTokens + second.totalTokens,
+    cost: {
+      input: first.cost.input + second.cost.input,
+      output: first.cost.output + second.cost.output,
+      cacheRead: first.cost.cacheRead + second.cost.cacheRead,
+      cacheWrite: first.cost.cacheWrite + second.cost.cacheWrite,
+      total: first.cost.total + second.cost.total
+    }
+  };
+}
+async function nativeAndPortableCompaction(pi, event, ctx) {
+  const model = ctx.model;
+  const protocol = resolveNativeProtocol(model);
+  if (!model || !protocol || genericCompactionSelected(pi, ctx))
+    return;
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok)
+    return;
+  const provider = ctx.modelRegistry.getProvider(model.provider);
+  if (!provider)
+    return;
+  const identity = routeIdentity(model, auth);
+  const branchEntries = event.branchEntries;
+  const activeEntries = ctx.sessionManager.buildContextEntries();
+  const previous = findLatestNativeCompaction(branchEntries, model, identity);
+  const input = nativeRequestInput(model, branchEntries, activeEntries, previous);
+  const native = await requestProviderCompaction({
+    provider,
+    model,
+    context: providerContext(pi, ctx, activeEntries),
+    input,
+    protocol,
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    env: auth.env,
+    signal: event.signal
+  });
+  const portable = await compact(event.preparation, model, auth.apiKey, cleanHeaders(auth.headers), event.customInstructions, event.signal, ctx.thinkingLevel, provider.streamSimple.bind(provider), auth.env, undefined, undefined, ctx.sessionManager.getSessionId());
+  const portableDetails = isObject(portable.details) ? portable.details : {};
+  const details = {
+    type: NATIVE_COMPACTION_TYPE,
+    version: NATIVE_COMPACTION_VERSION,
+    provider: model.provider,
+    api: model.api,
+    model: model.id,
+    protocol,
+    identity,
+    output: native.output,
+    nativeUsage: native.usage,
+    portableUsage: portable.usage,
+    readFiles: Array.isArray(portableDetails.readFiles) ? portableDetails.readFiles.filter((item) => typeof item === "string") : undefined,
+    modifiedFiles: Array.isArray(portableDetails.modifiedFiles) ? portableDetails.modifiedFiles.filter((item) => typeof item === "string") : undefined
+  };
+  return {
+    compaction: {
+      ...portable,
+      usage: combineUsage(native.usage, portable.usage),
+      details
+    }
+  };
+}
+function pi_provider_compaction_default(pi) {
+  pi.on("before_provider_request", async (event, ctx) => {
+    const model = ctx.model;
+    if (!supportsNativeCompaction(model))
+      return;
+    const branch = ctx.sessionManager.getBranch();
+    const candidate = findLatestNativeCompaction(branch, model);
+    if (!candidate || genericCompactionSelected(pi, ctx))
+      return;
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok)
+      return;
+    const latest = findLatestNativeCompaction(branch, model, routeIdentity(model, auth));
+    if (!latest)
+      return;
+    const index = branch.findIndex((entry) => entry.id === latest.entryId);
+    const postItems = index >= 0 ? responseItemsFromEntries(model, branch.slice(index + 1)) : [];
+    const rewritten = rewriteResponsesPayload(event.payload, latest, postItems);
+    if (rewritten === event.payload || !isObject(rewritten))
+      return rewritten;
+    const systemPrompt = ctx.getSystemPrompt();
+    return systemPrompt ? { ...rewritten, instructions: systemPrompt } : rewritten;
+  });
+  pi.on("session_before_compact", async (event, ctx) => {
+    try {
+      return await nativeAndPortableCompaction(pi, event, ctx);
+    } catch (error) {
+      if (event.signal.aborted || error instanceof Error && error.name === "AbortError")
+        return;
+      console.error(`[pi-provider-compaction] native compaction failed: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+  });
+}
+export {
+  NATIVE_COMPACTION_SUMMARY,
+  NATIVE_COMPACTION_TYPE,
+  NATIVE_COMPACTION_VERSION,
+  compactOpenAIResponses,
+  pi_provider_compaction_default as default,
+  findLatestNativeCompaction,
+  readNativeCompactionDetails,
+  rewriteResponsesPayload,
+  supportsNativeCompaction
+};