zevairouter 1.0.154 → 1.0.155

package/open-sse/executors/kiro.js

@@ -1,537 +0,0 @@
-import { BaseExecutor } from "./base.js";
-import { PROVIDERS } from "../config/providers.js";
-import { v4 as uuidv4 } from "uuid";
-import { refreshKiroToken } from "../services/tokenRefresh.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-import { HTTP_STATUS, RETRY_CONFIG, DEFAULT_RETRY_CONFIG, resolveRetryEntry } from "../config/runtimeConfig.js";
-import { fetchImageAsBase64 } from "../translator/helpers/imageHelper.js";
-
-/**
- * KiroExecutor - Executor for Kiro AI (AWS CodeWhisperer)
- * Uses AWS CodeWhisperer streaming API with AWS EventStream binary format
- */
-export class KiroExecutor extends BaseExecutor {
-  constructor() {
-    super("kiro", PROVIDERS.kiro);
-  }
-
-  buildHeaders(credentials, stream = true) {
-    const headers = {
-      ...this.config.headers,
-      "Amz-Sdk-Request": "attempt=1; max=3",
-      "Amz-Sdk-Invocation-Id": uuidv4()
-    };
-
-    if (credentials.accessToken) {
-      headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-    }
-
-    return headers;
-  }
-
-  transformRequest(model, body, stream, credentials) {
-    return body;
-  }
-
-  async prefetchImages(body, signal) {
-    const state = body?.conversationState;
-    const carriers = [state?.currentMessage, ...(state?.history || [])];
-
-    for (const carrier of carriers) {
-      const message = carrier?.userInputMessage;
-      if (!Array.isArray(message?.images)) continue;
-
-      const resolved = await Promise.all(message.images.map(async image => {
-        const url = image?.source?.url;
-        if (!url) return image;
-        const fetched = await fetchImageAsBase64(url, { signal, timeoutMs: 15000 });
-        if (!fetched?.url) {
-          const marker = `[Image unavailable: ${url}]`;
-          message.content = message.content ? `${message.content}\n\n${marker}` : marker;
-          return null;
-        }
-        const match = fetched.url.match(/^data:([^;]+);base64,(.+)$/);
-        if (!match) return null;
-        const subtype = match[1].split("/")[1] || image.format || "jpeg";
-        return { format: subtype === "jpg" ? "jpeg" : subtype, source: { bytes: match[2] } };
-      }));
-      message.images = resolved.filter(Boolean);
-      if (message.images.length === 0) delete message.images;
-    }
-  }
-
-  /**
-   * Custom execute for Kiro - handles AWS EventStream binary response with retry support
-   */
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
-    const url = this.buildUrl(model, stream, 0);
-    await this.prefetchImages(body, signal);
-    const transformedBody = this.transformRequest(model, body, stream, credentials);
-    
-    // Merge default retry config with provider-specific config
-    const retryConfig = { ...DEFAULT_RETRY_CONFIG, ...this.config.retry };
-    let retryAttempts = 0;
-
-    while (true) {
-      const headers = this.buildHeaders(credentials, stream);
-      
-      const response = await proxyAwareFetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(transformedBody),
-        signal
-      }, proxyOptions);
-
-      // Check if should retry based on status code
-      const { attempts: maxRetries, delayMs } = resolveRetryEntry(retryConfig[response.status]);
-      if (!response.ok && maxRetries > 0 && retryAttempts < maxRetries) {
-        retryAttempts++;
-        log?.debug?.("RETRY", `${response.status} retry ${retryAttempts}/${maxRetries} after ${delayMs / 1000}s`);
-        await new Promise(resolve => setTimeout(resolve, delayMs));
-        continue;
-      }
-
-      if (!response.ok) {
-        return { response, url, headers, transformedBody };
-      }
-
-      // Success - transform and return
-      // For Kiro, we need to transform the binary EventStream to SSE
-      // Create a TransformStream to convert binary to SSE text
-      const transformedResponse = this.transformEventStreamToSSE(response, model, transformedBody);
-      return { response: transformedResponse, url, headers, transformedBody };
-    }
-  }
-
-  /**
-   * Transform AWS EventStream binary response to SSE text stream
-   * Using TransformStream instead of ReadableStream.pull() to avoid Workers timeout
-   */
-  transformEventStreamToSSE(response, model, requestBody = null) {
-    let buffer = new Uint8Array(0);
-    let chunkIndex = 0;
-    const responseId = `chatcmpl-${Date.now()}`;
-    const created = Math.floor(Date.now() / 1000);
-    const exposeReasoning = requestBody?._kiroExposeReasoning === true;
-    const state = {
-      endDetected: false,
-      finishEmitted: false,
-      hasToolCalls: false,
-      hasReasoningContent: false,
-      reasoningChunkCount: 0,
-      toolCallIndex: 0,
-      seenToolIds: new Map()
-    };
-
-    const transformStream = new TransformStream({
-      async transform(chunk, controller) {
-        // Append to buffer
-        const newBuffer = new Uint8Array(buffer.length + chunk.length);
-        newBuffer.set(buffer);
-        newBuffer.set(chunk, buffer.length);
-        buffer = newBuffer;
-
-        // Parse events from buffer
-        let iterations = 0;
-        const maxIterations = 1000;
-        while (buffer.length >= 16 && iterations < maxIterations) {
-          iterations++;
-          const view = new DataView(buffer.buffer, buffer.byteOffset);
-          const totalLength = view.getUint32(0, false);
-
-          if (totalLength < 16 || totalLength > buffer.length || buffer.length < totalLength) break;
-
-          const eventData = buffer.slice(0, totalLength);
-          buffer = buffer.slice(totalLength);
-
-          const event = parseEventFrame(eventData);
-          if (!event) continue;
-
-          const eventType = event.headers[":event-type"] || "";
-          
-          // Track total content length for token estimation
-          if (!state.totalContentLength) state.totalContentLength = 0;
-          if (!state.contextUsagePercentage) state.contextUsagePercentage = 0;
-
-          // Handle assistantResponseEvent
-          if (eventType === "assistantResponseEvent" && event.payload?.content) {
-            const content = event.payload.content;
-            state.totalContentLength += content.length;
-            
-            const chunk = {
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{
-                index: 0,
-                delta: chunkIndex === 0
-                  ? { role: "assistant", content }
-                  : { content },
-                finish_reason: null
-              }]
-            };
-            chunkIndex++;
-            controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(chunk)}\n\n`));
-          }
-
-          // Handle reasoningContentEvent (Kiro thinking / reasoning)
-          // Kiro returns reasoning as a separate event when the request system
-          // prompt contains <thinking_mode>enabled</thinking_mode>. Surface it
-          // as OpenAI delta.reasoning_content so downstream translators can map
-          // it back to Claude thinking blocks / Anthropic reasoning, etc.
-          if (eventType === "reasoningContentEvent") {
-            const reasoning = event.payload?.reasoningContentEvent || event.payload || {};
-            const reasoningText = (typeof reasoning === "string")
-              ? reasoning
-              : (reasoning.text || reasoning.content || "");
-            if (reasoningText) {
-              state.hasReasoningContent = true;
-              state.totalContentLength += reasoningText.length;
-
-              if (!exposeReasoning) {
-                continue;
-              }
-
-              const reasoningDelta = state.reasoningChunkCount === 0 && chunkIndex === 0
-                ? { role: "assistant", reasoning_content: reasoningText }
-                : { reasoning_content: reasoningText };
-
-              const chunk = {
-                id: responseId,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                choices: [{
-                  index: 0,
-                  delta: reasoningDelta,
-                  finish_reason: null
-                }]
-              };
-              chunkIndex++;
-              state.reasoningChunkCount++;
-              controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(chunk)}\n\n`));
-            }
-          }
-
-          // Handle codeEvent
-          if (eventType === "codeEvent" && event.payload?.content) {
-            const chunk = {
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{
-                index: 0,
-                delta: { content: event.payload.content },
-                finish_reason: null
-              }]
-            };
-            chunkIndex++;
-            controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(chunk)}\n\n`));
-          }
-
-          // Handle toolUseEvent
-          if (eventType === "toolUseEvent" && event.payload) {
-            state.hasToolCalls = true;
-            const toolUse = event.payload;
-            const toolUses = Array.isArray(toolUse) ? toolUse : [toolUse];
-
-            for (const singleToolUse of toolUses) {
-              const toolCallId = singleToolUse.toolUseId || `call_${Date.now()}`;
-              const toolName = singleToolUse.name || "";
-              const toolInput = singleToolUse.input;
-
-              let toolIndex;
-              const isNewTool = !state.seenToolIds.has(toolCallId);
-
-              if (isNewTool) {
-                toolIndex = state.toolCallIndex++;
-                state.seenToolIds.set(toolCallId, toolIndex);
-
-                const startChunk = {
-                  id: responseId,
-                  object: "chat.completion.chunk",
-                  created,
-                  model,
-                  choices: [{
-                    index: 0,
-                    delta: {
-                      ...(chunkIndex === 0 ? { role: "assistant" } : {}),
-                      tool_calls: [{
-                        index: toolIndex,
-                        id: toolCallId,
-                        type: "function",
-                        function: {
-                          name: toolName,
-                          arguments: ""
-                        }
-                      }]
-                    },
-                    finish_reason: null
-                  }]
-                };
-                chunkIndex++;
-                controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(startChunk)}\n\n`));
-              } else {
-                toolIndex = state.seenToolIds.get(toolCallId);
-              }
-
-              if (toolInput !== undefined) {
-                let argumentsStr;
-
-                if (typeof toolInput === 'string') {
-                  argumentsStr = toolInput;
-                } else if (typeof toolInput === 'object') {
-                  argumentsStr = JSON.stringify(toolInput);
-                } else {
-                  continue;
-                }
-
-                const argsChunk = {
-                  id: responseId,
-                  object: "chat.completion.chunk",
-                  created,
-                  model,
-                  choices: [{
-                    index: 0,
-                    delta: {
-                      tool_calls: [{
-                        index: toolIndex,
-                        function: {
-                          arguments: argumentsStr
-                        }
-                      }]
-                    },
-                    finish_reason: null
-                  }]
-                };
-                chunkIndex++;
-                controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(argsChunk)}\n\n`));
-              }
-            }
-          }
-
-          // Handle messageStopEvent
-          if (eventType === "messageStopEvent") {
-            const chunk = {
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{
-                index: 0,
-                delta: {},
-                finish_reason: state.hasToolCalls ? "tool_calls" : "stop"
-              }]
-            };
-            state.finishEmitted = true;
-            controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(chunk)}\n\n`));
-          }
-
-          // Handle contextUsageEvent to extract contextUsagePercentage
-          if (eventType === "contextUsageEvent" && event.payload?.contextUsagePercentage) {
-            state.contextUsagePercentage = event.payload.contextUsagePercentage;
-            // Mark that we received context usage event
-            state.hasContextUsage = true;
-          }
-
-          // Handle meteringEvent - mark that we received it
-          if (eventType === "meteringEvent") {
-            state.hasMeteringEvent = true;
-          }
-
-          // Handle metricsEvent for token usage
-          if (eventType === "metricsEvent") {
-            // Extract usage data from metricsEvent payload
-            const metrics = event.payload?.metricsEvent || event.payload;
-            if (metrics && typeof metrics === 'object') {
-              const inputTokens = metrics.inputTokens || 0;
-              const outputTokens = metrics.outputTokens || 0;
-              
-              if (inputTokens > 0 || outputTokens > 0) {
-                state.usage = {
-                  prompt_tokens: inputTokens,
-                  completion_tokens: outputTokens,
-                  total_tokens: inputTokens + outputTokens
-                };
-              }
-            }
-          }
-
-          // Emit final chunk only after receiving BOTH meteringEvent AND contextUsageEvent
-          if (state.hasMeteringEvent && state.hasContextUsage && !state.finishEmitted) {
-            state.finishEmitted = true;
-            
-            // Estimate tokens if not available from events
-            if (!state.usage) {
-              // Estimate output tokens from content length
-              const estimatedOutputTokens = state.totalContentLength > 0 
-                ? Math.max(1, Math.floor(state.totalContentLength / 4))
-                : 0;
-              
-              // Estimate input tokens from contextUsagePercentage
-              // Kiro models typically have 200k context window
-              const estimatedInputTokens = state.contextUsagePercentage > 0
-                ? Math.floor(state.contextUsagePercentage * 200000 / 100)
-                : 0;
-              
-              state.usage = {
-                prompt_tokens: estimatedInputTokens,
-                completion_tokens: estimatedOutputTokens,
-                total_tokens: estimatedInputTokens + estimatedOutputTokens
-              };
-            }
-            
-            const finishChunk = {
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{
-                index: 0,
-                delta: {},
-                finish_reason: state.hasToolCalls ? "tool_calls" : "stop"
-              }]
-            };
-            
-            // Include usage in final chunk if available
-            if (state.usage) {
-              finishChunk.usage = state.usage;
-            }
-            
-            controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(finishChunk)}\n\n`));
-          }
-        }
-
-        if (iterations >= maxIterations) {
-          console.warn("[Kiro] Max iterations reached in event parsing");
-        }
-      },
-
-      flush(controller) {
-        // Emit finish chunk if not already sent
-        if (!state.finishEmitted) {
-          state.finishEmitted = true;
-          const finishChunk = {
-            id: responseId,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{
-              index: 0,
-              delta: {},
-              finish_reason: state.hasToolCalls ? "tool_calls" : "stop"
-            }]
-          };
-          controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(finishChunk)}\n\n`));
-        }
-
-        // Send final done message
-        controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
-      }
-    });
-
-    // Pipe response body through transform stream
-    if (!response.body) {
-      return new Response("data: [DONE]\n\n", { status: response.status, headers: { "Content-Type": "text/event-stream" } });
-    }
-    const transformedStream = response.body.pipeThrough(transformStream);
-
-    return new Response(transformedStream, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        "Connection": "keep-alive"
-      }
-    });
-  }
-
-  async refreshCredentials(credentials, log, proxyOptions = null) {
-    if (!credentials.refreshToken) return null;
-
-    try {
-      // Use centralized refreshKiroToken function (handles both AWS SSO OIDC and Social Auth)
-      const result = await refreshKiroToken(
-        credentials.refreshToken,
-        credentials.providerSpecificData,
-        log,
-        proxyOptions
-      );
-
-      return result;
-    } catch (error) {
-      log?.error?.("TOKEN", `Kiro refresh error: ${error.message}`);
-      return null;
-    }
-  }
-}
-
-/**
- * Parse AWS EventStream frame
- */
-function parseEventFrame(data) {
-  try {
-    const view = new DataView(data.buffer, data.byteOffset);
-    const headersLength = view.getUint32(4, false);
-
-    // Parse headers
-    const headers = {};
-    let offset = 12; // After prelude
-    const headerEnd = 12 + headersLength;
-
-    while (offset < headerEnd && offset < data.length) {
-      const nameLen = data[offset];
-      offset++;
-      if (offset + nameLen > data.length) break;
-
-      const name = new TextDecoder().decode(data.slice(offset, offset + nameLen));
-      offset += nameLen;
-
-      const headerType = data[offset];
-      offset++;
-
-      if (headerType === 7) { // String type
-        const valueLen = (data[offset] << 8) | data[offset + 1];
-        offset += 2;
-        if (offset + valueLen > data.length) break;
-
-        const value = new TextDecoder().decode(data.slice(offset, offset + valueLen));
-        offset += valueLen;
-        headers[name] = value;
-      } else {
-        break;
-      }
-    }
-
-    // Parse payload
-    const payloadStart = 12 + headersLength;
-    const payloadEnd = data.length - 4; // Exclude message CRC
-
-    let payload = null;
-    if (payloadEnd > payloadStart) {
-      const payloadStr = new TextDecoder().decode(data.slice(payloadStart, payloadEnd));
-
-      // Skip empty or whitespace-only payloads
-      if (!payloadStr || !payloadStr.trim()) {
-        return { headers, payload: null };
-      }
-
-      try {
-        payload = JSON.parse(payloadStr);
-      } catch (parseError) {
-        // Log parse error for debugging
-        console.warn(`[Kiro] Failed to parse payload: ${parseError.message} | payload: ${payloadStr.substring(0, 100)}`);
-        payload = { raw: payloadStr };
-      }
-    }
-
-    return { headers, payload };
-  } catch {
-    return null;
-  }
-}
-
-export default KiroExecutor;

