@chroxify/eunoe 1.0.0 → 1.2.0

package/src/context/content.ts

@@ -1,14 +1,40 @@
-import { SUMMARY_ARGUMENT_CHARS, SUMMARY_COMMAND_CHARS } from "./constants"
-import type { Block, Message } from "./types"
+export type Block = { type: string; [key: string]: any }
+
+export type Message = { role: string; content: string | Block[] }
+
+export type Body = {
+  model?: string
+  system?: string | Block[]
+  messages: Message[]
+  tools?: unknown[]
+  metadata?: { user_id?: string }
+  [key: string]: any
+}
 
 export function contentBlocks(content: unknown): Block[] {
-  return typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : []
+  if (typeof content === "string") return [{ type: "text", text: content }]
+  return Array.isArray(content) ? content : []
 }
 
 export function blocks(message: Message): Block[] {
   return contentBlocks(message.content)
 }
 
+function joinedText(list: Block[]): string {
+  return list
+    .filter((b) => b.type === "text")
+    .map((b) => String(b.text ?? ""))
+    .join("\n")
+}
+
+export function textOf(message: Message): string {
+  return joinedText(blocks(message))
+}
+
+export function resultText(block: Block): string {
+  return typeof block.content === "string" ? block.content : joinedText(contentBlocks(block.content))
+}
+
 export function withoutCacheControl(block: Block): Block {
   if (!("cache_control" in block)) return block
   const { cache_control: _, ...rest } = block
@@ -19,28 +45,28 @@ export function clean(message: Message): Message {
   return { role: message.role, content: blocks(message).map(withoutCacheControl) }
 }
 
+export function shortHash(json: string, chars: number): string {
+  return new Bun.CryptoHasher("sha256").update(json).digest("hex").slice(0, chars)
+}
+
 export function truncate(text: string, max: number): string {
   const cut = text.slice(0, max)
   return /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut
 }
 
-export function wellFormed(_key: string, value: unknown): unknown {
-  return typeof value === "string" ? value.toWellFormed() : value
-}
-
 export function clip(value: unknown, max: number): string {
   const text = String(value).replace(/\s+/g, " ").trim()
   return text.length > max ? `${truncate(text, max)}…` : text
 }
 
+export function wellFormed(_key: string, value: unknown): unknown {
+  return typeof value === "string" ? value.toWellFormed() : value
+}
+
 export function describeToolCall(block: Block): string {
   const input = block.input ?? {}
-  if (typeof input.command === "string") return `${block.name} \`${clip(input.command, SUMMARY_COMMAND_CHARS)}\``
+  if (typeof input.command === "string") return `${block.name} \`${clip(input.command, 100)}\``
   if (typeof input.file_path === "string") return `${block.name} ${input.file_path}`
-  if (typeof input.pattern === "string") return `${block.name} "${clip(input.pattern, SUMMARY_ARGUMENT_CHARS)}"`
-  return `${block.name} ${clip(JSON.stringify(input), SUMMARY_ARGUMENT_CHARS)}`
-}
-
-export function resultText(block: Block): string {
-  return typeof block.content === "string" ? block.content : contentBlocks(block.content).filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n")
+  if (typeof input.pattern === "string") return `${block.name} "${clip(input.pattern, 60)}"`
+  return `${block.name} ${clip(JSON.stringify(input), 60)}`
 }

package/src/context/fold/evidence.ts

@@ -0,0 +1,145 @@
+import { type Block, blocks, clip, describeToolCall, type Message, resultText } from "../content"
+import { toolEvidence } from "../prompts"
+
+export interface EvidenceOptions {
+  linesPerCall?: number
+  lineChars?: number
+  turnChars?: number
+  scanLines?: number
+  minScore?: number
+  allTools?: boolean
+  ranked?: boolean
+  labels?: boolean
+  callFloor?: number
+}
+
+interface Scored {
+  index: number
+  line: string
+  score: number
+}
+
+interface Entry {
+  head: string
+  lines: string[]
+}
+
+export const REREADABLE_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "NotebookRead", "WebFetch", "WebSearch", "TodoWrite", "Edit", "Write", "MultiEdit", "NotebookEdit"])
+
+const ERROR_LINE = /\b(?:error|errors|fail|fails|failed|failure|fatal|exception|panic|denied|refused|timed? ?out|traceback|cannot|unable to)\b/i
+
+const ERROR_CODE =
+  /\b[A-Z][A-Z0-9]*_[A-Z0-9_]{2,}\b|\bSIG[A-Z]{2,}\d*\b|\b[A-Z]{2,}\d{2,}\b|\bE(?:NOENT|ACCES|PERM|EXIST|CONN(?:REFUSED|RESET|ABORTED)|PIPE|ADDRINUSE|TIMEDOUT|NOTFOUND|INVAL|BUSY|MFILE|AGAIN|HOSTUNREACH|NOTDIR|ISDIR|BADF|NOSPC|AI_[A-Z]+)\b/
+
+const VALUE_TOKEN =
+  /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{4,}\b|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\b\d+(?:\.\d+)?\s?(?:ms|s|[KMGT]i?B|kB|%)(?![a-z])|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+|\b\d+ (?:pass(?:ed|ing)?|fail(?:ed|ing)?|tests?|files? changed|insertions?|deletions?|rows?|errors?|warnings?)\b|[$€£]\d+(?:[.,]\d+)?|\b(?:status|HTTP\/\d(?:\.\d)?)\s*[:=]?\s*[45]\d{2}\b|\bexit(?: code| status)?\s*[:=]?\s*(?!0\b)\d{1,3}\b/i
+
+const ID_TOKEN = /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+/i
+
+const KEY_VALUE = /^[\w .\-/()]{2,48}[:=]\s*\S/
+
+const VALUE_LABEL = /\b(?:ids?|hash|sha(?:256)?|checksum|trace|deploy(?:ment)?|preview|url|version|rows|p9[59]|exit(?: code)?|signal|request[_-]?id|job|migration|applied|bundle|build|status|took|updated|created)\b/i
+
+function resolved(options: EvidenceOptions) {
+  return {
+    linesPerCall: options.linesPerCall ?? 12,
+    lineChars: options.lineChars ?? 220,
+    turnChars: options.turnChars ?? 4_000,
+    scanLines: options.scanLines ?? 1_000_000,
+    minScore: options.minScore ?? 2,
+    ranked: options.ranked ?? true,
+    labels: options.labels ?? true,
+    callFloor: options.callFloor ?? 2,
+  }
+}
+
+const isError = (line: string) => ERROR_LINE.test(line) || ERROR_CODE.test(line)
+
+export function isSalient(line: string): boolean {
+  return isError(line) || VALUE_TOKEN.test(line)
+}
+
+function scoreLines(text: string, options: EvidenceOptions): Scored[] {
+  const { scanLines, lineChars, minScore, labels } = resolved(options)
+  const scored = text
+    .split("\n")
+    .slice(0, scanLines)
+    .flatMap((raw, index) => {
+      const line = raw.trim()
+      if (line.length < 4) return []
+      const error = isError(line)
+      const value = VALUE_TOKEN.test(line)
+      if (!error && !value) return []
+      const score = (error ? 3 : 0) + (value ? (ID_TOKEN.test(line) ? 3 : 2) : 0) + (KEY_VALUE.test(line) ? 1 : 0) + (line.length < 120 ? 1 : 0) + (labels && VALUE_LABEL.test(line) ? 1 : 0)
+      return score >= minScore ? [{ index, line: clip(line, lineChars), score }] : []
+    })
+  const seen = new Set<string>()
+  return scored.sort((a, b) => b.score - a.score || a.index - b.index).filter((s) => !seen.has(s.line) && seen.add(s.line))
+}
+
+export function salientLines(text: string, options: EvidenceOptions = {}): string[] {
+  return scoreLines(text, options)
+    .slice(0, resolved(options).linesPerCall)
+    .sort((a, b) => a.index - b.index)
+    .map((s) => s.line)
+}
+
+export function toolPairs(turn: Message[]): Array<{ call: Block; result: Block }> {
+  const results = new Map<string, Block>()
+  for (const message of turn) {
+    if (message.role !== "user") continue
+    for (const block of blocks(message)) if (block.type === "tool_result") results.set(block.tool_use_id, block)
+  }
+  return turn
+    .filter((m) => m.role === "assistant")
+    .flatMap((m) => blocks(m).filter((b) => b.type === "tool_use"))
+    .flatMap((call) => {
+      const result = results.get(call.id)
+      return result ? [{ call, result }] : []
+    })
+}
+
+function render(entries: Entry[]): string | null {
+  const shown = entries.filter((e) => e.lines.length > 0).map((e) => `- ${e.head}:\n${e.lines.map((l) => `    ${l}`).join("\n")}`)
+  return shown.length > 0 ? toolEvidence(shown) : null
+}
+
+function inCallOrder(heads: string[], pairs: Array<{ result: Block }>, options: EvidenceOptions): Entry[] {
+  const { turnChars } = resolved(options)
+  const entries: Entry[] = []
+  let used = 0
+  pairs.forEach(({ result }, i) => {
+    const lines = salientLines(resultText(result), options)
+    if (lines.length === 0) return
+    const size = heads[i].length + 4 + lines.reduce((s, l) => s + l.length + 5, 0)
+    if (used + size > turnChars) return
+    entries.push({ head: heads[i], lines })
+    used += size
+  })
+  return entries
+}
+
+function byScore(heads: string[], pairs: Array<{ result: Block }>, options: EvidenceOptions): Entry[] {
+  const { turnChars, linesPerCall, callFloor } = resolved(options)
+  const perCall = pairs.map(({ result }) => scoreLines(resultText(result), options))
+  const chosen = new Map<number, Scored[]>()
+  let used = 0
+  const take = (call: number, line: Scored) => {
+    const bucket = chosen.get(call) ?? []
+    const cost = line.line.length + 5 + (bucket.length > 0 ? 0 : heads[call].length + 4)
+    if (bucket.length >= linesPerCall || used + cost > turnChars) return
+    bucket.push(line)
+    chosen.set(call, bucket)
+    used += cost
+  }
+  for (const [call, lines] of perCall.entries()) for (const line of lines.slice(0, callFloor)) take(call, line)
+  const rest = perCall.flatMap((lines, call) => lines.slice(callFloor).map((line) => ({ line, call }))).sort((a, b) => b.line.score - a.line.score || a.call - b.call || a.line.index - b.line.index)
+  for (const { line, call } of rest) take(call, line)
+  return heads.map((head, i) => ({ head, lines: (chosen.get(i) ?? []).sort((a, b) => a.index - b.index).map((s) => s.line) }))
+}
+
+export function turnEvidence(turn: Message[], options: EvidenceOptions = {}): string | null {
+  const pairs = toolPairs(turn).filter(({ call }) => options.allTools || !REREADABLE_TOOLS.has(call.name))
+  const heads = pairs.map(({ call, result }) => `${describeToolCall(call)}${result.is_error ? " (failed)" : ""}`)
+  return render(resolved(options).ranked ? byScore(heads, pairs, options) : inCallOrder(heads, pairs, options))
+}

