@loreai/gateway 0.13.4 → 0.14.1

package/dist/index.js

@@ -1,3548 +0,0 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports, module) {
-    module.exports = {
-      name: "@loreai/gateway",
-      version: "0.13.4",
-      type: "module",
-      license: "FSL-1.1-Apache-2.0",
-      description: "Lore as a transparent LLM proxy \u2014 context management for any AI coding client",
-      main: "./dist/index.js",
-      types: "./dist/index.d.ts",
-      exports: {
-        ".": {
-          bun: "./src/index.ts",
-          default: "./dist/index.js"
-        }
-      },
-      bin: {
-        "lore-gateway": "./dist/index.js"
-      },
-      scripts: {
-        typecheck: "tsc --noEmit",
-        build: "bun run script/build.ts",
-        start: "bun run src/index.ts"
-      },
-      dependencies: {
-        "@loreai/core": "workspace:*"
-      },
-      files: [
-        "src/",
-        "dist/",
-        "README.md",
-        "LICENSE"
-      ],
-      engines: {
-        bun: ">=1.2.0"
-      },
-      repository: {
-        type: "git",
-        url: "git+https://github.com/BYK/loreai.git",
-        directory: "packages/gateway"
-      },
-      publishConfig: {
-        access: "public"
-      },
-      keywords: [
-        "lore",
-        "gateway",
-        "proxy",
-        "llm",
-        "context-management",
-        "anthropic",
-        "openai"
-      ],
-      author: "BYK"
-    };
-  }
-});
-
-// src/config.ts
-function loadConfig() {
-  const env = process.env;
-  return {
-    port: parsePort(env.LORE_LISTEN_PORT, 6969),
-    host: env.LORE_LISTEN_HOST || "127.0.0.1",
-    upstreamAnthropic: trimTrailingSlash(
-      env.LORE_UPSTREAM_ANTHROPIC || "https://api.anthropic.com"
-    ),
-    upstreamOpenAI: trimTrailingSlash(
-      env.LORE_UPSTREAM_OPENAI || "https://api.openai.com"
-    ),
-    idleTimeoutSeconds: parsePositiveInt(env.LORE_IDLE_TIMEOUT, 60),
-    debug: isTruthy(env.LORE_DEBUG)
-  };
-}
-var UPSTREAM_ROUTES = [
-  // Anthropic
-  { prefix: "claude-", url: "https://api.anthropic.com", protocol: "anthropic" },
-  // Nvidia NIM
-  { prefix: "nvidia/", url: "https://integrate.api.nvidia.com", protocol: "openai" },
-  { prefix: "meta/", url: "https://integrate.api.nvidia.com", protocol: "openai" },
-  { prefix: "mistralai/", url: "https://integrate.api.nvidia.com", protocol: "openai" },
-  { prefix: "google/", url: "https://integrate.api.nvidia.com", protocol: "openai" },
-  { prefix: "qwen/", url: "https://integrate.api.nvidia.com", protocol: "openai" },
-  { prefix: "deepseek/", url: "https://integrate.api.nvidia.com", protocol: "openai" },
-  // OpenAI
-  { prefix: "gpt-", url: "https://api.openai.com", protocol: "openai" },
-  { prefix: "o1-", url: "https://api.openai.com", protocol: "openai" },
-  { prefix: "o3-", url: "https://api.openai.com", protocol: "openai" },
-  { prefix: "o4-", url: "https://api.openai.com", protocol: "openai" },
-  // xAI
-  { prefix: "grok-", url: "https://api.x.ai", protocol: "openai" },
-  // Mistral (direct)
-  { prefix: "mistral-", url: "https://api.mistral.ai", protocol: "openai" },
-  { prefix: "codestral-", url: "https://api.mistral.ai", protocol: "openai" },
-  // Google (direct)
-  { prefix: "gemini-", url: "https://generativelanguage.googleapis.com", protocol: "openai" }
-];
-function resolveUpstreamRoute(model) {
-  for (const route of UPSTREAM_ROUTES) {
-    if (model.startsWith(route.prefix)) {
-      return { url: route.url, protocol: route.protocol };
-    }
-  }
-  return null;
-}
-var PROJECT_PATH_PATTERNS = [
-  // "cwd": "/home/…/project" or "cwd":"/Users/…/project" (JSON-style)
-  /["']?cwd["']?\s*[:=]\s*["']?(\/(?:home|Users)\/[^\s"',}]+)/,
-  // Working directory: /home/user/project
-  /[Ww]orking\s+directory[:=]\s*(\/(?:home|Users)\/[^\s"',]+)/,
-  // CLAUDE.md / AGENTS.md / .lore.md file path → take the directory
-  /(\/(?:home|Users)\/[^\s"',]+)\/(?:CLAUDE|AGENTS|\.lore)\.md/,
-  // Generic absolute path starting with /home/ or /Users/ — first occurrence
-  // Captures until whitespace, quote, comma, or bracket.
-  /(\/(?:home|Users)\/[\w./-]+)/
-];
-function inferProjectPath(systemPrompt) {
-  for (const pattern of PROJECT_PATH_PATTERNS) {
-    const match = pattern.exec(systemPrompt);
-    if (match?.[1]) {
-      return match[1].replace(/\/+$/, "") || null;
-    }
-  }
-  return null;
-}
-function getProjectPath(systemPrompt, headers) {
-  const headerPath = headers["x-lore-project"];
-  if (headerPath) return headerPath;
-  const inferred = inferProjectPath(systemPrompt);
-  if (inferred) return inferred;
-  return process.cwd();
-}
-function parsePort(value, fallback) {
-  if (!value) return fallback;
-  const n = Number.parseInt(value, 10);
-  if (Number.isNaN(n) || n < 0 || n > 65535) return fallback;
-  return n;
-}
-function parsePositiveInt(value, fallback) {
-  if (!value) return fallback;
-  const n = Number.parseInt(value, 10);
-  if (Number.isNaN(n) || n <= 0) return fallback;
-  return n;
-}
-function isTruthy(value) {
-  return value === "1" || value?.toLowerCase() === "true";
-}
-function trimTrailingSlash(url) {
-  return url.replace(/\/+$/, "");
-}
-
-// src/auth.ts
-function extractAuth(headers) {
-  const apiKey = headers["x-api-key"] || headers["X-Api-Key"];
-  if (apiKey) return { scheme: "api-key", value: apiKey };
-  const authHeader = headers["authorization"] || headers["Authorization"];
-  if (authHeader) {
-    const match = /^Bearer\s+(\S+)$/i.exec(authHeader);
-    if (match) return { scheme: "bearer", value: match[1] };
-  }
-  return null;
-}
-function authHeaders(cred) {
-  switch (cred.scheme) {
-    case "api-key":
-      return { "x-api-key": cred.value };
-    case "bearer":
-      return { Authorization: `Bearer ${cred.value}` };
-  }
-}
-function authFingerprint(cred) {
-  return cred.value.slice(-8);
-}
-var sessionAuth = /* @__PURE__ */ new Map();
-function setSessionAuth(sessionID, cred) {
-  sessionAuth.set(sessionID, cred);
-}
-function getSessionAuth(sessionID) {
-  return sessionAuth.get(sessionID) ?? null;
-}
-var lastSeenAuth = null;
-function setLastSeenAuth(cred) {
-  lastSeenAuth = cred;
-}
-function getLastSeenAuth() {
-  return lastSeenAuth;
-}
-function resolveAuth(sessionID) {
-  if (sessionID) {
-    const cred = getSessionAuth(sessionID);
-    if (cred) return cred;
-  }
-  return getLastSeenAuth();
-}
-
-// src/translate/anthropic.ts
-var ANTHROPIC_VERSION = "2023-06-01";
-var KNOWN_BODY_FIELDS = /* @__PURE__ */ new Set([
-  "model",
-  "system",
-  "messages",
-  "tools",
-  "max_tokens",
-  "stream"
-]);
-function toGatewayBlock(block) {
-  switch (block.type) {
-    case "text":
-      return { type: "text", text: String(block.text ?? "") };
-    case "thinking":
-      return {
-        type: "thinking",
-        thinking: String(block.thinking ?? ""),
-        ...block.signature != null ? { signature: String(block.signature) } : void 0
-      };
-    case "tool_use":
-      return {
-        type: "tool_use",
-        id: String(block.id ?? ""),
-        name: String(block.name ?? ""),
-        input: block.input
-      };
-    case "tool_result": {
-      let content = "";
-      if (typeof block.content === "string") {
-        content = block.content;
-      } else if (Array.isArray(block.content)) {
-        content = block.content.filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n");
-      }
-      return {
-        type: "tool_result",
-        toolUseId: String(block.tool_use_id ?? ""),
-        content,
-        ...block.is_error ? { isError: true } : void 0
-      };
-    }
-    default:
-      return { type: "text", text: JSON.stringify(block) };
-  }
-}
-function normalizeContent(content) {
-  if (typeof content === "string") {
-    return [{ type: "text", text: content }];
-  }
-  if (Array.isArray(content)) {
-    return content.map(
-      (block) => toGatewayBlock(block)
-    );
-  }
-  return [];
-}
-function normalizeSystem(system) {
-  if (system == null) return "";
-  if (typeof system === "string") return system;
-  if (Array.isArray(system)) {
-    return system.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("\n");
-  }
-  return String(system);
-}
-function toAnthropicBlock(block) {
-  switch (block.type) {
-    case "text":
-      return { type: "text", text: block.text };
-    case "thinking":
-      return {
-        type: "thinking",
-        thinking: block.thinking,
-        ...block.signature != null ? { signature: block.signature } : void 0
-      };
-    case "tool_use":
-      return {
-        type: "tool_use",
-        id: block.id,
-        name: block.name,
-        input: block.input
-      };
-    case "tool_result": {
-      const result = {
-        type: "tool_result",
-        tool_use_id: block.toolUseId,
-        content: block.content
-      };
-      if (block.isError) result.is_error = true;
-      return result;
-    }
-  }
-}
-function parseAnthropicRequest(body, headers) {
-  const raw = body ?? {};
-  const model = String(raw.model ?? "");
-  const system = normalizeSystem(raw.system);
-  const stream = raw.stream === true;
-  const maxTokens = typeof raw.max_tokens === "number" ? raw.max_tokens : 4096;
-  const rawMessages = Array.isArray(raw.messages) ? raw.messages : [];
-  const messages = rawMessages.map(
-    (msg) => ({
-      role: msg.role === "assistant" ? "assistant" : "user",
-      content: normalizeContent(msg.content)
-    })
-  );
-  const rawTools = Array.isArray(raw.tools) ? raw.tools : [];
-  const tools = rawTools.map(
-    (t) => ({
-      name: String(t.name ?? ""),
-      description: String(t.description ?? ""),
-      inputSchema: t.input_schema ?? {}
-    })
-  );
-  const metadata = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (!KNOWN_BODY_FIELDS.has(key)) {
-      metadata[key] = value;
-    }
-  }
-  return {
-    protocol: "anthropic",
-    model,
-    system,
-    messages,
-    tools,
-    stream,
-    maxTokens,
-    metadata,
-    rawHeaders: headers
-  };
-}
-function buildAnthropicRequest(req, cache) {
-  const headers = {
-    "content-type": "application/json",
-    "anthropic-version": ANTHROPIC_VERSION
-  };
-  const cred = extractAuth(req.rawHeaders);
-  if (cred) {
-    Object.assign(headers, authHeaders(cred));
-  }
-  const beta = req.rawHeaders["anthropic-beta"] || req.rawHeaders["Anthropic-Beta"] || "";
-  if (beta) {
-    headers["anthropic-beta"] = beta;
-  }
-  const body = {
-    model: req.model,
-    max_tokens: req.maxTokens,
-    stream: req.stream
-  };
-  if (req.system) {
-    const systemTTL = cache?.systemTTL;
-    if (systemTTL) {
-      const cacheControl = systemTTL === "1h" ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
-      body.system = [
-        { type: "text", text: req.system, cache_control: cacheControl }
-      ];
-    } else {
-      body.system = req.system;
-    }
-  }
-  const messages = req.messages.map((msg) => ({
-    role: msg.role,
-    content: msg.content.map(toAnthropicBlock)
-  }));
-  if (cache?.cacheConversation && messages.length > 0) {
-    const lastMsg = messages[messages.length - 1];
-    if (lastMsg.content.length > 0) {
-      const lastBlock = lastMsg.content[lastMsg.content.length - 1];
-      lastBlock.cache_control = {
-        type: "ephemeral"
-      };
-    }
-  }
-  body.messages = messages;
-  if (req.tools.length > 0) {
-    body.tools = req.tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
-  }
-  for (const [key, value] of Object.entries(req.metadata)) {
-    body[key] = value;
-  }
-  return {
-    url: "/v1/messages",
-    headers,
-    body
-  };
-}
-function buildAnthropicNonStreamResponse(resp) {
-  const usage = {
-    input_tokens: resp.usage.inputTokens,
-    output_tokens: resp.usage.outputTokens
-  };
-  if (resp.usage.cacheReadInputTokens != null) {
-    usage.cache_read_input_tokens = resp.usage.cacheReadInputTokens;
-  }
-  if (resp.usage.cacheCreationInputTokens != null) {
-    usage.cache_creation_input_tokens = resp.usage.cacheCreationInputTokens;
-  }
-  return {
-    id: resp.id,
-    type: "message",
-    role: "assistant",
-    model: resp.model,
-    content: resp.content.map(toAnthropicBlock),
-    stop_reason: resp.stopReason,
-    stop_sequence: null,
-    usage
-  };
-}
-
-// src/translate/openai.ts
-function parseOpenAIRequest(body, headers) {
-  const raw = body ?? {};
-  const model = String(raw.model ?? "");
-  const stream = raw.stream === true;
-  const maxTokens = typeof raw.max_tokens === "number" ? raw.max_tokens : 4096;
-  const extras = {};
-  if (typeof raw.temperature === "number") {
-    extras.temperature = raw.temperature;
-  }
-  if (typeof raw.top_p === "number") {
-    extras.top_p = raw.top_p;
-  }
-  if (typeof raw.frequency_penalty === "number") {
-    extras.frequency_penalty = raw.frequency_penalty;
-  }
-  if (typeof raw.presence_penalty === "number") {
-    extras.presence_penalty = raw.presence_penalty;
-  }
-  if (typeof raw.user === "string") {
-    extras.user = raw.user;
-  }
-  if (raw.logprobs === true || raw.logprobs === false) {
-    extras.logprobs = raw.logprobs;
-  }
-  if (typeof raw.top_logprobs === "number") {
-    extras.top_logprobs = raw.top_logprobs;
-  }
-  const rawMessages = Array.isArray(raw.messages) ? raw.messages : [];
-  let system = "";
-  const messages = [];
-  for (const msg of rawMessages) {
-    const role = msg.role;
-    const content = msg.content;
-    if (role === "system") {
-      const text = typeof content === "string" ? content : "";
-      if (system) {
-        system += "\n\n" + text;
-      } else {
-        system = text;
-      }
-      continue;
-    }
-    if (role === "user") {
-      const blocks = parseUserContent(content, msg.tool_calls);
-      messages.push({ role: "user", content: blocks });
-      continue;
-    }
-    if (role === "assistant") {
-      const blocks = parseAssistantContent(
-        content,
-        msg.tool_calls
-      );
-      messages.push({ role: "assistant", content: blocks });
-      continue;
-    }
-    if (role === "tool") {
-      const toolResultBlocks = parseToolResult(msg);
-      if (toolResultBlocks.length > 0) {
-        messages.push({ role: "user", content: toolResultBlocks });
-      }
-      continue;
-    }
-  }
-  const rawTools = Array.isArray(raw.tools) ? raw.tools : [];
-  const tools = rawTools.map(
-    (t) => {
-      const func = t.function;
-      return {
-        name: String(func?.name ?? t.name ?? ""),
-        description: String(func?.description ?? ""),
-        inputSchema: func?.parameters ?? {}
-      };
-    }
-  );
-  return {
-    protocol: "openai",
-    model,
-    system,
-    messages,
-    tools,
-    stream,
-    maxTokens,
-    metadata: {},
-    rawHeaders: {
-      ...headers,
-      "x-api-key": headers["x-api-key"] ?? ""
-    },
-    extras
-  };
-}
-function parseUserContent(content, toolCalls) {
-  const blocks = [];
-  if (typeof content === "string" && content) {
-    blocks.push({ type: "text", text: content });
-  } else if (Array.isArray(content)) {
-    for (const item of content) {
-      if (item.type === "text") {
-        blocks.push({ type: "text", text: String(item.text ?? "") });
-      } else if (item.type === "tool_use") {
-        blocks.push({
-          type: "tool_use",
-          id: String(item.id ?? ""),
-          name: String(item.name ?? ""),
-          input: item.input ?? {}
-        });
-      }
-    }
-  }
-  if (toolCalls) {
-    for (const tc of toolCalls) {
-      const fn = tc.function;
-      blocks.push({
-        type: "tool_use",
-        id: String(tc.id ?? ""),
-        name: String(fn?.name ?? ""),
-        input: fn?.arguments ? JSON.parse(fn.arguments) : {}
-      });
-    }
-  }
-  return blocks;
-}
-function parseAssistantContent(content, toolCalls) {
-  const blocks = [];
-  if (typeof content === "string" && content) {
-    blocks.push({ type: "text", text: content });
-  } else if (Array.isArray(content)) {
-    for (const item of content) {
-      if (item.type === "text") {
-        blocks.push({ type: "text", text: String(item.text ?? "") });
-      } else if (item.type === "tool_use") {
-        blocks.push({
-          type: "tool_use",
-          id: String(item.id ?? ""),
-          name: String(item.name ?? ""),
-          input: item.input ?? {}
-        });
-      }
-    }
-  }
-  if (toolCalls) {
-    for (const tc of toolCalls) {
-      const fn = tc.function;
-      blocks.push({
-        type: "tool_use",
-        id: String(tc.id ?? ""),
-        name: String(fn?.name ?? ""),
-        input: fn?.arguments ? JSON.parse(fn.arguments) : {}
-      });
-    }
-  }
-  return blocks;
-}
-function parseToolResult(msg) {
-  const blocks = [];
-  const toolCallId = String(msg.tool_call_id ?? "");
-  const content = msg.content;
-  if (typeof content === "string" && content) {
-    blocks.push({
-      type: "tool_result",
-      toolUseId: toolCallId,
-      content
-    });
-  } else if (Array.isArray(content)) {
-    for (const item of content) {
-      if (item.type === "text") {
-        blocks.push({
-          type: "tool_result",
-          toolUseId: toolCallId,
-          content: String(item.text ?? "")
-        });
-      }
-    }
-  }
-  return blocks;
-}
-function buildOpenAIResponse(resp, wasStreaming) {
-  if (wasStreaming) {
-    return buildOpenAIStreamResponse(resp);
-  }
-  return buildOpenAINonStreamResponse(resp);
-}
-function buildOpenAINonStreamResponse(resp) {
-  const chunks = [];
-  let content = "";
-  const toolCalls = [];
-  for (const block of resp.content) {
-    if (block.type === "text") {
-      content += block.text;
-    } else if (block.type === "tool_use") {
-      toolCalls.push({
-        id: block.id,
-        type: "function",
-        function: {
-          name: block.name,
-          arguments: JSON.stringify(block.input)
-        }
-      });
-    }
-  }
-  const message = {
-    role: "assistant",
-    content: content || null
-  };
-  if (toolCalls.length > 0) {
-    message.tool_calls = toolCalls;
-  }
-  const response = {
-    id: resp.id.startsWith("chatcmpl-") ? resp.id : `chatcmpl-${resp.id}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1e3),
-    model: resp.model,
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: mapStopReason(resp.stopReason),
-        logprobs: null
-      }
-    ],
-    usage: {
-      prompt_tokens: resp.usage.inputTokens,
-      completion_tokens: resp.usage.outputTokens,
-      total_tokens: resp.usage.inputTokens + resp.usage.outputTokens
-    }
-  };
-  return new Response(JSON.stringify(response), {
-    status: 200,
-    headers: { "content-type": "application/json" }
-  });
-}
-function mapStopReason(reason) {
-  switch (reason) {
-    case "end_turn":
-    case "stop":
-    case "stop_sequence":
-      return "stop";
-    case "max_tokens":
-    case "length":
-      return "length";
-    case "tool_use":
-      return "tool_calls";
-    default:
-      return "stop";
-  }
-}
-function buildOpenAIStreamResponse(resp) {
-  const encoder = new TextEncoder();
-  let offset = 0;
-  const stream = new ReadableStream({
-    start(controller) {
-      const baseId = resp.id.startsWith("chatcmpl-") ? resp.id : `chatcmpl-${resp.id}`;
-      const created = Math.floor(Date.now() / 1e3);
-      function emitChunk(delta, finishReason) {
-        const chunk = {
-          id: baseId,
-          object: "chat.completion.chunk",
-          created,
-          model: resp.model,
-          choices: [
-            {
-              index: 0,
-              delta,
-              finish_reason: finishReason
-            }
-          ]
-        };
-        controller.enqueue(
-          encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`)
-        );
-      }
-      emitChunk({ role: "assistant" }, null);
-      for (const block of resp.content) {
-        if (block.type === "text") {
-          const text = block.text;
-          let pos = 0;
-          while (pos < text.length) {
-            const chunk = text.slice(pos, pos + 10);
-            emitChunk({ content: chunk }, null);
-            pos += 10;
-          }
-        } else if (block.type === "tool_use") {
-          emitChunk(
-            {
-              tool_calls: [
-                {
-                  index: offset,
-                  id: block.id,
-                  type: "function",
-                  function: {
-                    name: block.name,
-                    arguments: JSON.stringify(block.input)
-                  }
-                }
-              ]
-            },
-            null
-          );
-          offset++;
-        }
-      }
-      emitChunk({}, mapStopReason(resp.stopReason));
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-      controller.close();
-    }
-  });
-  return new Response(stream, {
-    status: 200,
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      connection: "keep-alive"
-    }
-  });
-}
-function buildOpenAIUpstreamRequest(req, upstreamBase) {
-  const headers = {
-    "content-type": "application/json"
-  };
-  const cred = extractAuth(req.rawHeaders);
-  if (cred) {
-    headers["Authorization"] = `Bearer ${cred.value}`;
-  }
-  const body = {
-    model: req.model,
-    messages: buildOpenAIMessages(req.messages, req.system),
-    stream: req.stream
-  };
-  if (req.maxTokens) {
-    body.max_tokens = req.maxTokens;
-  }
-  if (req.tools.length > 0) {
-    body.tools = req.tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
-  }
-  if (req.extras) {
-    if (req.extras.temperature !== void 0) {
-      body.temperature = req.extras.temperature;
-    }
-    if (req.extras.top_p !== void 0) {
-      body.top_p = req.extras.top_p;
-    }
-    if (req.extras.frequency_penalty !== void 0) {
-      body.frequency_penalty = req.extras.frequency_penalty;
-    }
-    if (req.extras.presence_penalty !== void 0) {
-      body.presence_penalty = req.extras.presence_penalty;
-    }
-    if (req.extras.user !== void 0) {
-      body.user = req.extras.user;
-    }
-    if (req.extras.logprobs !== void 0) {
-      body.logprobs = req.extras.logprobs;
-    }
-    if (req.extras.top_logprobs !== void 0) {
-      body.top_logprobs = req.extras.top_logprobs;
-    }
-  }
-  return {
-    url: `${upstreamBase}/v1/chat/completions`,
-    headers,
-    body
-  };
-}
-function buildOpenAIMessages(messages, system) {
-  const result = [];
-  if (system) {
-    result.push({ role: "system", content: system });
-  }
-  for (const msg of messages) {
-    const blocks = msg.content;
-    const role = msg.role;
-    const textParts = [];
-    const toolUses = [];
-    for (const block of blocks) {
-      if (block.type === "text") {
-        textParts.push(block.text);
-      } else if (block.type === "tool_use") {
-        toolUses.push({
-          id: block.id,
-          type: "function",
-          function: {
-            name: block.name,
-            arguments: JSON.stringify(block.input)
-          }
-        });
-      } else if (block.type === "tool_result") {
-      }
-    }
-    const msgRecord = { role };
-    if (textParts.length > 0) {
-      msgRecord.content = textParts.join("");
-    }
-    if (toolUses.length > 0) {
-      msgRecord.tool_calls = toolUses;
-    }
-    result.push(msgRecord);
-  }
-  return result;
-}
-
-// src/stream/anthropic.ts
-function formatSSEEvent(eventType, data) {
-  return `event: ${eventType}
-data: ${data}
-
-`;
-}
-async function* parseSSEStream(reader) {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (value) {
-      buffer += decoder.decode(value, { stream: true });
-    }
-    let boundary;
-    while ((boundary = buffer.indexOf("\n\n")) !== -1) {
-      const block = buffer.slice(0, boundary);
-      buffer = buffer.slice(boundary + 2);
-      if (block.trim() === "") continue;
-      let eventType = "message";
-      const dataLines = [];
-      for (const line of block.split("\n")) {
-        if (line.startsWith("event:")) {
-          eventType = line.slice(6).trim();
-        } else if (line.startsWith("data:")) {
-          dataLines.push(line.slice(5).trimStart());
-        }
-      }
-      if (dataLines.length > 0) {
-        yield { event: eventType, data: dataLines.join("\n") };
-      }
-    }
-    if (done) {
-      if (buffer.trim()) {
-        let eventType = "message";
-        const dataLines = [];
-        for (const line of buffer.split("\n")) {
-          if (line.startsWith("event:")) {
-            eventType = line.slice(6).trim();
-          } else if (line.startsWith("data:")) {
-            dataLines.push(line.slice(5).trimStart());
-          }
-        }
-        if (dataLines.length > 0) {
-          yield { event: eventType, data: dataLines.join("\n") };
-        }
-      }
-      break;
-    }
-  }
-}
-function createStreamAccumulator() {
-  let id = "";
-  let model = "";
-  let stopReason = "";
-  let done = false;
-  const usage = {
-    inputTokens: 0,
-    outputTokens: 0
-  };
-  const blocks = /* @__PURE__ */ new Map();
-  const content = [];
-  const finalized = /* @__PURE__ */ new Set();
-  function processEvent(eventType, data) {
-    const forwarded = formatSSEEvent(eventType, data);
-    let parsed;
-    try {
-      parsed = JSON.parse(data);
-    } catch {
-      return forwarded;
-    }
-    switch (eventType) {
-      case "message_start":
-        handleMessageStart(parsed);
-        break;
-      case "content_block_start":
-        handleContentBlockStart(parsed);
-        break;
-      case "content_block_delta":
-        handleContentBlockDelta(parsed);
-        break;
-      case "content_block_stop":
-        handleContentBlockStop(parsed);
-        break;
-      case "message_delta":
-        handleMessageDelta(parsed);
-        break;
-      case "message_stop":
-        done = true;
-        break;
-    }
-    return forwarded;
-  }
-  function handleMessageStart(parsed) {
-    const message = parsed.message;
-    if (!message) return;
-    if (typeof message.id === "string") id = message.id;
-    if (typeof message.model === "string") model = message.model;
-    const msgUsage = message.usage;
-    if (msgUsage) {
-      if (typeof msgUsage.input_tokens === "number") {
-        usage.inputTokens = msgUsage.input_tokens;
-      }
-      if (typeof msgUsage.output_tokens === "number") {
-        usage.outputTokens = msgUsage.output_tokens;
-      }
-      if (typeof msgUsage.cache_read_input_tokens === "number") {
-        usage.cacheReadInputTokens = msgUsage.cache_read_input_tokens;
-      }
-      if (typeof msgUsage.cache_creation_input_tokens === "number") {
-        usage.cacheCreationInputTokens = msgUsage.cache_creation_input_tokens;
-      }
-    }
-  }
-  function handleContentBlockStart(parsed) {
-    const index = parsed.index;
-    if (typeof index !== "number") return;
-    const block = parsed.content_block;
-    if (!block || typeof block.type !== "string") return;
-    switch (block.type) {
-      case "text":
-        blocks.set(index, {
-          type: "text",
-          text: typeof block.text === "string" ? block.text : ""
-        });
-        break;
-      case "thinking":
-        blocks.set(index, {
-          type: "thinking",
-          thinking: typeof block.thinking === "string" ? block.thinking : "",
-          signature: ""
-        });
-        break;
-      case "tool_use":
-        blocks.set(index, {
-          type: "tool_use",
-          id: typeof block.id === "string" ? block.id : "",
-          name: typeof block.name === "string" ? block.name : "",
-          partialJson: ""
-        });
-        break;
-    }
-  }
-  function handleContentBlockDelta(parsed) {
-    const index = parsed.index;
-    if (typeof index !== "number") return;
-    const delta = parsed.delta;
-    if (!delta || typeof delta.type !== "string") return;
-    const block = blocks.get(index);
-    if (!block) return;
-    switch (delta.type) {
-      case "text_delta":
-        if (block.type === "text" && typeof delta.text === "string") {
-          block.text += delta.text;
-        }
-        break;
-      case "thinking_delta":
-        if (block.type === "thinking" && typeof delta.thinking === "string") {
-          block.thinking += delta.thinking;
-        }
-        break;
-      case "signature_delta":
-        if (block.type === "thinking" && typeof delta.signature === "string") {
-          block.signature += delta.signature;
-        }
-        break;
-      case "input_json_delta":
-        if (block.type === "tool_use" && typeof delta.partial_json === "string") {
-          block.partialJson += delta.partial_json;
-        }
-        break;
-    }
-  }
-  function handleContentBlockStop(parsed) {
-    const index = parsed.index;
-    if (typeof index !== "number") return;
-    const block = blocks.get(index);
-    if (!block || finalized.has(index)) return;
-    finalized.add(index);
-    switch (block.type) {
-      case "text":
-        content.push({ type: "text", text: block.text });
-        break;
-      case "thinking": {
-        const thinkingBlock = {
-          type: "thinking",
-          thinking: block.thinking
-        };
-        if (block.signature) {
-          thinkingBlock.signature = block.signature;
-        }
-        content.push(thinkingBlock);
-        break;
-      }
-      case "tool_use": {
-        let input = {};
-        if (block.partialJson) {
-          try {
-            input = JSON.parse(block.partialJson);
-          } catch {
-            input = block.partialJson;
-          }
-        }
-        content.push({
-          type: "tool_use",
-          id: block.id,
-          name: block.name,
-          input
-        });
-        break;
-      }
-    }
-  }
-  function handleMessageDelta(parsed) {
-    const delta = parsed.delta;
-    if (delta && typeof delta.stop_reason === "string") {
-      stopReason = delta.stop_reason;
-    }
-    const deltaUsage = parsed.usage;
-    if (deltaUsage) {
-      if (typeof deltaUsage.output_tokens === "number") {
-        usage.outputTokens = deltaUsage.output_tokens;
-      }
-    }
-  }
-  function getResponse() {
-    for (const [index, block] of blocks) {
-      if (!finalized.has(index)) {
-        finalized.add(index);
-        switch (block.type) {
-          case "text":
-            content.push({ type: "text", text: block.text });
-            break;
-          case "thinking":
-            content.push({
-              type: "thinking",
-              thinking: block.thinking,
-              ...block.signature ? { signature: block.signature } : {}
-            });
-            break;
-          case "tool_use": {
-            let input = {};
-            if (block.partialJson) {
-              try {
-                input = JSON.parse(block.partialJson);
-              } catch {
-                input = block.partialJson;
-              }
-            }
-            content.push({
-              type: "tool_use",
-              id: block.id,
-              name: block.name,
-              input
-            });
-            break;
-          }
-        }
-      }
-    }
-    return {
-      id,
-      model,
-      content,
-      stopReason,
-      usage: { ...usage }
-    };
-  }
-  return {
-    processEvent,
-    getResponse,
-    isDone: () => done
-  };
-}
-function buildSSETextResponse(id, model, text, usage) {
-  const events = [];
-  events.push(
-    formatSSEEvent(
-      "message_start",
-      JSON.stringify({
-        type: "message_start",
-        message: {
-          id,
-          type: "message",
-          role: "assistant",
-          content: [],
-          model,
-          stop_reason: null,
-          stop_sequence: null,
-          usage: {
-            input_tokens: usage.inputTokens,
-            output_tokens: 1
-          }
-        }
-      })
-    )
-  );
-  events.push(
-    formatSSEEvent(
-      "content_block_start",
-      JSON.stringify({
-        type: "content_block_start",
-        index: 0,
-        content_block: { type: "text", text: "" }
-      })
-    )
-  );
-  events.push(
-    formatSSEEvent(
-      "content_block_delta",
-      JSON.stringify({
-        type: "content_block_delta",
-        index: 0,
-        delta: { type: "text_delta", text }
-      })
-    )
-  );
-  events.push(
-    formatSSEEvent(
-      "content_block_stop",
-      JSON.stringify({
-        type: "content_block_stop",
-        index: 0
-      })
-    )
-  );
-  events.push(
-    formatSSEEvent(
-      "message_delta",
-      JSON.stringify({
-        type: "message_delta",
-        delta: { stop_reason: "end_turn", stop_sequence: null },
-        usage: { output_tokens: usage.outputTokens }
-      })
-    )
-  );
-  events.push(
-    formatSSEEvent(
-      "message_stop",
-      JSON.stringify({ type: "message_stop" })
-    )
-  );
-  return events.join("");
-}
-function createRecallAwareAccumulator(recallToolName = "recall") {
-  const inner = createStreamAccumulator();
-  const suppressedIndices = /* @__PURE__ */ new Set();
-  const otherToolIndices = /* @__PURE__ */ new Set();
-  let suppressedCount = 0;
-  let firstSuppressedIndex = -1;
-  let clientBlocks = 0;
-  let heldBack = "";
-  let recallDetected = false;
-  function processEvent(eventType, data) {
-    inner.processEvent(eventType, data);
-    let parsed;
-    try {
-      parsed = JSON.parse(data);
-    } catch {
-      return formatSSEEvent(eventType, data);
-    }
-    switch (eventType) {
-      case "content_block_start": {
-        const index = parsed.index;
-        if (typeof index !== "number") break;
-        const block = parsed.content_block;
-        if (block?.type === "tool_use" && block.name === recallToolName) {
-          suppressedIndices.add(index);
-          suppressedCount++;
-          recallDetected = true;
-          if (firstSuppressedIndex < 0) firstSuppressedIndex = index;
-          return "";
-        }
-        if (block?.type === "tool_use") {
-          otherToolIndices.add(index);
-        }
-        clientBlocks++;
-        if (suppressedCount > 0) {
-          const adjusted = { ...parsed, index: index - suppressedCount };
-          return formatSSEEvent(eventType, JSON.stringify(adjusted));
-        }
-        break;
-      }
-      case "content_block_delta":
-      case "content_block_stop": {
-        const index = parsed.index;
-        if (typeof index === "number" && suppressedIndices.has(index)) {
-          return "";
-        }
-        if (suppressedCount > 0 && typeof parsed.index === "number") {
-          const adjusted = {
-            ...parsed,
-            index: parsed.index - suppressedCount
-          };
-          return formatSSEEvent(eventType, JSON.stringify(adjusted));
-        }
-        break;
-      }
-      case "message_delta":
-      case "message_stop": {
-        if (recallDetected) {
-          heldBack += formatSSEEvent(eventType, data);
-          return "";
-        }
-        break;
-      }
-    }
-    return formatSSEEvent(eventType, data);
-  }
-  return {
-    processEvent,
-    getResponse: () => inner.getResponse(),
-    isDone: () => inner.isDone(),
-    hasRecall: () => recallDetected,
-    hasOtherTools: () => otherToolIndices.size > 0,
-    recallBlockIndex: () => firstSuppressedIndex,
-    clientBlockCount: () => clientBlocks,
-    heldBackEvents: () => heldBack
-  };
-}
-async function accumulateSSEResponse(response) {
-  const accumulator = createStreamAccumulator();
-  const text = await response.text();
-  for (const block of text.split("\n\n")) {
-    if (!block.trim()) continue;
-    let eventType = "message";
-    const dataLines = [];
-    for (const line of block.split("\n")) {
-      if (line.startsWith("event:")) {
-        eventType = line.slice(6).trim();
-      } else if (line.startsWith("data:")) {
-        dataLines.push(line.slice(5).trimStart());
-      }
-    }
-    if (dataLines.length > 0) {
-      accumulator.processEvent(eventType, dataLines.join("\n"));
-    }
-  }
-  return accumulator.getResponse();
-}
-
-// src/pipeline.ts
-import {
-  load,
-  config as loreConfig4,
-  ensureProject,
-  isFirstRun,
-  temporal as temporal3,
-  ltm as ltm2,
-  distillation as distillation2,
-  curator as curator2,
-  log as log6,
-  transform,
-  setModelLimits,
-  setLtmTokens,
-  getLtmBudget,
-  setMaxLayer0Tokens,
-  computeLayer0Cap,
-  calibrate,
-  getLastTransformedCount,
-  onIdleResume,
-  consumeCameOutOfIdle,
-  needsUrgentDistillation,
-  formatKnowledge,
-  buildCompactPrompt
-} from "@loreai/core";
-
-// src/session.ts
-var BASE62_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-var BASE = 62n;
-function base62Encode(bytes, minLength = 0) {
-  let n = 0n;
-  for (const b of bytes) {
-    n = n << 8n | BigInt(b);
-  }
-  if (n === 0n) return BASE62_ALPHABET[0].repeat(Math.max(1, minLength));
-  const chars = [];
-  while (n > 0n) {
-    chars.push(BASE62_ALPHABET[Number(n % BASE)]);
-    n /= BASE;
-  }
-  chars.reverse();
-  while (chars.length < minLength) {
-    chars.unshift(BASE62_ALPHABET[0]);
-  }
-  return chars.join("");
-}
-var SESSION_ID_MIN_LENGTH = 17;
-function generateSessionID() {
-  const buf = new Uint8Array(12);
-  crypto.getRandomValues(buf.subarray(0, 8));
-  const ts = Math.floor(Date.now() / 1e3);
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  view.setUint32(8, ts >>> 0, false);
-  return base62Encode(buf, SESSION_ID_MIN_LENGTH);
-}
-function extractTextParts(content) {
-  if (typeof content === "string") return [content];
-  if (Array.isArray(content)) {
-    const texts = [];
-    for (const block of content) {
-      if (block && typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") {
-        texts.push(block.text);
-      }
-    }
-    return texts;
-  }
-  return [];
-}
-async function fingerprintMessages(messages, extras) {
-  let firstUserContent = "";
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      const texts = extractTextParts(msg.content);
-      firstUserContent = texts.join("");
-      break;
-    }
-  }
-  const material = firstUserContent + (extras?.model ?? "") + (extras?.authSuffix ?? "");
-  const encoded = new TextEncoder().encode(material);
-  const hash = await crypto.subtle.digest("SHA-256", encoded);
-  const bytes = new Uint8Array(hash);
-  let hex = "";
-  for (let i = 0; i < 8; i++) {
-    hex += bytes[i].toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-var MESSAGE_COUNT_PROXIMITY_THRESHOLD = 20;
-
-// src/compaction.ts
-var COMPACTION_SYSTEM_PATTERNS = [
-  "anchored context summarization assistant"
-];
-var COMPACTION_USER_PATTERNS = [
-  "anchored summary from the conversation history above",
-  "Update the anchored summary below",
-  "<previous-summary>"
-];
-var COMPACTION_TEMPLATE_SECTIONS = [
-  "## Goal",
-  "## Progress",
-  "## Key Decisions",
-  "## Next Steps",
-  "## Critical Context",
-  "## Relevant Files"
-];
-var MIN_TEMPLATE_SECTION_MATCHES = 4;
-function lastUserText(req) {
-  for (let i = req.messages.length - 1; i >= 0; i--) {
-    const msg = req.messages[i];
-    if (msg.role === "user") {
-      return msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-    }
-  }
-  return "";
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function isCompactionRequest(req) {
-  const systemLower = req.system.toLowerCase();
-  for (const pattern of COMPACTION_SYSTEM_PATTERNS) {
-    if (systemLower.includes(pattern.toLowerCase())) return true;
-  }
-  const userText = lastUserText(req);
-  if (req.tools.length === 0 && userText) {
-    for (const pattern of COMPACTION_USER_PATTERNS) {
-      if (userText.includes(pattern)) return true;
-    }
-  }
-  if (userText.includes("<template>")) {
-    let matches = 0;
-    for (const section of COMPACTION_TEMPLATE_SECTIONS) {
-      if (userText.includes(section)) matches++;
-    }
-    if (matches >= MIN_TEMPLATE_SECTION_MATCHES) return true;
-  }
-  return false;
-}
-var PREVIOUS_SUMMARY_RE = /<previous-summary>\n(.*?)\n<\/previous-summary>/s;
-function extractPreviousSummary(req) {
-  const userText = lastUserText(req);
-  const match = PREVIOUS_SUMMARY_RE.exec(userText);
-  return match?.[1] ?? void 0;
-}
-var TITLE_SUMMARY_MAX_SYSTEM_LENGTH = 500;
-var TITLE_SUMMARY_MAX_TOOLS = 2;
-var TITLE_SUMMARY_MAX_MESSAGES = 2;
-function isTitleOrSummaryRequest(req) {
-  if (isCompactionRequest(req)) return false;
-  return req.tools.length <= TITLE_SUMMARY_MAX_TOOLS && req.messages.length <= TITLE_SUMMARY_MAX_MESSAGES && req.system.length < TITLE_SUMMARY_MAX_SYSTEM_LENGTH;
-}
-function buildCompactionResponse(_sessionID, summary, model) {
-  return {
-    id: `msg_lore_compact_${crypto.randomUUID().slice(0, 8)}`,
-    model,
-    content: [{ type: "text", text: summary }],
-    stopReason: "end_turn",
-    usage: {
-      inputTokens: 0,
-      outputTokens: estimateTokens(summary)
-    }
-  };
-}
-
-// src/temporal-adapter.ts
-import { createHash, randomUUID } from "crypto";
-import { isToolPart } from "@loreai/core";
-function deterministicID(role, index, content) {
-  const h = createHash("sha256");
-  h.update(`${role}:${index}:`);
-  for (const block of content) {
-    switch (block.type) {
-      case "text":
-        h.update(`text:${block.text}`);
-        break;
-      case "thinking":
-        h.update(`thinking:${block.thinking}`);
-        break;
-      case "tool_use":
-        h.update(`tool_use:${block.id}:${block.name}:${JSON.stringify(block.input)}`);
-        break;
-      case "tool_result":
-        h.update(`tool_result:${block.toolUseId}:${block.content}`);
-        break;
-    }
-  }
-  return h.digest("hex").slice(0, 32);
-}
-function deterministicPartID(messageID, partIndex) {
-  const h = createHash("sha256");
-  h.update(`${messageID}:part:${partIndex}`);
-  return h.digest("hex").slice(0, 32);
-}
-function contentBlockToPart(block, sessionID, messageID, partIndex) {
-  const now = Date.now();
-  const id = deterministicPartID(messageID, partIndex);
-  switch (block.type) {
-    case "text":
-      return {
-        id,
-        sessionID,
-        messageID,
-        type: "text",
-        text: block.text,
-        time: { start: now, end: now }
-      };
-    case "thinking":
-      return {
-        id,
-        sessionID,
-        messageID,
-        type: "reasoning",
-        text: block.thinking
-      };
-    case "tool_use":
-      return {
-        id,
-        sessionID,
-        messageID,
-        type: "tool",
-        tool: block.name,
-        callID: block.id,
-        state: { status: "pending", input: block.input }
-      };
-    case "tool_result":
-      return {
-        id,
-        sessionID,
-        messageID,
-        type: "tool",
-        tool: "result",
-        callID: block.toolUseId,
-        state: {
-          status: "completed",
-          input: null,
-          output: block.content,
-          time: { start: now, end: now }
-        }
-      };
-  }
-}
-function gatewayMessagesToLore(messages, sessionID) {
-  const out = [];
-  const now = Date.now();
-  for (let i = 0; i < messages.length; i++) {
-    const m = messages[i];
-    const id = deterministicID(m.role, i, m.content);
-    const parts = m.content.map(
-      (block, pi) => contentBlockToPart(block, sessionID, id, pi)
-    );
-    if (m.role === "user") {
-      const info = {
-        id,
-        sessionID,
-        role: "user",
-        time: { created: now },
-        agent: "gateway",
-        model: { providerID: "anthropic", modelID: "unknown" }
-      };
-      out.push({ info, parts });
-    } else {
-      const info = {
-        id,
-        sessionID,
-        role: "assistant",
-        time: { created: now },
-        parentID: "",
-        modelID: "unknown",
-        providerID: "anthropic",
-        mode: "gateway",
-        path: { cwd: "", root: "" },
-        cost: 0,
-        tokens: {
-          input: 0,
-          output: 0,
-          reasoning: 0,
-          cache: { read: 0, write: 0 }
-        }
-      };
-      out.push({ info, parts });
-    }
-  }
-  return out;
-}
-function updateAssistantMessageTokens(msg, usage, model) {
-  const info = msg.info;
-  if (info.role !== "assistant") return;
-  info.tokens.input = usage.inputTokens;
-  info.tokens.output = usage.outputTokens;
-  info.tokens.cache.read = usage.cacheReadInputTokens ?? 0;
-  info.tokens.cache.write = usage.cacheCreationInputTokens ?? 0;
-  info.modelID = model;
-}
-function resolveToolResults(messages) {
-  const resultsByCallID = /* @__PURE__ */ new Map();
-  for (const msg of messages) {
-    for (const part of msg.parts) {
-      if (isToolPart(part) && part.tool === "result" && part.state.status === "completed") {
-        resultsByCallID.set(part.callID, {
-          output: part.state.output,
-          isError: false
-        });
-      }
-    }
-  }
-  const now = Date.now();
-  for (const msg of messages) {
-    for (const part of msg.parts) {
-      if (isToolPart(part) && part.tool !== "result" && part.state.status === "pending") {
-        const result = resultsByCallID.get(part.callID);
-        if (result) {
-          part.state = {
-            status: "completed",
-            input: part.state.input,
-            output: result.output,
-            time: { start: now, end: now }
-          };
-        }
-      }
-    }
-  }
-  for (const msg of messages) {
-    if (msg.info.role !== "user") continue;
-    const before = msg.parts.length;
-    msg.parts = msg.parts.filter(
-      (p) => !(isToolPart(p) && p.tool === "result")
-    );
-    if (msg.parts.length === 0 && before > 0) {
-      msg.parts = [
-        {
-          id: randomUUID(),
-          sessionID: "",
-          messageID: msg.info.id,
-          type: "text",
-          text: "[tool results provided]",
-          time: { start: 0, end: 0 }
-        }
-      ];
-    }
-  }
-}
-
-// src/llm-adapter.ts
-import { log } from "@loreai/core";
-var activeWorkerCalls = /* @__PURE__ */ new Set();
-function createGatewayLLMClient(upstreamUrl, getAuth, defaultModel) {
-  return {
-    async prompt(system, user, opts) {
-      const cred = getAuth(opts?.sessionID);
-      if (!cred) {
-        log.warn("no auth credentials available for worker call");
-        return null;
-      }
-      const model = opts?.model ?? defaultModel;
-      const url = `${upstreamUrl.replace(/\/$/, "")}/v1/messages`;
-      const callID = `gw-worker-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      activeWorkerCalls.add(callID);
-      try {
-        const systemPayload = system ? [
-          {
-            type: "text",
-            text: system,
-            cache_control: { type: "ephemeral", ttl: "1h" }
-          }
-        ] : void 0;
-        const response = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "anthropic-version": "2023-06-01",
-            ...authHeaders(cred)
-          },
-          // opts.thinking is intentionally not forwarded — this bare API
-          // call never includes the `thinking` parameter so Anthropic
-          // models won't produce thinking tokens regardless.
-          body: JSON.stringify({
-            model: model.modelID,
-            max_tokens: 8192,
-            system: systemPayload ?? system,
-            messages: [{ role: "user", content: user }]
-          })
-        });
-        if (!response.ok) {
-          const text = await response.text().catch(() => "(no body)");
-          log.error(
-            `worker upstream request failed: ${response.status} ${response.statusText} \u2014 ${text}`
-          );
-          return null;
-        }
-        const data = await response.json();
-        const textBlock = data.content?.find(
-          (b) => b.type === "text" && typeof b.text === "string"
-        );
-        return textBlock?.text ?? null;
-      } catch (e) {
-        log.error("worker prompt failed:", e);
-        return null;
-      } finally {
-        activeWorkerCalls.delete(callID);
-      }
-    }
-  };
-}
-
-// src/batch-queue.ts
-import { log as log2 } from "@loreai/core";
-var DEFAULT_FLUSH_INTERVAL_MS = 3e4;
-var DEFAULT_MAX_QUEUE_SIZE = 50;
-var DEFAULT_POLL_INTERVAL_MS = 6e4;
-var DEFAULT_MAX_BATCH_AGE_MS = 36e5;
-var idCounter = 0;
-function generateCustomId() {
-  const ts = Date.now().toString(36);
-  const seq = (idCounter++).toString(36);
-  const rand = Math.random().toString(36).slice(2, 8);
-  return `lore-${ts}-${seq}-${rand}`;
-}
-function authKey(cred) {
-  return `${cred.scheme}:${cred.value}`;
-}
-function createBatchLLMClient(inner, upstreamUrl, getAuth, defaultModel, batchConfig) {
-  const flushIntervalMs = batchConfig?.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
-  const maxQueueSize = batchConfig?.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
-  const pollIntervalMs = batchConfig?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const maxBatchAgeMs = batchConfig?.maxBatchAgeMs ?? DEFAULT_MAX_BATCH_AGE_MS;
-  const queue = [];
-  const inflight = /* @__PURE__ */ new Map();
-  let flushTimer = null;
-  let shuttingDown = false;
-  let totalQueued = 0;
-  let totalBatched = 0;
-  let totalUrgent = 0;
-  let totalFallback = 0;
-  let totalResolved = 0;
-  let totalFailed = 0;
-  async function submitBatch(auth, items) {
-    const requests = items.map((item) => ({
-      custom_id: item.customId,
-      params: item.params
-    }));
-    log2.info(`batch flush: submitting ${items.length} requests`);
-    try {
-      const url = `${upstreamUrl.replace(/\/$/, "")}/v1/messages/batches`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "anthropic-version": "2023-06-01",
-          ...authHeaders(auth)
-        },
-        body: JSON.stringify({ requests })
-      });
-      if (!response.ok) {
-        const text = await response.text().catch(() => "(no body)");
-        log2.error(`batch create failed: ${response.status} ${response.statusText} \u2014 ${text}`);
-        await fallbackAll(items);
-        return;
-      }
-      const data = await response.json();
-      totalBatched += items.length;
-      const requestMap = /* @__PURE__ */ new Map();
-      for (const item of items) {
-        requestMap.set(item.customId, item);
-      }
-      const pollTimer = setInterval(
-        () => pollBatch(data.id).catch((e) => log2.error("batch poll error:", e)),
-        pollIntervalMs
-      );
-      inflight.set(data.id, {
-        batchId: data.id,
-        requests: requestMap,
-        submittedAt: Date.now(),
-        pollTimer,
-        auth
-      });
-      log2.info(`batch created: ${data.id} with ${items.length} requests`);
-    } catch (e) {
-      log2.error("batch create error:", e);
-      await fallbackAll(items);
-    }
-  }
-  async function flush() {
-    if (queue.length === 0) return;
-    const batch = queue.splice(0);
-    const byAuth = /* @__PURE__ */ new Map();
-    for (const item of batch) {
-      const key = authKey(item.auth);
-      let group = byAuth.get(key);
-      if (!group) {
-        group = { auth: item.auth, items: [] };
-        byAuth.set(key, group);
-      }
-      group.items.push(item);
-    }
-    for (const { auth, items } of byAuth.values()) {
-      await submitBatch(auth, items);
-    }
-  }
-  async function pollBatch(batchId) {
-    const batch = inflight.get(batchId);
-    if (!batch) return;
-    if (Date.now() - batch.submittedAt > maxBatchAgeMs) {
-      log2.warn(`batch ${batchId} exceeded max age \u2014 falling back to synchronous`);
-      clearInterval(batch.pollTimer);
-      inflight.delete(batchId);
-      await fallbackAll([...batch.requests.values()]);
-      return;
-    }
-    try {
-      const url = `${upstreamUrl.replace(/\/$/, "")}/v1/messages/batches/${batchId}`;
-      const response = await fetch(url, {
-        headers: {
-          "anthropic-version": "2023-06-01",
-          ...authHeaders(batch.auth)
-        }
-      });
-      if (!response.ok) {
-        log2.error(`batch poll failed for ${batchId}: ${response.status}`);
-        return;
-      }
-      const data = await response.json();
-      if (data.processing_status !== "ended") return;
-      log2.info(`batch ${batchId} ended \u2014 retrieving results`);
-      if (data.results_url) {
-        await retrieveResults(batchId, data.results_url);
-      } else {
-        await retrieveResults(
-          batchId,
-          `${upstreamUrl.replace(/\/$/, "")}/v1/messages/batches/${batchId}/results`
-        );
-      }
-    } catch (e) {
-      log2.error(`batch poll error for ${batchId}:`, e);
-    }
-  }
-  async function retrieveResults(batchId, resultsUrl) {
-    const batch = inflight.get(batchId);
-    if (!batch) return;
-    try {
-      const response = await fetch(resultsUrl, {
-        headers: {
-          "anthropic-version": "2023-06-01",
-          ...authHeaders(batch.auth)
-        }
-      });
-      if (!response.ok) {
-        log2.error(`batch results fetch failed for ${batchId}: ${response.status}`);
-        return;
-      }
-      const text = await response.text();
-      const lines = text.split("\n").filter((l) => l.trim());
-      for (const line of lines) {
-        try {
-          const result = JSON.parse(line);
-          const pending = batch.requests.get(result.custom_id);
-          if (!pending) continue;
-          switch (result.result.type) {
-            case "succeeded": {
-              const textBlock = result.result.message?.content?.find(
-                (b) => b.type === "text" && typeof b.text === "string"
-              );
-              pending.resolve(textBlock?.text ?? null);
-              totalResolved++;
-              break;
-            }
-            case "errored":
-              pending.resolve(null);
-              totalFailed++;
-              log2.error(
-                `batch item ${result.custom_id} errored: ${result.result.error?.type ?? "unknown"} \u2014 ${result.result.error?.message ?? JSON.stringify(result.result.error)}`
-              );
-              break;
-            case "canceled":
-            case "expired":
-              pending.resolve(null);
-              totalFailed++;
-              log2.warn(`batch item ${result.custom_id} ${result.result.type}`);
-              break;
-          }
-          batch.requests.delete(result.custom_id);
-        } catch {
-          log2.error(`failed to parse batch result line: ${line.slice(0, 200)}`);
-        }
-      }
-      for (const [, pending] of batch.requests) {
-        pending.resolve(null);
-        totalFailed++;
-      }
-      clearInterval(batch.pollTimer);
-      inflight.delete(batchId);
-      log2.info(
-        `batch ${batchId} fully resolved (${totalResolved} ok, ${totalFailed} failed total)`
-      );
-    } catch (e) {
-      log2.error(`batch results retrieval error for ${batchId}:`, e);
-    }
-  }
-  async function fallbackAll(items) {
-    totalFallback += items.length;
-    log2.info(`batch fallback: processing ${items.length} items synchronously`);
-    const CONCURRENCY = 5;
-    for (let i = 0; i < items.length; i += CONCURRENCY) {
-      const chunk = items.slice(i, i + CONCURRENCY);
-      await Promise.all(
-        chunk.map(async (item) => {
-          try {
-            const system = typeof item.params.system === "string" ? item.params.system : item.params.system.map((b) => b.text).join("\n");
-            const user = item.params.messages[0]?.content ?? "";
-            const result = await inner.prompt(system, user, { urgent: true });
-            item.resolve(result);
-          } catch (e) {
-            log2.error(`batch fallback error for ${item.customId}:`, e);
-            item.resolve(null);
-          }
-        })
-      );
-    }
-  }
-  flushTimer = setInterval(() => {
-    flush().catch((e) => log2.error("batch flush timer error:", e));
-  }, flushIntervalMs);
-  return {
-    async prompt(system, user, opts) {
-      if (opts?.urgent || shuttingDown) {
-        totalUrgent++;
-        return inner.prompt(system, user, opts);
-      }
-      const cred = getAuth(opts?.sessionID);
-      if (!cred) {
-        totalUrgent++;
-        return inner.prompt(system, user, opts);
-      }
-      totalQueued++;
-      const model = opts?.model ?? defaultModel;
-      const systemPayload = system ? [
-        {
-          type: "text",
-          text: system,
-          cache_control: { type: "ephemeral", ttl: "1h" }
-        }
-      ] : system;
-      const customId = generateCustomId();
-      const promise = new Promise((resolve, reject) => {
-        queue.push({
-          customId,
-          params: {
-            model: model.modelID,
-            max_tokens: 8192,
-            system: systemPayload ?? system,
-            messages: [{ role: "user", content: user }]
-          },
-          resolve,
-          reject,
-          enqueuedAt: Date.now(),
-          auth: cred
-        });
-      });
-      if (queue.length >= maxQueueSize) {
-        flush().catch((e) => log2.error("batch auto-flush error:", e));
-      }
-      return promise;
-    },
-    /**
-     * Gracefully shut down the batch queue:
-     * 1. Stop the flush timer
-     * 2. Flush any remaining queued items (as a batch if possible, fallback sync)
-     * 3. Switch to synchronous mode for future calls
-     * 4. DON'T wait for inflight batches — they resolve eventually or expire
-     */
-    async shutdown() {
-      shuttingDown = true;
-      if (flushTimer) {
-        clearInterval(flushTimer);
-        flushTimer = null;
-      }
-      if (queue.length > 0) {
-        log2.info(`batch shutdown: processing ${queue.length} remaining items synchronously`);
-        await fallbackAll(queue.splice(0));
-      }
-      for (const [batchId, batch] of inflight) {
-        clearInterval(batch.pollTimer);
-        for (const [, pending] of batch.requests) {
-          pending.resolve(null);
-        }
-        log2.warn(`batch shutdown: abandoned inflight batch ${batchId}`);
-      }
-      inflight.clear();
-    },
-    /** Return current batch queue statistics. */
-    stats() {
-      return {
-        queued: queue.length,
-        inflightBatches: inflight.size,
-        inflightRequests: [...inflight.values()].reduce(
-          (sum, b) => sum + b.requests.size,
-          0
-        ),
-        totalQueued,
-        totalBatched,
-        totalUrgent,
-        totalFallback,
-        totalResolved,
-        totalFailed
-      };
-    }
-  };
-}
-
-// src/idle.ts
-import { join } from "node:path";
-import {
-  temporal as temporal2,
-  distillation,
-  curator,
-  ltm,
-  latReader,
-  log as log4,
-  config as loreConfig2,
-  exportToFile,
-  exportLoreFile
-} from "@loreai/core";
-
-// src/worker-model.ts
-import {
-  workerModel,
-  temporal,
-  distillation as distillationMod,
-  config as loreConfig,
-  log as log3
-} from "@loreai/core";
-var MODELS_DEV_API = "https://models.dev/api.json";
-var cachedCostMap = null;
-var cachedCostMapAt = 0;
-var COST_CACHE_TTL_MS = 60 * 60 * 1e3;
-var FALLBACK_COSTS = [
-  { prefix: "claude-opus-4", inputCostPerToken: 15 / 1e6 },
-  { prefix: "claude-sonnet-4", inputCostPerToken: 3 / 1e6 },
-  { prefix: "claude-haiku-4", inputCostPerToken: 1 / 1e6 },
-  { prefix: "claude-haiku-3-5", inputCostPerToken: 0.8 / 1e6 },
-  { prefix: "claude-sonnet-3-5", inputCostPerToken: 3 / 1e6 },
-  { prefix: "claude-3-haiku", inputCostPerToken: 0.25 / 1e6 },
-  { prefix: "claude-3-sonnet", inputCostPerToken: 3 / 1e6 },
-  { prefix: "claude-3-opus", inputCostPerToken: 15 / 1e6 }
-];
-function fallbackCost(modelID) {
-  for (const { prefix, inputCostPerToken } of FALLBACK_COSTS) {
-    if (modelID.startsWith(prefix)) return inputCostPerToken;
-  }
-  return 100 / 1e6;
-}
-async function fetchCostMap() {
-  if (cachedCostMap && Date.now() - cachedCostMapAt < COST_CACHE_TTL_MS) {
-    return cachedCostMap;
-  }
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    const response = await fetch(MODELS_DEV_API, { signal: controller.signal });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      log3.warn(`models.dev API failed: ${response.status} ${response.statusText}`);
-      return cachedCostMap ?? /* @__PURE__ */ new Map();
-    }
-    const data = await response.json();
-    const anthropic = data.anthropic?.models;
-    if (!anthropic) {
-      log3.warn("models.dev API: no anthropic provider found");
-      return cachedCostMap ?? /* @__PURE__ */ new Map();
-    }
-    const costMap = /* @__PURE__ */ new Map();
-    for (const [modelId, entry] of Object.entries(anthropic)) {
-      if (entry.cost?.input != null) {
-        costMap.set(modelId, entry.cost.input);
-      }
-    }
-    cachedCostMap = costMap;
-    cachedCostMapAt = Date.now();
-    log3.info(`models.dev: loaded costs for ${costMap.size} anthropic models`);
-    return costMap;
-  } catch (e) {
-    log3.warn("models.dev API error:", e);
-    return cachedCostMap ?? /* @__PURE__ */ new Map();
-  }
-}
-function clearCostCache() {
-  cachedCostMap = null;
-  cachedCostMapAt = 0;
-}
-async function fetchModelCosts(modelIDs) {
-  const costMap = await fetchCostMap();
-  const costs = /* @__PURE__ */ new Map();
-  for (const id of modelIDs) {
-    const costPerMillion = costMap.get(id);
-    if (costPerMillion != null) {
-      costs.set(id, costPerMillion / 1e6);
-    } else {
-      costs.set(id, fallbackCost(id));
-    }
-  }
-  return costs;
-}
-var cachedModels = null;
-var cachedModelsAt = 0;
-var MODEL_CACHE_TTL_MS = 60 * 60 * 1e3;
-async function discoverModels(upstreamUrl, cred) {
-  if (cachedModels && Date.now() - cachedModelsAt < MODEL_CACHE_TTL_MS) {
-    return cachedModels;
-  }
-  try {
-    const entries = [];
-    let afterId;
-    do {
-      const url = new URL(`${upstreamUrl}/v1/models`);
-      url.searchParams.set("limit", "1000");
-      if (afterId) url.searchParams.set("after_id", afterId);
-      const response = await fetch(url.toString(), {
-        headers: {
-          "content-type": "application/json",
-          "anthropic-version": "2023-06-01",
-          ...authHeaders(cred)
-        }
-      });
-      if (!response.ok) {
-        const text = await response.text().catch(() => "(no body)");
-        log3.warn(
-          `model discovery failed: ${response.status} ${response.statusText} \u2014 ${text}`
-        );
-        return cachedModels ?? [];
-      }
-      const data = await response.json();
-      for (const entry of data.data) {
-        entries.push(entry);
-      }
-      afterId = data.has_more ? data.last_id : void 0;
-    } while (afterId);
-    const modelIDs = entries.map((e) => e.id);
-    const costs = await fetchModelCosts(modelIDs);
-    const models = entries.map((entry) => ({
-      id: entry.id,
-      providerID: "anthropic",
-      cost: { input: costs.get(entry.id) ?? fallbackCost(entry.id) },
-      status: "active",
-      // Only active models are returned by the API
-      capabilities: {
-        input: { text: true },
-        // All Anthropic models accept text
-        reasoning: entry.capabilities?.thinking?.supported ?? false
-      }
-    }));
-    cachedModels = models;
-    cachedModelsAt = Date.now();
-    log3.info(
-      `model discovery: found ${models.length} models (${models.map((m) => m.id).join(", ")})`
-    );
-    return models;
-  } catch (e) {
-    log3.warn("model discovery error:", e);
-    return cachedModels ?? [];
-  }
-}
-function clearModelCache() {
-  cachedModels = null;
-  cachedModelsAt = 0;
-}
-var validating = false;
-async function maybeValidateWorkerModel(sessionModel, upstreamUrl, cred, llm, projectPath, sessionID) {
-  if (validating) return;
-  const cfg = loreConfig();
-  if (cfg.workerModel) return;
-  const models = await discoverModels(upstreamUrl, cred);
-  if (models.length === 0) return;
-  const discoveredModel = models.find((m) => m.id === sessionModel);
-  const sessionModelInfo = {
-    id: sessionModel,
-    providerID: "anthropic",
-    cost: { input: discoveredModel?.cost.input ?? fallbackCost(sessionModel) }
-  };
-  const candidates = workerModel.selectWorkerCandidates(sessionModelInfo, models);
-  if (candidates.length === 0) return;
-  if (candidates.length === 1 && candidates[0].id === sessionModel) return;
-  const fingerprint = workerModel.computeModelFingerprint(
-    "anthropic",
-    sessionModel,
-    models.filter((m) => m.providerID === "anthropic").map((m) => m.id)
-  );
-  const stored = workerModel.getValidatedWorkerModel("anthropic");
-  if (!workerModel.isValidationStale(stored, fingerprint)) return;
-  const distillations = distillationMod.loadForSession(projectPath, sessionID, true);
-  const gen0 = distillations.filter((d) => d.generation === 0);
-  if (gen0.length === 0) return;
-  const reference = gen0[gen0.length - 1];
-  const sourceIds = reference.source_ids;
-  if (sourceIds.length === 0) return;
-  const allMessages = temporal.bySession(projectPath, sessionID);
-  const sourceSet = new Set(sourceIds);
-  const sourceMessages = allMessages.filter((m) => sourceSet.has(m.id));
-  if (sourceMessages.length === 0) return;
-  const messagesText = sourceMessages.map((m) => m.content).join("\n");
-  const date = new Date(sourceMessages[0].created_at).toLocaleDateString(
-    "en-US",
-    { year: "numeric", month: "long", day: "numeric" }
-  );
-  validating = true;
-  try {
-    const result = await workerModel.runValidation({
-      llm,
-      providerID: "anthropic",
-      sessionModelID: sessionModel,
-      candidates,
-      referenceObservations: reference.observations,
-      sourceMessagesText: messagesText,
-      date
-    });
-    if (result) {
-      log3.info(
-        `worker model validated: ${result.modelID} (judge=${result.judgeScore}) \u2014 saving 50%+ on worker calls`
-      );
-    }
-  } catch (e) {
-    log3.error("worker model validation error:", e);
-  } finally {
-    validating = false;
-  }
-}
-function getWorkerModel() {
-  const cfg = loreConfig();
-  return workerModel.resolveWorkerModel(
-    "anthropic",
-    cfg.workerModel,
-    cfg.model
-  );
-}
-function resetWorkerModelState() {
-  clearModelCache();
-  clearCostCache();
-  validating = false;
-}
-
-// src/idle.ts
-var POLL_INTERVAL_MS = 3e4;
-function startIdleScheduler(config2, sessions2, doIdleWork) {
-  const inProgress = /* @__PURE__ */ new Set();
-  const timer = setInterval(() => {
-    const now = Date.now();
-    const timeoutMs = config2.idleTimeoutSeconds * 1e3;
-    for (const [sessionID, state] of sessions2) {
-      if (inProgress.has(sessionID)) continue;
-      if (now - state.lastRequestTime < timeoutMs) continue;
-      inProgress.add(sessionID);
-      doIdleWork(sessionID, state).catch((e) => log4.error(`idle work failed for session ${sessionID}:`, e)).finally(() => inProgress.delete(sessionID));
-    }
-  }, POLL_INTERVAL_MS);
-  return () => clearInterval(timer);
-}
-function buildIdleWorkHandler(projectPath, llm, upstreamUrl, getAuth, sessionModel, onLtmInvalidated) {
-  return async (sessionID, state) => {
-    const cfg = loreConfig2();
-    try {
-      const cred = getAuth();
-      if (cred) {
-        await maybeValidateWorkerModel(
-          sessionModel,
-          upstreamUrl,
-          cred,
-          llm,
-          projectPath,
-          sessionID
-        );
-      }
-    } catch (e) {
-      log4.error("idle worker model validation error:", e);
-    }
-    const model = getWorkerModel();
-    try {
-      const pending = temporal2.undistilledCount(projectPath, sessionID);
-      if (pending > 0) {
-        await distillation.run({ llm, projectPath, sessionID, model, force: true });
-      }
-    } catch (e) {
-      log4.error("idle distillation error:", e);
-    }
-    if (cfg.knowledge.enabled && cfg.curator.onIdle) {
-      try {
-        if (state.turnsSinceCuration >= cfg.curator.afterTurns) {
-          await curator.run({ llm, projectPath, sessionID, model });
-          state.turnsSinceCuration = 0;
-          onLtmInvalidated?.();
-        }
-      } catch (e) {
-        log4.error("idle curation error:", e);
-      }
-    }
-    if (cfg.knowledge.enabled) {
-      try {
-        const entries = ltm.forProject(projectPath, false);
-        if (entries.length > cfg.curator.maxEntries) {
-          log4.info(
-            `entry count ${entries.length} exceeds maxEntries ${cfg.curator.maxEntries} \u2014 running consolidation`
-          );
-          const { updated, deleted } = await curator.consolidate({
-            llm,
-            projectPath,
-            sessionID,
-            model
-          });
-          if (updated > 0 || deleted > 0) {
-            log4.info(`consolidation: ${updated} updated, ${deleted} deleted`);
-            onLtmInvalidated?.();
-          }
-        }
-      } catch (e) {
-        log4.error("idle consolidation error:", e);
-      }
-    }
-    try {
-      const { ttlDeleted, capDeleted } = temporal2.prune({
-        projectPath,
-        retentionDays: cfg.pruning.retention,
-        maxStorageMB: cfg.pruning.maxStorage
-      });
-      if (ttlDeleted > 0 || capDeleted > 0) {
-        log4.info(
-          `pruned temporal messages: ${ttlDeleted} by TTL, ${capDeleted} by size cap`
-        );
-      }
-    } catch (e) {
-      log4.error("idle pruning error:", e);
-    }
-    if (cfg.knowledge.enabled) {
-      try {
-        const entries = ltm.forProject(projectPath, false);
-        if (entries.length > 0) {
-          if (cfg.agentsFile.enabled) {
-            const filePath = join(projectPath, cfg.agentsFile.path);
-            exportToFile({ projectPath, filePath });
-          } else {
-            exportLoreFile(projectPath);
-          }
-        }
-      } catch (e) {
-        log4.error("idle knowledge export error:", e);
-      }
-    }
-    if (cfg.knowledge.enabled) {
-      try {
-        const cleaned = ltm.cleanDeadRefs();
-        if (cleaned > 0) {
-          log4.info(`cleaned ${cleaned} dead knowledge cross-references`);
-          onLtmInvalidated?.();
-        }
-      } catch (e) {
-        log4.error("idle dead-ref cleanup error:", e);
-      }
-    }
-    try {
-      latReader.refresh(projectPath);
-    } catch (e) {
-      log4.error("idle lat-reader refresh error:", e);
-    }
-  };
-}
-
-// src/recall.ts
-import {
-  runRecall,
-  RECALL_TOOL_DESCRIPTION,
-  RECALL_PARAM_DESCRIPTIONS,
-  log as log5,
-  config as loreConfig3
-} from "@loreai/core";
-var RECALL_GATEWAY_TOOL = {
-  name: "recall",
-  description: RECALL_TOOL_DESCRIPTION,
-  inputSchema: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: RECALL_PARAM_DESCRIPTIONS.query
-      },
-      scope: {
-        type: "string",
-        enum: ["all", "session", "project", "knowledge"],
-        description: RECALL_PARAM_DESCRIPTIONS.scope
-      }
-    },
-    required: ["query"]
-  }
-};
-var RECALL_TOOL_NAME = "recall";
-var PENDING_RECALL_TTL_MS = 6e4;
-function isPendingRecallValid(pending) {
-  return Date.now() - pending.timestamp < PENDING_RECALL_TTL_MS;
-}
-function findRecallToolUse(resp) {
-  return resp.content.find(
-    (b) => b.type === "tool_use" && b.name === RECALL_TOOL_NAME
-  );
-}
-function hasRecallToolUse(resp) {
-  return findRecallToolUse(resp) !== void 0;
-}
-function hasOtherToolUse(resp) {
-  return resp.content.some(
-    (b) => b.type === "tool_use" && b.name !== RECALL_TOOL_NAME
-  );
-}
-function clientHasRecallTool(tools) {
-  return tools.some((t) => t.name === RECALL_TOOL_NAME);
-}
-function parseRecallInput(block) {
-  const input = block.input;
-  return {
-    query: typeof input.query === "string" ? input.query : "",
-    scope: input.scope ?? "all"
-  };
-}
-async function executeRecall(block, projectPath, sessionID) {
-  const { query, scope } = parseRecallInput(block);
-  const cfg = loreConfig3();
-  try {
-    const result = await runRecall({
-      query,
-      scope,
-      projectPath,
-      sessionID,
-      knowledgeEnabled: cfg.knowledge?.enabled ?? true,
-      searchConfig: cfg.search
-    });
-    return { result, input: { query, scope } };
-  } catch (e) {
-    log5.error("gateway recall execution failed:", e);
-    return {
-      result: "Recall search failed. The memory system encountered an error.",
-      input: { query, scope }
-    };
-  }
-}
-function buildRecallFollowUp(originalReq, resp, recallResult, recallToolUseBlock) {
-  const assistantMessage = {
-    role: "assistant",
-    content: [recallToolUseBlock]
-  };
-  const toolResultMessage = {
-    role: "user",
-    content: [
-      {
-        type: "tool_result",
-        toolUseId: recallToolUseBlock.id,
-        content: recallResult || "[No results found.]"
-      }
-    ]
-  };
-  const toolsWithoutRecall = originalReq.tools.filter(
-    (t) => t.name !== RECALL_TOOL_NAME
-  );
-  return {
-    ...originalReq,
-    messages: [
-      ...originalReq.messages,
-      assistantMessage,
-      toolResultMessage
-    ],
-    tools: toolsWithoutRecall
-  };
-}
-function injectPendingRecall(req, pending) {
-  const messages = req.messages;
-  if (messages.length < 2) return false;
-  let assistantIdx = -1;
-  for (let i = messages.length - 2; i >= 0; i--) {
-    if (messages[i].role === "assistant" && messages[i + 1]?.role === "user") {
-      assistantIdx = i;
-      break;
-    }
-  }
-  if (assistantIdx < 0) {
-    log5.warn("injectPendingRecall: no assistant\u2192user pair found");
-    return false;
-  }
-  const assistantMsg = messages[assistantIdx];
-  const userMsg = messages[assistantIdx + 1];
-  const insertPos = Math.min(pending.position, assistantMsg.content.length);
-  const recallToolUse = {
-    type: "tool_use",
-    id: pending.toolUseId,
-    name: RECALL_TOOL_NAME,
-    input: pending.input
-  };
-  assistantMsg.content.splice(insertPos, 0, recallToolUse);
-  userMsg.content.unshift({
-    type: "tool_result",
-    toolUseId: pending.toolUseId,
-    content: pending.result
-  });
-  req.tools = req.tools.filter((t) => t.name !== RECALL_TOOL_NAME);
-  return true;
-}
-function stripRecallFromResponse(resp) {
-  return {
-    ...resp,
-    content: resp.content.filter(
-      (b) => !(b.type === "tool_use" && b.name === RECALL_TOOL_NAME)
-    )
-  };
-}
-
-// src/pipeline.ts
-var initialized = false;
-var activeInterceptor;
-async function resetPipelineState() {
-  initialized = false;
-  cachedProjectPath = null;
-  sessions.clear();
-  ltmSessionCache.clear();
-  if (llmClient && "shutdown" in llmClient) {
-    await llmClient.shutdown();
-  }
-  llmClient = null;
-  activeInterceptor = void 0;
-  if (stopIdleScheduler) {
-    stopIdleScheduler();
-    stopIdleScheduler = null;
-  }
-  lastSeenSessionModel = null;
-  resetWorkerModelState();
-}
-var cachedProjectPath = null;
-var sessions = /* @__PURE__ */ new Map();
-var ltmSessionCache = /* @__PURE__ */ new Map();
-var llmClient = null;
-var stopIdleScheduler = null;
-var lastSeenSessionModel = null;
-var MODEL_SPECS = {
-  // Pricing: https://docs.anthropic.com/en/docs/about-claude/models
-  // Cache-read = input_price / 1_000_000 * 0.1 (10% of input for Anthropic)
-  "claude-opus-4": { context: 2e5, output: 32e3, cacheReadCost: 15 / 1e6 * 0.1 },
-  "claude-sonnet-4": { context: 2e5, output: 16e3, cacheReadCost: 3 / 1e6 * 0.1 },
-  "claude-sonnet-3-5": { context: 2e5, output: 8192, cacheReadCost: 3 / 1e6 * 0.1 },
-  "claude-haiku-3-5": { context: 2e5, output: 8192, cacheReadCost: 0.8 / 1e6 * 0.1 }
-};
-var DEFAULT_MODEL_SPEC = { context: 2e5, output: 8192 };
-function getModelSpec(model) {
-  for (const [prefix, spec] of Object.entries(MODEL_SPECS)) {
-    if (model.startsWith(prefix)) return spec;
-  }
-  return DEFAULT_MODEL_SPEC;
-}
-async function initIfNeeded(projectPath, config2) {
-  if (initialized) return;
-  await load(projectPath);
-  ensureProject(projectPath);
-  initialized = true;
-  cachedProjectPath = projectPath;
-  if (config2 && !stopIdleScheduler) {
-    const llm = getLLMClient(config2);
-    const sessionModelID = lastSeenSessionModel ?? (loreConfig4().model?.modelID ?? "claude-sonnet-4-20250514");
-    const idleHandler = buildIdleWorkHandler(
-      projectPath,
-      llm,
-      config2.upstreamAnthropic,
-      () => resolveAuth(),
-      sessionModelID,
-      // onLtmInvalidated: clear the LTM session cache
-      () => ltmSessionCache.clear()
-    );
-    stopIdleScheduler = startIdleScheduler(config2, sessions, idleHandler);
-  }
-  log6.info(`gateway pipeline initialized: ${projectPath}`);
-}
-function getLLMClient(config2) {
-  if (!llmClient) {
-    const cfg = loreConfig4();
-    const defaultModel = cfg.model ?? {
-      providerID: "anthropic",
-      modelID: "claude-sonnet-4-20250514"
-    };
-    const inner = createGatewayLLMClient(
-      config2.upstreamAnthropic,
-      resolveAuth,
-      defaultModel
-    );
-    const batchDisabled = process.env.LORE_BATCH_DISABLED === "1";
-    if (batchDisabled) {
-      llmClient = inner;
-    } else {
-      llmClient = createBatchLLMClient(
-        inner,
-        config2.upstreamAnthropic,
-        resolveAuth,
-        defaultModel
-      );
-    }
-  }
-  return llmClient;
-}
-function getOrCreateSession(sessionID, projectPath) {
-  let state = sessions.get(sessionID);
-  if (!state) {
-    state = {
-      sessionID,
-      projectPath,
-      fingerprint: "",
-      lastRequestTime: Date.now(),
-      messageCount: 0,
-      turnsSinceCuration: 0
-    };
-    sessions.set(sessionID, state);
-  }
-  state.lastRequestTime = Date.now();
-  if (state.pendingRecall && !isPendingRecallValid(state.pendingRecall)) {
-    log6.warn(
-      `lazy cleanup: discarding expired pending recall for session ${sessionID.slice(0, 16)}`
-    );
-    state.pendingRecall = void 0;
-  }
-  return state;
-}
-async function identifySession(req, _projectPath) {
-  const rawMessages = req.messages.map((m) => ({
-    role: m.role,
-    content: m.content
-  }));
-  const cred = extractAuth(req.rawHeaders);
-  const fingerprint = await fingerprintMessages(rawMessages, {
-    model: req.model,
-    authSuffix: cred ? authFingerprint(cred) : ""
-  });
-  const msgCount = req.messages.length;
-  let bestMatch = null;
-  for (const [sid, state] of sessions) {
-    if (state.fingerprint !== fingerprint) continue;
-    const diff = msgCount - state.messageCount;
-    if (diff < -MESSAGE_COUNT_PROXIMITY_THRESHOLD) continue;
-    const absDiff = Math.abs(diff);
-    if (!bestMatch || absDiff < bestMatch.countDiff) {
-      bestMatch = { sid, countDiff: absDiff };
-    }
-  }
-  if (bestMatch) {
-    return { sessionID: bestMatch.sid, isNew: false };
-  }
-  const sessionID = generateSessionID();
-  return { sessionID, isNew: true };
-}
-async function forwardToUpstream(req, config2, interceptor, cache) {
-  let url;
-  let headers;
-  let body;
-  const route = resolveUpstreamRoute(req.model);
-  const effectiveProtocol = route?.protocol ?? req.protocol;
-  const effectiveUpstreamBase = route?.url ?? (effectiveProtocol === "openai" ? config2.upstreamOpenAI : config2.upstreamAnthropic);
-  if (effectiveProtocol === "openai") {
-    const result = buildOpenAIUpstreamRequest(req, effectiveUpstreamBase);
-    url = result.url;
-    headers = result.headers;
-    body = result.body;
-  } else {
-    const result = buildAnthropicRequest(req, cache);
-    url = `${effectiveUpstreamBase}${result.url}`;
-    headers = result.headers;
-    body = result.body;
-  }
-  const effectiveInterceptor = interceptor ?? activeInterceptor;
-  if (effectiveInterceptor) {
-    return effectiveInterceptor(
-      body,
-      req.model,
-      req.stream,
-      () => fetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body)
-      })
-    );
-  }
-  return fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-}
-function buildStreamingResponse(upstreamResponse, onComplete, recallContext) {
-  const recallAccum = recallContext ? createRecallAwareAccumulator(RECALL_TOOL_NAME) : null;
-  const accumulator = recallAccum ?? createStreamAccumulator();
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    async start(controller) {
-      try {
-        const reader = upstreamResponse.body.getReader();
-        for await (const { event, data } of parseSSEStream(reader)) {
-          const forwarded = accumulator.processEvent(event, data);
-          if (forwarded) {
-            controller.enqueue(encoder.encode(forwarded));
-          }
-        }
-        if (recallAccum?.hasRecall()) {
-          const resp = recallAccum.getResponse();
-          const recallBlock = findRecallToolUse(resp);
-          if (recallBlock && recallContext) {
-            const { result, input } = await executeRecall(
-              recallBlock,
-              recallContext.sessionState.projectPath,
-              recallContext.sessionState.sessionID
-            );
-            if (recallAccum.hasOtherTools()) {
-              const position = resp.content.indexOf(recallBlock);
-              recallContext.sessionState.pendingRecall = {
-                toolUseId: recallBlock.id,
-                input,
-                position,
-                result,
-                timestamp: Date.now()
-              };
-              log6.info(
-                `recall (stream, mixed): stored pending result for session ${recallContext.sessionState.sessionID.slice(0, 16)}`
-              );
-              const searchingIdx = recallAccum.clientBlockCount();
-              const syntheticCase2 = [
-                formatSSEEvent("content_block_start", JSON.stringify({
-                  type: "content_block_start",
-                  index: searchingIdx,
-                  content_block: { type: "text", text: "" }
-                })),
-                formatSSEEvent("content_block_delta", JSON.stringify({
-                  type: "content_block_delta",
-                  index: searchingIdx,
-                  delta: { type: "text_delta", text: "\n\n[Searching memory...]" }
-                })),
-                formatSSEEvent("content_block_stop", JSON.stringify({
-                  type: "content_block_stop",
-                  index: searchingIdx
-                }))
-              ].join("");
-              controller.enqueue(encoder.encode(syntheticCase2));
-              const heldBack = recallAccum.heldBackEvents();
-              if (heldBack) {
-                controller.enqueue(encoder.encode(heldBack));
-              }
-              controller.close();
-              const cleanResp = stripRecallFromResponse(resp);
-              onComplete(cleanResp);
-              return;
-            }
-            log6.info(
-              `recall (stream, only): executing follow-up for session ${recallContext.sessionState.sessionID.slice(0, 16)}`
-            );
-            const searchingIndex = recallAccum.clientBlockCount();
-            const syntheticBlock = [
-              formatSSEEvent("content_block_start", JSON.stringify({
-                type: "content_block_start",
-                index: searchingIndex,
-                content_block: { type: "text", text: "" }
-              })),
-              formatSSEEvent("content_block_delta", JSON.stringify({
-                type: "content_block_delta",
-                index: searchingIndex,
-                delta: { type: "text_delta", text: "\n\n[Searching memory...]" }
-              })),
-              formatSSEEvent("content_block_stop", JSON.stringify({
-                type: "content_block_stop",
-                index: searchingIndex
-              }))
-            ].join("");
-            controller.enqueue(encoder.encode(syntheticBlock));
-            const followUp = buildRecallFollowUp(
-              recallContext.modifiedReq,
-              resp,
-              result,
-              recallBlock
-            );
-            const followUpResponse = await forwardToUpstream(
-              followUp,
-              recallContext.config,
-              void 0,
-              recallContext.cacheOptions
-            );
-            if (!followUpResponse.ok) {
-              const errorBody = await followUpResponse.text();
-              log6.error(
-                `recall follow-up upstream error: ${followUpResponse.status} ${errorBody.slice(0, 500)}`
-              );
-              const heldBack = recallAccum.heldBackEvents();
-              if (heldBack) {
-                controller.enqueue(encoder.encode(heldBack));
-              }
-              controller.close();
-              const cleanResp = stripRecallFromResponse(resp);
-              onComplete(cleanResp);
-              return;
-            }
-            const blockOffset = recallAccum.clientBlockCount() + 1;
-            const contReader = followUpResponse.body.getReader();
-            for await (const { event: contEvent, data: contData } of parseSSEStream(contReader)) {
-              if (contEvent === "message_start") {
-                continue;
-              }
-              if (contEvent === "content_block_start" || contEvent === "content_block_delta" || contEvent === "content_block_stop") {
-                try {
-                  const parsed = JSON.parse(contData);
-                  if (typeof parsed.index === "number") {
-                    parsed.index = parsed.index + blockOffset;
-                    const adjusted = formatSSEEvent(
-                      contEvent,
-                      JSON.stringify(parsed)
-                    );
-                    controller.enqueue(encoder.encode(adjusted));
-                    continue;
-                  }
-                } catch {
-                }
-              }
-              const forwarded = formatSSEEvent(contEvent, contData);
-              controller.enqueue(encoder.encode(forwarded));
-            }
-            controller.close();
-            onComplete(resp);
-            return;
-          }
-        }
-        controller.close();
-        const response = accumulator.getResponse();
-        onComplete(response);
-      } catch (err) {
-        log6.error("streaming pipeline error:", err);
-        controller.error(err);
-      }
-    }
-  });
-  return new Response(stream, {
-    status: 200,
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      connection: "keep-alive"
-    }
-  });
-}
-async function accumulateNonStreamResponse(upstreamResponse) {
-  const json = await upstreamResponse.json();
-  const content = [];
-  const rawContent = json.content;
-  if (rawContent) {
-    for (const block of rawContent) {
-      switch (block.type) {
-        case "text":
-          content.push({ type: "text", text: String(block.text ?? "") });
-          break;
-        case "thinking":
-          content.push({
-            type: "thinking",
-            thinking: String(block.thinking ?? ""),
-            ...block.signature ? { signature: String(block.signature) } : void 0
-          });
-          break;
-        case "tool_use":
-          content.push({
-            type: "tool_use",
-            id: String(block.id ?? ""),
-            name: String(block.name ?? ""),
-            input: block.input
-          });
-          break;
-      }
-    }
-  }
-  const usage = json.usage;
-  return {
-    id: String(json.id ?? ""),
-    model: String(json.model ?? ""),
-    content,
-    stopReason: String(
-      json.stop_reason ?? "end_turn"
-    ),
-    usage: {
-      inputTokens: usage?.input_tokens ?? 0,
-      outputTokens: usage?.output_tokens ?? 0,
-      cacheReadInputTokens: usage?.cache_read_input_tokens,
-      cacheCreationInputTokens: usage?.cache_creation_input_tokens
-    }
-  };
-}
-function nonStreamHttpResponse(resp) {
-  const body = buildAnthropicNonStreamResponse(resp);
-  return new Response(JSON.stringify(body), {
-    status: 200,
-    headers: { "content-type": "application/json" }
-  });
-}
-function streamHttpResponse(resp) {
-  const textBlocks = resp.content.filter(
-    (b) => b.type === "text"
-  );
-  const fullText = textBlocks.map((b) => b.text).join("");
-  const sseBody = buildSSETextResponse(resp.id, resp.model, fullText, {
-    inputTokens: resp.usage.inputTokens,
-    outputTokens: resp.usage.outputTokens
-  });
-  return new Response(sseBody, {
-    status: 200,
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      connection: "keep-alive"
-    }
-  });
-}
-function postResponse(req, resp, sessionState, config2) {
-  const { sessionID, projectPath } = sessionState;
-  try {
-    const actualInput = (resp.usage.inputTokens ?? 0) + (resp.usage.cacheReadInputTokens ?? 0) + (resp.usage.cacheCreationInputTokens ?? 0);
-    calibrate(
-      actualInput,
-      sessionID,
-      getLastTransformedCount(sessionID)
-    );
-    const loreMessages = gatewayMessagesToLore(req.messages, sessionID);
-    resolveToolResults(loreMessages);
-    for (let i = loreMessages.length - 1; i >= 0; i--) {
-      if (loreMessages[i].info.role === "user") {
-        temporal3.store({
-          projectPath,
-          info: loreMessages[i].info,
-          parts: loreMessages[i].parts
-        });
-        break;
-      }
-    }
-    const assistantMsg = gatewayMessagesToLore(
-      [{ role: "assistant", content: resp.content }],
-      sessionID
-    )[0];
-    updateAssistantMessageTokens(assistantMsg, resp.usage, resp.model);
-    temporal3.store({
-      projectPath,
-      info: assistantMsg.info,
-      parts: assistantMsg.parts
-    });
-    sessionState.turnsSinceCuration = (sessionState.turnsSinceCuration ?? 0) + 1;
-    scheduleBackgroundWork(sessionState, config2);
-  } catch (e) {
-    log6.error("post-response processing failed:", e);
-  }
-}
-function scheduleBackgroundWork(sessionState, config2) {
-  const { sessionID, projectPath } = sessionState;
-  const llm = getLLMClient(config2);
-  const cfg = loreConfig4();
-  const model = getWorkerModel();
-  if (needsUrgentDistillation()) {
-    distillation2.run({
-      llm,
-      projectPath,
-      sessionID,
-      model,
-      force: true,
-      urgent: true
-    }).catch((e) => log6.error("background distillation failed:", e));
-  }
-  const pending = temporal3.undistilledCount(projectPath, sessionID);
-  if (pending >= cfg.distillation.maxSegment) {
-    log6.info(
-      `incremental distillation: ${pending} undistilled messages in ${sessionID.slice(0, 16)}`
-    );
-    distillation2.run({ llm, projectPath, sessionID, model }).catch((e) => log6.error("background distillation failed:", e));
-  }
-  if (cfg.knowledge.enabled && cfg.curator.onIdle && sessionState.turnsSinceCuration >= cfg.curator.afterTurns) {
-    curator2.run({ llm, projectPath, sessionID, model }).then(() => {
-      sessionState.turnsSinceCuration = 0;
-      ltmSessionCache.delete(sessionID);
-    }).catch((e) => log6.error("background curation failed:", e));
-  }
-}
-async function handleCompaction(req, config2) {
-  const projectPath = cachedProjectPath ?? getProjectPath(req.system, req.rawHeaders);
-  await initIfNeeded(projectPath, config2);
-  const { sessionID } = await identifySession(req, projectPath);
-  const sessionState = getOrCreateSession(sessionID, projectPath);
-  const llm = getLLMClient(config2);
-  log6.info(`compaction intercepted for session ${sessionID.slice(0, 16)}`);
-  const model = getWorkerModel();
-  await distillation2.run({
-    llm,
-    projectPath,
-    sessionID,
-    model,
-    force: true,
-    urgent: true
-  });
-  const distillations = distillation2.loadForSession(projectPath, sessionID);
-  const previousSummary = extractPreviousSummary(req);
-  const cfg = loreConfig4();
-  const entries = cfg.knowledge.enabled ? ltm2.forProject(projectPath, cfg.crossProject) : [];
-  const knowledge = entries.length ? formatKnowledge(
-    entries.map((e) => ({
-      category: e.category,
-      title: e.title,
-      content: e.content
-    }))
-  ) : "";
-  const compactPrompt = buildCompactPrompt({
-    hasDistillations: distillations.length > 0,
-    knowledge,
-    previousSummary
-  });
-  let context = "";
-  if (distillations.length > 0) {
-    context = `## Lore Pre-computed Session Summaries
-
-The following ${distillations.length} summary chunk(s) were pre-computed from the conversation history. Use these as the authoritative source.
-
-` + distillations.map(
-      (d, i) => `### Chunk ${i + 1}${d.generation > 0 ? " (consolidated)" : ""}
-${d.observations}`
-    ).join("\n\n");
-  }
-  const userContent = context ? `${context}
-
----
-
-${compactPrompt}` : compactPrompt;
-  const summaryText = await llm.prompt(compactPrompt, userContent, {
-    model: cfg.model,
-    workerID: "lore-compact",
-    urgent: true
-    // Client is blocking on this response
-  });
-  const summary = summaryText ?? "(Compaction failed \u2014 no summary generated.)";
-  const resp = buildCompactionResponse(sessionID, summary, req.model);
-  if (req.stream) {
-    return streamHttpResponse(resp);
-  }
-  return nonStreamHttpResponse(resp);
-}
-async function handlePassthrough(req, config2) {
-  const upstreamResponse = await forwardToUpstream(req, config2);
-  if (req.stream && upstreamResponse.body) {
-    return new Response(upstreamResponse.body, {
-      status: upstreamResponse.status,
-      headers: {
-        "content-type": upstreamResponse.headers.get("content-type") ?? "text/event-stream"
-      }
-    });
-  }
-  const body = await upstreamResponse.text();
-  return new Response(body, {
-    status: upstreamResponse.status,
-    headers: {
-      "content-type": "application/json"
-    }
-  });
-}
-async function handleConversationTurn(req, config2) {
-  const projectPath = getProjectPath(req.system, req.rawHeaders);
-  await initIfNeeded(projectPath, config2);
-  const cred = extractAuth(req.rawHeaders);
-  if (cred) {
-    setLastSeenAuth(cred);
-  }
-  const { sessionID, isNew } = await identifySession(req, projectPath);
-  const sessionState = getOrCreateSession(sessionID, projectPath);
-  if (cred) {
-    setSessionAuth(sessionID, cred);
-  }
-  if (isNew) {
-    const fingerprint = await fingerprintMessages(
-      req.messages.map((m) => ({ role: m.role, content: m.content })),
-      {
-        model: req.model,
-        authSuffix: cred ? authFingerprint(cred) : ""
-      }
-    );
-    sessionState.fingerprint = fingerprint;
-  }
-  sessionState.messageCount = req.messages.length;
-  lastSeenSessionModel = req.model;
-  if (sessionState.pendingRecall) {
-    if (isPendingRecallValid(sessionState.pendingRecall)) {
-      const injected = injectPendingRecall(req, sessionState.pendingRecall);
-      if (injected) {
-        log6.info(
-          `injected pending recall result into request for session ${sessionID.slice(0, 16)}`
-        );
-      } else {
-        log6.warn(
-          `failed to inject pending recall \u2014 conversation structure mismatch`
-        );
-      }
-    } else {
-      log6.warn(
-        `discarding expired pending recall for session ${sessionID.slice(0, 16)}`
-      );
-    }
-    sessionState.pendingRecall = void 0;
-  }
-  log6.info(
-    `turn: session=${sessionID.slice(0, 16)} messages=${req.messages.length} model=${req.model} stream=${req.stream} new=${isNew}`
-  );
-  const modelSpec = getModelSpec(req.model);
-  setModelLimits({ context: modelSpec.context, output: modelSpec.output });
-  const cfg = loreConfig4();
-  if (cfg.budget.maxLayer0Tokens !== void 0) {
-    setMaxLayer0Tokens(cfg.budget.maxLayer0Tokens);
-  } else if (modelSpec.cacheReadCost && cfg.budget.targetCacheReadCostPerTurn > 0) {
-    setMaxLayer0Tokens(computeLayer0Cap(
-      cfg.budget.targetCacheReadCostPerTurn,
-      modelSpec.cacheReadCost
-    ));
-  }
-  const thresholdMs = cfg.idleResumeMinutes * 6e4;
-  const idleResult = onIdleResume(sessionID, thresholdMs);
-  if (idleResult.triggered) {
-    ltmSessionCache.delete(sessionID);
-    log6.info(
-      `session idle ${Math.round(idleResult.idleMs / 6e4)}min \u2014 refreshing caches`
-    );
-  }
-  let modifiedSystem = req.system;
-  if (cfg.knowledge.enabled) {
-    try {
-      let cached = ltmSessionCache.get(sessionID);
-      if (!cached) {
-        const ltmFraction = cfg.budget.ltm;
-        const ltmBudget = getLtmBudget(ltmFraction);
-        const entries = ltm2.forSession(projectPath, sessionID, ltmBudget);
-        if (entries.length) {
-          const formatted = formatKnowledge(
-            entries.map((e) => ({
-              category: e.category,
-              title: e.title,
-              content: e.content
-            })),
-            ltmBudget
-          );
-          if (formatted) {
-            const tokenCount = Math.ceil(formatted.length / 3);
-            cached = { formatted, tokenCount };
-            ltmSessionCache.set(sessionID, cached);
-          }
-        }
-      }
-      if (cached) {
-        setLtmTokens(cached.tokenCount, sessionID);
-        modifiedSystem = `${req.system}
-
-${cached.formatted}`;
-      } else {
-        setLtmTokens(0, sessionID);
-      }
-    } catch (e) {
-      log6.error("LTM injection failed:", e);
-      setLtmTokens(0, sessionID);
-    } finally {
-      consumeCameOutOfIdle(sessionID);
-    }
-  } else {
-    setLtmTokens(0, sessionID);
-    consumeCameOutOfIdle(sessionID);
-  }
-  if (isFirstRun()) {
-    modifiedSystem += "\n\n[Lore plugin] This is the first time Lore has been activated. Briefly let the user know that Lore is now active and their coding agent will get progressively smarter on this codebase over time as knowledge accumulates across sessions.";
-  }
-  if (cfg.knowledge.enabled) {
-    const filesToTrack = [".lore.md"];
-    if (cfg.agentsFile.enabled) filesToTrack.push(cfg.agentsFile.path);
-    modifiedSystem += `
-
-When making git commits, always check if ${filesToTrack.join(" and ")} have unstaged changes and include them in the commit. These files contain shared project knowledge managed by lore and must be version-controlled.`;
-  }
-  const loreMessages = gatewayMessagesToLore(req.messages, sessionID);
-  resolveToolResults(loreMessages);
-  const result = transform({
-    messages: loreMessages,
-    projectPath,
-    sessionID
-  });
-  while (result.messages.length > 0 && result.messages.at(-1).info.role !== "user") {
-    const last = result.messages.at(-1);
-    const hasToolParts = last.parts.some((p) => p.type === "tool");
-    if (hasToolParts) break;
-    result.messages.pop();
-  }
-  const transformedMessages = loreMessagesToGateway(result.messages);
-  removeOrphanedToolResults(transformedMessages);
-  const modifiedReq = {
-    ...req,
-    system: modifiedSystem,
-    messages: transformedMessages
-  };
-  if (modifiedReq.tools.length > 0 && !clientHasRecallTool(modifiedReq.tools)) {
-    modifiedReq.tools = [...modifiedReq.tools, RECALL_GATEWAY_TOOL];
-  }
-  const cacheOptions = {
-    systemTTL: "5m",
-    cacheConversation: true
-  };
-  const upstreamResponse = await forwardToUpstream(
-    modifiedReq,
-    config2,
-    void 0,
-    cacheOptions
-  );
-  if (!upstreamResponse.ok) {
-    const errorBody = await upstreamResponse.text();
-    log6.error(
-      `upstream error: ${upstreamResponse.status} ${errorBody.slice(0, 500)}`
-    );
-    return new Response(errorBody, {
-      status: upstreamResponse.status,
-      headers: { "content-type": "application/json" }
-    });
-  }
-  if (req.stream && upstreamResponse.body) {
-    const hasRecallTool = modifiedReq.tools.some(
-      (t) => t.name === RECALL_TOOL_NAME
-    );
-    return buildStreamingResponse(
-      upstreamResponse,
-      (resp2) => postResponse(req, resp2, sessionState, config2),
-      hasRecallTool ? { modifiedReq, config: config2, sessionState, cacheOptions } : void 0
-    );
-  }
-  const resp = await accumulateNonStreamResponse(upstreamResponse);
-  if (hasRecallToolUse(resp)) {
-    const recallBlock = findRecallToolUse(resp);
-    const { result: result2, input } = await executeRecall(
-      recallBlock,
-      sessionState.projectPath,
-      sessionState.sessionID
-    );
-    if (hasOtherToolUse(resp)) {
-      const position = resp.content.indexOf(recallBlock);
-      sessionState.pendingRecall = {
-        toolUseId: recallBlock.id,
-        input,
-        position,
-        result: result2,
-        timestamp: Date.now()
-      };
-      log6.info(
-        `recall (non-stream, mixed): stored pending result for session ${sessionState.sessionID.slice(0, 16)}`
-      );
-      const cleanResp = stripRecallFromResponse(resp);
-      postResponse(req, cleanResp, sessionState, config2);
-      return nonStreamHttpResponse(cleanResp);
-    }
-    log6.info(
-      `recall (non-stream, only): executing follow-up for session ${sessionState.sessionID.slice(0, 16)}`
-    );
-    const followUp = buildRecallFollowUp(modifiedReq, resp, result2, recallBlock);
-    const followUpResponse = await forwardToUpstream(
-      followUp,
-      config2,
-      void 0,
-      cacheOptions
-    );
-    if (!followUpResponse.ok) {
-      const errorBody = await followUpResponse.text();
-      log6.error(
-        `recall follow-up upstream error: ${followUpResponse.status} ${errorBody.slice(0, 500)}`
-      );
-      const cleanResp = stripRecallFromResponse(resp);
-      postResponse(req, cleanResp, sessionState, config2);
-      return nonStreamHttpResponse(cleanResp);
-    }
-    const continuationResp = await accumulateNonStreamResponse(followUpResponse);
-    continuationResp.usage.inputTokens += resp.usage.inputTokens;
-    continuationResp.usage.outputTokens += resp.usage.outputTokens;
-    if (resp.usage.cacheReadInputTokens) {
-      continuationResp.usage.cacheReadInputTokens = (continuationResp.usage.cacheReadInputTokens ?? 0) + resp.usage.cacheReadInputTokens;
-    }
-    if (resp.usage.cacheCreationInputTokens) {
-      continuationResp.usage.cacheCreationInputTokens = (continuationResp.usage.cacheCreationInputTokens ?? 0) + resp.usage.cacheCreationInputTokens;
-    }
-    postResponse(req, continuationResp, sessionState, config2);
-    return nonStreamHttpResponse(continuationResp);
-  }
-  postResponse(req, resp, sessionState, config2);
-  return nonStreamHttpResponse(resp);
-}
-function loreMessagesToGateway(messages) {
-  const out = [];
-  let pendingToolResults = [];
-  for (const msg of messages) {
-    const content = [];
-    if (msg.info.role === "user") {
-      content.push(...pendingToolResults);
-      pendingToolResults = [];
-    } else {
-      pendingToolResults = [];
-    }
-    for (const part of msg.parts) {
-      switch (part.type) {
-        case "text":
-          content.push({
-            type: "text",
-            text: part.text
-          });
-          break;
-        case "reasoning":
-          content.push({
-            type: "thinking",
-            thinking: part.text ?? ""
-          });
-          break;
-        case "tool": {
-          const toolPart = part;
-          if (toolPart.tool === "result") {
-            content.push({
-              type: "tool_result",
-              toolUseId: toolPart.callID,
-              content: toolPart.state.output ?? ""
-            });
-          } else {
-            content.push({
-              type: "tool_use",
-              id: toolPart.callID,
-              name: toolPart.tool,
-              input: toolPart.state.input ?? {}
-            });
-            if (toolPart.state.status === "completed") {
-              pendingToolResults.push({
-                type: "tool_result",
-                toolUseId: toolPart.callID,
-                content: toolPart.state.output ?? ""
-              });
-            } else if (toolPart.state.status === "error") {
-              pendingToolResults.push({
-                type: "tool_result",
-                toolUseId: toolPart.callID,
-                content: toolPart.state.error ?? "[error]",
-                isError: true
-              });
-            }
-          }
-          break;
-        }
-        // Generic / unknown parts — skip or represent as text
-        default:
-          if ("text" in part && typeof part.text === "string") {
-            content.push({ type: "text", text: part.text });
-          }
-          break;
-      }
-    }
-    out.push({ role: msg.info.role, content });
-  }
-  return out;
-}
-function removeOrphanedToolResults(messages) {
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role !== "user") continue;
-    if (!msg.content.some((b) => b.type === "tool_result")) continue;
-    const prev = i > 0 && messages[i - 1].role === "assistant" ? messages[i - 1] : null;
-    const toolUseIds = new Set(
-      (prev?.content ?? []).filter((b) => b.type === "tool_use").map((b) => b.id)
-    );
-    const before = msg.content.length;
-    msg.content = msg.content.filter(
-      (b) => b.type !== "tool_result" || toolUseIds.has(b.toolUseId)
-    );
-    if (msg.content.length < before) {
-      log6.warn(
-        `removed ${before - msg.content.length} orphaned tool_result block(s) from message ${i}`
-      );
-    }
-    if (msg.content.length === 0) {
-      msg.content = [{ type: "text", text: "[tool results provided]" }];
-    }
-  }
-}
-function errorResponse(status, message) {
-  return new Response(
-    JSON.stringify({
-      type: "error",
-      error: {
-        type: "server_error",
-        message
-      }
-    }),
-    {
-      status,
-      headers: { "content-type": "application/json" }
-    }
-  );
-}
-async function handleRequest(req, config2) {
-  try {
-    const earlyAuth = extractAuth(req.rawHeaders);
-    if (earlyAuth) {
-      setLastSeenAuth(earlyAuth);
-    }
-    if (isCompactionRequest(req)) {
-      return await handleCompaction(req, config2);
-    }
-    if (isTitleOrSummaryRequest(req)) {
-      return await handlePassthrough(req, config2);
-    }
-    return await handleConversationTurn(req, config2);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown gateway error";
-    log6.error("pipeline error:", err);
-    return errorResponse(502, message);
-  }
-}
-
-// src/server.ts
-var version = "unknown";
-try {
-  const pkg = require_package();
-  if (pkg.version) version = pkg.version;
-} catch {
-}
-var CORS_HEADERS = {
-  "access-control-allow-origin": "*",
-  "access-control-allow-methods": "GET, POST, OPTIONS",
-  "access-control-allow-headers": "*",
-  "access-control-max-age": "86400"
-};
-function withCors(response) {
-  for (const [key, value] of Object.entries(CORS_HEADERS)) {
-    response.headers.set(key, value);
-  }
-  return response;
-}
-function headersToRecord(headers) {
-  const record = {};
-  headers.forEach((value, key) => {
-    record[key] = value;
-  });
-  return record;
-}
-function jsonResponse(body, status = 200) {
-  return withCors(
-    new Response(JSON.stringify(body), {
-      status,
-      headers: { "content-type": "application/json" }
-    })
-  );
-}
-function errorResponse2(status, type, message) {
-  return jsonResponse(
-    {
-      type: "error",
-      error: { type, message }
-    },
-    status
-  );
-}
-async function handleAnthropicMessages(req, config2) {
-  let body;
-  try {
-    body = await req.json();
-  } catch {
-    return errorResponse2(400, "invalid_request_error", "Invalid JSON body");
-  }
-  let gatewayReq;
-  try {
-    gatewayReq = parseAnthropicRequest(body, headersToRecord(req.headers));
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Failed to parse request";
-    return errorResponse2(400, "invalid_request_error", msg);
-  }
-  try {
-    const result = await handleRequest(gatewayReq, config2);
-    return withCors(result);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Pipeline error";
-    console.error(`[lore] pipeline error: ${msg}`);
-    return errorResponse2(502, "api_error", `Gateway pipeline error: ${msg}`);
-  }
-}
-async function handleModelsPassthrough(config2) {
-  try {
-    const upstream = await fetch(`${config2.upstreamAnthropic}/v1/models`, {
-      headers: { "content-type": "application/json" }
-    });
-    const response = new Response(upstream.body, {
-      status: upstream.status,
-      statusText: upstream.statusText,
-      headers: new Headers(upstream.headers)
-    });
-    return withCors(response);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Upstream unreachable";
-    return errorResponse2(502, "api_error", `Failed to fetch models: ${msg}`);
-  }
-}
-function handleHealth() {
-  return jsonResponse({ status: "ok", version });
-}
-async function handleOpenAIChatCompletions(req, config2) {
-  let body;
-  try {
-    body = await req.json();
-  } catch {
-    return errorResponse2(400, "invalid_request_error", "Invalid JSON body");
-  }
-  let gatewayReq;
-  try {
-    gatewayReq = parseOpenAIRequest(body, headersToRecord(req.headers));
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Failed to parse request";
-    return errorResponse2(400, "invalid_request_error", msg);
-  }
-  let pipelineResp;
-  try {
-    pipelineResp = await handleRequest(gatewayReq, config2);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Pipeline error";
-    console.error(`[lore] pipeline error: ${msg}`);
-    return errorResponse2(502, "api_error", `Gateway pipeline error: ${msg}`);
-  }
-  if (!pipelineResp.ok) {
-    return withCors(pipelineResp);
-  }
-  const contentType = pipelineResp.headers.get("content-type") ?? "";
-  if (contentType.includes("text/event-stream")) {
-    const accumulated = await accumulateSSEResponse(pipelineResp);
-    return withCors(buildOpenAIResponse(accumulated, true));
-  }
-  const respBody = await pipelineResp.json();
-  return withCors(buildOpenAIResponse(respBody, false));
-}
-function startServer(config2) {
-  const server2 = Bun.serve({
-    port: config2.port,
-    hostname: config2.host,
-    async fetch(req) {
-      const url = new URL(req.url);
-      const { pathname } = url;
-      const method = req.method;
-      if (method === "OPTIONS") {
-        return withCors(new Response(null, { status: 204 }));
-      }
-      if (config2.debug) {
-        console.error(`[lore] ${method} ${pathname}`);
-      }
-      try {
-        if (method === "POST" && pathname === "/v1/messages") {
-          return await handleAnthropicMessages(req, config2);
-        }
-        if (method === "POST" && pathname === "/v1/chat/completions") {
-          return await handleOpenAIChatCompletions(req, config2);
-        }
-        if (method === "GET" && pathname === "/v1/models") {
-          return await handleModelsPassthrough(config2);
-        }
-        if (method === "GET" && pathname === "/health") {
-          return handleHealth();
-        }
-        return errorResponse2(404, "not_found", `No route for ${method} ${pathname}`);
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : "Internal server error";
-        console.error(`[lore] uncaught error: ${msg}`);
-        return errorResponse2(500, "api_error", msg);
-      }
-    }
-  });
-  return {
-    stop: () => server2.stop(),
-    port: server2.port ?? config2.port
-  };
-}
-
-// src/index.ts
-var config = loadConfig();
-var server = startServer(config);
-var addr = `http://${config.host}:${server.port}`;
-console.error(`[lore] Gateway listening on ${addr}`);
-console.error(`[lore] Model routing: claude-* \u2192 Anthropic, nvidia/* \u2192 Nvidia NIM, gpt-* \u2192 OpenAI, \u2026`);
-console.error(`[lore] Plugin auto-detects gateway \u2014 just start OpenCode normally`);
-async function shutdown() {
-  console.error("[lore] Shutting down\u2026");
-  server.stop();
-  await resetPipelineState();
-  process.exit(0);
-}
-process.on("SIGINT", () => shutdown());
-process.on("SIGTERM", () => shutdown());
-//# sourceMappingURL=index.js.map