@poolzin/pool-bot 2026.2.7 → 2026.2.8

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v2026.2.8 (2026-02-15)
+
+### Features
+- NVIDIA dynamic model discovery — users with `NVIDIA_API_KEY` now see 50+ free-tier NIM models (Llama 3.3/3.1, DeepSeek R1, Mistral Large 2, Qwen 2.5, vision models, and more) instead of a single hardcoded Nemotron Ultra 253B
+- Follows the Venice discovery pattern: static fallback catalog + live `/v1/models` fetch with 5s timeout
+
+### Fixes
+- Use the provider's default vision model (not the active chat model) for image understanding, fixing media pipeline failures on text-only models
+
+### Improvements
+- Upstream port: security hardening, graceful restart, Ollama native streaming, tool mutation, compaction safety
+
+---
+
 ## v2026.1.40 (2026-02-09)
 
 ### Rebrand

package/dist/agents/models-config.providers.js

@@ -5,6 +5,7 @@ import { discoverBedrockModels } from "./bedrock-discovery.js";
 import { buildCloudflareAiGatewayModelDefinition, resolveCloudflareAiGatewayBaseUrl, } from "./cloudflare-ai-gateway.js";
 import { buildSyntheticModelDefinition, SYNTHETIC_BASE_URL, SYNTHETIC_MODEL_CATALOG, } from "./synthetic-models.js";
 import { TOGETHER_BASE_URL, TOGETHER_MODEL_CATALOG, buildTogetherModelDefinition, } from "./together-models.js";
+import { discoverNvidiaModels, NVIDIA_BASE_URL } from "./nvidia-models.js";
 import { discoverVeniceModels, VENICE_BASE_URL } from "./venice-models.js";
 const MINIMAX_API_BASE_URL = "https://api.minimax.chat/v1";
 const MINIMAX_PORTAL_BASE_URL = "https://api.minimax.io/anthropic";
@@ -345,6 +346,14 @@ function buildTogetherProvider() {
         models: TOGETHER_MODEL_CATALOG.map(buildTogetherModelDefinition),
     };
 }