package/src/context/fold/index.ts

@@ -0,0 +1,65 @@
+import { type Message, textOf } from "../content"
+import { type RecallChunk, recallChunks, terms } from "../recall"
+import { isPrompt, reduceTurn, splitTurns } from "./turns"
+
+export interface FoldedTurn {
+  user: string
+  evidence: string
+  reply: string
+}
+
+export const FOLD_CAP_CHARS = 400_000
+
+const spoken = (message: Message) =>
+  textOf(message)
+    .replace(/<(system-reminder|system-message|recalled-context|handoff)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, "")
+    .trim()
+
+const isEvidence = (text: string) => text.startsWith("<tool-evidence>")
+
+export function foldedTurns(messages: Message[]): FoldedTurn[] {
+  return splitTurns(messages)
+    .turns.filter((turn) => isPrompt(turn[0]))
+    .map((turn) => {
+      const reduced = reduceTurn(turn, { evidence: true })
+      const users = reduced.filter((m) => m.role === "user").map(spoken)
+      return {
+        user: users.filter((t) => t && !isEvidence(t)).join("\n\n"),
+        evidence: users.filter(isEvidence).join("\n"),
+        reply: reduced
+          .filter((m) => m.role === "assistant")
+          .map(spoken)
+          .join("\n"),
+      }
+    })
+}
+
+function renderTurn(turn: FoldedTurn, index: number, full: boolean): string {
+  const parts = [`### Turn ${index + 1}`, `**You:** ${turn.user}`]
+  if (full && turn.evidence) parts.push(turn.evidence)
+  if (full && turn.reply) parts.push(`**Agent:** ${turn.reply}`)
+  return parts.join("\n\n")
+}
+
+export function foldedView(messages: Message[], cap = Number.POSITIVE_INFINITY): string {
+  const turns = foldedTurns(messages)
+  const full = new Set<number>()
+  let used = 0
+  for (let i = turns.length - 1; i >= 0; i -= 1) {
+    const size = renderTurn(turns[i], i, true).length
+    if (used + size > cap) break
+    full.add(i)
+    used += size
+  }
+  return turns.map((turn, i) => renderTurn(turn, i, full.has(i))).join("\n\n")
+}
+
+export function sourceChunks(messages: Message[], from: string, users = false): RecallChunk[] {
+  const chunks = recallChunks([...messages, { role: "user", content: "" }], new Map()).map((chunk) => ({ ...chunk, from }))
+  if (!users) return chunks
+  const said = splitTurns(messages)
+    .turns.filter((turn) => isPrompt(turn[0]))
+    .map((turn, i) => ({ turn: i + 1, text: spoken(turn[0]) }))
+    .filter((t) => t.text)
+  return [...said.map((t) => ({ turn: t.turn, from, call: "you", lines: t.text.split("\n"), terms: terms(t.text) })), ...chunks]
+}

