@synapseia-network/node 0.8.5

package/dist/chunk-T2ZRG5CX.js

@@ -0,0 +1,1380 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  OllamaHelper
+} from "./chunk-2X7MSWD4.js";
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/llm/providers.ts
+var CLOUD_PROVIDERS = [
+  {
+    id: "openai",
+    label: "OpenAI",
+    endpoint: "https://api.openai.com/v1/chat/completions",
+    apiKeyEnvVar: "OPENAI_API_KEY",
+    models: {
+      top: {
+        modelId: "gpt-5",
+        latencyMs: 600,
+        maxTokens: 4e5,
+        costPerCall: 5e-3
+      },
+      mid: {
+        modelId: "gpt-4o",
+        latencyMs: 400,
+        maxTokens: 128e3,
+        costPerCall: 25e-4
+      },
+      budget: {
+        modelId: "gpt-4o-mini",
+        latencyMs: 250,
+        maxTokens: 128e3,
+        costPerCall: 6e-4
+      }
+    }
+  },
+  {
+    id: "anthropic",
+    label: "Anthropic",
+    endpoint: "https://api.anthropic.com/v1/messages",
+    apiKeyEnvVar: "ANTHROPIC_API_KEY",
+    models: {
+      top: {
+        modelId: "claude-opus-4-7",
+        latencyMs: 700,
+        maxTokens: 2e5,
+        costPerCall: 0.015
+      },
+      mid: {
+        modelId: "claude-sonnet-4-6",
+        latencyMs: 300,
+        maxTokens: 2e5,
+        costPerCall: 3e-3
+      },
+      budget: {
+        modelId: "claude-haiku-4-5",
+        latencyMs: 200,
+        maxTokens: 2e5,
+        costPerCall: 8e-4
+      }
+    }
+  },
+  {
+    id: "google",
+    label: "Google (Gemini)",
+    endpoint: "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
+    apiKeyEnvVar: "GEMINI_API_KEY",
+    models: {
+      top: {
+        modelId: "gemini-2.5-pro",
+        latencyMs: 600,
+        maxTokens: 1048576,
+        costPerCall: 35e-4
+      },
+      mid: {
+        modelId: "gemini-2.5-flash",
+        latencyMs: 300,
+        maxTokens: 1048576,
+        costPerCall: 8e-4
+      },
+      budget: {
+        modelId: "gemini-2.5-flash-lite",
+        latencyMs: 200,
+        maxTokens: 1048576,
+        costPerCall: 15e-5
+      }
+    }
+  },
+  {
+    id: "moonshot",
+    label: "Kimi (Moonshot)",
+    endpoint: "https://api.moonshot.ai/v1/chat/completions",
+    apiKeyEnvVar: "MOONSHOT_API_KEY",
+    models: {
+      top: {
+        modelId: "kimi-k2.6",
+        latencyMs: 500,
+        maxTokens: 256e3,
+        costPerCall: 2e-3
+      },
+      mid: {
+        modelId: "kimi-k2-0711-preview",
+        latencyMs: 350,
+        maxTokens: 131072,
+        costPerCall: 1e-3
+      },
+      budget: {
+        modelId: "moonshot-v1-32k",
+        latencyMs: 300,
+        maxTokens: 32768,
+        costPerCall: 5e-4
+      }
+    }
+  },
+  {
+    id: "minimax",
+    label: "MiniMax",
+    endpoint: "https://api.minimax.io/v1/chat/completions",
+    apiKeyEnvVar: "MINIMAX_API_KEY",
+    models: {
+      top: {
+        modelId: "MiniMax-M2.7",
+        latencyMs: 400,
+        maxTokens: 245760,
+        costPerCall: 15e-4
+      },
+      mid: {
+        modelId: "abab7-chat-preview",
+        latencyMs: 350,
+        maxTokens: 245760,
+        costPerCall: 8e-4
+      },
+      budget: {
+        modelId: "abab6.5s-chat",
+        latencyMs: 300,
+        maxTokens: 245760,
+        costPerCall: 3e-4
+      }
+    }
+  },
+  {
+    id: "zhipu",
+    label: "Zhipu (GLM)",
+    endpoint: "https://open.bigmodel.cn/api/paas/v4/chat/completions",
+    apiKeyEnvVar: "ZHIPU_API_KEY",
+    models: {
+      top: {
+        modelId: "glm-4.6",
+        latencyMs: 500,
+        maxTokens: 2e5,
+        costPerCall: 15e-4
+      },
+      mid: {
+        modelId: "glm-4-plus",
+        latencyMs: 400,
+        maxTokens: 128e3,
+        costPerCall: 8e-4
+      },
+      budget: {
+        modelId: "glm-4-flash",
+        latencyMs: 250,
+        maxTokens: 128e3,
+        costPerCall: 1e-4
+      }
+    }
+  }
+];
+var CLOUD_PROVIDERS_BY_ID = new Map(CLOUD_PROVIDERS.map((p) => [
+  p.id,
+  p
+]));
+var OLLAMA_DEFAULT_MODELS = [
+  {
+    modelId: "qwen2.5:0.5b",
+    latencyMs: 300,
+    maxTokens: 4096
+  },
+  {
+    modelId: "qwen2.5:3b",
+    latencyMs: 800,
+    maxTokens: 8192
+  },
+  {
+    modelId: "gemma3:4b",
+    latencyMs: 1200,
+    maxTokens: 8192
+  },
+  {
+    modelId: "llama3.2:3b",
+    latencyMs: 900,
+    maxTokens: 8192
+  }
+];
+function resolveSlug(slug) {
+  const slash = slug.indexOf("/");
+  if (slash <= 0) return null;
+  const provider = slug.slice(0, slash);
+  const modelId = slug.slice(slash + 1);
+  if (!modelId) return null;
+  if (provider === "ollama") {
+    const descriptor2 = OLLAMA_DEFAULT_MODELS.find((m) => m.modelId === modelId);
+    return {
+      provider: "ollama",
+      modelId,
+      endpoint: "",
+      descriptor: descriptor2
+    };
+  }
+  if (provider === "synapseia") {
+    return {
+      provider: "synapseia",
+      modelId,
+      endpoint: ""
+    };
+  }
+  const entry = CLOUD_PROVIDERS_BY_ID.get(provider);
+  if (!entry) return null;
+  const descriptor = Object.values(entry.models).find((m) => m.modelId === modelId);
+  if (!descriptor) return null;
+  return {
+    provider: entry.id,
+    modelId,
+    endpoint: entry.endpoint,
+    descriptor
+  };
+}
+__name(resolveSlug, "resolveSlug");
+var FALLBACK_MODEL_SLUG = "anthropic/claude-sonnet-4-6";
+function topSlugFor(provider) {
+  const entry = CLOUD_PROVIDERS_BY_ID.get(provider);
+  if (!entry) return FALLBACK_MODEL_SLUG;
+  return `${entry.id}/${entry.models.top.modelId}`;
+}
+__name(topSlugFor, "topSlugFor");
+
+// src/modules/llm/llm-provider.ts
+import { Injectable as Injectable2, Optional } from "@nestjs/common";
+
+// src/shared/sanitize-llm-output.ts
+var REASONING_PATTERNS = [
+  /<(think|thinking|reasoning|scratchpad)\b[^>]*>[\s\S]*?<\/\1>/gi,
+  /<\|(?:start_of_thinking|reasoning|scratchpad|thought)\|>[\s\S]*?<\|end_of_(?:thinking|reasoning|scratchpad|thought)\|>/gi
+];
+var UNCLOSED_REASONING_PATTERNS = [
+  /<(think|thinking|reasoning|scratchpad)\b[^>]*>[\s\S]*$/i,
+  /<\|(?:start_of_thinking|reasoning|scratchpad|thought)\|>[\s\S]*$/i
+];
+function stripReasoning(input) {
+  if (input == null) return "";
+  const text = typeof input === "string" ? input : String(input);
+  let out = text;
+  for (const re of REASONING_PATTERNS) out = out.replace(re, "");
+  for (const re of UNCLOSED_REASONING_PATTERNS) out = out.replace(re, "");
+  return out.trim();
+}
+__name(stripReasoning, "stripReasoning");
+
+// src/modules/llm/synapseia-serving-client.ts
+init_logger();
+import { Injectable } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var DEFAULT_URL = "http://127.0.0.1:8080";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var SynapseiaServingClient = class {
+  static {
+    __name(this, "SynapseiaServingClient");
+  }
+  /**
+  * The serving URL + the Synapseia version currently loaded. Set by
+  * `ActiveModelSubscriber` at boot and after every hot-reload.
+  */
+  servingUrl;
+  activeVersion = null;
+  constructor() {
+    this.servingUrl = process.env.SYNAPSEIA_SERVING_URL ?? DEFAULT_URL;
+  }
+  setActiveVersion(version, url) {
+    this.activeVersion = version;
+    if (url) this.servingUrl = url;
+    logger_default.info(`[SynapseiaServing] now serving ${version} at ${this.servingUrl}`);
+  }
+  getActiveVersion() {
+    return this.activeVersion;
+  }
+  /**
+  * Returns `true` when the local runtime answers `GET /health` (or
+  * `GET /v1/models`) within 2s. Used by the bidder to decide whether
+  * to advertise a Synapseia bid this auction.
+  */
+  async isAvailable() {
+    try {
+      const res = await fetch(`${this.servingUrl}/v1/models`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async generate(opts) {
+    if (!this.activeVersion) {
+      throw new Error("Synapseia serving not initialized (no active version)");
+    }
+    const started = Date.now();
+    const res = await fetch(`${this.servingUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.activeVersion,
+        messages: opts.messages,
+        temperature: opts.temperature ?? 0.2,
+        max_tokens: opts.maxTokens ?? 2048
+      }),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Synapseia serving HTTP ${res.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    const content = data.choices?.[0]?.message?.content ?? "";
+    if (!content) {
+      throw new Error("Synapseia serving returned empty content");
+    }
+    return {
+      content,
+      modelVersion: this.activeVersion,
+      latencyMs: Date.now() - started
+    };
+  }
+};
+SynapseiaServingClient = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [])
+], SynapseiaServingClient);
+
+// src/modules/llm/llm-provider.ts
+init_logger();
+
+// src/modules/llm/adapters/llm-response-adapter.ts
+function readString(obj, ...path) {
+  let cur = obj;
+  for (const k of path) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[k];
+  }
+  return typeof cur === "string" ? cur : void 0;
+}
+__name(readString, "readString");
+function readNumber(obj, ...path) {
+  let cur = obj;
+  for (const k of path) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[k];
+  }
+  return typeof cur === "number" ? cur : void 0;
+}
+__name(readNumber, "readNumber");
+function readArray(obj, ...path) {
+  let cur = obj;
+  for (const k of path) {
+    if (cur == null || typeof cur !== "object") return [];
+    cur = cur[k];
+  }
+  return Array.isArray(cur) ? cur : [];
+}
+__name(readArray, "readArray");
+function defaultErrorMessage(httpStatus, body, fallbackText) {
+  const err = readString(body, "error", "message") ?? readString(body, "message") ?? readString(body, "error");
+  if (err) return `HTTP ${httpStatus}: ${err}`;
+  if (fallbackText) {
+    const snippet = fallbackText.replace(/\s+/g, " ").trim().slice(0, 200);
+    return `HTTP ${httpStatus}: ${snippet}`;
+  }
+  return `HTTP ${httpStatus}`;
+}
+__name(defaultErrorMessage, "defaultErrorMessage");
+
+// src/modules/llm/adapters/openai.adapter.ts
+var FINISH_REASON_MAP = {
+  stop: "stop",
+  length: "length",
+  content_filter: "content_filter",
+  tool_calls: "tool_calls",
+  function_call: "tool_calls"
+};
+var OpenAIAdapter = class {
+  static {
+    __name(this, "OpenAIAdapter");
+  }
+  providerId = "openai";
+  buildRequest(req) {
+    const entry = CLOUD_PROVIDERS_BY_ID.get("openai");
+    if (!entry) throw new Error("openai provider not registered");
+    const body = {
+      model: req.model,
+      messages: [
+        {
+          role: "user",
+          content: req.prompt
+        }
+      ]
+    };
+    if (req.hyperparams?.temperature !== void 0) body.temperature = req.hyperparams.temperature;
+    if (req.hyperparams?.maxTokens !== void 0) body.max_tokens = req.hyperparams.maxTokens;
+    if (req.hyperparams?.forceJson) body.response_format = {
+      type: "json_object"
+    };
+    return {
+      url: entry.endpoint,
+      init: {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${req.apiKey}`
+        },
+        body: JSON.stringify(body)
+      }
+    };
+  }
+  parseResponse(_httpStatus, body) {
+    const choices = readArray(body, "choices");
+    if (choices.length === 0) {
+      throw new Error("OpenAI response had no choices[]");
+    }
+    const choice = choices[0];
+    const refusal = readString(choice, "message", "refusal");
+    if (refusal) {
+      throw new Error(`OpenAI refused to answer: ${refusal}`);
+    }
+    const content = readString(choice, "message", "content");
+    if (typeof content !== "string" || content.length === 0) {
+      const finish = readString(choice, "finish_reason") ?? "unknown";
+      throw new Error(`OpenAI returned no message.content (finish_reason=${finish}); tool_calls/multimodal responses are not supported by this node`);
+    }
+    const finishStr = readString(choice, "finish_reason") ?? "stop";
+    return {
+      text: content,
+      finishReason: FINISH_REASON_MAP[finishStr] ?? "unknown",
+      usage: {
+        promptTokens: readNumber(body, "usage", "prompt_tokens"),
+        completionTokens: readNumber(body, "usage", "completion_tokens"),
+        totalTokens: readNumber(body, "usage", "total_tokens")
+      },
+      raw: body
+    };
+  }
+  parseError(httpStatus, body, fallbackText) {
+    return new Error(defaultErrorMessage(httpStatus, body, fallbackText));
+  }
+};
+
+// src/modules/llm/adapters/anthropic.adapter.ts
+var STOP_REASON_MAP = {
+  end_turn: "stop",
+  stop_sequence: "stop",
+  max_tokens: "length",
+  tool_use: "tool_calls",
+  refusal: "content_filter"
+};
+var ANTHROPIC_VERSION = "2023-06-01";
+var AnthropicAdapter = class {
+  static {
+    __name(this, "AnthropicAdapter");
+  }
+  providerId = "anthropic";
+  buildRequest(req) {
+    const entry = CLOUD_PROVIDERS_BY_ID.get("anthropic");
+    if (!entry) throw new Error("anthropic provider not registered");
+    const body = {
+      model: req.model,
+      max_tokens: req.hyperparams?.maxTokens ?? 4096,
+      messages: [
+        {
+          role: "user",
+          content: req.prompt
+        }
+      ]
+    };
+    if (req.hyperparams?.temperature !== void 0) body.temperature = req.hyperparams.temperature;
+    return {
+      url: entry.endpoint,
+      init: {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": req.apiKey,
+          "anthropic-version": ANTHROPIC_VERSION,
+          // Required when the request runs from a browser-like environment;
+          // Tauri / Electron embedded fetch occasionally tags itself as such.
+          "anthropic-dangerous-direct-browser-access": "true"
+        },
+        body: JSON.stringify(body)
+      }
+    };
+  }
+  parseResponse(_httpStatus, body) {
+    const blocks = readArray(body, "content");
+    if (blocks.length === 0) {
+      throw new Error("Anthropic response had no content[] blocks");
+    }
+    const textParts = [];
+    for (const block of blocks) {
+      const type = readString(block, "type");
+      if (type === "text") {
+        const t = readString(block, "text");
+        if (t) textParts.push(t);
+      }
+    }
+    if (textParts.length === 0) {
+      const stop = readString(body, "stop_reason") ?? "unknown";
+      throw new Error(`Anthropic returned no text blocks (stop_reason=${stop}); tool_use / thinking-only responses are not consumable by this node`);
+    }
+    const stopStr = readString(body, "stop_reason") ?? "end_turn";
+    return {
+      text: textParts.join(""),
+      finishReason: STOP_REASON_MAP[stopStr] ?? "unknown",
+      usage: {
+        promptTokens: readNumber(body, "usage", "input_tokens"),
+        completionTokens: readNumber(body, "usage", "output_tokens"),
+        // Anthropic doesn't publish a total — it's input + output and we
+        // expose it pre-computed for parity with OpenAI usage telemetry.
+        totalTokens: (readNumber(body, "usage", "input_tokens") ?? 0) + (readNumber(body, "usage", "output_tokens") ?? 0) || void 0
+      },
+      raw: body
+    };
+  }
+  parseError(httpStatus, body, fallbackText) {
+    const msg = readString(body, "error", "message") ?? readString(body, "message");
+    if (msg) return new Error(`HTTP ${httpStatus}: ${msg}`);
+    return new Error(defaultErrorMessage(httpStatus, body, fallbackText));
+  }
+};
+
+// src/modules/llm/adapters/google.adapter.ts
+var FINISH_REASON_MAP2 = {
+  STOP: "stop",
+  MAX_TOKENS: "length",
+  SAFETY: "content_filter",
+  RECITATION: "content_filter",
+  PROHIBITED_CONTENT: "content_filter",
+  SPII: "content_filter",
+  BLOCKLIST: "content_filter",
+  LANGUAGE: "content_filter",
+  OTHER: "unknown",
+  TOOL_CODE_FAILURE: "tool_calls"
+};
+var GoogleAdapter = class {
+  static {
+    __name(this, "GoogleAdapter");
+  }
+  providerId = "google";
+  buildRequest(req) {
+    const entry = CLOUD_PROVIDERS_BY_ID.get("google");
+    if (!entry) throw new Error("google provider not registered");
+    const url = entry.endpoint.replace("{model}", encodeURIComponent(req.model));
+    const generationConfig = {};
+    if (req.hyperparams?.temperature !== void 0) {
+      generationConfig.temperature = req.hyperparams.temperature;
+    }
+    if (req.hyperparams?.maxTokens !== void 0) {
+      generationConfig.maxOutputTokens = req.hyperparams.maxTokens;
+    }
+    if (req.hyperparams?.forceJson) {
+      generationConfig.responseMimeType = "application/json";
+    }
+    const body = {
+      contents: [
+        {
+          role: "user",
+          parts: [
+            {
+              text: req.prompt
+            }
+          ]
+        }
+      ]
+    };
+    if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+    return {
+      url,
+      init: {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": req.apiKey
+        },
+        body: JSON.stringify(body)
+      }
+    };
+  }
+  parseResponse(_httpStatus, body) {
+    const blockReason = readString(body, "promptFeedback", "blockReason");
+    if (blockReason) {
+      throw new Error(`Google blocked the prompt: blockReason=${blockReason}`);
+    }
+    const candidates = readArray(body, "candidates");
+    if (candidates.length === 0) {
+      throw new Error("Google response had no candidates[]");
+    }
+    const candidate = candidates[0];
+    const finishStr = readString(candidate, "finishReason") ?? "STOP";
+    const parts = readArray(candidate, "content", "parts");
+    const textParts = [];
+    for (const part of parts) {
+      if (readString(part, "functionCall", "name")) continue;
+      const isThought = part?.thought === true;
+      if (isThought) continue;
+      const t = readString(part, "text");
+      if (t) textParts.push(t);
+    }
+    if (textParts.length === 0) {
+      throw new Error(`Google returned no text parts (finishReason=${finishStr}); function-call / thought-only responses are not consumable by this node`);
+    }
+    return {
+      text: textParts.join(""),
+      finishReason: FINISH_REASON_MAP2[finishStr] ?? "unknown",
+      usage: {
+        promptTokens: readNumber(body, "usageMetadata", "promptTokenCount"),
+        completionTokens: readNumber(body, "usageMetadata", "candidatesTokenCount"),
+        totalTokens: readNumber(body, "usageMetadata", "totalTokenCount")
+      },
+      raw: body
+    };
+  }
+  parseError(httpStatus, body, fallbackText) {
+    const msg = readString(body, "error", "message");
+    if (msg) return new Error(`HTTP ${httpStatus}: ${msg}`);
+    return new Error(defaultErrorMessage(httpStatus, body, fallbackText));
+  }
+};
+
+// src/modules/llm/adapters/openai-compat.adapter.ts
+var FINISH_REASON_MAP3 = {
+  stop: "stop",
+  length: "length",
+  content_filter: "content_filter",
+  tool_calls: "tool_calls",
+  function_call: "tool_calls"
+};
+var OpenAICompatAdapter = class {
+  static {
+    __name(this, "OpenAICompatAdapter");
+  }
+  /** Subclasses can extend if they need extra Authorization shapes. */
+  buildHeaders(req) {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${req.apiKey}`
+    };
+  }
+  buildRequest(req) {
+    const body = {
+      model: req.model,
+      messages: [
+        {
+          role: "user",
+          content: req.prompt
+        }
+      ]
+    };
+    if (req.hyperparams?.temperature !== void 0) body.temperature = req.hyperparams.temperature;
+    if (req.hyperparams?.maxTokens !== void 0) body.max_tokens = req.hyperparams.maxTokens;
+    if (req.hyperparams?.forceJson) body.response_format = {
+      type: "json_object"
+    };
+    return {
+      url: this.endpoint,
+      init: {
+        method: "POST",
+        headers: this.buildHeaders(req),
+        body: JSON.stringify(body)
+      }
+    };
+  }
+  parseResponse(_httpStatus, body) {
+    if (this.validateResponseBody) this.validateResponseBody(body);
+    const choices = readArray(body, "choices");
+    if (choices.length === 0) {
+      throw new Error(`${this.providerId} response had no choices[]`);
+    }
+    const choice = choices[0];
+    const content = readString(choice, "message", "content");
+    if (typeof content !== "string" || content.length === 0) {
+      const finish = readString(choice, "finish_reason") ?? "unknown";
+      throw new Error(`${this.providerId} returned no message.content (finish_reason=${finish})`);
+    }
+    const finishStr = readString(choice, "finish_reason") ?? "stop";
+    return {
+      text: content,
+      finishReason: FINISH_REASON_MAP3[finishStr] ?? "unknown",
+      usage: {
+        promptTokens: readNumber(body, "usage", "prompt_tokens"),
+        completionTokens: readNumber(body, "usage", "completion_tokens"),
+        totalTokens: readNumber(body, "usage", "total_tokens")
+      },
+      raw: body
+    };
+  }
+  parseError(httpStatus, body, fallbackText) {
+    return new Error(defaultErrorMessage(httpStatus, body, fallbackText));
+  }
+};
+
+// src/modules/llm/adapters/moonshot.adapter.ts
+var MoonshotAdapter = class extends OpenAICompatAdapter {
+  static {
+    __name(this, "MoonshotAdapter");
+  }
+  providerId = "moonshot";
+  endpoint = (() => {
+    const e = CLOUD_PROVIDERS_BY_ID.get("moonshot")?.endpoint;
+    if (!e) throw new Error("moonshot provider missing from CLOUD_PROVIDERS table");
+    return e;
+  })();
+};
+
+// src/modules/llm/adapters/minimax.adapter.ts
+var MINIMAX_TRANSIENT_CODES = /* @__PURE__ */ new Set([
+  1002,
+  1004,
+  1027,
+  2013,
+  2064
+]);
+var MinimaxAdapter = class extends OpenAICompatAdapter {
+  static {
+    __name(this, "MinimaxAdapter");
+  }
+  providerId = "minimax";
+  endpoint = (() => {
+    const e = CLOUD_PROVIDERS_BY_ID.get("minimax")?.endpoint;
+    if (!e) throw new Error("minimax provider missing from CLOUD_PROVIDERS table");
+    return e;
+  })();
+  validateResponseBody(body) {
+    const code = readNumber(body, "base_resp", "status_code");
+    if (code !== void 0 && code !== 0) {
+      const msg = readString(body, "base_resp", "status_msg") ?? "unknown";
+      const transient = MINIMAX_TRANSIENT_CODES.has(code);
+      throw new Error(`MiniMax base_resp ${code}: ${msg}` + (transient ? " (transient)" : ""));
+    }
+  }
+  isTransientError(err) {
+    const msg = String(err?.message ?? err ?? "");
+    if (msg.includes("(transient)")) return true;
+    for (const code of MINIMAX_TRANSIENT_CODES) {
+      if (msg.includes(`base_resp ${code}`)) return true;
+    }
+    return false;
+  }
+};
+
+// src/modules/llm/adapters/zhipu.adapter.ts
+var ZhipuAdapter = class extends OpenAICompatAdapter {
+  static {
+    __name(this, "ZhipuAdapter");
+  }
+  providerId = "zhipu";
+  endpoint = (() => {
+    const e = CLOUD_PROVIDERS_BY_ID.get("zhipu")?.endpoint;
+    if (!e) throw new Error("zhipu provider missing from CLOUD_PROVIDERS table");
+    return e;
+  })();
+};
+
+// src/modules/llm/adapters/index.ts
+var ADAPTERS = /* @__PURE__ */ new Map([
+  [
+    "openai",
+    new OpenAIAdapter()
+  ],
+  [
+    "anthropic",
+    new AnthropicAdapter()
+  ],
+  [
+    "google",
+    new GoogleAdapter()
+  ],
+  [
+    "moonshot",
+    new MoonshotAdapter()
+  ],
+  [
+    "minimax",
+    new MinimaxAdapter()
+  ],
+  [
+    "zhipu",
+    new ZhipuAdapter()
+  ]
+]);
+function getAdapter(providerId) {
+  const adapter = ADAPTERS.get(providerId);
+  if (!adapter) {
+    throw new Error(`No LLM response adapter registered for provider '${providerId}'`);
+  }
+  return adapter;
+}
+__name(getAdapter, "getAdapter");
+
+// src/modules/llm/llm-provider.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+function buildSupportedModels() {
+  const out = {};
+  for (const entry of CLOUD_PROVIDERS) {
+    for (const tier of [
+      "top",
+      "mid",
+      "budget"
+    ]) {
+      const desc = entry.models[tier];
+      out[`${entry.id}/${desc.modelId}`] = {
+        provider: "cloud",
+        providerId: entry.id,
+        modelId: desc.modelId
+      };
+    }
+  }
+  for (const m of OLLAMA_DEFAULT_MODELS) {
+    out[`ollama/${m.modelId}`] = {
+      provider: "ollama",
+      providerId: "",
+      modelId: m.modelId
+    };
+  }
+  return out;
+}
+__name(buildSupportedModels, "buildSupportedModels");
+function buildModelMetadata() {
+  const out = {};
+  for (const entry of CLOUD_PROVIDERS) {
+    for (const tier of [
+      "top",
+      "mid",
+      "budget"
+    ]) {
+      const d = entry.models[tier];
+      out[d.modelId] = d;
+    }
+  }
+  for (const m of OLLAMA_DEFAULT_MODELS) {
+    out[m.modelId] = m;
+  }
+  return out;
+}
+__name(buildModelMetadata, "buildModelMetadata");
+var SUPPORTED_MODELS = buildSupportedModels();
+var MODEL_METADATA = buildModelMetadata();
+function isTransientLlmError(err) {
+  const msg = String(err?.message ?? err ?? "").toLowerCase();
+  return msg.includes("2064") || msg.includes("high load") || msg.includes("overloaded") || msg.includes("rate limit") || msg.includes("rate-limit") || msg.includes("too many requests") || msg.includes("429") || msg.includes("503") || msg.includes("502") || msg.includes("504") || msg.includes("timeout") || msg.includes("econn") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("socket hang up") || msg.includes("runner process") || msg.includes("%!w") || msg.includes("unexpected eof") || msg.includes("try again") || msg.includes("(transient)");
+}
+__name(isTransientLlmError, "isTransientLlmError");
+var RETRY_SCHEDULE_MS = [
+  1e3,
+  3e3,
+  8e3
+];
+var LlmProviderHelper = class {
+  static {
+    __name(this, "LlmProviderHelper");
+  }
+  synapseia;
+  ollamaHelper = new OllamaHelper();
+  // F3-C7 — optional Synapseia client. When Nest wires it, any model
+  // with `provider: 'synapseia'` is dispatched through it; otherwise we
+  // fall back to cloud/ollama so the node keeps serving even pre-F3.
+  constructor(synapseia) {
+    this.synapseia = synapseia;
+  }
+  // ── Public methods ────────────────────────────────────────────────────────
+  toErrorMessage(error) {
+    try {
+      return String(error?.message ?? "Unknown error");
+    } catch {
+      return "Unknown error";
+    }
+  }
+  /**
+  * Resolve a slug against the whitelist. Returns null for anything we
+  * don't recognise so callers (CLI, config validation) can decide
+  * whether to migrate or hard-fail.
+  */
+  parseModel(modelStr) {
+    const known = SUPPORTED_MODELS[modelStr];
+    if (known) return known;
+    const slash = modelStr.indexOf("/");
+    if (slash <= 0) return null;
+    const provider = modelStr.slice(0, slash);
+    const modelId = modelStr.slice(slash + 1);
+    if (!modelId) return null;
+    if (provider === "ollama") {
+      return {
+        provider: "ollama",
+        providerId: "",
+        modelId
+      };
+    }
+    if (provider === "synapseia") {
+      return {
+        provider: "synapseia",
+        providerId: "",
+        modelId
+      };
+    }
+    if (CLOUD_PROVIDERS_BY_ID.has(provider)) {
+      return {
+        provider: "cloud",
+        providerId: provider,
+        modelId
+      };
+    }
+    return null;
+  }
+  async checkLLM(model, config) {
+    if (model.provider === "ollama") return this.checkOllamaLLM(model);
+    if (model.provider === "cloud") return this.checkCloudLLM(model, config);
+    if (model.provider === "synapseia") return this.checkSynapseiaLLM(model);
+    return {
+      available: false,
+      model,
+      estimatedLatencyMs: 0,
+      error: "Unknown provider"
+    };
+  }
+  async generateLLM(model, prompt, config, hyperparams) {
+    let raw;
+    let lastErr;
+    for (let attempt = 0; attempt <= RETRY_SCHEDULE_MS.length; attempt++) {
+      try {
+        if (model.provider === "ollama") {
+          raw = await this.generateOllamaLLM(model, prompt, hyperparams);
+        } else if (model.provider === "cloud") {
+          raw = await this.generateCloudLLM(model, prompt, config, hyperparams);
+        } else if (model.provider === "synapseia") {
+          raw = await this.generateSynapseiaLLM(model, prompt, hyperparams);
+        } else {
+          throw new Error("Unknown provider");
+        }
+        break;
+      } catch (err) {
+        lastErr = err;
+        const adapterTransient = model.provider === "cloud" && model.providerId ? this.adapterIsTransient(model.providerId, err) : false;
+        if (attempt >= RETRY_SCHEDULE_MS.length || !isTransientLlmError(err) && !adapterTransient) {
+          throw err;
+        }
+        const wait = RETRY_SCHEDULE_MS[attempt];
+        logger_default.warn(`[LLM] transient error on attempt ${attempt + 1}/${RETRY_SCHEDULE_MS.length + 1} (${this.toErrorMessage(err)}) \u2014 retrying in ${wait}ms`);
+        await new Promise((resolve) => setTimeout(resolve, wait));
+      }
+    }
+    if (raw === void 0) throw lastErr ?? new Error("LLM generation failed");
+    return stripReasoning(raw);
+  }
+  checkOllama() {
+    return this.ollamaHelper.checkOllama();
+  }
+  generateOllama(prompt, modelId) {
+    return this.ollamaHelper.generate(prompt, modelId);
+  }
+  get supportedModels() {
+    return SUPPORTED_MODELS;
+  }
+  get modelMetadata() {
+    return MODEL_METADATA;
+  }
+  // ── Private: Ollama ───────────────────────────────────────────────────────
+  async checkOllamaLLM(model) {
+    try {
+      const status = await this.ollamaHelper.checkOllama();
+      if (!status.available) {
+        return {
+          available: false,
+          model,
+          estimatedLatencyMs: 0,
+          error: status.error || "Ollama not available"
+        };
+      }
+      const meta = MODEL_METADATA[model.modelId];
+      const modelAvailable = status.models.includes(model.modelId);
+      if (!modelAvailable) {
+        return {
+          available: false,
+          model,
+          estimatedLatencyMs: meta?.latencyMs ?? 500,
+          error: `Model ${model.modelId} not found. Pull with: ollama pull ${model.modelId}`
+        };
+      }
+      return {
+        available: true,
+        model,
+        estimatedLatencyMs: meta?.latencyMs ?? 500,
+        maxTokens: meta?.maxTokens
+      };
+    } catch (error) {
+      return {
+        available: false,
+        model,
+        estimatedLatencyMs: 0,
+        error: this.toErrorMessage(error)
+      };
+    }
+  }
+  async generateOllamaLLM(model, prompt, hyperparams) {
+    return this.ollamaHelper.generate(prompt, model.modelId, void 0, hyperparams);
+  }
+  // ── Private: Cloud routing ────────────────────────────────────────────────
+  async checkCloudLLM(model, config) {
+    if (!config?.apiKey) {
+      return {
+        available: false,
+        model,
+        estimatedLatencyMs: 0,
+        error: "API key required for cloud provider"
+      };
+    }
+    if (config.baseUrl) {
+      const safeUrl = config.baseUrl.split("?")[0];
+      logger_default.warn(`[LLM] config.baseUrl is set ('${safeUrl}') but is ignored \u2014 endpoints are hardcoded per provider`);
+    }
+    if (!model.providerId || !CLOUD_PROVIDERS_BY_ID.has(model.providerId)) {
+      return {
+        available: false,
+        model,
+        estimatedLatencyMs: 0,
+        error: `Unknown cloud provider '${model.providerId}'`
+      };
+    }
+    const meta = MODEL_METADATA[model.modelId];
+    try {
+      await this.runAdapterRequest(model, "Hi", config.apiKey, {
+        maxTokens: 16
+      });
+      return {
+        available: true,
+        model,
+        estimatedLatencyMs: meta?.latencyMs ?? 400,
+        estimatedCostPerCall: meta?.costPerCall,
+        maxTokens: meta?.maxTokens
+      };
+    } catch (error) {
+      return {
+        available: false,
+        model,
+        estimatedLatencyMs: 0,
+        error: this.toErrorMessage(error)
+      };
+    }
+  }
+  async generateCloudLLM(model, prompt, config, hyperparams) {
+    if (!config?.apiKey) throw new Error("API key required for cloud provider");
+    if (!model.providerId || !CLOUD_PROVIDERS_BY_ID.has(model.providerId)) {
+      throw new Error(`Unknown cloud provider '${model.providerId}'`);
+    }
+    if (config.baseUrl) {
+      const safeUrl = config.baseUrl.split("?")[0];
+      logger_default.warn(`[LLM] config.baseUrl is set ('${safeUrl}') but is ignored \u2014 endpoints are hardcoded per provider`);
+    }
+    return this.runAdapterRequest(model, prompt, config.apiKey, hyperparams);
+  }
+  async runAdapterRequest(model, prompt, apiKey, hyperparams) {
+    const adapter = getAdapter(model.providerId);
+    const chatReq = {
+      model: model.modelId,
+      prompt,
+      apiKey,
+      hyperparams: hyperparams ? {
+        temperature: hyperparams.temperature,
+        maxTokens: hyperparams.maxTokens,
+        forceJson: hyperparams.forceJson
+      } : void 0
+    };
+    const { url, init } = adapter.buildRequest(chatReq);
+    const response = await fetch(url, init);
+    const text = await response.text().catch(() => "");
+    let body = null;
+    if (text) {
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = null;
+      }
+    }
+    if (!response.ok) {
+      throw adapter.parseError(response.status, body, text);
+    }
+    const normalized = adapter.parseResponse(response.status, body);
+    return normalized.text;
+  }
+  adapterIsTransient(providerId, err) {
+    try {
+      const adapter = getAdapter(providerId);
+      return Boolean(adapter.isTransientError?.(err));
+    } catch {
+      return false;
+    }
+  }
+  // ── Private: Synapseia (F3-C7) ────────────────────────────────────────────
+  async checkSynapseiaLLM(model) {
+    if (!this.synapseia) {
+      return {
+        available: false,
+        model,
+        estimatedLatencyMs: 0,
+        error: "Synapseia client not wired"
+      };
+    }
+    const ok = await this.synapseia.isAvailable();
+    return {
+      available: ok,
+      model,
+      estimatedLatencyMs: 600,
+      error: ok ? void 0 : "local serving runtime not reachable"
+    };
+  }
+  async generateSynapseiaLLM(model, prompt, hyperparams) {
+    if (!this.synapseia) {
+      throw new Error("Synapseia client not wired \u2014 operator must launch llama.cpp + register swap hook");
+    }
+    const expected = model.synapseiaVersion;
+    const active = this.synapseia.getActiveVersion();
+    if (expected && active && expected !== active) {
+      throw new Error(`Synapseia version mismatch: caller asked ${expected}, node is serving ${active}`);
+    }
+    const result = await this.synapseia.generate({
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ],
+      temperature: hyperparams?.temperature,
+      maxTokens: hyperparams?.maxTokens
+    });
+    return result.content;
+  }
+};
+LlmProviderHelper = _ts_decorate2([
+  Injectable2(),
+  _ts_param(0, Optional()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof SynapseiaServingClient === "undefined" ? Object : SynapseiaServingClient
+  ])
+], LlmProviderHelper);
+
+// src/modules/p2p/stream-codec.ts
+var MAX_FRAME_BYTES = 1 << 20;
+async function sendJsonOverStream(stream, obj) {
+  const json = new TextEncoder().encode(JSON.stringify(obj));
+  if (json.byteLength > MAX_FRAME_BYTES) {
+    throw new Error(`stream-codec: payload ${json.byteLength} > ${MAX_FRAME_BYTES}`);
+  }
+  const full = new Uint8Array(4 + json.byteLength);
+  new DataView(full.buffer, full.byteOffset, 4).setUint32(0, json.byteLength, true);
+  full.set(json, 4);
+  const ok = stream.send(full);
+  if (!ok) {
+    await new Promise((resolve, reject) => {
+      const onDrain = /* @__PURE__ */ __name(() => {
+        cleanup();
+        resolve();
+      }, "onDrain");
+      const onClose = /* @__PURE__ */ __name(() => {
+        cleanup();
+        reject(new Error("stream closed before drain"));
+      }, "onClose");
+      const cleanup = /* @__PURE__ */ __name(() => {
+        stream.removeEventListener?.("drain", onDrain);
+        stream.removeEventListener?.("close", onClose);
+        stream.removeEventListener?.("remoteCloseRead", onClose);
+      }, "cleanup");
+      stream.addEventListener?.("drain", onDrain, {
+        once: true
+      });
+      stream.addEventListener?.("close", onClose, {
+        once: true
+      });
+      stream.addEventListener?.("remoteCloseRead", onClose, {
+        once: true
+      });
+    });
+  }
+  try {
+    await stream.closeWrite?.();
+  } catch {
+  }
+}
+__name(sendJsonOverStream, "sendJsonOverStream");
+async function readJsonFromStream(stream) {
+  const buffers = [];
+  let total = 0;
+  let expected = null;
+  for await (const chunk of stream) {
+    const bytes = chunk instanceof Uint8Array ? chunk : chunk.subarray();
+    buffers.push(bytes);
+    total += bytes.byteLength;
+    if (expected === null && total >= 4) {
+      const head = coalesceFirstN(buffers, 4);
+      expected = new DataView(head.buffer, head.byteOffset, 4).getUint32(0, true);
+      if (expected > MAX_FRAME_BYTES) {
+        throw new Error(`stream-codec: frame length ${expected} > ${MAX_FRAME_BYTES}`);
+      }
+    }
+    if (expected !== null && total >= 4 + expected) break;
+  }
+  if (expected === null) throw new Error("stream-codec: stream ended before header");
+  const all = coalesce(buffers);
+  if (all.byteLength < 4 + expected) {
+    throw new Error(`stream-codec: stream ended mid-frame (got ${all.byteLength - 4} of ${expected})`);
+  }
+  const payload = all.subarray(4, 4 + expected);
+  return JSON.parse(new TextDecoder().decode(payload));
+}
+__name(readJsonFromStream, "readJsonFromStream");
+async function sendJsonFrame(stream, obj) {
+  const json = new TextEncoder().encode(JSON.stringify(obj));
+  if (json.byteLength > MAX_FRAME_BYTES) {
+    throw new Error(`stream-codec: payload ${json.byteLength} > ${MAX_FRAME_BYTES}`);
+  }
+  const full = new Uint8Array(4 + json.byteLength);
+  new DataView(full.buffer, full.byteOffset, 4).setUint32(0, json.byteLength, true);
+  full.set(json, 4);
+  const ok = stream.send(full);
+  if (!ok) {
+    await new Promise((resolve, reject) => {
+      const onDrain = /* @__PURE__ */ __name(() => {
+        cleanup();
+        resolve();
+      }, "onDrain");
+      const onClose = /* @__PURE__ */ __name(() => {
+        cleanup();
+        reject(new Error("stream closed before drain"));
+      }, "onClose");
+      const cleanup = /* @__PURE__ */ __name(() => {
+        stream.removeEventListener?.("drain", onDrain);
+        stream.removeEventListener?.("close", onClose);
+        stream.removeEventListener?.("remoteCloseRead", onClose);
+      }, "cleanup");
+      stream.addEventListener?.("drain", onDrain, {
+        once: true
+      });
+      stream.addEventListener?.("close", onClose, {
+        once: true
+      });
+      stream.addEventListener?.("remoteCloseRead", onClose, {
+        once: true
+      });
+    });
+  }
+}
+__name(sendJsonFrame, "sendJsonFrame");
+async function endJsonStream(stream) {
+  try {
+    await stream.closeWrite?.();
+  } catch {
+  }
+}
+__name(endJsonStream, "endJsonStream");
+async function readJsonFramesUntilDone(stream, onFrame, isDone, hardCapFrames = 5e6) {
+  const buffers = [];
+  let total = 0;
+  let expected = null;
+  let frames = 0;
+  let lastDone = null;
+  for await (const chunk of stream) {
+    const bytes = chunk instanceof Uint8Array ? chunk : chunk.subarray();
+    buffers.push(bytes);
+    total += bytes.byteLength;
+    while (true) {
+      if (expected === null) {
+        if (total < 4) break;
+        const head = coalesceFirstN(buffers, 4);
+        expected = new DataView(head.buffer, head.byteOffset, 4).getUint32(0, true);
+        if (expected > MAX_FRAME_BYTES) {
+          throw new Error(`stream-codec: frame length ${expected} > ${MAX_FRAME_BYTES}`);
+        }
+      }
+      if (total < 4 + expected) break;
+      const all = coalesce(buffers);
+      const payload = all.subarray(4, 4 + expected);
+      const frame = JSON.parse(new TextDecoder().decode(payload));
+      const remainder = all.subarray(4 + expected);
+      buffers.length = 0;
+      total = 0;
+      if (remainder.byteLength > 0) {
+        buffers.push(remainder);
+        total = remainder.byteLength;
+      }
+      expected = null;
+      frames++;
+      if (frames > hardCapFrames) {
+        throw new Error(`stream-codec: exceeded ${hardCapFrames} frames`);
+      }
+      if (isDone(frame)) {
+        lastDone = frame;
+        return lastDone;
+      }
+      await onFrame(frame);
+    }
+  }
+  if (lastDone) return lastDone;
+  throw new Error("stream-codec: stream ended before done frame");
+}
+__name(readJsonFramesUntilDone, "readJsonFramesUntilDone");
+function coalesce(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.byteLength;
+  }
+  return out;
+}
+__name(coalesce, "coalesce");
+function coalesceFirstN(chunks, n) {
+  const out = new Uint8Array(n);
+  let off = 0;
+  for (const c of chunks) {
+    if (off >= n) break;
+    const take = Math.min(c.byteLength, n - off);
+    out.set(c.subarray(0, take), off);
+    off += take;
+  }
+  return out;
+}
+__name(coalesceFirstN, "coalesceFirstN");
+
+export {
+  CLOUD_PROVIDERS,
+  CLOUD_PROVIDERS_BY_ID,
+  resolveSlug,
+  FALLBACK_MODEL_SLUG,
+  topSlugFor,
+  stripReasoning,
+  SynapseiaServingClient,
+  LlmProviderHelper,
+  sendJsonOverStream,
+  readJsonFromStream,
+  sendJsonFrame,
+  endJsonStream,
+  readJsonFramesUntilDone
+};