pi-cliffcompaction 0.1.0

package/lib/dialects/base.ts

@@ -0,0 +1,79 @@
+/**
+ * Dialect interface and shared summary helpers.
+ *
+ * The marker by which a previously injected summary is recognized (and
+ * dropped on re-compaction). Keep it stable: changing a byte breaks
+ * recognition of summaries produced by earlier versions.
+ */
+
+import type { Config } from "../config.ts";
+import type { JsonObject } from "../decode.ts";
+
+export const SUMMARY_HEADER =
+  "The following is a summary of your previous actions (long observations omitted):";
+
+export const PI_COMPACTION_PREFIX =
+  "The conversation history before this point was compacted into the following summary:";
+
+const TASK_NOTIFICATION_RE = /<task-notification>[\s\S]*?<\/task-notification>\s*/g;
+
+export function stripTaskNotifications(text: string): string {
+  return text.replace(TASK_NOTIFICATION_RE, "");
+}
+
+/** Truncate with ellipsis; maxChars <= 0 means unlimited. */
+export function truncate(text: string, maxChars: number): string {
+  const value = text || "";
+
+  if (maxChars && maxChars > 0 && value.length > maxChars) {
+    return value.slice(0, maxChars) + "...";
+  }
+
+  return value;
+}
+
+export function startsWithSummaryHeader(text: string): boolean {
+  return text.startsWith(SUMMARY_HEADER) || text.startsWith(PI_COMPACTION_PREFIX);
+}
+
+export type Dialect = {
+  name: string;
+  digestMessage: (msg: JsonObject) => string;
+  isAssistant: (msg: JsonObject) => boolean;
+  summarizeMessage: (msg: JsonObject, cfg: Config) => string[];
+  userMessage: (text: string) => JsonObject;
+  isSummaryMessage: (msg: JsonObject) => boolean;
+  sessionKey: (body: JsonObject) => string | null;
+  messagesKey: string;
+  groupTurns: ((body: JsonObject[]) => JsonObject[][]) | null;
+  trimFromHead: ((msg: JsonObject) => boolean) | null;
+  openingUserMessages: number;
+};
+
+export function makeDialect(partial: {
+  name: string;
+  digestMessage: (msg: JsonObject) => string;
+  isAssistant: (msg: JsonObject) => boolean;
+  summarizeMessage: (msg: JsonObject, cfg: Config) => string[];
+  userMessage: (text: string) => JsonObject;
+  isSummaryMessage: (msg: JsonObject) => boolean;
+  sessionKey: (body: JsonObject) => string | null;
+  messagesKey?: string;
+  groupTurns?: ((body: JsonObject[]) => JsonObject[][]) | null;
+  trimFromHead?: ((msg: JsonObject) => boolean) | null;
+  openingUserMessages?: number;
+}): Dialect {
+  return {
+    name: partial.name,
+    digestMessage: partial.digestMessage,
+    isAssistant: partial.isAssistant,
+    summarizeMessage: partial.summarizeMessage,
+    userMessage: partial.userMessage,
+    isSummaryMessage: partial.isSummaryMessage,
+    sessionKey: partial.sessionKey,
+    messagesKey: partial.messagesKey ?? "messages",
+    groupTurns: partial.groupTurns ?? null,
+    trimFromHead: partial.trimFromHead ?? null,
+    openingUserMessages: partial.openingUserMessages ?? 1,
+  };
+}

package/lib/dialects/index.ts

@@ -0,0 +1,48 @@
+/**
+ * API dialects: Anthropic Messages, OpenAI Chat Completions, OpenAI
+ * Responses, and Pi agent messages.
+ */
+
+import { DIALECT as anthropic } from "./anthropic.ts";
+import { DIALECT as openaiChat } from "./openai-chat.ts";
+import { DIALECT as openaiResponses } from "./openai-responses.ts";
+import { DIALECT as pi } from "./pi.ts";
+import type { Dialect } from "./base.ts";
+
+export type { Dialect } from "./base.ts";
+
+export { SUMMARY_HEADER, PI_COMPACTION_PREFIX, truncate, stripTaskNotifications } from "./base.ts";
+
+export { DIALECT as anthropicDialect } from "./anthropic.ts";
+
+export { DIALECT as openaiChatDialect } from "./openai-chat.ts";
+
+export { DIALECT as openaiResponsesDialect } from "./openai-responses.ts";
+
+export { DIALECT as piDialect } from "./pi.ts";
+
+/**
+ * Pick the dialect for a request path, or null for raw passthrough.
+ * /v1/messages/count_tokens is deliberately not matched.
+ */
+export function detect(path: string): Dialect | null {
+  const p = path.replace(/\/+$/, "");
+
+  if (p.endsWith("/v1/messages") || p.endsWith("/messages")) {
+    return anthropic;
+  }
+
+  if (p.endsWith("/chat/completions")) {
+    return openaiChat;
+  }
+
+  if (p.endsWith("/responses")) {
+    return openaiResponses;
+  }
+
+  if (p === "pi" || p.endsWith("/pi")) {
+    return pi;
+  }
+
+  return null;
+}

