open-agents-ai 0.184.44 → 0.184.45

package/dist/index.js

@@ -672,20 +672,20 @@ var init_VllmBackend = __esm({
       // -------------------------------------------------------------------------
       // LLMBackend — complete
       // -------------------------------------------------------------------------
-      async complete(request2) {
-        const messages = request2.messages.map(agentMessageToChatMessage);
+      async complete(request) {
+        const messages = request.messages.map(agentMessageToChatMessage);
         const body = {
           model: this.model,
           messages,
-          temperature: request2.temperature ?? 0,
-          max_tokens: request2.maxTokens ?? 4096
+          temperature: request.temperature ?? 0,
+          max_tokens: request.maxTokens ?? 4096
         };
-        if (request2.tools && request2.tools.length > 0) {
-          body.tools = request2.tools;
+        if (request.tools && request.tools.length > 0) {
+          body.tools = request.tools;
           body.tool_choice = "auto";
         }
-        if (request2.responseFormat) {
-          body.response_format = request2.responseFormat;
+        if (request.responseFormat) {
+          body.response_format = request.responseFormat;
         }
         const start = Date.now();
         const rawResponse = await this.postWithRetry("/v1/chat/completions", body);
@@ -822,24 +822,24 @@ var init_OllamaBackend = __esm({
       // -------------------------------------------------------------------------
       // LLMBackend — complete
       // -------------------------------------------------------------------------
-      async complete(request2) {
-        const messages = request2.messages.map(agentMessageToChatMessage2);
+      async complete(request) {
+        const messages = request.messages.map(agentMessageToChatMessage2);
         const body = {
           model: this.model,
           messages,
-          temperature: request2.temperature ?? 0,
-          max_tokens: request2.maxTokens ?? 4096,
+          temperature: request.temperature ?? 0,
+          max_tokens: request.maxTokens ?? 4096,
           // Disable Qwen thinking mode by default so tokens go to content,
           // not reasoning. The model still produces good output without it
           // and coding agents need structured JSON in the content field.
           think: false
         };
-        if (request2.tools && request2.tools.length > 0) {
-          body.tools = request2.tools;
+        if (request.tools && request.tools.length > 0) {
+          body.tools = request.tools;
           body.tool_choice = "auto";
         }
-        if (request2.responseFormat) {
-          body.response_format = request2.responseFormat;
+        if (request.responseFormat) {
+          body.response_format = request.responseFormat;
         }
         const start = Date.now();
         const rawResponse = await this.postWithRetry("/v1/chat/completions", body);
@@ -1003,19 +1003,19 @@ var init_FakeBackend = __esm({
         this._healthCheckCount++;
         return this.options.healthy;
       }
-      async complete(request2) {
+      async complete(request) {
         this._completeCount++;
         if (this.options.shouldThrow) {
           throw new Error(this.options.errorMessage);
         }
-        const lastMessage = request2.messages[request2.messages.length - 1];
+        const lastMessage = request.messages[request.messages.length - 1];
         const inputKey = lastMessage ? `${lastMessage.role}:${lastMessage.content}` : "empty";
         const hash = fnv1a32(inputKey);
         const deterministicContent = `fake-response-${hash.toString(16).padStart(8, "0")}`;
         const usage = {
-          prompt_tokens: request2.messages.length * 10,
+          prompt_tokens: request.messages.length * 10,
           completion_tokens: 20,
-          total_tokens: request2.messages.length * 10 + 20
+          total_tokens: request.messages.length * 10 + 20
         };
         if (this.options.toolCallResponses.length > 0) {
           return {
@@ -11711,13 +11711,13 @@ Validation: ${validation.pass ? "PASS" : "NEEDS IMPROVEMENT"} (${validation.over
       // -------------------------------------------------------------------------
       // Phase 1: Seed Analysis
       // -------------------------------------------------------------------------
-      async analyzeSeed(request2) {
+      async analyzeSeed(request) {
         const prompt = loadBuilderPrompt("seed-analysis.md", {
-          skill_request: request2
+          skill_request: request
         });
         const response = await this.llmCall([
           { role: "system", content: prompt },
-          { role: "user", content: `Analyze this skill request: "${request2}"` }
+          { role: "user", content: `Analyze this skill request: "${request}"` }
         ]);
         const jsonStr = extractJSON(response);
         const seed = JSON.parse(jsonStr);
@@ -24287,22 +24287,22 @@ var init_snippetPacker = __esm({
 });
 
 // packages/retrieval/dist/contextAssembler.js
-async function assembleContext(request2, opts) {
+async function assembleContext(request, opts) {
   const { repoRoot, graph, semanticEngine, summaryMap, maxFiles = 8, maxSnippets = 20, maxLogs = 3, maxTokens = 24e3, expandNeighbors = true, architectureNote, priorAttemptNote } = opts;
   const lexOpts = {
     rootDir: repoRoot,
     includePatterns: [],
-    includeTests: request2.includeTests,
-    includeConfigs: request2.includeConfigs,
+    includeTests: request.includeTests,
+    includeConfigs: request.includeConfigs,
     maxMatches: 30
   };
   const [pathMatches, symbolMatches, errorMatches, semanticResults] = await Promise.all([
-    Promise.all(request2.pathsHint.map((p) => searchByPath(p, { rootDir: repoRoot, maxMatches: 10 }))).then((res) => res.flat()),
-    Promise.all(request2.symbolHint.map((s) => searchBySymbol(s, { rootDir: repoRoot, maxMatches: 10 }))).then((res) => res.flat()),
-    Promise.all(request2.errorHint.slice(0, maxLogs).map((e) => searchByError(e, { rootDir: repoRoot, maxMatches: 5 }))).then((res) => res.flat()),
-    semanticEngine?.isAvailable ? semanticEngine.search(request2.query, maxFiles) : Promise.resolve([])
+    Promise.all(request.pathsHint.map((p) => searchByPath(p, { rootDir: repoRoot, maxMatches: 10 }))).then((res) => res.flat()),
+    Promise.all(request.symbolHint.map((s) => searchBySymbol(s, { rootDir: repoRoot, maxMatches: 10 }))).then((res) => res.flat()),
+    Promise.all(request.errorHint.slice(0, maxLogs).map((e) => searchByError(e, { rootDir: repoRoot, maxMatches: 5 }))).then((res) => res.flat()),
+    semanticEngine?.isAvailable ? semanticEngine.search(request.query, maxFiles) : Promise.resolve([])
   ]);
-  const queryType = classifyQuery(request2.query);
+  const queryType = classifyQuery(request.query);
   const rrfK = adaptiveK(queryType, opts.rrfConfig?.k);
   const wFts = opts.rrfConfig?.weightFts ?? 1;
   const wSem = opts.rrfConfig?.weightSemantic ?? 1;
@@ -24373,7 +24373,7 @@ async function assembleContext(request2, opts) {
     }
   }
   return {
-    request: request2,
+    request,
     files,
     snippets: packed.slice(0, maxSnippets),
     architectureNote,
@@ -28232,14 +28232,14 @@ ${transcript}`
        * assembles and returns the same response format as chatCompletion().
        * The non-streaming chatCompletion path is NEVER touched by this code.
        */
-      async streamingRequest(request2, turn) {
+      async streamingRequest(request, turn) {
         const backend = this.backend;
         let content = "";
         let inThinkTag = false;
         const toolCallAccumulators = /* @__PURE__ */ new Map();
         let streamUsage;
         this.emit({ type: "stream_start", turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-        for await (const chunk of backend.chatCompletionStream(request2)) {
+        for await (const chunk of backend.chatCompletionStream(request)) {
           if (this.aborted)
             break;
           if (chunk.type === "usage" && chunk.usage) {
@@ -28349,13 +28349,13 @@ ${transcript}`
         }
         return headers;
       }
-      async chatCompletion(request2) {
+      async chatCompletion(request) {
         const body = {
           model: this.model,
-          messages: request2.messages,
-          tools: request2.tools,
-          temperature: request2.temperature,
-          max_tokens: request2.maxTokens,
+          messages: request.messages,
+          tools: request.tools,
+          temperature: request.temperature,
+          max_tokens: request.maxTokens,
           think: this.thinking
         };
         const fetchOpts = {
@@ -28412,13 +28412,13 @@ ${transcript}`
        * Uses `stream: true` and the current thinking setting.
        * The existing chatCompletion() method is completely unmodified.
        */
-      async *chatCompletionStream(request2) {
+      async *chatCompletionStream(request) {
         const body = {
           model: this.model,
-          messages: request2.messages,
-          tools: request2.tools,
-          temperature: request2.temperature,
-          max_tokens: request2.maxTokens,
+          messages: request.messages,
+          tools: request.tools,
+          temperature: request.temperature,
+          max_tokens: request.maxTokens,
           stream: true,
           stream_options: { include_usage: true },
           think: this.thinking
@@ -28538,7 +28538,7 @@ var init_nexusBackend = __esm({
         this.targetPeer = peerId;
         this.consecutiveFailures = 0;
       }
-      async chatCompletion(request2) {
+      async chatCompletion(request) {
         if (this.consecutiveFailures >= _NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES) {
           const err = new Error(`Remote peer unreachable after ${this.consecutiveFailures} attempts. Use /endpoint to switch to a local model or reconnect.`);
           err.fatal = true;
@@ -28546,10 +28546,10 @@ var init_nexusBackend = __esm({
         }
         const daemonArgs = {
           model: this.model,
-          messages: JSON.stringify(request2.messages),
-          tools: JSON.stringify(request2.tools),
-          temperature: String(request2.temperature),
-          max_tokens: String(request2.maxTokens)
+          messages: JSON.stringify(request.messages),
+          tools: JSON.stringify(request.tools),
+          temperature: String(request.temperature),
+          max_tokens: String(request.maxTokens)
         };
         if (this.targetPeer) {
           daemonArgs.target_peer = this.targetPeer;
@@ -28560,7 +28560,7 @@ var init_nexusBackend = __esm({
         daemonArgs.think = String(this.thinking);
         let rawResult;
         try {
-          rawResult = await this.sendFn("remote_infer", daemonArgs, request2.timeoutMs || 12e4);
+          rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
         } catch (sendErr) {
           this.consecutiveFailures++;
           throw sendErr;
@@ -28653,15 +28653,15 @@ var init_nexusBackend = __esm({
        * the file for token-by-token delivery from the remote peer.
        * Falls back to unary + word-split if streaming setup fails.
        */
-      async *chatCompletionStream(request2) {
+      async *chatCompletionStream(request) {
         const streamFile = join47(tmpdir7(), `nexus-stream-${randomBytes11(6).toString("hex")}.jsonl`);
         writeFileSync11(streamFile, "", "utf8");
         const daemonArgs = {
           model: this.model,
-          messages: JSON.stringify(request2.messages),
-          tools: JSON.stringify(request2.tools),
-          temperature: String(request2.temperature),
-          max_tokens: String(request2.maxTokens),
+          messages: JSON.stringify(request.messages),
+          tools: JSON.stringify(request.tools),
+          temperature: String(request.temperature),
+          max_tokens: String(request.maxTokens),
           stream_file: streamFile
         };
         if (this.targetPeer)
@@ -28671,7 +28671,7 @@ var init_nexusBackend = __esm({
         daemonArgs.think = String(this.thinking);
         let rawResult;
         try {
-          rawResult = await this.sendFn("remote_infer", daemonArgs, request2.timeoutMs || 12e4);
+          rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
         } catch (sendErr) {
           this.consecutiveFailures++;
           try {
@@ -28744,7 +28744,7 @@ var init_nexusBackend = __esm({
         this.consecutiveFailures = 0;
         let position = 0;
         let done = false;
-        const deadline = Date.now() + (request2.timeoutMs ?? 12e4);
+        const deadline = Date.now() + (request.timeoutMs ?? 12e4);
         try {
           while (!done && Date.now() < deadline) {
             await new Promise((resolve36) => {
@@ -28917,10 +28917,10 @@ var init_cascadeBackend = __esm({
       get fallbackCount() {
         return this.endpoints.filter((ep, i) => i !== this.activeIndex && ep.modelAvailable !== false).length;
       }
-      async chatCompletion(request2) {
+      async chatCompletion(request) {
         const backend = this.getActiveBackend();
         try {
-          const result = await backend.chatCompletion(request2);
+          const result = await backend.chatCompletion(request);
           this.consecutiveFailures = 0;
           return result;
         } catch (err) {
@@ -28936,7 +28936,7 @@ var init_cascadeBackend = __esm({
               this.onSwitch?.(from, to, reason);
               const newBackend = this.getActiveBackend();
               try {
-                const result = await newBackend.chatCompletion(request2);
+                const result = await newBackend.chatCompletion(request);
                 return result;
               } catch (cascadeErr) {
                 this.consecutiveFailures++;
@@ -28950,11 +28950,11 @@ var init_cascadeBackend = __esm({
       /**
        * Streaming support — delegates to active backend's stream method if available.
        */
-      async *chatCompletionStream(request2) {
+      async *chatCompletionStream(request) {
         const backend = this.getActiveBackend();
         const streamable = backend;
         if (typeof streamable.chatCompletionStream !== "function") {
-          const result = await this.chatCompletion(request2);
+          const result = await this.chatCompletion(request);
           const choice = result.choices[0];
           if (choice?.message.content) {
             yield { type: "content", content: choice.message.content };
@@ -28985,7 +28985,7 @@ var init_cascadeBackend = __esm({
           return;
         }
         try {
-          for await (const chunk of streamable.chatCompletionStream(request2)) {
+          for await (const chunk of streamable.chatCompletionStream(request)) {
             yield chunk;
           }
           this.consecutiveFailures = 0;
@@ -28999,7 +28999,7 @@ var init_cascadeBackend = __esm({
               this.activeIndex = nextIdx;
               this.consecutiveFailures = 0;
               this.onSwitch?.(from, to, err instanceof Error ? err.message : String(err));
-              const result = await this.chatCompletion(request2);
+              const result = await this.chatCompletion(request);
               const choice = result.choices[0];
               if (choice?.message.content) {
                 yield { type: "content", content: choice.message.content };
@@ -32596,7 +32596,7 @@ var require_websocket = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
     var EventEmitter7 = __require("events");
-    var https = __require("https");
+    var https2 = __require("https");
     var http2 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
@@ -33131,7 +33131,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes18(16).toString("base64");
-      const request2 = isSecure ? https.request : http2.request;
+      const request = isSecure ? https2.request : http2.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -33208,12 +33208,12 @@ var require_websocket = __commonJS({
         if (opts.auth && !options.headers.authorization) {
           options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
         }
-        req = websocket._req = request2(opts);
+        req = websocket._req = request(opts);
         if (websocket._redirects) {
           websocket.emit("redirect", websocket.url, req);
         }
       } else {
-        req = websocket._req = request2(opts);
+        req = websocket._req = request(opts);
       }
       if (opts.timeout) {
         req.on("timeout", () => {
@@ -37601,7 +37601,7 @@ var init_peer_mesh = __esm({
        * Send an inference request to a specific peer.
        * Returns a promise that resolves when the response arrives.
        */
-      async requestInference(peerId, request2, timeoutMs = 12e4) {
+      async requestInference(peerId, request, timeoutMs = 12e4) {
         const ws = this.connections.get(peerId);
         if (!ws || ws.readyState !== import_websocket.default.OPEN) {
           throw new Error(`Peer ${peerId} not connected`);
@@ -37613,7 +37613,7 @@ var init_peer_mesh = __esm({
             reject(new Error(`Inference timeout (${timeoutMs}ms)`));
           }, timeoutMs);
           this.pendingRequests.set(msgId, { resolve: resolve36, reject, timeout, chunks: [] });
-          this.sendMsg(ws, "infer_request", request2, msgId);
+          this.sendMsg(ws, "infer_request", request, msgId);
         });
       }
       // ── Inbound connection handling ─────────────────────────────────────────
@@ -37955,7 +37955,7 @@ var init_inference_router = __esm({
             }
           }));
         }
-        const request2 = {
+        const request = {
           model,
           messages: redactedMessages,
           tools: redactedTools,
@@ -37968,7 +37968,7 @@ var init_inference_router = __esm({
         if (redactedCount > 0)
           this._totalRedacted++;
         try {
-          const response = await this.mesh.requestInference(peer.peerId, request2, options?.timeoutMs ?? this.defaultTimeoutMs);
+          const response = await this.mesh.requestInference(peer.peerId, request, options?.timeoutMs ?? this.defaultTimeoutMs);
           const injectedContent = this.vault.inject(response.content);
           const injectedToolCalls = response.toolCalls?.map((tc) => ({
             ...tc,
@@ -38001,8 +38001,8 @@ var init_inference_router = __esm({
        * The response text may contain placeholders from the requester's vault,
        * which is fine — we don't have their secrets and don't need them.
        */
-      async handleInboundRequest(request2, inferFn) {
-        for (const msg of request2.messages) {
+      async handleInboundRequest(request, inferFn) {
+        for (const msg of request.messages) {
           const found = this.vault.scan(msg.content);
           if (found.length > 0) {
             this.emit("leaked_secrets_detected", {
@@ -38011,7 +38011,7 @@ var init_inference_router = __esm({
             });
           }
         }
-        return inferFn(request2);
+        return inferFn(request);
       }
       // ── Scoring ────────────────────────────────────────────────────────────
       scoreRoute(peer, model) {
@@ -61892,6 +61892,7 @@ __export(serve_exports, {
   startApiServer: () => startApiServer
 });
 import * as http from "node:http";
+import * as https from "node:https";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { dirname as dirname20, join as join69, resolve as resolve31 } from "node:path";
@@ -61977,20 +61978,29 @@ async function parseJsonBody(req) {
     return null;
   }
 }
+function backendAuthHeaders() {
+  const config = loadConfig();
+  if (config.apiKey)
+    return { Authorization: `Bearer ${config.apiKey}` };
+  return {};
+}
 function ollamaRequest(ollamaUrl, path, method, body) {
   return new Promise((resolve36, reject) => {
     const url = new URL(path, ollamaUrl);
+    const isHttps = url.protocol === "https:";
     const options = {
       hostname: url.hostname,
-      port: url.port,
+      port: url.port || (isHttps ? 443 : 80),
       path: url.pathname + url.search,
       method,
       headers: {
         "Content-Type": "application/json",
-        ...body ? { "Content-Length": Buffer.byteLength(body) } : {}
+        ...body ? { "Content-Length": Buffer.byteLength(body) } : {},
+        ...backendAuthHeaders()
       }
     };
-    const proxyReq = http.request(options, (proxyRes) => {
+    const transport = isHttps ? https : http;
+    const proxyReq = transport.request(options, (proxyRes) => {
       const chunks = [];
       proxyRes.on("data", (chunk) => chunks.push(chunk));
       proxyRes.on("end", () => {
@@ -62012,17 +62022,20 @@ function ollamaRequest(ollamaUrl, path, method, body) {
 }
 function ollamaStream(ollamaUrl, path, method, body, onData, onEnd, onError) {
   const url = new URL(path, ollamaUrl);
+  const isHttps = url.protocol === "https:";
   const options = {
     hostname: url.hostname,
-    port: url.port,
+    port: url.port || (isHttps ? 443 : 80),
     path: url.pathname + url.search,
     method,
     headers: {
       "Content-Type": "application/json",
-      ...body ? { "Content-Length": Buffer.byteLength(body) } : {}
+      ...body ? { "Content-Length": Buffer.byteLength(body) } : {},
+      ...backendAuthHeaders()
     }
   };
-  const proxyReq = http.request(options, (proxyRes) => {
+  const transport = isHttps ? https : http;
+  const proxyReq = transport.request(options, (proxyRes) => {
     proxyRes.setEncoding("utf-8");
     proxyRes.on("data", onData);
     proxyRes.on("end", onEnd);
@@ -62117,14 +62130,17 @@ function handleHealth(res) {
 }
 async function handleHealthReady(res, ollamaUrl) {
   try {
-    const result = await ollamaRequest(ollamaUrl, "/api/tags", "GET");
+    const config = loadConfig();
+    const isVllm = config.backendType === "vllm";
+    const checkPath = isVllm ? "/v1/models" : "/api/tags";
+    const result = await ollamaRequest(ollamaUrl, checkPath, "GET");
     if (result.status === 200) {
-      jsonResponse(res, 200, { status: "ready", ollama: "reachable" });
+      jsonResponse(res, 200, { status: "ready", backend: "reachable", type: config.backendType || "ollama" });
     } else {
-      jsonResponse(res, 503, { status: "not_ready", ollama: "unreachable", code: result.status });
+      jsonResponse(res, 503, { status: "not_ready", backend: "unreachable", code: result.status });
     }
   } catch {
-    jsonResponse(res, 503, { status: "not_ready", ollama: "unreachable" });
+    jsonResponse(res, 503, { status: "not_ready", backend: "unreachable" });
   }
 }
 function handleHealthStartup(res) {
@@ -62143,9 +62159,20 @@ function handleMetrics(res) {
 }
 async function handleV1Models(res, ollamaUrl) {
   try {
+    const config = loadConfig();
+    const isVllm = config.backendType === "vllm";
+    if (isVllm) {
+      const result2 = await ollamaRequest(ollamaUrl, "/v1/models", "GET");
+      if (result2.status !== 200) {
+        jsonResponse(res, result2.status, { error: "Failed to fetch models from backend" });
+        return;
+      }
+      jsonResponse(res, 200, JSON.parse(result2.body));
+      return;
+    }
     const result = await ollamaRequest(ollamaUrl, "/api/tags", "GET");
     if (result.status !== 200) {
-      jsonResponse(res, result.status, { error: "Failed to fetch models from Ollama" });
+      jsonResponse(res, result.status, { error: "Failed to fetch models from backend" });
       return;
     }
     const ollamaBody = JSON.parse(result.body);
@@ -62158,7 +62185,7 @@ async function handleV1Models(res, ollamaUrl) {
     jsonResponse(res, 200, { object: "list", data: models });
   } catch (err) {
     jsonResponse(res, 502, {
-      error: "Failed to proxy to Ollama",
+      error: "Failed to proxy to backend",
       message: err instanceof Error ? err.message : String(err)
     });
   }
@@ -62172,6 +62199,51 @@ async function handleV1ChatCompletions(req, res, ollamaUrl) {
   const requestBody = body;
   const stream = requestBody["stream"] === true;
   const model = requestBody["model"] || "unknown";
+  const config = loadConfig();
+  const isVllm = config.backendType === "vllm";
+  if (isVllm) {
+    const payload = JSON.stringify(requestBody);
+    if (stream) {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization"
+      });
+      ollamaStream(ollamaUrl, "/v1/chat/completions", "POST", payload, (chunk) => {
+        res.write(chunk);
+      }, () => {
+        res.end();
+      }, (err) => {
+        try {
+          res.write(`data: ${JSON.stringify({ error: err.message })}
+
+`);
+        } catch {
+        }
+        res.end();
+      });
+    } else {
+      try {
+        const result = await ollamaRequest(ollamaUrl, "/v1/chat/completions", "POST", payload);
+        if (result.status !== 200) {
+          jsonResponse(res, result.status, { error: "Backend request failed", details: result.body });
+          return;
+        }
+        const parsed = JSON.parse(result.body);
+        if (parsed.usage) {
+          metrics.totalTokensIn += parsed.usage.prompt_tokens ?? 0;
+          metrics.totalTokensOut += parsed.usage.completion_tokens ?? 0;
+        }
+        jsonResponse(res, 200, parsed);
+      } catch (err) {
+        jsonResponse(res, 502, { error: "Failed to proxy to backend", message: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    return;
+  }
   const ollamaPayload = JSON.stringify({
     ...requestBody,
     stream,
@@ -62329,6 +62401,22 @@ async function handleV1Embeddings(req, res, ollamaUrl) {
     return;
   }
   const requestBody = body;
+  const config = loadConfig();
+  const isVllm = config.backendType === "vllm";
+  if (isVllm) {
+    try {
+      const payload = JSON.stringify(requestBody);
+      const result = await ollamaRequest(ollamaUrl, "/v1/embeddings", "POST", payload);
+      if (result.status !== 200) {
+        jsonResponse(res, result.status, { error: "Backend embeddings request failed", details: result.body });
+        return;
+      }
+      jsonResponse(res, 200, JSON.parse(result.body));
+    } catch (err) {
+      jsonResponse(res, 502, { error: "Failed to proxy to backend", message: err instanceof Error ? err.message : String(err) });
+    }
+    return;
+  }
   const ollamaPayload = JSON.stringify({
     model: requestBody["model"],
     input: requestBody["input"]
@@ -62337,7 +62425,7 @@ async function handleV1Embeddings(req, res, ollamaUrl) {
     const result = await ollamaRequest(ollamaUrl, "/api/embed", "POST", ollamaPayload);
     if (result.status !== 200) {
       jsonResponse(res, result.status, {
-        error: "Ollama embeddings request failed",
+        error: "Backend embeddings request failed",
         details: result.body
       });
       return;
@@ -62356,7 +62444,7 @@ async function handleV1Embeddings(req, res, ollamaUrl) {
     });
   } catch (err) {
     jsonResponse(res, 502, {
-      error: "Failed to proxy to Ollama",
+      error: "Failed to proxy to backend",
       message: err instanceof Error ? err.message : String(err)
     });
   }
@@ -62564,10 +62652,16 @@ function handleV1RunsDelete(res, id) {
   }
   jsonResponse(res, 200, { run_id: id, status: "aborted" });
 }
+function redactSecrets(obj) {
+  const copy = { ...obj };
+  if (typeof copy.apiKey === "string" && copy.apiKey)
+    copy.apiKey = "[redacted]";
+  return copy;
+}
 function handleGetConfig(res) {
   const config = loadConfig();
   const settings = loadGlobalSettings();
-  jsonResponse(res, 200, { config, settings });
+  jsonResponse(res, 200, { config: redactSecrets(config), settings: redactSecrets(settings) });
 }
 async function handlePatchConfig(req, res) {
   const body = await parseJsonBody(req);
@@ -62595,7 +62689,7 @@ async function handlePatchConfig(req, res) {
     settingsUpdate.timeoutMs = updates["timeoutMs"];
   saveGlobalSettings(settingsUpdate);
   const updatedConfig = loadConfig();
-  jsonResponse(res, 200, { config: updatedConfig, updated: Object.keys(settingsUpdate) });
+  jsonResponse(res, 200, { config: redactSecrets(updatedConfig), updated: Object.keys(settingsUpdate) });
 }
 function handleGetConfigModel(res) {
   const config = loadConfig();
@@ -62936,7 +63030,8 @@ function startApiServer(options = {}) {
 `);
     process.stderr.write(`  Listening on http://${host}:${port}
 `);
-    process.stderr.write(`  Ollama proxy: ${ollamaUrl}
+    const beType = config.backendType || "ollama";
+    process.stderr.write(`  Backend (${beType}): ${ollamaUrl}
 `);
     if (process.env["OA_API_KEYS"]) {
       const keyCount = process.env["OA_API_KEYS"].split(",").length;
@@ -68616,17 +68711,17 @@ async function evalCommand(opts, config) {
     rawBackend = new FakeBackend();
   }
   const backend = {
-    async complete(request2) {
+    async complete(request) {
       const result = await rawBackend.complete({
-        messages: request2.messages.map((m) => ({
+        messages: request.messages.map((m) => ({
           id: globalThis.crypto.randomUUID(),
           sessionId: globalThis.crypto.randomUUID(),
           role: m.role,
           content: m.content,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         })),
-        maxTokens: request2.maxTokens,
-        temperature: request2.temperature
+        maxTokens: request.maxTokens,
+        temperature: request.temperature
       });
       return { content: result.content ?? "" };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.184.44",
+  "version": "0.184.45",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",