package/open-sse/executors/mimo-free.js

@@ -1,156 +0,0 @@
-import { BaseExecutor } from "./base.js";
-import { PROVIDERS } from "../config/providers.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-import { createHash } from "crypto";
-import os from "os";
-
-const BOOTSTRAP_URL = "https://api.xiaomimimo.com/api/free-ai/bootstrap";
-const CHAT_URL = PROVIDERS["mimo-free"]?.baseUrl || "https://api.xiaomimimo.com/api/free-ai/openai/chat";
-const SESSION_AFFINITY_PREFIX = "ses_";
-const SESSION_ID_LENGTH = 24;
-const JWT_FALLBACK_TTL_SEC = 3000;
-const JWT_EXPIRY_BUFFER_MS = 300000;
-const SESSION_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
-
-// Anti-abuse gate: upstream rejects requests without a Chrome-like User-Agent with 403 "Illegal access"
-const USER_AGENTS = [
-  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-];
-
-// Anti-abuse gate marker: free chat endpoint returns 403 unless a system message contains this.
-export const MIMO_SYSTEM_MARKER =
-  "You are MiMoCode, an interactive CLI tool that helps users with software engineering tasks.";
-
-let cachedJwt = null;
-let jwtExpiresAt = 0;
-
-function generateFingerprint() {
-  let username = "unknown-user";
-  try {
-    username = os.userInfo().username;
-  } catch {
-    // ignore
-  }
-  const cpu = (os.cpus()[0]?.model || "unknown-cpu").trim();
-  const seed = `${os.hostname()}|${os.platform()}|${os.arch()}|${cpu}|${username}`;
-  return createHash("sha256").update(seed).digest("hex");
-}
-
-function generateSessionId() {
-  let id = SESSION_AFFINITY_PREFIX;
-  for (let i = 0; i < SESSION_ID_LENGTH; i++) {
-    id += SESSION_CHARS[Math.floor(Math.random() * SESSION_CHARS.length)];
-  }
-  return id;
-}
-
-function parseJwtExp(jwt) {
-  try {
-    const payload = JSON.parse(Buffer.from(jwt.split(".")[1], "base64").toString());
-    if (payload.exp) return payload.exp * 1000;
-  } catch {
-    // ignore
-  }
-  return Date.now() + JWT_FALLBACK_TTL_SEC * 1000;
-}
-
-function injectSystemMarker(body) {
-  const messages = body?.messages;
-  if (!Array.isArray(messages)) return body;
-  const hasMarker = messages.some(
-    (m) => m?.role === "system" && typeof m.content === "string" && m.content.includes(MIMO_SYSTEM_MARKER),
-  );
-  if (hasMarker) return body;
-  return { ...body, messages: [{ role: "system", content: MIMO_SYSTEM_MARKER }, ...messages] };
-}
-
-function resetJwtCache() {
-  cachedJwt = null;
-  jwtExpiresAt = 0;
-}
-
-async function bootstrapJwt(proxyOptions = null) {
-  if (cachedJwt && Date.now() < jwtExpiresAt - JWT_EXPIRY_BUFFER_MS) {
-    return cachedJwt;
-  }
-
-  const response = await proxyAwareFetch(BOOTSTRAP_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
-    },
-    body: JSON.stringify({ client: generateFingerprint() }),
-  }, proxyOptions);
-
-  if (!response.ok) {
-    throw new Error(`MiMo bootstrap failed: ${response.status}`);
-  }
-
-  const data = await response.json();
-  if (!data.jwt) {
-    throw new Error("MiMo bootstrap returned no JWT");
-  }
-
-  cachedJwt = data.jwt;
-  jwtExpiresAt = parseJwtExp(data.jwt);
-  return cachedJwt;
-}
-
-export class MimoFreeExecutor extends BaseExecutor {
-  constructor() {
-    super("mimo-free", PROVIDERS["mimo-free"]);
-    this.sessionId = generateSessionId();
-  }
-
-  buildUrl() {
-    return CHAT_URL;
-  }
-
-  buildHeaders(credentials, stream = true) {
-    return {
-      "Content-Type": "application/json",
-      "X-Mimo-Source": "mimocode-cli-free",
-      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
-      "x-session-affinity": this.sessionId,
-      Accept: stream ? "text/event-stream" : "application/json",
-    };
-  }
-
-  transformRequest(model, body) {
-    return injectSystemMarker(body);
-  }
-
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
-    let jwt;
-    try {
-      jwt = await bootstrapJwt(proxyOptions);
-    } catch (error) {
-      log?.error?.("AUTH", `MiMo bootstrap failed: ${error.message}`);
-      throw error;
-    }
-
-    const url = this.buildUrl();
-    const transformedBody = this.transformRequest(model, body);
-    const headers = { ...this.buildHeaders(credentials, stream), Authorization: `Bearer ${jwt}` };
-    const bodyStr = JSON.stringify(transformedBody);
-    log?.debug?.("FETCH", `MIMO-FREE → ${url} | body=${bodyStr.length}B`);
-
-    const response = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
-
-    if (response.status === 401 || response.status === 403) {
-      log?.debug?.("AUTH", `MiMo auth failed (${response.status}), re-bootstrapping...`);
-      resetJwtCache();
-      jwt = await bootstrapJwt(proxyOptions);
-      headers.Authorization = `Bearer ${jwt}`;
-      const retryResponse = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
-      return { response: retryResponse, url, headers, transformedBody };
-    }
-
-    return { response, url, headers, transformedBody };
-  }
-}
-
-export default MimoFreeExecutor;

package/open-sse/executors/ollama-local.js

@@ -1,14 +0,0 @@
-import { DefaultExecutor } from "./default.js";
-import { resolveOllamaLocalHost } from "../config/providers.js";
-
-export class OllamaLocalExecutor extends DefaultExecutor {
-  constructor() {
-    super("ollama-local");
-  }
-
-  buildUrl(model, stream, urlIndex = 0, credentials = null) {
-    return `${resolveOllamaLocalHost(credentials)}/api/chat`;
-  }
-}
-
-export default OllamaLocalExecutor;