package/lib/dialects/openai-chat.ts

@@ -0,0 +1,225 @@
+/**
+ * OpenAI Chat Completions dialect.
+ *
+ * Tool results have role "tool". Assistant tool calls live in tool_calls
+ * (function name + JSON-string arguments); assistant content is the
+ * visible thought.
+ */
+
+import type { Config } from "../config.ts";
+import {
+  asArray,
+  asObject,
+  asString,
+  isArray,
+  isRecord,
+  isString,
+  type JsonArray,
+  type JsonObject,
+  type JsonValue,
+} from "../decode.ts";
+import { digestBytes, digestObj } from "../hashing.ts";
+import { canonicalJson } from "../json.ts";
+import {
+  makeDialect,
+  startsWithSummaryHeader,
+  stripTaskNotifications,
+  truncate,
+  type Dialect,
+} from "./base.ts";
+
+function canonPart(part: JsonObject): JsonArray {
+  const t = asString(part.type);
+
+  if (t === "text") {
+    return ["text", asString(part.text)];
+  }
+
+  if (t === "image_url") {
+    const url = asString(asObject(part.image_url)?.url);
+
+    return ["image", digestBytes(url)];
+  }
+
+  return ["other", canonicalJson(part)];
+}
+
+export function contentText(content: JsonValue | undefined): string {
+  if (isString(content)) {
+    return content;
+  }
+
+  if (isArray(content)) {
+    const parts: string[] = [];
+
+    for (const p of content) {
+      if (isRecord(p) && asString(p.type) === "text") {
+        parts.push(asString(p.text));
+      }
+    }
+
+    return parts.join("\n");
+  }
+
+  if (content === undefined || content === null) {
+    return "";
+  }
+
+  return String(content);
+}
+
+export function digestMessage(msg: JsonObject): string {
+  const content = msg.content;
+  let blocks: JsonArray = [];
+
+  if (isString(content)) {
+    blocks = [["text", content]];
+  } else if (isArray(content)) {
+    const out: JsonArray = [];
+
+    for (const p of content) {
+      if (isRecord(p)) {
+        out.push(canonPart(p));
+      }
+    }
+
+    blocks = out;
+  }
+
+  const toolCalls: JsonArray = [];
+
+  for (const tc of asArray(msg.tool_calls)) {
+    if (!isRecord(tc)) {
+      continue;
+    }
+
+    const fn = asObject(tc.function) ?? {};
+    toolCalls.push([asString(tc.id), asString(fn.name), asString(fn.arguments)]);
+  }
+
+  return digestObj([
+    asString(msg.role),
+    blocks,
+    toolCalls,
+    asString(msg.tool_call_id),
+    asString(msg.name),
+  ]);
+}
+
+export function isAssistant(msg: JsonObject): boolean {
+  return asString(msg.role) === "assistant";
+}
+
+export function isSummaryMessage(msg: JsonObject): boolean {
+  return asString(msg.role) === "user" && startsWithSummaryHeader(contentText(msg.content));
+}
+
+export function sessionKey(_body: JsonObject): string | null {
+  return null;
+}
+
+function summarizeAssistant(msg: JsonObject, cfg: Config): string[] {
+  let thinking = "";
+
+  if (cfg.keepThinking) {
+    const raw = msg.reasoning_content ?? msg.reasoning;
+
+    if (isString(raw)) {
+      thinking = truncate(raw.trim(), cfg.thinkingMaxChars);
+    }
+  }
+
+  const thought = truncate(contentText(msg.content).trim(), cfg.thoughtMaxChars);
+  const sigs: string[] = [];
+
+  for (const tc of asArray(msg.tool_calls)) {
+    if (!isRecord(tc)) {
+      continue;
+    }
+
+    const fn = asObject(tc.function) ?? {};
+    let args = fn.arguments;
+
+    if (!isString(args)) {
+      args = canonicalJson(args ?? "");
+    }
+
+    sigs.push("[" + asString(fn.name, "?") + "] " + truncate(args, cfg.cmdMaxChars));
+  }
+
+  const lines: string[] = [];
+
+  if (thinking) {
+    lines.push("thinking: " + thinking);
+  }
+
+  if (thought) {
+    lines.push("assistant: " + thought);
+  }
+
+  if (sigs.length > 0) {
+    lines.push(sigs.join("\n"));
+  }
+
+  return lines.length > 0 ? [lines.join("\n")] : [];
+}
+
+export function summarizeMessage(msg: JsonObject, cfg: Config): string[] {
+  const role = asString(msg.role);
+
+  if (role === "assistant") {
+    return summarizeAssistant(msg, cfg);
+  }
+
+  if (role === "tool") {
+    const text = contentText(msg.content).trim();
+
+    if (text && text.length <= cfg.resultMaxChars) {
+      return ["result: " + text];
+    }
+
+    return [];
+  }
+
+  if (role === "user") {
+    let text = contentText(msg.content).trim();
+
+    if (!text || startsWithSummaryHeader(text)) {
+      return [];
+    }
+
+    text = stripTaskNotifications(text).trim();
+
+    if (!text) {
+      return [];
+    }
+
+    return ["user: " + truncate(text, cfg.humanMaxChars)];
+  }
+
+  if (role === "system" || role === "developer") {
+    const text = contentText(msg.content).trim();
+
+    if (!text) {
+      return [];
+    }
+
+    return [role + ": " + truncate(text, cfg.humanMaxChars)];
+  }
+
+  return [];
+}
+
+export function userMessage(text: string): JsonObject {
+  return { role: "user", content: text };
+}
+
+export const DIALECT: Dialect = makeDialect({
+  name: "openai",
+  digestMessage,
+  isAssistant,
+  summarizeMessage,
+  userMessage,
+  isSummaryMessage,
+  sessionKey,
+});

