karajan-code 1.58.2 → 1.59.0

package/src/orchestrator.js

@@ -47,6 +47,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 +105,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 +381,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 +407,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?`;
@@ -1310,19 +1330,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 +1372,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 +1657,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";
+}

package/src/proxy/adapters/openai.js

@@ -0,0 +1,71 @@
+/**
+ * OpenAI message format adapter.
+ *
+ * OpenAI Chat Completions API uses messages with `role: "tool"`.
+ * Each tool message has a `tool_call_id` linking back to the assistant's
+ * `tool_calls` array, and a `content` string with the tool output.
+ *
+ * @module
+ */
+
+/**
+ * Extract tool results from OpenAI-format messages.
+ *
+ * @param {Array<object>} messages - OpenAI messages array
+ * @returns {Array<{id: string, toolName: string, text: string, turnIndex: number}>}
+ */
+export function extractToolResults(messages) {
+  const results = [];
+  const toolNameMap = buildToolNameMap(messages);
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg || msg.role !== "tool") continue;
+
+    const id = msg.tool_call_id || "";
+    const text = typeof msg.content === "string" ? msg.content : "";
+    const toolName = toolNameMap.get(id) || "unknown";
+
+    results.push({ id, toolName, text, turnIndex: i });
+  }
+
+  return results;
+}
+
+/**
+ * Rebuild messages replacing tool message content with compressed versions.
+ *
+ * @param {Array<object>} messages - Original OpenAI 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 || msg.role !== "tool") return msg;
+
+    const id = msg.tool_call_id || "";
+    if (!map.has(id)) return msg;
+
+    return { ...msg, content: map.get(id) };
+  });
+}
+
+// ── helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Build a map of tool_call id → function name by scanning assistant messages.
+ * Assistant messages contain `tool_calls: [{id, function: {name, arguments}}]`.
+ */
+function buildToolNameMap(messages) {
+  const map = new Map();
+  for (const msg of messages) {
+    if (!msg || msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) continue;
+    for (const call of msg.tool_calls) {
+      if (call.id && call.function) {
+        map.set(call.id, call.function.name || "unknown");
+      }
+    }
+  }
+  return map;
+}