karajan-code 1.58.2 → 1.59.1

package/src/mcp/handlers/run-handler.js

@@ -8,6 +8,7 @@ import { runFlow, resumeFlow } from "../../orchestrator.js";
 import { loadConfig, applyRunOverrides, validateConfig, resolveRole } from "../../config.js";
 import { createLogger } from "../../utils/logger.js";
 import { assertAgentsAvailable } from "../../agents/availability.js";
+import { validatePolicyCompliance } from "../../guards/policy-guard.js";
 import { createRunLog } from "../../utils/run-log.js";
 import { buildProgressHandler, buildProgressNotifier, buildPipelineTracker } from "../progress.js";
 import { isPreflightAcked, ackPreflight, getSessionOverrides } from "../preflight.js";
@@ -113,7 +114,7 @@ function collectRequiredProviders(config) {
 
 export async function handleRunDirect(a, server, extra) {
   const config = await buildConfig(a);
-  await assertNotOnBaseBranch(config);
+  await assertNotOnBaseBranch(config, { allowForRun: true });
   const logger = createLogger(config.output.log_level, "mcp");
 
   // Best-effort session cleanup before starting
@@ -203,7 +204,7 @@ const RESUME_INJECTION_PATTERNS = [
   /force\s+(approve|merge|push|commit)\b/i,
 ];
 
-export function validateResumeAnswer(answer) {
+export function validateResumeAnswer(answer, pauseContext) {
   if (answer == null || answer === "") return { valid: true, sanitized: answer ?? null };
   if (typeof answer !== "string") return { valid: true, sanitized: String(answer) };
   if (answer.length > RESUME_MAX_ANSWER_LENGTH) {
@@ -214,6 +215,14 @@ export function validateResumeAnswer(answer) {
       return { valid: false, reason: "Answer rejected: matches guardrail bypass pattern" };
     }
   }
+  // Policy compliance: reject attempts to bypass TDD, reviewer, security, etc.
+  const policy = validatePolicyCompliance(answer, pauseContext);
+  if (!policy.valid) {
+    const suggestionsText = policy.suggestions.length > 0
+      ? `\nValid alternatives:\n${policy.suggestions.map(s => `  - ${s}`).join("\n")}`
+      : "";
+    return { valid: false, reason: `${policy.reason}${suggestionsText}` };
+  }
   return { valid: true, sanitized: answer.trim() };
 }
 
@@ -240,7 +249,15 @@ export async function handleResume(a, server, extra) {
   }
   await runBootstrapGate(server, a);
   if (a.answer) {
-    const validation = validateResumeAnswer(a.answer);
+    // Load session to get pause context for policy-aware validation
+    let pauseContext;
+    try {
+      const { loadSession } = await import("../../session-store.js");
+      const session = await loadSession(a.sessionId);
+      const ctx = session?.paused_state?.context;
+      pauseContext = typeof ctx === "string" ? ctx : ctx?.reason;
+    } catch { /* session read error — validate without context */ }
+    const validation = validateResumeAnswer(a.answer, pauseContext);
     if (!validation.valid) {
       return failPayload(`Resume answer rejected: ${validation.reason}`);
     }

package/src/mcp/shared-helpers.js

@@ -67,15 +67,17 @@ export function failPayload(message, details = {}) {
   };
 }
 
-export async function assertNotOnBaseBranch(config) {
+export async function assertNotOnBaseBranch(config, { allowForRun = false } = {}) {
   const baseBranch = config?.base_branch || "main";
   let branch;
   try {
     branch = await currentBranch();
   } catch {
-    return;
+    return; // No git repo or no commits — bootstrap/orchestrator will handle it
   }
   if (branch === baseBranch) {
+    // kj_run creates its own branch via prepareGitAutomation — allow it
+    if (allowForRun) return;
     throw new Error(
       `You are on the base branch '${baseBranch}'. Karajan needs a feature branch to compute the diff for review. ` +
       `Create a new branch first (e.g. 'git checkout -b feat/<task-description>') and then run this command again. ` +

package/src/mcp/sovereignty-guard.js

@@ -24,7 +24,7 @@ const ALLOWED_PARAMS = new Set([
   "autoCommit", "autoPush", "autoPr", "autoRebase", "branchPrefix",
   "autoSimplify", "smartModels", "checkpointInterval",
   "taskType", "quiet", "noSonar", "enableSonarcloud",
-  "kjHome", "sonarToken", "timeoutMs",
+  "kjHome", "sonarToken", "timeoutMs", "domain",
   // Sovereign flags — validated below but still "known"
   "enableTriage", "enableHuReviewer",
 ]);

package/src/mcp/tools.js

@@ -104,7 +104,8 @@ export const tools = [
         enableSonarcloud: { type: "boolean", description: "Enable SonarCloud scan (complementary to SonarQube)" },
         kjHome: { type: "string" },
         sonarToken: { type: "string" },
-        timeoutMs: { type: "number" }
+        timeoutMs: { type: "number" },
+        domain: { type: "string", description: "Domain knowledge: inline text describing the project domain, or absolute path to a .md file. Auto-saved to .karajan/domains/ for the curator." }
       }
     }
   },

package/src/orchestrator.js

@@ -35,6 +35,7 @@ import { msg, getLang } from "./utils/messages.js";
 import { PipelineContext } from "./orchestrator/pipeline-context.js";
 import { runTriageStage, runResearcherStage, runArchitectStage, runPlannerStage, runDiscoverStage, runHuReviewerStage } from "./orchestrator/pre-loop-stages.js";
 import { runDomainCuratorStage } from "./orchestrator/stages/domain-curator-stage.js";
+import { persistInlineDomain } from "./domains/domain-loader.js";
 import { runCoderStage, runRefactorerStage, runTddCheckStage, runSonarStage, runSonarCloudStage, runReviewerStage } from "./orchestrator/iteration-stages.js";
 import { runTesterStage, runSecurityStage, runImpeccableStage, runFinalAuditStage } from "./orchestrator/post-loop-stages.js";
 import { needsSubPipeline, runHuSubPipeline } from "./orchestrator/hu-sub-pipeline.js";
@@ -47,6 +48,7 @@ import { setRunner as setDiffRunner } from "./review/diff-generator.js";
 import { setRunner as setGitRunner } from "./utils/git.js";
 import { detectNeededSkills, autoInstallSkills, cleanupAutoInstalledSkills } from "./skills/skill-detector.js";
 import { isOpenSkillsAvailable } from "./skills/openskills-client.js";
+import { startProxy, stopProxy } from "./proxy/proxy-lifecycle.js";
 
 
 // --- Product Context loader ---
@@ -104,8 +106,8 @@ async function handleDryRun({ task, config, flags, emitter, pipelineFlags }) {
   const projectDir = config.projectDir || process.cwd();
   const { rules: reviewRules } = await resolveReviewProfile({ mode: config.review_mode, projectDir });
   const coderRules = await loadFirstExisting(resolveRoleMdPath("coder", projectDir));
-  const coderPrompt = await buildCoderPrompt({ task, coderRules, methodology: config.development?.methodology, serenaEnabled: Boolean(config.serena?.enabled), rtkAvailable: Boolean(config.rtk?.available), productContext: config.productContext || null });
-  const reviewerPrompt = await buildReviewerPrompt({ task, diff: "(dry-run: no diff)", reviewRules, mode: config.review_mode, serenaEnabled: Boolean(config.serena?.enabled), rtkAvailable: Boolean(config.rtk?.available), productContext: config.productContext || null });
+  const coderPrompt = await buildCoderPrompt({ task, coderRules, methodology: config.development?.methodology, serenaEnabled: Boolean(config.serena?.enabled), rtkAvailable: Boolean(config.rtk?.available), proxyEnabled: Boolean(config.proxy?.enabled), productContext: config.productContext || null });
+  const reviewerPrompt = await buildReviewerPrompt({ task, diff: "(dry-run: no diff)", reviewRules, mode: config.review_mode, serenaEnabled: Boolean(config.serena?.enabled), rtkAvailable: Boolean(config.rtk?.available), proxyEnabled: Boolean(config.proxy?.enabled), productContext: config.productContext || null });
 
   const summary = {
     dry_run: true,
@@ -380,6 +382,24 @@ function takeCheckpointSnapshot(session) {
   };
 }
 
+/**
+ * Determine if checkpoint should auto-continue without asking the user.
+ * Exported for testing.
+ */
+export function shouldAutoContinueCheckpoint(session, hasProgress) {
+  if (hasProgress) {
+    session._checkpoint_stall_count = 0;
+    return { autoContinue: true, reason: "progress_detected" };
+  }
+  const wasRateLimited = (session.standby_retry_count || 0) > 0;
+  const consecutiveStalls = (session._checkpoint_stall_count || 0) + 1;
+  session._checkpoint_stall_count = consecutiveStalls;
+  if (wasRateLimited && consecutiveStalls < 3) {
+    return { autoContinue: true, reason: "recoverable_stall" };
+  }
+  return { autoContinue: false, reason: consecutiveStalls >= 3 ? "max_stalls_reached" : "no_progress" };
+}
+
 async function handleCheckpoint({ checkpointDisabled, askQuestion, lastCheckpointAt, checkpointIntervalMs, elapsedMinutes, i, config, budgetTracker, stageResults, emitter, eventBase, session, budgetSummary, lastCheckpointSnapshot }) {
   if (checkpointDisabled || !askQuestion || (Date.now() - lastCheckpointAt) < checkpointIntervalMs) {
     return { action: "continue_loop", checkpointDisabled, lastCheckpointAt, lastCheckpointSnapshot };
@@ -388,22 +408,23 @@ async function handleCheckpoint({ checkpointDisabled, askQuestion, lastCheckpoin
   const elapsedStr = elapsedMinutes.toFixed(1);
   const stagesCompleted = Object.keys(stageResults).join(", ") || "none";
 
-  // Auto-continue if progress detected since last checkpoint
+  // Decide whether to auto-continue or ask the user
   const hasProgress = detectCheckpointProgress(session, lastCheckpointSnapshot);
   const newSnapshot = takeCheckpointSnapshot(session);
+  const decision = shouldAutoContinueCheckpoint(session, hasProgress);
 
-  if (hasProgress) {
+  if (decision.autoContinue) {
     emitProgress(
       emitter,
       makeEvent("session:checkpoint", { ...eventBase, iteration: i, stage: "checkpoint" }, {
-        message: `Checkpoint: progress detected, continuing (${elapsedStr} min elapsed)`,
-        detail: { elapsed_minutes: Number(elapsedStr), iterations_done: i - 1, stages: stagesCompleted, auto_continued: true, executorType: "system" }
+        message: `Checkpoint: ${decision.reason === "progress_detected" ? "progress detected" : "stall caused by rate limit/cooldown"}, auto-continuing (${elapsedStr} min elapsed)`,
+        detail: { elapsed_minutes: Number(elapsedStr), iterations_done: i - 1, stages: stagesCompleted, auto_continued: true, reason: decision.reason }
       })
     );
     return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now(), lastCheckpointSnapshot: newSnapshot };
   }
 
-  // No progress — ask human
+  // No progress and not recoverable — ask human
   const iterInfo = `${i - 1}/${config.max_iterations} iterations completed`;
   const budgetInfo = budgetTracker.total().cost_usd > 0 ? ` | Budget: $${budgetTracker.total().cost_usd.toFixed(2)}` : "";
   const checkpointMsg = `Checkpoint — ${elapsedStr} min elapsed | ${iterInfo}${budgetInfo} | Stages completed: ${stagesCompleted}. No progress since last checkpoint. What would you like to do?`;
@@ -920,6 +941,15 @@ async function runPreLoopStages({ config, logger, emitter, eventBase, session, f
     logger.warn(`Skill auto-install failed (non-blocking): ${err.message}`);
   }
 
+  // --- Persist inline domain if provided via --domain flag ---
+  if (flags?.domain) {
+    try {
+      await persistInlineDomain(flags.domain, config.projectDir || process.cwd());
+    } catch (err) {
+      logger.warn(`Failed to persist inline domain: ${err.message}`);
+    }
+  }
+
   // --- Domain Curator (after triage + skill auto-install, before planning phases) ---
   const domainHints = triageResult.stageResult?.domainHints || [];
   if (domainHints.length > 0 || config.projectDir) {
@@ -1310,19 +1340,23 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
   ctx.trackBudget = trackBudget;
 
   // --- RTK detection ---
-  const rtkResult = await detectRtk();
-  if (rtkResult.available) {
-    config = { ...config, rtk: { available: true, version: rtkResult.version } };
-    const rtkTracker = new RtkSavingsTracker();
-    const rtkRunner = createRtkRunner(true, rtkTracker);
-    setDiffRunner(rtkRunner);
-    setGitRunner(rtkRunner);
-    ctx.rtkTracker = rtkTracker;
-    logger.info(`RTK detected (${rtkResult.version}) — wrapping internal git/diff commands with rtk`);
-    emitProgress(emitter, makeEvent("rtk:detected", ctx.eventBase, {
-      message: "RTK detected — internal commands wrapped for token optimization",
-      detail: { version: rtkResult.version, executorType: "local" }
-    }));
+  if (config.proxy?.enabled) {
+    logger.info("Proxy compression active, RTK not needed");
+  } else {
+    const rtkResult = await detectRtk();
+    if (rtkResult.available) {
+      config = { ...config, rtk: { available: true, version: rtkResult.version } };
+      const rtkTracker = new RtkSavingsTracker();
+      const rtkRunner = createRtkRunner(true, rtkTracker);
+      setDiffRunner(rtkRunner);
+      setGitRunner(rtkRunner);
+      ctx.rtkTracker = rtkTracker;
+      logger.info(`RTK detected (${rtkResult.version}) — wrapping internal git/diff commands with rtk`);
+      emitProgress(emitter, makeEvent("rtk:detected", ctx.eventBase, {
+        message: "RTK detected — internal commands wrapped for token optimization",
+        detail: { version: rtkResult.version, executorType: "local" }
+      }));
+    }
   }
 
   // --- HU Board auto-start ---
@@ -1348,6 +1382,21 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
   ctx.pgCard = pgAdapterResult.pgCard;
   ctx.session.pg_card = ctx.pgCard || null;
 
+  // --- Proxy startup ---
+  if (config.proxy?.enabled !== false) {
+    try {
+      const proxyResult = await startProxy({ config: config.proxy || {}, sessionId: ctx.session.id });
+      ctx.proxyPort = proxyResult.port;
+      logger.info(`Proxy started on 127.0.0.1:${proxyResult.port}`);
+      emitProgress(emitter, makeEvent("proxy:started", ctx.eventBase, {
+        message: `Proxy started on port ${proxyResult.port}`,
+        detail: { port: proxyResult.port, baseUrls: proxyResult.baseUrls }
+      }));
+    } catch (err) {
+      logger.warn(`Proxy startup failed (non-blocking): ${err.message}`);
+    }
+  }
+
   emitProgress(
     emitter,
     makeEvent("session:start", ctx.eventBase, {
@@ -1618,6 +1667,14 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     await writeHistoryRecord({ sessionId: ctx.session.id, task, result, logger });
     return result;
   } finally {
+    // --- Proxy shutdown ---
+    try {
+      await stopProxy();
+      if (ctx.proxyPort) {
+        logger.info("Proxy stopped");
+      }
+    } catch { /* non-blocking */ }
+
     // --- Cleanup auto-installed skills ---
     const autoSkills = ctx.session?.autoInstalledSkills;
     if (autoSkills && autoSkills.length > 0) {

package/src/prompts/coder.js

@@ -1,4 +1,4 @@
-import { RTK_INSTRUCTIONS } from "./rtk-snippet.js";
+import { buildRtkInstructions } from "./rtk-snippet.js";
 import { loadAvailableSkills, buildSkillSection } from "../skills/skill-loader.js";
 import { getLanguageInstruction } from "../utils/locale.js";
 
@@ -33,7 +33,7 @@ const SERENA_INSTRUCTIONS = [
   "Fall back to reading files only when Serena tools are not sufficient."
 ].join("\n");
 
-export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, rtkAvailable = false, deferredContext = null, productContext = null, domainContext = null, plan = null, projectDir = null, language = "en" }) {
+export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, rtkAvailable = false, proxyEnabled = false, deferredContext = null, productContext = null, domainContext = null, plan = null, projectDir = null, language = "en" }) {
   const langInstruction = getLanguageInstruction(language);
   const sections = [
     serenaEnabled ? SUBAGENT_PREAMBLE_SERENA : SUBAGENT_PREAMBLE,
@@ -48,8 +48,9 @@ export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSum
     sections.push(SERENA_INSTRUCTIONS);
   }
 
-  if (rtkAvailable) {
-    sections.push(RTK_INSTRUCTIONS);
+  const rtkSnippet = buildRtkInstructions({ rtkAvailable, proxyEnabled });
+  if (rtkSnippet) {
+    sections.push(rtkSnippet);
   }
 
   if (productContext) {

package/src/prompts/reviewer.js

@@ -1,4 +1,4 @@
-import { RTK_INSTRUCTIONS } from "./rtk-snippet.js";
+import { buildRtkInstructions } from "./rtk-snippet.js";
 import { loadAvailableSkills, buildSkillSection } from "../skills/skill-loader.js";
 import { getLanguageInstruction } from "../utils/locale.js";
 
@@ -24,7 +24,7 @@ const SERENA_INSTRUCTIONS = [
   "Fall back to reading files only when Serena tools are not sufficient."
 ].join("\n");
 
-export async function buildReviewerPrompt({ task, diff, reviewRules, mode, serenaEnabled = false, rtkAvailable = false, productContext = null, domainContext = null, projectDir = null, language = "en" }) {
+export async function buildReviewerPrompt({ task, diff, reviewRules, mode, serenaEnabled = false, rtkAvailable = false, proxyEnabled = false, productContext = null, domainContext = null, projectDir = null, language = "en" }) {
   const truncatedDiff = diff.length > 12000 ? `${diff.slice(0, 12000)}\n\n[TRUNCATED]` : diff;
 
   const langInstruction = getLanguageInstruction(language);
@@ -43,8 +43,9 @@ export async function buildReviewerPrompt({ task, diff, reviewRules, mode, seren
     sections.push(SERENA_INSTRUCTIONS);
   }
 
-  if (rtkAvailable) {
-    sections.push(RTK_INSTRUCTIONS);
+  const rtkSnippet = buildRtkInstructions({ rtkAvailable, proxyEnabled });
+  if (rtkSnippet) {
+    sections.push(rtkSnippet);
   }
 
   if (productContext) {

package/src/prompts/rtk-snippet.js

@@ -13,3 +13,15 @@ export const RTK_INSTRUCTIONS = [
   "- Use `rtk cat` instead of `cat`",
   "This does NOT apply to non-Bash tools (Read, Write, Edit, Glob, Grep)."
 ].join("\n");
+
+/**
+ * Build RTK instructions, returning empty string when proxy compression
+ * handles token optimization at the HTTP layer.
+ * @param {{ rtkAvailable?: boolean, proxyEnabled?: boolean }} options
+ * @returns {string}
+ */
+export function buildRtkInstructions({ rtkAvailable = false, proxyEnabled = false } = {}) {
+  if (proxyEnabled) return "";
+  if (!rtkAvailable) return "";
+  return RTK_INSTRUCTIONS;
+}

package/src/proxy/adapters/anthropic.js

@@ -0,0 +1,131 @@
+/**
+ * Anthropic message format adapter.
+ *
+ * Anthropic messages API uses an array of messages where each message has a
+ * `content` array. Tool results appear as content blocks with
+ * `type: "tool_result"`. Each tool_result block contains an `id` (matching
+ * the prior tool_use), optional `tool_use_id`, and nested `content` that
+ * can be a string or an array of content blocks (text, image, etc.).
+ *
+ * @module
+ */
+
+/**
+ * Extract tool results from Anthropic-format messages.
+ *
+ * @param {Array<object>} messages - Anthropic messages array
+ * @returns {Array<{id: string, toolName: string, text: string, turnIndex: number}>}
+ */
+export function extractToolResults(messages) {
+  const results = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg || !Array.isArray(msg.content)) continue;
+
+    // Collect tool_use names from assistant messages so we can map ids to names
+    const toolNameMap = buildToolNameMap(messages, i);
+
+    for (const block of msg.content) {
+      if (block.type !== "tool_result") continue;
+
+      const id = block.tool_use_id || block.id || "";
+      const text = extractText(block);
+      const toolName = toolNameMap.get(id) || "unknown";
+
+      results.push({ id, toolName, text, turnIndex: i });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Rebuild messages replacing tool_result text with compressed versions.
+ *
+ * @param {Array<object>} messages - Original Anthropic messages array
+ * @param {Map<string, string>|Record<string, string>} compressedMap - id → compressed text
+ * @returns {Array<object>} Deep-cloned messages with replacements applied
+ */
+export function rebuildMessages(messages, compressedMap) {
+  const map = compressedMap instanceof Map ? compressedMap : new Map(Object.entries(compressedMap));
+  return messages.map((msg) => {
+    if (!msg || !Array.isArray(msg.content)) return msg;
+
+    const newContent = msg.content.map((block) => {
+      if (block.type !== "tool_result") return block;
+
+      const id = block.tool_use_id || block.id || "";
+      if (!map.has(id)) return block;
+
+      const compressed = map.get(id);
+      return replaceText(block, compressed);
+    });
+
+    return { ...msg, content: newContent };
+  });
+}
+
+// ── helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Build a map of tool_use id → tool name by scanning assistant messages
+ * that precede or are at the given turn index.
+ */
+function buildToolNameMap(messages, upToIndex) {
+  const map = new Map();
+  for (let i = 0; i <= upToIndex; i++) {
+    const msg = messages[i];
+    if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        map.set(block.id, block.name || "unknown");
+      }
+    }
+  }
+  return map;
+}
+
+/**
+ * Extract plain text from a tool_result block.
+ * Content can be a string, an array of {type:"text", text} blocks, or absent.
+ */
+function extractText(block) {
+  if (typeof block.content === "string") return block.content;
+  if (Array.isArray(block.content)) {
+    return block.content
+      .filter((c) => c.type === "text")
+      .map((c) => c.text)
+      .join("\n");
+  }
+  return "";
+}
+
+/**
+ * Return a new tool_result block with text replaced.
+ * Preserves the content shape (string vs array).
+ */
+function replaceText(block, newText) {
+  if (typeof block.content === "string") {
+    return { ...block, content: newText };
+  }
+  if (Array.isArray(block.content)) {
+    // Replace only text blocks, keep images etc.
+    const newContent = block.content.map((c) =>
+      c.type === "text" ? { ...c, text: newText } : c,
+    );
+    // If there were text blocks, replace the first and remove the rest
+    let seenText = false;
+    const filtered = newContent.filter((c) => {
+      if (c.type !== "text") return true;
+      if (!seenText) {
+        seenText = true;
+        return true;
+      }
+      return false;
+    });
+    return { ...block, content: filtered };
+  }
+  // No content field — add it as string
+  return { ...block, content: newText };
+}

package/src/proxy/adapters/gemini.js

@@ -0,0 +1,106 @@
+/**
+ * Gemini message format adapter.
+ *
+ * Gemini API uses `contents[]` where each content has `parts[]`.
+ * Function responses appear as parts with a `functionResponse` field:
+ * `{ functionResponse: { name: "...", response: { content: "..." } } }`
+ *
+ * Gemini does not use explicit IDs for function calls/responses. Instead,
+ * the function name serves as the correlation key. When multiple calls to
+ * the same function exist, we generate synthetic IDs combining turnIndex
+ * and part index for disambiguation.
+ *
+ * @module
+ */
+
+/**
+ * Extract tool results from Gemini-format messages (contents array).
+ *
+ * @param {Array<object>} messages - Gemini contents array
+ * @returns {Array<{id: string, toolName: string, text: string, turnIndex: number}>}
+ */
+export function extractToolResults(messages) {
+  const results = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const content = messages[i];
+    if (!content || !Array.isArray(content.parts)) continue;
+
+    for (let p = 0; p < content.parts.length; p++) {
+      const part = content.parts[p];
+      if (!part.functionResponse) continue;
+
+      const fr = part.functionResponse;
+      const toolName = fr.name || "unknown";
+      const text = extractResponseText(fr.response);
+      // Synthetic ID: turn index + part index (Gemini has no explicit IDs)
+      const id = `gemini-${i}-${p}`;
+
+      results.push({ id, toolName, text, turnIndex: i });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Rebuild messages replacing functionResponse content with compressed versions.
+ *
+ * @param {Array<object>} messages - Original Gemini contents array
+ * @param {Map<string, string>|Record<string, string>} compressedMap - id → compressed text
+ * @returns {Array<object>} Deep-cloned messages with replacements applied
+ */
+export function rebuildMessages(messages, compressedMap) {
+  const map = compressedMap instanceof Map ? compressedMap : new Map(Object.entries(compressedMap));
+
+  return messages.map((content, i) => {
+    if (!content || !Array.isArray(content.parts)) return content;
+
+    const newParts = content.parts.map((part, p) => {
+      if (!part.functionResponse) return part;
+
+      const id = `gemini-${i}-${p}`;
+      if (!map.has(id)) return part;
+
+      const compressed = map.get(id);
+      return {
+        ...part,
+        functionResponse: {
+          ...part.functionResponse,
+          response: replaceResponseText(part.functionResponse.response, compressed),
+        },
+      };
+    });
+
+    return { ...content, parts: newParts };
+  });
+}
+
+// ── helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Extract text from a Gemini function response object.
+ * The response can have `content` (string), `result` (string),
+ * or be a nested object that we JSON-serialize.
+ */
+function extractResponseText(response) {
+  if (!response) return "";
+  if (typeof response === "string") return response;
+  if (typeof response.content === "string") return response.content;
+  if (typeof response.result === "string") return response.result;
+  // For structured responses, serialize to JSON
+  return JSON.stringify(response);
+}
+
+/**
+ * Replace text in a Gemini function response object.
+ * Preserves the original shape (content field, result field, etc.).
+ */
+function replaceResponseText(response, newText) {
+  if (!response) return { content: newText };
+  if (typeof response === "string") return newText;
+  if (typeof response.content === "string") return { ...response, content: newText };
+  if (typeof response.result === "string") return { ...response, result: newText };
+  // Default: replace with content field
+  return { content: newText };
+}

package/src/proxy/adapters/index.js

@@ -0,0 +1,51 @@
+/**
+ * Provider adapter registry.
+ *
+ * Each adapter implements the contract:
+ *   extractToolResults(messages) → [{id, toolName, text, turnIndex}]
+ *   rebuildMessages(messages, compressedMap) → messages
+ *
+ * @module
+ */
+
+import * as anthropic from "./anthropic.js";
+import * as openai from "./openai.js";
+import * as gemini from "./gemini.js";
+
+const adapters = {
+  anthropic,
+  openai,
+  gemini,
+};
+
+/**
+ * Hostname → provider mapping.
+ * @type {Record<string, string>}
+ */
+const HOST_MAP = {
+  "api.anthropic.com": "anthropic",
+  "api.openai.com": "openai",
+  "generativelanguage.googleapis.com": "gemini",
+};
+
+/**
+ * Get the adapter for a given provider name.
+ *
+ * @param {string} provider - "anthropic" | "openai" | "gemini"
+ * @returns {object|null} Adapter with extractToolResults and rebuildMessages, or null
+ */
+export function getAdapter(provider) {
+  return adapters[provider] || null;
+}
+
+/**
+ * Detect the provider from a hostname.
+ *
+ * @param {string} hostname - e.g. "api.anthropic.com", "api.openai.com:443"
+ * @returns {string} Provider name or "unknown"
+ */
+export function detectProvider(hostname) {
+  // Strip port if present
+  const host = (hostname || "").split(":")[0];
+  return HOST_MAP[host] || "unknown";
+}