package/src/context/fold/strategies.ts

@@ -0,0 +1,94 @@
+import { type Block, type Body, blocks, type Message, truncate, withoutCacheControl } from "../content"
+import { clearedInput, compactionNotice, truncationNotice } from "../prompts"
+import { hasContent, isHarness, type ReduceOptions, reduceTurn, splitTurns } from "./turns"
+
+export interface CompactOptions extends ReduceOptions {
+  keepTurns: number
+  capChars?: number
+  guide: string | null
+  omittedBefore?: number
+  reduce?: (turn: Message[], options: ReduceOptions) => Message[]
+}
+
+export function trimMessages(messages: Message[], options: ReduceOptions = {}): Message[] {
+  const { preamble, turns } = splitTurns(messages)
+  if (turns.length < 2) return messages
+  return [...preamble, ...turns.slice(0, -1).flatMap((turn) => reduceTurn(turn, options)), ...(turns.at(-1) ?? [])]
+}
+
+export function compactMessages(messages: Message[], cutIndex: number, options: CompactOptions): Message[] {
+  const { preamble, turns } = splitTurns(messages)
+  if (cutIndex <= 0 || cutIndex >= turns.length) return messages
+  const reduce = options.reduce ?? reduceTurn
+  const keptFrom = Math.max(1, cutIndex - options.keepTurns)
+  const notice = compactionNotice({ omitted: keptFrom - 1 + (options.omittedBefore ?? 0), kept: cutIndex - keptFrom, guide: options.guide })
+  const removed = [...turns[0].slice(1), ...turns.slice(1, keptFrom).flat()]
+  const carried = removed
+    .filter((m) => isHarness(m) && hasContent(m))
+    .flatMap((m) => blocks(m).filter((b) => b.type === "text"))
+    .map((b) => ({ type: "text", text: `<system-reminder>\n${b.text}\n</system-reminder>` }))
+  return [...preamble, turns[0][0], { role: "user", content: [{ type: "text", text: notice }, ...carried] }, ...turns.slice(keptFrom, cutIndex).flatMap((turn) => reduce(turn, options)), ...turns.slice(cutIndex).flat()]
+}
+
+export function capTurns(messages: Message[], options: CompactOptions): Message[] {
+  const { capChars } = options
+  if (!capChars) return messages
+  const { preamble, turns } = splitTurns(messages)
+  if (turns.length < 3) return messages
+  const live = turns.length - 1
+  const over = (turn: Message[], i: number) => i > 0 && i < live && JSON.stringify(turn).length > capChars
+  if (!turns.some(over)) return messages
+  const reduce = options.reduce ?? reduceTurn
+  return [...preamble, ...turns.flatMap((turn, i) => (over(turn, i) ? reduce(turn, options) : turn))]
+}
+
+export function tailMessages(messages: Message[], from: number, guide: string | null): Message[] {
+  const { preamble, turns } = splitTurns(messages)
+  if (turns.length === 0 || from <= 1) return messages
+  const notice = truncationNotice({ omitted: from - 1, kept: turns.length - from, guide })
+  return [...preamble, turns[0][0], { role: "user", content: [{ type: "text", text: notice }] }, ...turns.slice(from).flat()]
+}
+
+export function countToolResults(messages: Message[], from: number): number {
+  return messages
+    .slice(from)
+    .filter((m) => m.role === "user")
+    .reduce((total, m) => total + blocks(m).filter((b) => b.type === "tool_result").length, 0)
+}
+
+function shortenInput(input: unknown): unknown {
+  if (typeof input === "string") return input.length > 2_000 ? clearedInput(truncate(input, 500), input.length - 500) : input
+  if (Array.isArray(input)) return input.map(shortenInput)
+  if (input && typeof input === "object") return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, shortenInput(v)]))
+  return input
+}
+
+export function clearToolResults(messages: Message[], from: number, count: number, placeholder: string): Message[] {
+  let left = count
+  const cleared = new Set<string>()
+  const clearResult = (b: Block): Block => {
+    if (b.type !== "tool_result" || left <= 0) return b
+    left -= 1
+    cleared.add(b.tool_use_id)
+    return { type: "tool_result", tool_use_id: b.tool_use_id, ...(b.is_error ? { is_error: true } : {}), content: placeholder }
+  }
+  const withResultsCleared = messages.map((message, index) => {
+    if (left <= 0 || index < from || message.role !== "user" || typeof message.content === "string") return message
+    if (!message.content.some((b) => b.type === "tool_result")) return message
+    return { ...message, content: message.content.map(clearResult) }
+  })
+  const isClearedCall = (b: Block) => b.type === "tool_use" && cleared.has(b.id)
+  return withResultsCleared.map((message) => {
+    if (message.role !== "assistant" || typeof message.content === "string" || !message.content.some(isClearedCall)) return message
+    return { ...message, content: message.content.map((b) => (isClearedCall(b) ? { ...b, input: shortenInput(b.input) } : b)) }
+  })
+}
+
+export function appendSystem(system: Body["system"], text: string): Block[] {
+  const list: Block[] = typeof system === "string" ? [{ type: "text", text: system }] : [...(system ?? [])]
+  const lastCached = list.findLastIndex((b) => b.cache_control)
+  const cacheControl = lastCached >= 0 ? list[lastCached].cache_control : undefined
+  if (lastCached >= 0) list[lastCached] = withoutCacheControl(list[lastCached])
+  list.push({ type: "text", text, ...(cacheControl ? { cache_control: cacheControl } : {}) })
+  return list
+}