+async function buildNvidiaProvider(apiKey) {
+    const models = await discoverNvidiaModels(apiKey);
+    return {
+        baseUrl: NVIDIA_BASE_URL,
+        api: "openai-completions",
+        models,
+    };
+}
 export function buildQianfanProvider() {
     return {
         baseUrl: QIANFAN_BASE_URL,
@@ -457,6 +466,11 @@ export async function resolveImplicitProviders(params) {
     if (qianfanKey) {
         providers.qianfan = { ...buildQianfanProvider(), apiKey: qianfanKey };
     }
+    const nvidiaKey = resolveEnvApiKeyVarName("nvidia") ??
+        resolveApiKeyFromProfiles({ provider: "nvidia", store: authStore });
+    if (nvidiaKey) {
+        providers.nvidia = { ...(await buildNvidiaProvider(nvidiaKey)), apiKey: nvidiaKey };
+    }
     return providers;
 }
 export async function resolveImplicitCopilotProvider(params) {

package/dist/agents/nvidia-models.js

@@ -0,0 +1,228 @@
+export const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+export const NVIDIA_DEFAULT_MODEL_ID = "llama-3.1-nemotron-ultra-253b-v1";
+// NVIDIA free-tier models have no per-token cost.
+export const NVIDIA_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+/**
+ * Static catalog of popular NVIDIA NIM free-tier models.
+ *
+ * NVIDIA's `integrate.api.nvidia.com` hosts 50+ models via OpenAI-compatible
+ * `/v1/chat/completions`. This catalog acts as a fallback when the `/v1/models`
+ * endpoint is unreachable or the API key isn't valid for discovery.
+ *
+ * Model IDs match what NVIDIA's API returns — some use `org/model` format,
+ * others use bare IDs.
+ */
+export const NVIDIA_MODEL_CATALOG = [
+    // ── Flagship ──────────────────────────────────────────
+    {
+        id: "llama-3.1-nemotron-ultra-253b-v1",
+        name: "Nemotron Ultra 253B",
+        reasoning: true,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    // ── Meta Llama ────────────────────────────────────────
+    {
+        id: "meta/llama-3.3-70b-instruct",
+        name: "Llama 3.3 70B Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    {
+        id: "meta/llama-3.1-405b-instruct",
+        name: "Llama 3.1 405B Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 4096,
+    },
+    {
+        id: "meta/llama-3.1-8b-instruct",
+        name: "Llama 3.1 8B Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    // ── DeepSeek ──────────────────────────────────────────
+    {
+        id: "deepseek-ai/deepseek-r1",
+        name: "DeepSeek R1",
+        reasoning: true,
+        input: ["text"],
+        contextWindow: 65536,
+        maxTokens: 8192,
+    },
+    // ── Mistral ───────────────────────────────────────────
+    {
+        id: "mistralai/mistral-large-2-instruct",
+        name: "Mistral Large 2 Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    // ── Qwen ──────────────────────────────────────────────
+    {
+        id: "qwen/qwen2.5-72b-instruct",
+        name: "Qwen 2.5 72B Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    {
+        id: "qwen/qwq-32b",
+        name: "QwQ 32B",
+        reasoning: true,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    // ── Vision models ─────────────────────────────────────
+    {
+        id: "microsoft/phi-3.5-vision-instruct",
+        name: "Phi 3.5 Vision Instruct",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 131072,
+        maxTokens: 4096,
+    },
+    {
+        id: "nvidia/llama-3.2-nv-vision-instruct-v1",
+        name: "Llama 3.2 NV Vision Instruct",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 131072,
+        maxTokens: 4096,
+    },
+    // ── Code ──────────────────────────────────────────────
+    {
+        id: "nvidia/llama-3.1-nemotron-70b-instruct",
+        name: "Nemotron 70B Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+    {
+        id: "ibm/granite-3.1-8b-instruct",
+        name: "Granite 3.1 8B Instruct",
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 131072,
+        maxTokens: 8192,
+    },
+];
+/**
+ * Build a ModelDefinitionConfig from a static catalog entry.
+ */
+export function buildNvidiaModelDefinition(entry) {
+    return {
+        id: entry.id,
+        name: entry.name,
+        reasoning: entry.reasoning,
+        input: [...entry.input],
+        cost: NVIDIA_DEFAULT_COST,
+        contextWindow: entry.contextWindow,
+        maxTokens: entry.maxTokens,
+    };
+}
+// Model IDs known to be embedding/reranking/image-gen — not chat-compatible.
+const NON_CHAT_PATTERNS = [
+    "embed",
+    "rerank",
+    "nv-rerankqa",
+    "sdxl",
+    "stable-diffusion",
+    "consistory",
+    "shutterstock",
+    "image",
+    "usearch",
+    "parakeet",
+    "canary",
+    "whisper",
+    "speech",
+    "audio",
+    "tts",
+    "asr",
+];
+function isLikelyChatModel(id) {
+    const lower = id.toLowerCase();
+    return !NON_CHAT_PATTERNS.some((p) => lower.includes(p));
+}
+/**
+ * Discover models from NVIDIA's OpenAI-compatible `/v1/models` endpoint.
+ *
+ * Requires a valid API key (unlike Venice which is public).
+ * Falls back to the static catalog on any failure.
+ */
+export async function discoverNvidiaModels(apiKey) {
+    // Skip API discovery in test environments
+    if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+        return NVIDIA_MODEL_CATALOG.map(buildNvidiaModelDefinition);
+    }
+    try {
+        const response = await fetch(`${NVIDIA_BASE_URL}/models`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            console.warn(`[nvidia-models] Discovery failed: HTTP ${response.status}, using static catalog`);
+            return NVIDIA_MODEL_CATALOG.map(buildNvidiaModelDefinition);
+        }
+        const data = (await response.json());
+        if (!Array.isArray(data.data) || data.data.length === 0) {
+            console.warn("[nvidia-models] No models returned from API, using static catalog");
+            return NVIDIA_MODEL_CATALOG.map(buildNvidiaModelDefinition);
+        }
+        // Build lookup from static catalog for enrichment
+        const catalogById = new Map(NVIDIA_MODEL_CATALOG.map((m) => [m.id, m]));
+        const models = [];
+        for (const apiModel of data.data) {
+            if (!isLikelyChatModel(apiModel.id))
+                continue;
+            const catalogEntry = catalogById.get(apiModel.id);
+            if (catalogEntry) {
+                // Use curated metadata for known models
+                models.push(buildNvidiaModelDefinition(catalogEntry));
+            }
+            else {
+                // Create a best-effort definition for newly discovered models
+                const lower = apiModel.id.toLowerCase();
+                const isReasoning = lower.includes("r1") ||
+                    lower.includes("reasoning") ||
+                    lower.includes("thinking") ||
+                    lower.includes("nemotron-ultra");
+                const hasVision = lower.includes("vision") || lower.includes("-vl-") || lower.includes("nvlm");
+                // Derive a human-friendly name from the model ID
+                const name = apiModel.id
+                    .replace(/^[^/]+\//, "") // strip org/ prefix
+                    .replace(/-/g, " ")
+                    .replace(/\b\w/g, (c) => c.toUpperCase());
+                models.push({
+                    id: apiModel.id,
+                    name,
+                    reasoning: isReasoning,
+                    input: hasVision ? ["text", "image"] : ["text"],
+                    cost: NVIDIA_DEFAULT_COST,
+                    contextWindow: 131072, // safe default for NIM models
+                    maxTokens: 8192,
+                });
+            }
+        }
+        return models.length > 0 ? models : NVIDIA_MODEL_CATALOG.map(buildNvidiaModelDefinition);
+    }
+    catch (error) {
+        console.warn(`[nvidia-models] Discovery failed: ${String(error)}, using static catalog`);
+        return NVIDIA_MODEL_CATALOG.map(buildNvidiaModelDefinition);
+    }
+}

package/dist/agents/ollama-stream.js

@@ -0,0 +1,294 @@
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
+import { randomUUID } from "node:crypto";
+export const OLLAMA_NATIVE_BASE_URL = "http://127.0.0.1:11434";
+function extractTextContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+function extractOllamaImages(content) {
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    return content
+        .filter((part) => part.type === "image")
+        .map((part) => part.data);
+}
+function extractToolCalls(content) {
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const parts = content;
+    const result = [];
+    for (const part of parts) {
+        if (part.type === "toolCall") {
+            result.push({ function: { name: part.name, arguments: part.arguments } });
+        }
+        else if (part.type === "tool_use") {
+            result.push({ function: { name: part.name, arguments: part.input } });
+        }
+    }
+    return result;
+}
+export function convertToOllamaMessages(messages, system) {
+    const result = [];
+    if (system) {
+        result.push({ role: "system", content: system });
+    }
+    for (const msg of messages) {
+        const { role } = msg;
+        if (role === "user") {
+            const text = extractTextContent(msg.content);
+            const images = extractOllamaImages(msg.content);
+            result.push({
+                role: "user",
+                content: text,
+                ...(images.length > 0 ? { images } : {}),
+            });
+        }
+        else if (role === "assistant") {
+            const text = extractTextContent(msg.content);
+            const toolCalls = extractToolCalls(msg.content);
+            result.push({
+                role: "assistant",
+                content: text,
+                ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+            });
+        }
+        else if (role === "tool" || role === "toolResult") {
+            // SDK uses "toolResult" (camelCase) for tool result messages.
+            // Ollama API expects "tool" role with tool_name per the native spec.
+            const text = extractTextContent(msg.content);
+            const toolName = typeof msg.toolName === "string"
+                ? msg.toolName
+                : undefined;
+            result.push({
+                role: "tool",
+                content: text,
+                ...(toolName ? { tool_name: toolName } : {}),
+            });
+        }
+    }
+    return result;
+}
+// ── Tool extraction ─────────────────────────────────────────────────────────
+function extractOllamaTools(tools) {
+    if (!tools || !Array.isArray(tools)) {
+        return [];
+    }
+    const result = [];
+    for (const tool of tools) {
+        if (typeof tool.name !== "string" || !tool.name) {
+            continue;
+        }
+        result.push({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: typeof tool.description === "string" ? tool.description : "",
+                parameters: (tool.parameters ?? {}),
+            },
+        });
+    }
+    return result;
+}
+// ── Response conversion ─────────────────────────────────────────────────────
+export function buildAssistantMessage(response, modelInfo) {
+    const content = [];
+    if (response.message.content) {
+        content.push({ type: "text", text: response.message.content });
+    }
+    const toolCalls = response.message.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+        for (const tc of toolCalls) {
+            content.push({
+                type: "toolCall",
+                id: `ollama_call_${randomUUID()}`,
+                name: tc.function.name,
+                arguments: tc.function.arguments,
+            });
+        }
+    }
+    const hasToolCalls = toolCalls && toolCalls.length > 0;
+    const stopReason = hasToolCalls ? "toolUse" : "stop";
+    const usage = {
+        input: response.prompt_eval_count ?? 0,
+        output: response.eval_count ?? 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+    return {
+        role: "assistant",
+        content,
+        stopReason,
+        api: modelInfo.api,
+        provider: modelInfo.provider,
+        model: modelInfo.id,
+        usage,
+        timestamp: Date.now(),
+    };
+}
+// ── NDJSON streaming parser ─────────────────────────────────────────────────
+export async function* parseNdjsonStream(reader) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                yield JSON.parse(trimmed);
+            }
+            catch {
+                console.warn("[ollama-stream] Skipping malformed NDJSON line:", trimmed.slice(0, 120));
+            }
+        }
+    }
+    if (buffer.trim()) {
+        try {
+            yield JSON.parse(buffer.trim());
+        }
+        catch {
+            console.warn("[ollama-stream] Skipping malformed trailing data:", buffer.trim().slice(0, 120));
+        }
+    }
+}
+// ── Main StreamFn factory ───────────────────────────────────────────────────
+function resolveOllamaChatUrl(baseUrl) {
+    const trimmed = baseUrl.trim().replace(/\/+$/, "");
+    const normalizedBase = trimmed.replace(/\/v1$/i, "");
+    const apiBase = normalizedBase || OLLAMA_NATIVE_BASE_URL;
+    return `${apiBase}/api/chat`;
+}
+export function createOllamaStreamFn(baseUrl) {
+    const chatUrl = resolveOllamaChatUrl(baseUrl);
+    return (model, context, options) => {
+        const stream = createAssistantMessageEventStream();
+        const run = async () => {
+            try {
+                const ollamaMessages = convertToOllamaMessages(context.messages ?? [], context.systemPrompt);
+                const ollamaTools = extractOllamaTools(context.tools);
+                // Ollama defaults to num_ctx=4096 which is too small for large
+                // system prompts + many tool definitions. Use model's contextWindow.
+                const ollamaOptions = { num_ctx: model.contextWindow ?? 65536 };
+                if (typeof options?.temperature === "number") {
+                    ollamaOptions.temperature = options.temperature;
+                }
+                if (typeof options?.maxTokens === "number") {
+                    ollamaOptions.num_predict = options.maxTokens;
+                }
+                const body = {
+                    model: model.id,
+                    messages: ollamaMessages,
+                    stream: true,
+                    ...(ollamaTools.length > 0 ? { tools: ollamaTools } : {}),
+                    options: ollamaOptions,
+                };
+                const headers = {
+                    "Content-Type": "application/json",
+                    ...options?.headers,
+                };
+                if (options?.apiKey) {
+                    headers.Authorization = `Bearer ${options.apiKey}`;
+                }
+                const response = await fetch(chatUrl, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: options?.signal,
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "unknown error");
+                    throw new Error(`Ollama API error ${response.status}: ${errorText}`);
+                }
+                if (!response.body) {
+                    throw new Error("Ollama API returned empty response body");
+                }
+                const reader = response.body.getReader();
+                let accumulatedContent = "";
+                const accumulatedToolCalls = [];
+                let finalResponse;
+                for await (const chunk of parseNdjsonStream(reader)) {
+                    if (chunk.message?.content) {
+                        accumulatedContent += chunk.message.content;
+                    }
+                    // Ollama sends tool_calls in intermediate (done:false) chunks,
+                    // NOT in the final done:true chunk. Collect from all chunks.
+                    if (chunk.message?.tool_calls) {
+                        accumulatedToolCalls.push(...chunk.message.tool_calls);
+                    }
+                    if (chunk.done) {
+                        finalResponse = chunk;
+                        break;
+                    }
+                }
+                if (!finalResponse) {
+                    throw new Error("Ollama API stream ended without a final response");
+                }
+                finalResponse.message.content = accumulatedContent;
+                if (accumulatedToolCalls.length > 0) {
+                    finalResponse.message.tool_calls = accumulatedToolCalls;
+                }
+                const assistantMessage = buildAssistantMessage(finalResponse, {
+                    api: model.api,
+                    provider: model.provider,
+                    id: model.id,
+                });
+                const reason = assistantMessage.stopReason === "toolUse" ? "toolUse" : "stop";
+                stream.push({
+                    type: "done",
+                    reason,
+                    message: assistantMessage,
+                });
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                stream.push({
+                    type: "error",
+                    reason: "error",
+                    error: {
+                        role: "assistant",
+                        content: [],
+                        stopReason: "error",
+                        errorMessage,
+                        api: model.api,
+                        provider: model.provider,
+                        model: model.id,
+                        usage: {
+                            input: 0,
+                            output: 0,
+                            cacheRead: 0,
+                            cacheWrite: 0,
+                            totalTokens: 0,
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+                        },
+                        timestamp: Date.now(),
+                    },
+                });
+            }
+            finally {
+                stream.end();
+            }
+        };
+        queueMicrotask(() => void run());
+        return stream;
+    };
+}

package/dist/agents/pi-embedded-runner/compaction-safety-timeout.js

@@ -0,0 +1,5 @@
+import { withTimeout } from "../../node-host/with-timeout.js";
+export const EMBEDDED_COMPACTION_TIMEOUT_MS = 300_000;
+export async function compactWithSafetyTimeout(compact, timeoutMs = EMBEDDED_COMPACTION_TIMEOUT_MS) {
+    return await withTimeout(() => compact(), timeoutMs, "Compaction");
+}

package/dist/agents/pi-embedded-runner/run/compaction-timeout.js

@@ -0,0 +1,27 @@
+export function shouldFlagCompactionTimeout(signal) {
+    if (!signal.isTimeout) {
+        return false;
+    }
+    return signal.isCompactionPendingOrRetrying || signal.isCompactionInFlight;
+}
+export function selectCompactionTimeoutSnapshot(params) {
+    if (!params.timedOutDuringCompaction) {
+        return {
+            messagesSnapshot: params.currentSnapshot,
+            sessionIdUsed: params.currentSessionId,
+            source: "current",
+        };
+    }
+    if (params.preCompactionSnapshot) {
+        return {
+            messagesSnapshot: params.preCompactionSnapshot,
+            sessionIdUsed: params.preCompactionSessionId,
+            source: "pre-compaction",
+        };
+    }
+    return {
+        messagesSnapshot: params.currentSnapshot,
+        sessionIdUsed: params.currentSessionId,
+        source: "current",
+    };
+}

package/dist/agents/pi-embedded-runner/wait-for-idle-before-flush.js

@@ -0,0 +1,29 @@
+export const DEFAULT_WAIT_FOR_IDLE_TIMEOUT_MS = 30_000;
+async function waitForAgentIdleBestEffort(agent, timeoutMs) {
+    const waitForIdle = agent?.waitForIdle;
+    if (typeof waitForIdle !== "function") {
+        return;
+    }
+    let timeoutHandle;
+    try {
+        await Promise.race([
+            waitForIdle.call(agent),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(resolve, timeoutMs);
+                timeoutHandle.unref?.();
+            }),
+        ]);
+    }
+    catch {
+        // Best-effort during cleanup.
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
+export async function flushPendingToolResultsAfterIdle(opts) {
+    await waitForAgentIdleBestEffort(opts.agent, opts.timeoutMs ?? DEFAULT_WAIT_FOR_IDLE_TIMEOUT_MS);
+    opts.sessionManager?.flushPendingToolResults?.();
+}