privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-I2MCJ34O.mjs

@@ -0,0 +1,464 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  canonicalJson
+} from "./c-KIVXWBYD.mjs";
+import {
+  isJsonObject
+} from "./c-I3C6LBW4.mjs";
+import {
+  buildSessionContext,
+  convertToLlm
+} from "./c-SKMK3PEE.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/context/visible-conversation-v2.ts?ext=pi-background-tasks
+import { createHash } from "node:crypto";
+var CONVERSATION_IMAGE_OMISSION_PREFIX = "[Image omitted from fusion text transcript: ";
+var UnsupportedConversationBlockError = class extends Error {
+  static {
+    __name(this, "UnsupportedConversationBlockError");
+  }
+  label;
+  constructor(label) {
+    super(`fusion context projection encountered an unsupported conversation block: ${label}`);
+    this.name = "UnsupportedConversationBlockError";
+    this.label = label;
+  }
+};
+function utf8Bytes(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+__name(utf8Bytes, "utf8Bytes");
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+__name(sha256Hex, "sha256Hex");
+function uint64be(value) {
+  const out = Buffer.alloc(8);
+  out.writeBigUInt64BE(BigInt(value));
+  return out;
+}
+__name(uint64be, "uint64be");
+function lengthPrefixed(bytes) {
+  return Buffer.concat([uint64be(bytes.length), bytes]);
+}
+__name(lengthPrefixed, "lengthPrefixed");
+function ledgerLeafHash(index, record) {
+  return createHash("sha256").update(Buffer.from("pi-fusion-ledger-leaf-v1\0", "utf8")).update(uint64be(index)).update(lengthPrefixed(Buffer.from(canonicalJson(record), "utf8"))).digest();
+}
+__name(ledgerLeafHash, "ledgerLeafHash");
+function ledgerRootHash(leaves) {
+  const hash = createHash("sha256").update(Buffer.from("pi-fusion-ledger-root-v1\0", "utf8")).update(uint64be(leaves.length));
+  for (const leaf of leaves) hash.update(leaf);
+  return hash.digest("hex");
+}
+__name(ledgerRootHash, "ledgerRootHash");
+function unsupportedBlock(label) {
+  return new UnsupportedConversationBlockError(label);
+}
+__name(unsupportedBlock, "unsupportedBlock");
+function compactCounts(counts) {
+  const out = {};
+  if (counts.assistant_thinking > 0) out.assistant_thinking = counts.assistant_thinking;
+  if (counts.tool_calls > 0) out.tool_calls = counts.tool_calls;
+  if (counts.tool_result_texts > 0) out.tool_result_texts = counts.tool_result_texts;
+  return out;
+}
+__name(compactCounts, "compactCounts");
+function imageMarker(mimeType) {
+  return `${CONVERSATION_IMAGE_OMISSION_PREFIX}${mimeType}]`;
+}
+__name(imageMarker, "imageMarker");
+var ProjectionBuilder = class {
+  static {
+    __name(this, "ProjectionBuilder");
+  }
+  entries = [];
+  ledger = [];
+  leaves = [];
+  projectionMap = [];
+  toolCallNames = /* @__PURE__ */ new Map();
+  pendingCounts;
+  pendingBytes = 0;
+  pendingLedgerFirst = 0;
+  pendingLedgerLast = 0;
+  pendingSourceFirst = 0;
+  pendingSourceLast = 0;
+  includedUserTextBytes = 0;
+  includedAssistantTextBytes = 0;
+  includedImageMarkers = 0;
+  emptyTextBlocks = 0;
+  addText(entry) {
+    this.flush();
+    this.entries.push(entry);
+    if (entry.role === "user") this.includedUserTextBytes += utf8Bytes(entry.text);
+    else this.includedAssistantTextBytes += utf8Bytes(entry.text);
+  }
+  addOmission(sourceOrdinal, blockOrdinal, kind, payload, extra = {}) {
+    const index = this.ledger.length;
+    const record = {
+      index,
+      source_ordinal: sourceOrdinal,
+      block_ordinal: blockOrdinal,
+      kind,
+      payload_bytes: payload.length,
+      payload_sha256: sha256Hex(payload)
+    };
+    if (extra.toolName !== void 0) record.tool_name = extra.toolName;
+    if (extra.toolCallId !== void 0) record.tool_call_id = extra.toolCallId;
+    if (extra.mimeType !== void 0) record.mime_type = extra.mimeType;
+    this.ledger.push(record);
+    this.leaves.push(ledgerLeafHash(index, record));
+    if (extra.toolName !== void 0 && kind === "tool_call") {
+      this.toolCallNames.set(extra.toolName, (this.toolCallNames.get(extra.toolName) ?? 0) + 1);
+    }
+    if (kind === "tool_result_image") {
+      this.flush();
+      this.addLedgerOnlyImageMap(index);
+      return;
+    }
+    if (this.pendingCounts === void 0) {
+      this.pendingCounts = {
+        assistant_thinking: 0,
+        tool_calls: 0,
+        tool_result_texts: 0
+      };
+      this.pendingBytes = 0;
+      this.pendingLedgerFirst = index;
+      this.pendingSourceFirst = sourceOrdinal;
+    }
+    this.pendingLedgerLast = index;
+    this.pendingSourceLast = sourceOrdinal;
+    this.pendingBytes += payload.length;
+    if (kind === "assistant_thinking") this.pendingCounts.assistant_thinking += 1;
+    else if (kind === "tool_call") this.pendingCounts.tool_calls += 1;
+    else this.pendingCounts.tool_result_texts += 1;
+  }
+  addLedgerOnlyImageMap(index) {
+    const previous = this.projectionMap[this.projectionMap.length - 1];
+    if (previous !== void 0 && previous.entry_kind === "ledger_only_tool_result_image" && previous.ledger_index_last + 1 === index) {
+      previous.ledger_index_last = index;
+      return;
+    }
+    this.projectionMap.push({
+      entry_kind: "ledger_only_tool_result_image",
+      ledger_index_first: index,
+      ledger_index_last: index
+    });
+  }
+  flush() {
+    const counts = this.pendingCounts;
+    if (counts === void 0) return;
+    const canonicalEntryIndex = this.entries.length;
+    const entry = {
+      at: [this.pendingSourceFirst, this.pendingSourceLast],
+      bytes: this.pendingBytes,
+      counts: compactCounts(counts),
+      kind: "omitted_activity"
+    };
+    this.entries.push(entry);
+    this.projectionMap.push({
+      canonical_entry_index: canonicalEntryIndex,
+      entry_kind: "omitted_activity",
+      ledger_index_first: this.pendingLedgerFirst,
+      ledger_index_last: this.pendingLedgerLast
+    });
+    this.pendingCounts = void 0;
+    this.pendingBytes = 0;
+  }
+  finish(messageCount) {
+    this.flush();
+    const rootSha256 = ledgerRootHash(this.leaves);
+    let omittedRunCount = 0;
+    let includedTextEntries = 0;
+    let receiptBytes = 0;
+    for (const entry of this.entries) {
+      if (entry.kind === "text") includedTextEntries += 1;
+      else {
+        omittedRunCount += 1;
+        receiptBytes += utf8Bytes(canonicalJson(entry));
+      }
+    }
+    let thinkingBytes = 0;
+    let toolCallCount = 0;
+    let toolArgumentBytes = 0;
+    let toolResultTextCount = 0;
+    let toolResultTextBytes = 0;
+    let toolResultImageCount = 0;
+    let toolResultImageBytes = 0;
+    for (const row of this.ledger) {
+      if (row.kind === "assistant_thinking") thinkingBytes += row.payload_bytes;
+      else if (row.kind === "tool_call") {
+        toolCallCount += 1;
+        toolArgumentBytes += row.payload_bytes;
+      } else if (row.kind === "tool_result_text") {
+        toolResultTextCount += 1;
+        toolResultTextBytes += row.payload_bytes;
+      } else {
+        toolResultImageCount += 1;
+        toolResultImageBytes += row.payload_bytes;
+      }
+    }
+    const toolCallNames = [...this.toolCallNames.entries()].map(([name, calls]) => ({ name, calls })).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+    const accounting = {
+      message_count: messageCount,
+      included_text_entry_count: includedTextEntries,
+      included_user_text_bytes: this.includedUserTextBytes,
+      included_assistant_text_bytes: this.includedAssistantTextBytes,
+      included_image_marker_count: this.includedImageMarkers,
+      empty_text_block_count: this.emptyTextBlocks,
+      omitted_run_count: omittedRunCount,
+      omitted_event_count: this.ledger.length,
+      omitted_thinking_bytes: thinkingBytes,
+      omitted_tool_call_count: toolCallCount,
+      omitted_tool_call_argument_bytes: toolArgumentBytes,
+      omitted_tool_result_text_count: toolResultTextCount,
+      omitted_tool_result_text_bytes: toolResultTextBytes,
+      omitted_tool_result_image_count: toolResultImageCount,
+      omitted_tool_result_image_bytes: toolResultImageBytes,
+      tool_call_names: toolCallNames,
+      ledger_entry_count: this.ledger.length,
+      ledger_root_sha256: rootSha256,
+      omission_receipt_utf8_bytes: receiptBytes
+    };
+    return {
+      entries: this.entries,
+      accounting,
+      ledger: {
+        entries: this.ledger,
+        projection_map: this.projectionMap,
+        root_sha256: rootSha256
+      }
+    };
+  }
+};
+function projectUserMessage(builder, content, sourceOrdinal) {
+  if (typeof content === "string") {
+    if (content.length === 0) {
+      builder.emptyTextBlocks += 1;
+      return;
+    }
+    builder.addText({
+      kind: "text",
+      source_ordinal: sourceOrdinal,
+      block_ordinal: 0,
+      role: "user",
+      text: content
+    });
+    return;
+  }
+  for (const [blockOrdinal, block] of content.entries()) {
+    if (block.type === "text") {
+      if (block.text.length === 0) {
+        builder.emptyTextBlocks += 1;
+        continue;
+      }
+      builder.addText({
+        kind: "text",
+        source_ordinal: sourceOrdinal,
+        block_ordinal: blockOrdinal,
+        role: "user",
+        text: block.text
+      });
+      continue;
+    }
+    if (block.type === "image") {
+      builder.includedImageMarkers += 1;
+      builder.addText({
+        kind: "text",
+        source_ordinal: sourceOrdinal,
+        block_ordinal: blockOrdinal,
+        role: "user",
+        text: imageMarker(block.mimeType)
+      });
+      continue;
+    }
+    throw unsupportedBlock(`user block ${String(Reflect.get(block, "type"))}`);
+  }
+}
+__name(projectUserMessage, "projectUserMessage");
+function projectAssistantMessage(builder, content, sourceOrdinal) {
+  for (const [blockOrdinal, block] of content.entries()) {
+    if (block.type === "text") {
+      if (block.text.length === 0) {
+        builder.emptyTextBlocks += 1;
+        continue;
+      }
+      builder.addText({
+        kind: "text",
+        source_ordinal: sourceOrdinal,
+        block_ordinal: blockOrdinal,
+        role: "assistant",
+        text: block.text
+      });
+      continue;
+    }
+    if (block.type === "thinking") {
+      builder.addOmission(
+        sourceOrdinal,
+        blockOrdinal,
+        "assistant_thinking",
+        Buffer.from(block.thinking, "utf8")
+      );
+      continue;
+    }
+    if (block.type === "toolCall") {
+      builder.addOmission(
+        sourceOrdinal,
+        blockOrdinal,
+        "tool_call",
+        Buffer.from(canonicalJson(block.arguments), "utf8"),
+        { toolName: block.name, toolCallId: block.id }
+      );
+      continue;
+    }
+    throw unsupportedBlock(`assistant block ${String(Reflect.get(block, "type"))}`);
+  }
+}
+__name(projectAssistantMessage, "projectAssistantMessage");
+function projectToolResultMessage(builder, message, sourceOrdinal) {
+  const content = message.content;
+  if (typeof content === "string") {
+    builder.addOmission(sourceOrdinal, 0, "tool_result_text", Buffer.from(content, "utf8"), {
+      toolName: message.toolName,
+      toolCallId: message.toolCallId
+    });
+    return;
+  }
+  for (const [blockOrdinal, block] of content.entries()) {
+    if (block.type === "text") {
+      builder.addOmission(
+        sourceOrdinal,
+        blockOrdinal,
+        "tool_result_text",
+        Buffer.from(block.text, "utf8"),
+        { toolName: message.toolName, toolCallId: message.toolCallId }
+      );
+      continue;
+    }
+    if (block.type === "image") {
+      builder.addOmission(
+        sourceOrdinal,
+        blockOrdinal,
+        "tool_result_image",
+        Buffer.from(block.data, "utf8"),
+        {
+          toolName: message.toolName,
+          toolCallId: message.toolCallId,
+          mimeType: block.mimeType
+        }
+      );
+      continue;
+    }
+    throw unsupportedBlock(`tool result block ${String(Reflect.get(block, "type"))}`);
+  }
+}
+__name(projectToolResultMessage, "projectToolResultMessage");
+function projectVisibleConversationV2(messages) {
+  const builder = new ProjectionBuilder();
+  for (const [sourceOrdinal, message] of messages.entries()) {
+    if (message.role === "user") projectUserMessage(builder, message.content, sourceOrdinal);
+    else if (message.role === "assistant")
+      projectAssistantMessage(builder, message.content, sourceOrdinal);
+    else if (message.role === "toolResult")
+      projectToolResultMessage(builder, message, sourceOrdinal);
+    else throw unsupportedBlock(`message role ${String(Reflect.get(message, "role"))}`);
+  }
+  return builder.finish(messages.length);
+}
+__name(projectVisibleConversationV2, "projectVisibleConversationV2");
+
+// node_modules/pi-background-tasks/src/core/context/parent-snapshot.ts?ext=pi-background-tasks
+function isConversationMessage(message) {
+  switch (message.role) {
+    case "system":
+      return false;
+    case "user":
+    case "assistant":
+    case "toolResult":
+    case "custom":
+    case "bashExecution":
+    case "branchSummary":
+    case "compactionSummary":
+      return true;
+    default:
+      throw new UnsupportedConversationBlockError(`message role ${message.role}`);
+  }
+}
+__name(isConversationMessage, "isConversationMessage");
+function entriesById(entries) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of entries) byId.set(entry.id, entry);
+  return byId;
+}
+__name(entriesById, "entriesById");
+function readArray(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value : void 0;
+}
+__name(readArray, "readArray");
+function recordOf(value) {
+  if (!isJsonObject(value) || Array.isArray(value)) return void 0;
+  return value;
+}
+__name(recordOf, "recordOf");
+function entryMessage(entry) {
+  if (entry.type !== "message") return void 0;
+  return recordOf(entry.message);
+}
+__name(entryMessage, "entryMessage");
+function toolCallPartMatches(part, toolCallId, toolName) {
+  const record = recordOf(part);
+  if (record === void 0 || record["type"] !== "toolCall") return false;
+  if (toolCallId !== void 0) return record["id"] === toolCallId;
+  return record["name"] === toolName;
+}
+__name(toolCallPartMatches, "toolCallPartMatches");
+function messageContainsToolCall(message, toolCallId, toolName) {
+  if (message["role"] !== "assistant") return false;
+  const content = readArray(message, "content");
+  if (content === void 0) return false;
+  for (const part of content) {
+    if (toolCallPartMatches(part, toolCallId, toolName)) return true;
+  }
+  return false;
+}
+__name(messageContainsToolCall, "messageContainsToolCall");
+function effectiveLeafForTool(sessionManager, toolCallId, toolName) {
+  const leaf = sessionManager.getLeafEntry();
+  if (leaf === void 0)
+    return { leafId: sessionManager.getLeafId(), activeToolCallLeafExcluded: false };
+  const message = entryMessage(leaf);
+  if (message !== void 0 && messageContainsToolCall(message, toolCallId, toolName)) {
+    return { leafId: leaf.parentId, activeToolCallLeafExcluded: true };
+  }
+  return { leafId: sessionManager.getLeafId(), activeToolCallLeafExcluded: false };
+}
+__name(effectiveLeafForTool, "effectiveLeafForTool");
+function resolveEffectiveLeaf(sessionManager, options) {
+  if (!options.excludeActiveToolCallLeaf)
+    return { leafId: sessionManager.getLeafId(), activeToolCallLeafExcluded: false };
+  return effectiveLeafForTool(sessionManager, options.toolCallId, options.toolName);
+}
+__name(resolveEffectiveLeaf, "resolveEffectiveLeaf");
+function snapshotParentConversation(ctx, options) {
+  const entries = ctx.sessionManager.getEntries();
+  const leaf = resolveEffectiveLeaf(ctx.sessionManager, options);
+  const sessionContext = buildSessionContext(entries, leaf.leafId, entriesById(entries));
+  const conversation = sessionContext.messages.filter(isConversationMessage);
+  return {
+    systemPrompt: ctx.getSystemPrompt(),
+    messages: convertToLlm(conversation),
+    leafId: leaf.leafId,
+    activeToolCallLeafExcluded: leaf.activeToolCallLeafExcluded
+  };
+}
+__name(snapshotParentConversation, "snapshotParentConversation");
+
+export {
+  UnsupportedConversationBlockError,
+  projectVisibleConversationV2,
+  snapshotParentConversation
+};