swayrouter 1.0.0

package/src/utils/debugLog.js

@@ -0,0 +1,12 @@
+const isDev = process.env.NODE_ENV !== "production";
+
+function ts() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
+export function dbg(tag, msg) {
+  if (!isDev) return;
+  console.log(`[${ts()}] DEBUG [${tag}] ${msg}`);
+}
+
+export const isDebugEnabled = isDev;

package/src/utils/error.js

@@ -0,0 +1,120 @@
+import { ERROR_TYPES, DEFAULT_ERROR_MESSAGES } from "../config/errorConfig.js";
+
+export function buildErrorBody(statusCode, message) {
+  const errorInfo = ERROR_TYPES[statusCode] ||
+    (statusCode >= 500
+      ? { type: "server_error", code: "internal_server_error" }
+      : { type: "invalid_request_error", code: "" });
+
+  return {
+    error: {
+      message: message || DEFAULT_ERROR_MESSAGES[statusCode] || "An error occurred",
+      type: errorInfo.type,
+      code: errorInfo.code
+    }
+  };
+}
+
+export function errorResponse(statusCode, message) {
+  return new Response(JSON.stringify(buildErrorBody(statusCode, message)), {
+    status: statusCode,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+
+export async function writeStreamError(writer, statusCode, message) {
+  const errorBody = buildErrorBody(statusCode, message);
+  const encoder = new TextEncoder();
+  await writer.write(encoder.encode(`data: ${JSON.stringify(errorBody)}\n\n`));
+}
+
+export async function parseUpstreamError(response, executor = null) {
+  let bodyText = "";
+  try {
+    bodyText = await response.text();
+  } catch {
+    bodyText = "";
+  }
+
+  if (executor && typeof executor.parseError === "function") {
+    try {
+      const parsed = executor.parseError(response, bodyText);
+      if (parsed && typeof parsed === "object") {
+        return {
+          statusCode: parsed.status || response.status,
+          message: executor?.provider === "codebuddy-intl" && parsed.message
+            ? parsed.message
+            : DEFAULT_ERROR_MESSAGES[response.status] || "Upstream provider request failed",
+          resetsAtMs: parsed.resetsAtMs,
+        };
+      }
+    } catch {                                       }
+  }
+
+  return {
+    statusCode: response.status,
+    message: DEFAULT_ERROR_MESSAGES[response.status] || "Upstream provider request failed",
+  };
+}
+
+export function classifyUnsupportedParameter(bodyText, ctx = {}) {
+  if (bodyText == null) return null;
+
+  if (ctx.status != null && ctx.status !== 400 && ctx.status !== 422) return null;
+  const message = String(bodyText).toLowerCase();
+  if (!message) return null;
+
+  const m = message.match(
+    /(?:unsupported parameter|parameter unsupported|unknown parameter|invalid parameter|unsupported field|unknown field|unrecognized (?:request argument|parameter))[:\s]+["'`]?([a-z][a-z0-9_.-]*)/i,
+  );
+  if (m?.[1] !== undefined) return _normalizeFieldPath(m[1]);
+
+  const KNOWN = [
+    "prompt_cache_options", "prompt_cache_breakpoint",
+    "reasoning.max_tokens", "reasoning.effort", "reasoning",
+    "reasoning_effort", "thinking",
+    "output_config", "output_config.effort",
+    "response_format", "parallel_tool_calls", "tool_choice", "stream_options",
+  ];
+  return KNOWN.find((field) => message.includes(field)) ?? null;
+}
+
+function _normalizeFieldPath(value) {
+  return String(value).trim().toLowerCase().replace(/^["'`]|["'`]$/g, "");
+}
+
+export function createErrorResult(statusCode, message, resetsAtMs) {
+  return {
+    success: false,
+    status: statusCode,
+    error: message,
+    resetsAtMs,
+    response: errorResponse(statusCode, message)
+  };
+}
+
+export function unavailableResponse(statusCode, message, retryAfter, retryAfterHuman) {
+  const retryAfterSec = Math.max(Math.ceil((new Date(retryAfter).getTime() - Date.now()) / 1000), 1);
+  const msg = `${message} (${retryAfterHuman})`;
+  return new Response(
+    JSON.stringify({ error: { message: msg } }),
+    {
+      status: statusCode,
+      headers: {
+        "Content-Type": "application/json",
+        "Retry-After": String(retryAfterSec)
+      }
+    }
+  );
+}
+
+export function formatProviderError(error, provider, model, statusCode) {
+  const code = statusCode || error.code || "FETCH_FAILED";
+  if (code === 401 || code === 403) return DEFAULT_ERROR_MESSAGES[code] || "Authentication failed";
+  if (code === 429) return DEFAULT_ERROR_MESSAGES[code] || "Rate limit exceeded";
+  if (code >= 500) return DEFAULT_ERROR_MESSAGES[code] || "Upstream provider request failed";
+  return DEFAULT_ERROR_MESSAGES[code] || "Provider request failed";
+}

package/src/utils/inflight.js

@@ -0,0 +1,127 @@
+import { statsEmitter, getActiveRequests } from "@/lib/usageDb";
+
+const DEFAULT_THROTTLE_MS  = 2000;
+const DEFAULT_MAX_CLIENTS  = 10;
+const DEFAULT_KEEPALIVE_MS = 25000;
+
+const activeClients = new Set();
+
+export function buildInflightSnapshot(active) {
+  const byProvider = {};
+  const byAccount = {};
+  let total = 0;
+
+  for (const req of active) {
+    total += req.count;
+    byProvider[req.provider] = (byProvider[req.provider] || 0) + req.count;
+    if (!byAccount[req.account]) byAccount[req.account] = {};
+    byAccount[req.account][req.provider] = (byAccount[req.account][req.provider] || 0) + req.count;
+  }
+
+  return {
+    timestamp: new Date().toISOString(),
+    total,
+    byProvider,
+    byAccount,
+    requests: active,
+  };
+}
+
+export function createInflightStream(opts = {}) {
+  const throttleMs  = opts.throttleMs  ?? DEFAULT_THROTTLE_MS;
+  const maxClients  = opts.maxClients  ?? DEFAULT_MAX_CLIENTS;
+  const keepaliveMs = opts.keepaliveMs ?? DEFAULT_KEEPALIVE_MS;
+  const eventSource = opts.statsEmitter ?? statsEmitter;
+  const readActiveRequests = opts.getActiveRequests ?? getActiveRequests;
+
+  if (activeClients.size >= maxClients) {
+    return {
+      stream: null,
+      status: 429,
+      cleanup: () => {},
+    };
+  }
+
+  const encoder = new TextEncoder();
+  let closed = false;
+  let controllerRef = null;
+  let lastPushAt = 0;
+  let throttleTimer = null;
+  let keepaliveTimer = null;
+
+  const enqueue = (data) => {
+    if (closed || !controllerRef) return;
+    try {
+      controllerRef.enqueue(encoder.encode(data));
+    } catch {
+      cleanup();
+    }
+  };
+
+  const sendSnapshot = async () => {
+    if (closed) return;
+    try {
+      const result = await readActiveRequests();
+
+      const active = result?.activeRequests ?? [];
+      const snapshot = buildInflightSnapshot(active);
+      enqueue(`data: ${JSON.stringify(snapshot)}\n\n`);
+      lastPushAt = Date.now();
+    } catch {
+
+    }
+  };
+
+  const onPending = () => {
+    if (closed) return;
+    const now = Date.now();
+    const elapsed = now - lastPushAt;
+    if (elapsed >= throttleMs) {
+
+      sendSnapshot();
+    } else if (!throttleTimer) {
+
+      throttleTimer = setTimeout(() => {
+        throttleTimer = null;
+        sendSnapshot();
+      }, throttleMs - elapsed);
+    }
+
+  };
+
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    activeClients.delete(cleanup);
+    eventSource.off("pending", onPending);
+    if (throttleTimer) { clearTimeout(throttleTimer); throttleTimer = null; }
+    if (keepaliveTimer) { clearInterval(keepaliveTimer); keepaliveTimer = null; }
+    controllerRef = null;
+  };
+
+  const stream = new ReadableStream({
+    start(controller) {
+      controllerRef = controller;
+      activeClients.add(cleanup);
+
+      sendSnapshot();
+
+      eventSource.on("pending", onPending);
+
+      keepaliveTimer = setInterval(() => {
+        if (closed) { clearInterval(keepaliveTimer); return; }
+        enqueue(": ping\n\n");
+      }, keepaliveMs);
+    },
+
+    cancel() {
+      cleanup();
+    },
+  });
+
+  return { stream, status: 200, cleanup };
+}
+
+export function __resetInflightForTests() {
+  activeClients.clear();
+}

package/src/utils/kiroSessionReplay.js

@@ -0,0 +1,139 @@
+import { MEMORY_CONFIG } from "../config/runtimeConfig.js";
+
+const sessionStartStore = new Map();
+const MAX_SESSION_STARTS = 5000;
+
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function sessionKey(connectionId, conversationId) {
+  return `${connectionId || ""}:${conversationId || ""}`;
+}
+
+function ensureUserMessageModelId(message, modelId) {
+  if (message?.userInputMessage && !message.userInputMessage.modelId && modelId) {
+    message.userInputMessage.modelId = modelId;
+  }
+  return message;
+}
+
+function ensureHistoryModelIds(history, modelId) {
+  for (const item of history || []) {
+    ensureUserMessageModelId(item, modelId);
+  }
+  return history;
+}
+
+function prefixUserMessage(message, contentPrefix, modelId) {
+  const out = clone(message) || { userInputMessage: { content: "" } };
+  if (!out.userInputMessage) out.userInputMessage = { content: "" };
+  ensureUserMessageModelId(out, modelId);
+  if (contentPrefix) {
+    const content = out.userInputMessage.content || "";
+    out.userInputMessage.content = content
+      ? `${contentPrefix}\n\n${content}`
+      : contentPrefix;
+  }
+  return out;
+}
+
+function findFirstUserIndex(history) {
+  return history.findIndex((item) => item?.userInputMessage);
+}
+
+function hasToolResults(message) {
+  return !!message?.userInputMessage?.userInputMessageContext?.toolResults?.length;
+}
+
+function canReplaceSessionStart(history, firstUserIndex) {
+  return firstUserIndex === 0 && !hasToolResults(history[firstUserIndex]);
+}
+
+function rememberSessionStart(key, entry) {
+  if (sessionStartStore.size >= MAX_SESSION_STARTS) {
+    sessionStartStore.delete(sessionStartStore.keys().next().value);
+  }
+  sessionStartStore.set(key, { ...entry, lastUsed: Date.now() });
+}
+
+export function applyKiroSessionReplay({
+  conversationId,
+  connectionId,
+  modelId,
+  systemPrompt = "",
+  contentPrefix = "",
+  currentContentPrefix = "",
+  history = [],
+  currentMessage,
+} = {}) {
+  const key = sessionKey(connectionId, conversationId);
+  const existing = conversationId ? sessionStartStore.get(key) : null;
+  const baseHistory = clone(history) || [];
+  const baseCurrent = clone(currentMessage) || { userInputMessage: { content: "" } };
+
+  if (existing && existing.modelId === modelId && existing.systemPrompt === systemPrompt) {
+    existing.lastUsed = Date.now();
+    const firstUserIndex = findFirstUserIndex(baseHistory);
+    const sessionStart = ensureUserMessageModelId(clone(existing.sessionStart), modelId);
+    if (canReplaceSessionStart(baseHistory, firstUserIndex)) {
+      baseHistory[firstUserIndex] = sessionStart;
+    } else {
+      baseHistory.unshift(sessionStart);
+      if (baseHistory.length === 1) {
+        baseHistory.push({ assistantResponseMessage: { content: "" } });
+      }
+    }
+    return {
+      history: ensureHistoryModelIds(baseHistory, modelId),
+      currentMessage: prefixUserMessage(baseCurrent, currentContentPrefix, modelId),
+      replayed: true,
+    };
+  }
+
+  const firstUserIndex = findFirstUserIndex(baseHistory);
+  let sessionStart;
+  let nextCurrent = ensureUserMessageModelId(baseCurrent, modelId);
+  if (canReplaceSessionStart(baseHistory, firstUserIndex)) {
+    sessionStart = prefixUserMessage(baseHistory[firstUserIndex], contentPrefix, modelId);
+    baseHistory[firstUserIndex] = clone(sessionStart);
+    nextCurrent = prefixUserMessage(baseCurrent, currentContentPrefix, modelId);
+  } else if (firstUserIndex >= 0) {
+    sessionStart = prefixUserMessage(
+      { userInputMessage: { content: "", modelId } },
+      contentPrefix,
+      modelId
+    );
+    baseHistory.unshift(clone(sessionStart));
+    nextCurrent = prefixUserMessage(baseCurrent, currentContentPrefix, modelId);
+  } else {
+    sessionStart = prefixUserMessage(baseCurrent, contentPrefix, modelId);
+    nextCurrent = clone(sessionStart);
+  }
+
+  if (conversationId) {
+    rememberSessionStart(key, {
+      sessionStart: clone(sessionStart),
+      modelId,
+      systemPrompt,
+    });
+  }
+
+  return {
+    history: ensureHistoryModelIds(baseHistory, modelId),
+    currentMessage: nextCurrent,
+    replayed: false,
+  };
+}
+
+export function clearKiroSessionReplayStore() {
+  sessionStartStore.clear();
+}
+
+const cleanup = setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of sessionStartStore) {
+    if (now - entry.lastUsed > MEMORY_CONFIG.sessionTtlMs) sessionStartStore.delete(key);
+  }
+}, MEMORY_CONFIG.sessionCleanupIntervalMs);
+if (cleanup.unref) cleanup.unref();

package/src/utils/ollamaTransform.js

@@ -0,0 +1,83 @@
+export function transformToOllama(response, model) {
+  let buffer = "";
+  let pendingToolCalls = {};
+
+  const transform = new TransformStream({
+    transform(chunk, controller) {
+      const text = new TextDecoder().decode(chunk);
+      buffer += text;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+
+        if (data === "[DONE]") {
+          const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+          controller.enqueue(new TextEncoder().encode(ollamaEnd));
+          return;
+        }
+
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta || {};
+          const content = delta.content || "";
+          const toolCalls = delta.tool_calls;
+
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              const idx = tc.index;
+              if (!pendingToolCalls[idx]) {
+                pendingToolCalls[idx] = { id: tc.id, function: { name: "", arguments: "" } };
+              }
+              if (tc.function?.name) pendingToolCalls[idx].function.name += tc.function.name;
+              if (tc.function?.arguments) pendingToolCalls[idx].function.arguments += tc.function.arguments;
+            }
+          }
+
+          if (content) {
+            const ollama = JSON.stringify({ model, message: { role: "assistant", content }, done: false }) + "\n";
+            controller.enqueue(new TextEncoder().encode(ollama));
+          }
+
+          const finishReason = parsed.choices?.[0]?.finish_reason;
+          if (finishReason === "tool_calls" || finishReason === "stop") {
+            const toolCallsArr = Object.values(pendingToolCalls);
+            if (toolCallsArr.length > 0) {
+              const formattedCalls = toolCallsArr.map(tc => ({
+                function: {
+                  name: tc.function.name,
+                  arguments: (() => { try { return JSON.parse(tc.function.arguments || "{}"); } catch { return {}; } })()
+                }
+              }));
+              const ollama = JSON.stringify({
+                model,
+                message: { role: "assistant", content: "", tool_calls: formattedCalls },
+                done: true
+              }) + "\n";
+              controller.enqueue(new TextEncoder().encode(ollama));
+              pendingToolCalls = {};
+            } else if (finishReason === "stop") {
+              const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+              controller.enqueue(new TextEncoder().encode(ollamaEnd));
+            }
+          }
+        } catch (e) {
+
+        }
+      }
+    },
+    flush(controller) {
+      const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+      controller.enqueue(new TextEncoder().encode(ollamaEnd));
+    }
+  });
+
+  if (!response.body) {
+    return new Response("", { status: response.status, headers: { "Content-Type": "application/x-ndjson" } });
+  }
+  return new Response(response.body.pipeThrough(transform), {
+    headers: { "Content-Type": "application/x-ndjson", "Access-Control-Allow-Origin": "*" }
+  });
+}