package/lib/dialects/openai-responses.ts

@@ -0,0 +1,331 @@
+/**
+ * OpenAI Responses API dialect (stateless clients: full `input` resent).
+ *
+ * A model step spans MULTIPLE items: [reasoning?] then message/function_call,
+ * followed by function_call_output items. Turn grouping keeps contiguous
+ * model-output runs together.
+ */
+
+import type { Config } from "../config.ts";
+import {
+  asArray,
+  asObject,
+  asString,
+  isArray,
+  isRecord,
+  isString,
+  type JsonArray,
+  type JsonObject,
+  type JsonValue,
+} from "../decode.ts";
+import { digestObj } from "../hashing.ts";
+import { canonicalJson } from "../json.ts";
+import {
+  makeDialect,
+  startsWithSummaryHeader,
+  stripTaskNotifications,
+  truncate,
+  type Dialect,
+} from "./base.ts";
+
+const MODEL_ITEM_TYPES = new Set([
+  "reasoning",
+  "function_call",
+  "custom_tool_call",
+  "local_shell_call",
+  "web_search_call",
+  "tool_search_call",
+  "image_generation_call",
+]);
+
+function itemType(item: JsonObject): string {
+  const t = asString(item.type);
+
+  if (t) {
+    return t;
+  }
+
+  return Object.prototype.hasOwnProperty.call(item, "role") ? "message" : "other";
+}
+
+function isModelOutput(item: JsonObject): boolean {
+  const t = itemType(item);
+
+  if (t === "message") {
+    return asString(item.role) === "assistant";
+  }
+
+  return MODEL_ITEM_TYPES.has(t);
+}
+
+function contentText(content: JsonValue | undefined): string {
+  if (isString(content)) {
+    return content;
+  }
+
+  if (isArray(content)) {
+    const parts: string[] = [];
+
+    for (const p of content) {
+      if (!isRecord(p)) {
+        continue;
+      }
+
+      const t = asString(p.type);
+
+      if (t === "input_text" || t === "output_text" || t === "text") {
+        parts.push(asString(p.text));
+      }
+    }
+
+    return parts.join("\n");
+  }
+
+  if (content === undefined || content === null) {
+    return "";
+  }
+
+  return String(content);
+}
+
+function canonContent(content: JsonValue | undefined): JsonArray {
+  if (isString(content)) {
+    return [["text", content]];
+  }
+
+  if (isArray(content)) {
+    const out: JsonArray = [];
+
+    for (const p of content) {
+      if (!isRecord(p)) {
+        continue;
+      }
+
+      const t = asString(p.type);
+
+      if (t === "input_text" || t === "output_text" || t === "text") {
+        out.push(["text", asString(p.text)]);
+      } else {
+        out.push(["other", canonicalJson(p)]);
+      }
+    }
+
+    return out;
+  }
+
+  return [];
+}
+
+export function digestMessage(item: JsonObject): string {
+  const t = itemType(item);
+
+  if (t === "message") {
+    return digestObj(["message", asString(item.role), canonContent(item.content)]);
+  }
+
+  if (t === "reasoning") {
+    return digestObj([
+      "reasoning",
+      asString(item.encrypted_content),
+      canonicalJson(item.summary ?? []),
+    ]);
+  }
+
+  if (t === "function_call_output") {
+    let out = item.output;
+
+    if (!isString(out)) {
+      out = canonicalJson(out ?? null);
+    }
+
+    return digestObj(["function_call_output", asString(item.call_id), out]);
+  }
+
+  if (t.endsWith("_call") || t === "function_call") {
+    let args = item.arguments;
+
+    if (!isString(args)) {
+      args = canonicalJson(args ?? "");
+    }
+
+    return digestObj([t, asString(item.call_id), asString(item.name), args]);
+  }
+
+  const stripped: JsonObject = {};
+
+  for (const key of Object.keys(item)) {
+    if (key !== "id" && key !== "status") {
+      stripped[key] = item[key];
+    }
+  }
+
+  return digestObj(["other", canonicalJson(stripped)]);
+}
+
+export function isAssistant(item: JsonObject): boolean {
+  return isModelOutput(item);
+}
+
+export function isSummaryMessage(item: JsonObject): boolean {
+  return (
+    itemType(item) === "message" &&
+    asString(item.role) === "user" &&
+    startsWithSummaryHeader(contentText(item.content))
+  );
+}
+
+export function groupTurns(items: JsonObject[]): JsonObject[][] {
+  const turns: JsonObject[][] = [];
+  let current: JsonObject[] | null = null;
+  let prevModel = false;
+
+  for (const item of items) {
+    const model = isModelOutput(item);
+
+    if (model && !prevModel) {
+      if (current !== null) {
+        turns.push(current);
+      }
+
+      current = [item];
+    } else if (current === null) {
+      current = [item];
+    } else {
+      current.push(item);
+    }
+
+    prevModel = model;
+  }
+
+  if (current !== null) {
+    turns.push(current);
+  }
+
+  return turns;
+}
+
+export function sessionKey(body: JsonObject): string | null {
+  const key = body.prompt_cache_key;
+
+  if (isString(key) && key) {
+    return key;
+  }
+
+  const meta = asObject(body.client_metadata);
+
+  if (meta !== null) {
+    const tid = meta.thread_id;
+
+    if (isString(tid) && tid) {
+      return tid;
+    }
+  }
+
+  return null;
+}
+
+export function summarizeMessage(item: JsonObject, cfg: Config): string[] {
+  const t = itemType(item);
+
+  if (t === "message") {
+    const role = asString(item.role);
+    let text = contentText(item.content).trim();
+
+    if (!text) {
+      return [];
+    }
+
+    if (role === "assistant") {
+      return ["assistant: " + truncate(text, cfg.thoughtMaxChars)];
+    }
+
+    if (startsWithSummaryHeader(text)) {
+      return [];
+    }
+
+    if (role === "user") {
+      text = stripTaskNotifications(text).trim();
+
+      if (!text) {
+        return [];
+      }
+
+      return ["user: " + truncate(text, cfg.humanMaxChars)];
+    }
+
+    return [role + ": " + truncate(text, cfg.humanMaxChars)];
+  }
+
+  if (t === "reasoning") {
+    if (!cfg.keepThinking) {
+      return [];
+    }
+
+    const bits: string[] = [];
+
+    for (const p of asArray(item.summary)) {
+      if (isRecord(p)) {
+        bits.push(asString(p.text));
+      }
+    }
+
+    const text = bits.join("\n").trim();
+
+    if (!text) {
+      return [];
+    }
+
+    return ["thinking: " + truncate(text, cfg.thinkingMaxChars)];
+  }
+
+  if (t === "function_call_output") {
+    let out = item.output;
+
+    if (!isString(out)) {
+      out = contentText(out) || canonicalJson(out ?? null);
+    }
+
+    out = out.trim();
+
+    if (out && out.length <= cfg.resultMaxChars) {
+      return ["result: " + out];
+    }
+
+    return [];
+  }
+
+  if (t.endsWith("_call")) {
+    let args = item.arguments;
+
+    if (!isString(args)) {
+      args = canonicalJson(args ?? "");
+    }
+
+    const name = asString(item.name) || t;
+
+    return ["[" + name + "] " + truncate(args, cfg.cmdMaxChars)];
+  }
+
+  return [];
+}
+
+export function userMessage(text: string): JsonObject {
+  return {
+    type: "message",
+    role: "user",
+    content: [{ type: "input_text", text }],
+  };
+}
+
+export const DIALECT: Dialect = makeDialect({
+  name: "openai-responses",
+  digestMessage,
+  isAssistant,
+  summarizeMessage,
+  userMessage,
+  isSummaryMessage,
+  sessionKey,
+  openingUserMessages: 2,
+  messagesKey: "input",
+  groupTurns,
+});