@synapseia-network/node 0.8.5

package/dist/chain-info-lightweight-2UWAQZBF.js

@@ -0,0 +1,303 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  getCoordinatorUrl
+} from "./chunk-DXUYWRO7.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/cli/chain-info-lightweight.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function walletDir() {
+  return process.env.SYNAPSEIA_HOME ?? join(homedir(), ".synapseia");
+}
+__name(walletDir, "walletDir");
+function readPublicKey() {
+  const walletPath = join(walletDir(), "wallet.json");
+  if (!existsSync(walletPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(walletPath, "utf-8"));
+    if (typeof raw.publicKey === "string" && raw.publicKey.length >= 32) {
+      return raw.publicKey;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(readPublicKey, "readPublicKey");
+function readCoordinatorUrl() {
+  return getCoordinatorUrl();
+}
+__name(readCoordinatorUrl, "readCoordinatorUrl");
+async function fetchSolBalance(rpcUrl, pubkey) {
+  const { Connection, PublicKey } = await import("@solana/web3.js");
+  const conn = new Connection(rpcUrl, "confirmed");
+  try {
+    const lamports = await conn.getBalance(new PublicKey(pubkey));
+    return lamports / 1e9;
+  } catch {
+    return 0;
+  }
+}
+__name(fetchSolBalance, "fetchSolBalance");
+async function fetchSynBalance(rpcUrl, pubkey, mint) {
+  const { Connection, PublicKey } = await import("@solana/web3.js");
+  const conn = new Connection(rpcUrl, "confirmed");
+  try {
+    const accounts = await conn.getTokenAccountsByOwner(new PublicKey(pubkey), {
+      mint: new PublicKey(mint)
+    });
+    if (accounts.value.length === 0) {
+      return {
+        amount: 0,
+        accountExists: false
+      };
+    }
+    let total = 0n;
+    for (const acc of accounts.value) {
+      const info = await conn.getTokenAccountBalance(acc.pubkey);
+      total += BigInt(info.value.amount);
+    }
+    return {
+      amount: Number(total) / 1e9,
+      accountExists: true
+    };
+  } catch {
+    return {
+      amount: 0,
+      accountExists: false
+    };
+  }
+}
+__name(fetchSynBalance, "fetchSynBalance");
+async function fetchStakeInfo(rpcUrl, ownerPubkey, stakingProgramId) {
+  try {
+    const { Connection, PublicKey } = await import("@solana/web3.js");
+    const conn = new Connection(rpcUrl, "confirmed");
+    const owner = new PublicKey(ownerPubkey);
+    const accounts = await conn.getProgramAccounts(new PublicKey(stakingProgramId), {
+      filters: [
+        {
+          memcmp: {
+            offset: 8,
+            bytes: owner.toBase58()
+          }
+        }
+      ]
+    });
+    if (accounts.length === 0) {
+      return {
+        exists: false,
+        amount: 0,
+        rewardsPending: 0,
+        lockedUntil: 0
+      };
+    }
+    const data = accounts[0].account.data;
+    if (data.length < 178) {
+      return {
+        exists: false,
+        amount: 0,
+        rewardsPending: 0,
+        lockedUntil: 0
+      };
+    }
+    const amount = Number(data.readBigUInt64LE(72)) / 1e9;
+    const lockedUntil = Number(data.readBigInt64LE(162));
+    const rewardsPending = Number(data.readBigUInt64LE(170)) / 1e9;
+    return {
+      exists: true,
+      amount,
+      rewardsPending,
+      lockedUntil
+    };
+  } catch {
+    return {
+      exists: false,
+      amount: 0,
+      rewardsPending: 0,
+      lockedUntil: 0
+    };
+  }
+}
+__name(fetchStakeInfo, "fetchStakeInfo");
+async function fetchCoordinatorReachable(coordinatorUrl) {
+  try {
+    const res = await fetch(`${coordinatorUrl}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+__name(fetchCoordinatorReachable, "fetchCoordinatorReachable");
+async function fetchVaultClaimable(rpcUrl, ownerPubkey, vaultProgramId) {
+  try {
+    const { Connection, PublicKey } = await import("@solana/web3.js");
+    const conn = new Connection(rpcUrl, "confirmed");
+    const owner = new PublicKey(ownerPubkey);
+    const program = new PublicKey(vaultProgramId);
+    const [pda] = PublicKey.findProgramAddressSync([
+      Buffer.from("reward_account"),
+      owner.toBuffer()
+    ], program);
+    const info = await conn.getAccountInfo(pda, "confirmed");
+    if (!info || info.data.length < 8 + 32 + 8) return 0;
+    const lamports = info.data.readBigUInt64LE(8 + 32);
+    return Number(lamports) / 1e9;
+  } catch {
+    return 0;
+  }
+}
+__name(fetchVaultClaimable, "fetchVaultClaimable");
+async function fetchRewardsBreakdown(coordinatorUrl, pubkey) {
+  try {
+    const res = await fetch(`${coordinatorUrl}/rewards/claimable/${encodeURIComponent(pubkey)}`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return {
+      byType: {},
+      totalClaimedSyn: 0
+    };
+    const data = await res.json();
+    const byType = {};
+    for (const [k, v] of Object.entries(data.byType ?? {})) {
+      const n = typeof v === "string" ? parseFloat(v) : v;
+      if (Number.isFinite(n)) byType[k] = n;
+    }
+    const totalClaimedSyn = typeof data.totalClaimedSyn === "string" ? parseFloat(data.totalClaimedSyn) : typeof data.totalClaimedSyn === "number" ? data.totalClaimedSyn : 0;
+    return {
+      byType,
+      totalClaimedSyn: Number.isFinite(totalClaimedSyn) ? totalClaimedSyn : 0
+    };
+  } catch {
+    return {
+      byType: {},
+      totalClaimedSyn: 0
+    };
+  }
+}
+__name(fetchRewardsBreakdown, "fetchRewardsBreakdown");
+var EMPTY_STATS = {
+  presencePoints: 0,
+  totalWins: 0,
+  totalSubmissions: 0,
+  unclaimedSyn: 0,
+  totalClaimedSyn: 0,
+  canaryStrikes: 0,
+  anomalyWarnings: 0,
+  attestationFailures: 0,
+  tier: null,
+  name: null
+};
+async function fetchNodeStats(coordinatorUrl, pubkey) {
+  try {
+    const res = await fetch(`${coordinatorUrl}/node/${encodeURIComponent(pubkey)}`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return EMPTY_STATS;
+    const data = await res.json();
+    const toNumber = /* @__PURE__ */ __name((v) => {
+      const n = typeof v === "string" ? parseFloat(v) : typeof v === "number" ? v : 0;
+      return Number.isFinite(n) ? n : 0;
+    }, "toNumber");
+    const tierRaw = data.tier;
+    const tierNum = typeof tierRaw === "string" ? parseInt(tierRaw, 10) : typeof tierRaw === "number" ? tierRaw : NaN;
+    return {
+      presencePoints: toNumber(data.presencePoints),
+      totalWins: toNumber(data.totalWins),
+      totalSubmissions: toNumber(data.totalSubmissions),
+      unclaimedSyn: toNumber(data.unclaimedSyn),
+      totalClaimedSyn: toNumber(data.totalClaimedSyn),
+      canaryStrikes: toNumber(data.canaryStrikes),
+      anomalyWarnings: toNumber(data.anomalyWarnings),
+      attestationFailures: toNumber(data.attestationFailures),
+      tier: Number.isFinite(tierNum) ? tierNum : null,
+      name: typeof data.name === "string" ? data.name : null
+    };
+  } catch {
+    return EMPTY_STATS;
+  }
+}
+__name(fetchNodeStats, "fetchNodeStats");
+async function runChainInfoLightweight() {
+  const wallet = readPublicKey();
+  const rpcUrl = process.env.SOLANA_RPC_URL ?? "https://api.devnet.solana.com";
+  const synMint = process.env.SYN_TOKEN_MINT ?? "DCdWHhoeEwHJ3Fy3DRTk4yvZPXq3mSNZKtbPJzUfpUh8";
+  const stakingProgramId = process.env.STAKING_PROGRAM_ID ?? "CYW5Cprp5JuzaXtPyV8LPBgPzbze6QHnc3oFBAVaFkfw";
+  const rewardsVaultProgramId = process.env.REWARDS_VAULT_PROGRAM_ID ?? "D9pkzWv2Ak9J8vXDVcMM1P51hDmjRJEwbuYHxCuJKTEN";
+  const emptyPayload = {
+    wallet,
+    sol: 0,
+    syn: 0,
+    staked: 0,
+    rewardsPending: 0,
+    stakeAccountExists: false,
+    stakeLockedUntil: 0,
+    tokenAccountExists: false,
+    coordinatorReachable: false,
+    vaultClaimableSyn: 0,
+    rewardsByType: {},
+    presencePoints: 0,
+    totalWins: 0,
+    totalSubmissions: 0,
+    unclaimedSyn: 0,
+    totalClaimedSyn: 0,
+    canaryStrikes: 0,
+    anomalyWarnings: 0,
+    attestationFailures: 0,
+    tier: null,
+    nodeName: null
+  };
+  if (!wallet) {
+    process.stdout.write(`__CHAIN_INFO__ ${JSON.stringify(emptyPayload)}
+`);
+    process.exit(0);
+  }
+  const coordinatorUrl = readCoordinatorUrl();
+  const [solBalance, syn, stake, stats, coordReachable, vaultClaimable, breakdown] = await Promise.all([
+    fetchSolBalance(rpcUrl, wallet),
+    fetchSynBalance(rpcUrl, wallet, synMint),
+    fetchStakeInfo(rpcUrl, wallet, stakingProgramId),
+    fetchNodeStats(coordinatorUrl, wallet),
+    fetchCoordinatorReachable(coordinatorUrl),
+    fetchVaultClaimable(rpcUrl, wallet, rewardsVaultProgramId),
+    fetchRewardsBreakdown(coordinatorUrl, wallet)
+  ]);
+  const payload = {
+    ...emptyPayload,
+    sol: solBalance,
+    syn: syn.amount,
+    tokenAccountExists: syn.accountExists,
+    staked: stake.amount,
+    rewardsPending: stake.rewardsPending,
+    stakeAccountExists: stake.exists,
+    stakeLockedUntil: stake.lockedUntil,
+    coordinatorReachable: coordReachable,
+    vaultClaimableSyn: vaultClaimable,
+    rewardsByType: breakdown.byType,
+    presencePoints: stats.presencePoints,
+    totalWins: stats.totalWins,
+    totalSubmissions: stats.totalSubmissions,
+    unclaimedSyn: stats.unclaimedSyn,
+    // Prefer the /rewards/claimable endpoint's totalClaimedSyn over the one
+    // from /node/:wallet when available — it's the authoritative count.
+    totalClaimedSyn: breakdown.totalClaimedSyn || stats.totalClaimedSyn,
+    canaryStrikes: stats.canaryStrikes,
+    anomalyWarnings: stats.anomalyWarnings,
+    attestationFailures: stats.attestationFailures,
+    tier: stats.tier,
+    nodeName: stats.name
+  };
+  process.stdout.write(`__CHAIN_INFO__ ${JSON.stringify(payload)}
+`);
+  process.exit(0);
+}
+__name(runChainInfoLightweight, "runChainInfoLightweight");
+export {
+  runChainInfoLightweight
+};

package/dist/chat-stream-handler-BSHSGMFF.js

@@ -0,0 +1,127 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  LlmProviderHelper,
+  readJsonFromStream,
+  sendJsonOverStream
+} from "./chunk-T2ZRG5CX.js";
+import {
+  beginChatInference,
+  endChatInference
+} from "./chunk-5ZAJBIAV.js";
+import {
+  CHAT_PROTOCOL
+} from "./chunk-3BHRQWSM.js";
+import "./chunk-2X7MSWD4.js";
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/inference/chat-stream-handler.ts
+init_logger();
+var ChatStreamHandler = class {
+  static {
+    __name(this, "ChatStreamHandler");
+  }
+  p2p;
+  deps;
+  llmProvider = new LlmProviderHelper();
+  constructor(p2p, deps) {
+    this.p2p = p2p;
+    this.deps = deps;
+  }
+  async start() {
+    await this.p2p.handleProtocol(CHAT_PROTOCOL, (stream, _connection) => {
+      void this.onStream(stream);
+    });
+    const modelTag = this.deps.llmModel.provider === "cloud" ? `${this.deps.llmModel.providerId}/${this.deps.llmModel.modelId}` : this.deps.llmModel.modelId;
+    logger_default.log(`[ChatStreamHandler] listening on ${CHAT_PROTOCOL} (llm=${modelTag})`);
+  }
+  async onStream(stream) {
+    logger_default.log(`[ChatStreamHandler] \u26A1 inbound stream opened \u2014 reading request\u2026`);
+    try {
+      const req = await readJsonFromStream(stream);
+      if (!req?.messages || !Array.isArray(req.messages)) {
+        await sendJsonOverStream(stream, {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "invalid request"
+              }
+            }
+          ]
+        });
+        return;
+      }
+      logger_default.log(`[ChatStreamHandler] \u25B6 quote ${req.quoteId?.slice(0, 8)}\u2026 session ${req.sessionId?.slice(0, 8)}\u2026 (${req.messages.length} messages) \u2014 generating via ${this.deps.llmModel.provider}`);
+      beginChatInference();
+      const t0 = Date.now();
+      let response;
+      try {
+        response = await this.generateAnswer(req.messages);
+      } finally {
+        endChatInference();
+      }
+      logger_default.log(`[ChatStreamHandler] \u2713 LLM responded in ${Date.now() - t0}ms \u2014 writing response`);
+      await sendJsonOverStream(stream, response);
+      logger_default.log(`[ChatStreamHandler] \u2713 response sent for quote ${req.quoteId?.slice(0, 8)}\u2026`);
+    } catch (err) {
+      logger_default.warn(`[ChatStreamHandler] stream error: ${err.message}`);
+      try {
+        await sendJsonOverStream(stream, {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: `error: ${err.message}`
+              }
+            }
+          ]
+        });
+      } catch {
+      }
+    }
+  }
+  /**
+  * Flatten chat messages into a single prompt that preserves role context
+  * (the LlmProviderHelper.generateLLM API is prompt-based, not
+  * messages-based). This keeps the implementation simple — a future
+  * iteration can add a chat-native path through the cloud providers'
+  * `/chat/completions` endpoints to preserve tool-use / fine control.
+  */
+  async generateAnswer(messages) {
+    const prompt = this.flattenMessagesToPrompt(messages);
+    const content = await this.llmProvider.generateLLM(this.deps.llmModel, prompt, this.deps.llmConfig, {
+      temperature: 0.7,
+      maxTokens: 2048
+    });
+    return {
+      choices: [
+        {
+          message: {
+            role: "assistant",
+            content
+          }
+        }
+      ]
+    };
+  }
+  flattenMessagesToPrompt(messages) {
+    const parts = [
+      "You are Synapseia-Agent, a biomedical research assistant. Answer the user concisely and truthfully. If you do not know, say so."
+    ];
+    for (const m of messages) {
+      const role = m.role === "assistant" ? "Assistant" : m.role === "system" ? "System" : "User";
+      parts.push(`${role}: ${m.content}`);
+    }
+    parts.push("Assistant:");
+    return parts.join("\n\n");
+  }
+};
+export {
+  ChatStreamHandler
+};

package/dist/chunk-2X7MSWD4.js

@@ -0,0 +1,270 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/llm/ollama.ts
+import { Injectable, Logger } from "@nestjs/common";
+import axios from "axios";
+import { Ollama } from "ollama";
+
+// src/utils/circuit-breaker.ts
+init_logger();
+var CircuitOpenError = class extends Error {
+  static {
+    __name(this, "CircuitOpenError");
+  }
+  retryAfterMs;
+  constructor(name, retryAfterMs) {
+    super(`circuit "${name}" open \u2014 retry in ${Math.round(retryAfterMs / 1e3)}s`), this.retryAfterMs = retryAfterMs;
+    this.name = "CircuitOpenError";
+  }
+};
+var CircuitBreaker = class {
+  static {
+    __name(this, "CircuitBreaker");
+  }
+  opts;
+  state = "closed";
+  failures = [];
+  openedAt = 0;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+  * Run `op` under breaker control. Throws `CircuitOpenError` immediately
+  * when open; otherwise propagates the underlying success/failure.
+  */
+  async exec(op) {
+    const now = Date.now();
+    if (this.state === "open") {
+      const elapsed = now - this.openedAt;
+      if (elapsed < this.opts.cooldownMs) {
+        throw new CircuitOpenError(this.opts.name, this.opts.cooldownMs - elapsed);
+      }
+      this.state = "half-open";
+    }
+    try {
+      const result = await op();
+      this.onSuccess();
+      return result;
+    } catch (err) {
+      this.onFailure(now);
+      throw err;
+    }
+  }
+  onSuccess() {
+    if (this.state !== "closed") {
+      logger_default.warn(`[circuit:${this.opts.name}] recovered \u2014 closing`);
+    }
+    this.state = "closed";
+    this.failures = [];
+  }
+  onFailure(now) {
+    if (this.state === "half-open") {
+      this.openedAt = now;
+      this.state = "open";
+      logger_default.warn(`[circuit:${this.opts.name}] probe failed \u2014 reopening for ${this.opts.cooldownMs}ms`);
+      return;
+    }
+    const cutoff = now - this.opts.windowMs;
+    this.failures = this.failures.filter((t) => t >= cutoff);
+    this.failures.push(now);
+    if (this.failures.length >= this.opts.failureThreshold) {
+      this.openedAt = now;
+      this.state = "open";
+      this.failures = [];
+      logger_default.warn(`[circuit:${this.opts.name}] tripped \u2014 ${this.opts.failureThreshold} failures in ${this.opts.windowMs}ms; opening for ${this.opts.cooldownMs}ms`);
+    }
+  }
+  /** Test-only / introspection. */
+  getState() {
+    return this.state;
+  }
+};
+
+// src/modules/llm/ollama.ts
+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");
+var OllamaHelper = class _OllamaHelper {
+  static {
+    __name(this, "OllamaHelper");
+  }
+  /**
+  * Check Ollama availability and installed models
+  */
+  logger = new Logger(_OllamaHelper.name);
+  /**
+  * Per-process circuit breaker for `generate()`. When Ollama crashes
+  * under RAM pressure, the same generate calls fail in cascade. Without
+  * a breaker, every retry produces another `Generation failed: ...`
+  * log/telemetry event — 200+ events per minute observed in production.
+  *
+  * After 5 failures within 60s the breaker opens for 30s; subsequent
+  * calls throw CircuitOpenError immediately (no HTTP, no log spam) until
+  * the half-open probe succeeds.
+  */
+  static generateBreaker = new CircuitBreaker({
+    name: "ollama-generate",
+    failureThreshold: 5,
+    windowMs: 6e4,
+    cooldownMs: 3e4
+  });
+  async checkOllama(url = process.env.OLLAMA_URL || "http://localhost:11434") {
+    try {
+      const response = await axios.get(`${url}/api/tags`, {
+        timeout: 5e3
+      });
+      const models = response.data.models.map((m) => m.name);
+      const { HardwareHelper } = await import("./hardware-ITQQJ5YI.js");
+      const hwInfo = new HardwareHelper().detectHardware(false);
+      const hasGPU = hwInfo.gpuVramGb > 0;
+      const recommendedModel = hasGPU ? "qwen2.5:3b" : "qwen2.5:0.5b";
+      return {
+        available: true,
+        url,
+        models,
+        recommendedModel
+      };
+    } catch (error) {
+      const isAxiosError = error && typeof error === "object" && "isAxiosError" in error;
+      if (isAxiosError) {
+        return {
+          available: false,
+          url,
+          models: [],
+          recommendedModel: "qwen2.5:0.5b",
+          error: `Cannot connect to Ollama at ${url}: ${error.message}`
+        };
+      }
+      let errorMessage = "Unknown error";
+      if (error instanceof Error) errorMessage = error.message;
+      return {
+        available: false,
+        url,
+        models: [],
+        recommendedModel: "qwen2.5:0.5b",
+        error: errorMessage
+      };
+    }
+  }
+  /**
+  * Pull a model from Ollama registry
+  */
+  async pullModel(model, url = process.env.OLLAMA_URL || "http://localhost:11434") {
+    try {
+      this.logger.log(`\u{1F4E5} Pulling model ${model} from Ollama...`);
+      const ollamaClient = new Ollama({
+        host: url
+      });
+      const stream = await ollamaClient.pull({
+        model,
+        stream: true
+      });
+      let lastDigest = "";
+      for await (const part of stream) {
+        if (part.digest && part.digest !== lastDigest) {
+          const percent = part.total !== void 0 && part.completed !== void 0 ? Math.round(part.completed / part.total * 100) : 0;
+          this.logger.log(`\u{1F4E6} ${model}: ${percent}% complete`);
+          lastDigest = part.digest;
+        }
+        if (part.status === "success") {
+          this.logger.log(`\u2705 Model ${model} downloaded successfully`);
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to pull model ${model}: ${errorMessage}`);
+    }
+  }
+  /**
+  * Generate text using Ollama
+  */
+  async generate(prompt, model, url = process.env.OLLAMA_URL || "http://localhost:11434", options) {
+    return _OllamaHelper.generateBreaker.exec(async () => {
+      try {
+        let targetModel = model;
+        if (!targetModel) {
+          const status = await this.checkOllama(url);
+          if (!status.available) throw new Error("Ollama is not available");
+          targetModel = status.recommendedModel;
+        }
+        this.logger.log(`\u{1F9E0} Generating with model: ${targetModel}`);
+        const ollamaClient = new Ollama({
+          host: url
+        });
+        const response = await ollamaClient.chat({
+          model: targetModel,
+          messages: [
+            {
+              role: "user",
+              content: prompt
+            }
+          ],
+          stream: false,
+          // format: "json" enables grammar-based constrained decoding — the model
+          // is physically prevented from emitting non-JSON tokens, so JSON.parse
+          // never fails due to syntax errors (no fences, no trailing text, no
+          // unclosed strings). Still need to validate fields after parsing.
+          ...options?.forceJson && {
+            format: "json"
+          },
+          options: {
+            // Raise context window above the Ollama default (2048) so research
+            // prompts carrying paper abstracts + related DOIs + ontology
+            // context don't get truncated — truncation was surfacing as
+            // "unexpected EOF" when the prompt end landed mid-token on the
+            // llama runner. Qwen2.5 supports 32k; 8192 is a safe fit for 0.5b
+            // on a 3.8 GiB Docker VM.
+            num_ctx: 8192,
+            ...options?.temperature !== void 0 && {
+              temperature: options.temperature
+            },
+            ...options?.maxTokens !== void 0 && {
+              num_predict: options.maxTokens
+            },
+            ...options?.topP !== void 0 && {
+              top_p: options.topP
+            }
+          }
+        });
+        return response.message.content.trim();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Generation failed: ${errorMessage}`);
+      }
+    });
+  }
+  /**
+  * Ensure a model is available, pulling if necessary
+  */
+  async ensureModel(model, url = process.env.OLLAMA_URL || "http://localhost:11434") {
+    const status = await this.checkOllama(url);
+    if (!status.available) {
+      throw new Error("Ollama is not running. Start with: ollama serve");
+    }
+    const modelAvailable = status.models.some((m) => m.startsWith(model.split(":")[0]));
+    if (!modelAvailable) {
+      this.logger.log(`\u26A0\uFE0F Model ${model} not found. Pulling...`);
+      await this.pullModel(model, url);
+    } else {
+      this.logger.log(`\u2705 Model ${model} is available`);
+    }
+  }
+};
+OllamaHelper = _ts_decorate([
+  Injectable()
+], OllamaHelper);
+
+export {
+  OllamaHelper
+};