package/src/context/fold/turns.ts

@@ -0,0 +1,76 @@
+import { type Block, blocks, clean, describeToolCall, type Message, shortHash, textOf, withoutCacheControl } from "../content"
+import { interruptedReply } from "../prompts"
+import { turnEvidence } from "./evidence"
+
+export interface ReduceOptions {
+  evidence?: boolean
+}
+
+export function isPrompt(message: Message) {
+  if (message.role !== "user") return false
+  const content = blocks(message)
+  return !content.some((block) => block.type === "tool_result") && content.some((block) => block.type === "text" || block.type === "image" || block.type === "document")
+}
+
+export function splitTurns(messages: Message[]): { preamble: Message[]; turns: Message[][] } {
+  const preamble: Message[] = []
+  const turns: Message[][] = []
+  for (const message of messages) {
+    const current = turns.at(-1)
+    if (isPrompt(message) && !current?.every((m) => m.role === "user")) turns.push([message])
+    else if (current) current.push(message)
+    else preamble.push(message)
+  }
+  return { preamble, turns }
+}
+
+export function turnFingerprint(turn: Message[]): string {
+  return shortHash(JSON.stringify(blocks(turn[0]).map(withoutCacheControl)), 24)
+}
+
+export function isHarness(message: Message) {
+  return message.role === "system"
+}
+
+export function hasContent(message: Message) {
+  return blocks(message).some((block) => block.type !== "text" || String(block.text ?? "").trim())
+}
+
+const hasText = (block: Block) => block.type === "text" && String(block.text ?? "").trim() !== ""
+
+function mergedHarness(turn: Message[]): Message[] {
+  const content = turn.filter((m) => isHarness(m) && hasContent(m)).flatMap((m) => blocks(m).map(withoutCacheControl))
+  return content.length > 0 ? [{ role: "system", content }] : []
+}
+
+function interrupted(turn: Message[]): string {
+  const assistant = turn.filter((m) => m.role === "assistant")
+  const lastWords = assistant
+    .map((m) => textOf(m).trim())
+    .filter(Boolean)
+    .at(-1)
+  const calls = assistant.flatMap((m) => blocks(m).filter((b) => b.type === "tool_use")).map(describeToolCall)
+  return interruptedReply(lastWords, calls)
+}
+
+function carriedText(messages: Message[]): Block[] {
+  return messages
+    .filter((m) => m.role === "user")
+    .flatMap((m) => blocks(m).filter((b) => hasText(b) && !/^\s*(?:<system-reminder>[\s\S]*?<\/system-reminder>\s*)+$/.test(String(b.text))))
+    .map((b) => ({ type: "text", text: b.text }))
+}
+
+export function reduceTurn(turn: Message[], options: ReduceOptions = {}): Message[] {
+  const firstReply = turn.findIndex((m) => m.role === "assistant")
+  const opening = (firstReply === -1 ? turn : turn.slice(0, firstReply)).filter((m) => m.role === "user").map(clean)
+  const carried = carriedText(firstReply === -1 ? [] : turn.slice(firstReply))
+  if (carried.length > 0) opening.push({ role: "user", content: carried })
+  const evidence = options.evidence ? turnEvidence(turn) : null
+  if (evidence) opening.push({ role: "user", content: [{ type: "text", text: evidence }] })
+  opening.push(...mergedHarness(turn))
+  const last = turn.findLast((m) => m.role !== "system")
+  const content = last?.role === "assistant" ? blocks(last) : []
+  const text = content.filter(hasText)
+  const final = text.length > 0 && !content.some((b) => b.type === "tool_use") ? text.map((b) => ({ type: "text", text: b.text })) : [{ type: "text", text: interrupted(turn) }]
+  return [...opening, { role: "assistant", content: final }]
+}