Add tests for AI proxy handlers and SpacetimeDB client

- Introduced unit tests for `observeAndLog` in `ai-proxy-handlers.test.ts` to ensure correct behavior when logging functions throw errors.
- Added tests for `callSql` in `spacetimedb-client.test.ts` to verify 401 enrollment retry logic and error handling.
- Created tests for `buildProxyLogRow` in `ai-proxy-logger.test.ts` to validate tool-name extraction from parsed logs.
- Implemented validation tests for tool names in `index.test.ts` to ensure consistency with defined tool names.

These additions enhance test coverage and reliability of the AI-related functionalities.

Author: mantrakp04

apps/backend/src/lib/ai/ai-proxy-handlers.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Ensures `observeAndLog` returns upstream bytes even when proxy logging throws.
+ */
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("./loggers/ai-proxy-logger", () => ({
+  buildProxyLogRow: vi.fn(),
+  scheduleProxyLog: vi.fn(),
+}));
+
+vi.mock("./openrouter-usage", async (importOriginal) => {
+  const original = await importOriginal<Record<string, unknown>>();
+  return {
+    ...original,
+    extractOpenRouterUsage: vi.fn(() => ({})),
+    scanSseForUsage: vi.fn(async () => ({})),
+  };
+});
+
+vi.mock("@/private", () => ({
+  preprocessProxyBody: ({ parsedBody }: { parsedBody: unknown }) => parsedBody,
+}));
+
+import { buildProxyLogRow, scheduleProxyLog } from "./loggers/ai-proxy-logger";
+import { observeAndLog, sanitizeBody } from "./ai-proxy-handlers";
+
+const sanitized = sanitizeBody(new TextEncoder().encode(JSON.stringify({
+  model: "anthropic/claude-sonnet-4.6",
+  messages: [{ role: "user", content: "hi" }],
+})).buffer as ArrayBuffer);
+
+describe("observeAndLog body delivery", () => {
+  it("returns the upstream bytes even if buildProxyLogRow throws", async () => {
+    vi.mocked(buildProxyLogRow).mockImplementation(() => {
+      throw new Error("synthetic log construction failure");
+    });
+    vi.mocked(scheduleProxyLog).mockClear();
+
+    const upstreamBody = JSON.stringify({ id: "gen-1", choices: [{ message: { content: "hello" } }] });
+    const upstream = new Response(upstreamBody, {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+
+    const out = await observeAndLog({
+      response: upstream,
+      sanitizedBody: sanitized,
+      callerApiKey: "stack-auth-test",
+      correlationId: "corr-1",
+      startedAt: 0,
+      responseHeaders: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+    });
+
+    expect(out.status).toBe(200);
+    expect(await out.text()).toBe(upstreamBody);
+  });
+
+  it("returns the upstream bytes even if scheduleProxyLog throws", async () => {
+    vi.mocked(buildProxyLogRow).mockReturnValue({
+      correlationId: "corr-2",
+      mode: "generate",
+      systemPromptId: "stack-auth-test",
+      quality: "unknown",
+      speed: "unknown",
+      modelId: "anthropic/claude-sonnet-4.6",
+      isAuthenticated: false,
+      projectId: undefined,
+      userId: undefined,
+      requestedToolsJson: "[]",
+      messagesJson: "[]",
+      stepsJson: "[]",
+      finalText: "",
+      inputTokens: undefined,
+      outputTokens: undefined,
+      cachedInputTokens: undefined,
+      cacheCreationTokens: undefined,
+      costUsd: undefined,
+      cacheDiscountUsd: undefined,
+      openrouterGenerationId: undefined,
+      stepCount: 0,
+      durationMs: 0n,
+      errorMessage: undefined,
+      conversationId: undefined,
+    });
+    vi.mocked(scheduleProxyLog).mockImplementation(() => {
+      throw new Error("synthetic schedule failure");
+    });
+
+    const upstreamBody = JSON.stringify({ id: "gen-2", choices: [{ message: { content: "world" } }] });
+    const upstream = new Response(upstreamBody, {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+
+    const out = await observeAndLog({
+      response: upstream,
+      sanitizedBody: sanitized,
+      callerApiKey: "stack-auth-test",
+      correlationId: "corr-2",
+      startedAt: 0,
+      responseHeaders: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+    });
+
+    expect(out.status).toBe(200);
+    expect(await out.text()).toBe(upstreamBody);
+  });
+
+  it("delivers full streamed bytes via tee even when the observer arm throws", async () => {
+    vi.mocked(buildProxyLogRow).mockImplementation(() => {
+      throw new Error("synthetic log failure inside async observer");
+    });
+
+    const streamPayload = "data: {\"id\":\"gen-3\"}\n\ndata: [DONE]\n\n";
+    const upstream = new Response(streamPayload, {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream" },
+    });
+
+    const streamingSanitized = sanitizeBody(new TextEncoder().encode(JSON.stringify({
+      model: "anthropic/claude-sonnet-4.6",
+      stream: true,
+      messages: [{ role: "user", content: "hi" }],
+    })).buffer as ArrayBuffer);
+
+    const out = await observeAndLog({
+      response: upstream,
+      sanitizedBody: streamingSanitized,
+      callerApiKey: "stack-auth-test",
+      correlationId: "corr-3",
+      startedAt: 0,
+      responseHeaders: { "Content-Type": "text/event-stream", "Cache-Control": "no-store" },
+    });
+
+    expect(out.status).toBe(200);
+    expect(await out.text()).toBe(streamPayload);
+  });
+});

apps/backend/src/lib/ai/ai-proxy-handlers.ts

@@ -51,42 +51,50 @@ export async function observeAndLog(args: {
   if (isStreaming && response.body) {
     const [clientStream, observerStream] = response.body.tee();
     runAsynchronouslyAndWaitUntil((async () => {
-      let usage: UsageFields = {};
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 120_000);
       try {
-        usage = (await scanSseForUsage(observerStream, controller.signal)) ?? {};
+        let usage: UsageFields = {};
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 120_000);
+        try {
+          usage = (await scanSseForUsage(observerStream, controller.signal)) ?? {};
+        } catch (err) {
+          captureError("ai-proxy-scan-sse", err);
+        } finally {
+          clearTimeout(timeoutId);
+        }
+        scheduleProxyLog(buildProxyLogRow({
+          correlationId,
+          parsed: sanitizedBody.parsed,
+          apiKey: callerApiKey,
+          durationMs: BigInt(Math.round(performance.now() - startedAt)),
+          responseStatus: response.status,
+          usage,
+        }));
       } catch (err) {
-        captureError("ai-proxy-scan-sse", err);
-      } finally {
-        clearTimeout(timeoutId);
+        captureError("ai-proxy-observer", err);
       }
-      scheduleProxyLog(buildProxyLogRow({
-        correlationId,
-        parsed: sanitizedBody.parsed,
-        apiKey: callerApiKey,
-        durationMs: BigInt(Math.round(performance.now() - startedAt)),
-        responseStatus: response.status,
-        usage,
-      }));
     })());
     return new Response(clientStream, { status: response.status, headers: responseHeaders });
   }
 
   const bodyBytes = await response.arrayBuffer();
-  let parsedBody: unknown;
   try {
-    parsedBody = JSON.parse(new TextDecoder().decode(bodyBytes));
-  } catch {
-    parsedBody = undefined;
+    let parsedBody: unknown;
+    try {
+      parsedBody = JSON.parse(new TextDecoder().decode(bodyBytes));
+    } catch {
+      parsedBody = undefined;
+    }
+    scheduleProxyLog(buildProxyLogRow({
+      correlationId,
+      parsed: sanitizedBody.parsed,
+      apiKey: callerApiKey,
+      durationMs: BigInt(Math.round(performance.now() - startedAt)),
+      responseStatus: response.status,
+      usage: extractOpenRouterUsage(parsedBody),
+    }));
+  } catch (err) {
+    captureError("ai-proxy-log-build", err);
   }
-  scheduleProxyLog(buildProxyLogRow({
-    correlationId,
-    parsed: sanitizedBody.parsed,
-    apiKey: callerApiKey,
-    durationMs: BigInt(Math.round(performance.now() - startedAt)),
-    responseStatus: response.status,
-    usage: extractOpenRouterUsage(parsedBody),
-  }));
   return new Response(bodyBytes, { status: response.status, headers: responseHeaders });
 }

apps/backend/src/lib/ai/loggers/ai-proxy-logger.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Tool-name extraction in `buildProxyLogRow` for Anthropic and OpenAI shapes.
+ */
+import { describe, expect, it } from "vitest";
+import { buildProxyLogRow } from "./ai-proxy-logger";
+
+const baseInput = {
+  correlationId: "corr-1",
+  apiKey: "stack-auth-proxy",
+  durationMs: 0n,
+  responseStatus: 200,
+};
+
+describe("buildProxyLogRow tool-name extraction", () => {
+  it("captures Anthropic top-level tool names", () => {
+    const row = buildProxyLogRow({
+      ...baseInput,
+      parsed: {
+        model: "anthropic/claude-sonnet-4.6",
+        tools: [
+          { name: "get_weather", description: "...", input_schema: {} },
+          { name: "send_email", description: "...", input_schema: {} },
+        ],
+      },
+    });
+    expect(JSON.parse(row.requestedToolsJson)).toEqual(["get_weather", "send_email"]);
+  });
+
+  it("captures OpenAI/OpenRouter-format function tool names", () => {
+    const row = buildProxyLogRow({
+      ...baseInput,
+      parsed: {
+        model: "anthropic/claude-sonnet-4.6",
+        tools: [
+          { type: "function", function: { name: "get_weather", parameters: {} } },
+          { type: "function", function: { name: "send_email", parameters: {} } },
+        ],
+      },
+    });
+    expect(JSON.parse(row.requestedToolsJson)).toEqual(["get_weather", "send_email"]);
+  });
+
+  it("handles a mixed array gracefully", () => {
+    const row = buildProxyLogRow({
+      ...baseInput,
+      parsed: {
+        model: "anthropic/claude-sonnet-4.6",
+        tools: [
+          { name: "anthropic_tool", input_schema: {} },
+          { type: "function", function: { name: "openai_tool", parameters: {} } },
+          { type: "function" },
+          null,
+          "not an object",
+        ],
+      },
+    });
+    expect(JSON.parse(row.requestedToolsJson)).toEqual(["anthropic_tool", "openai_tool"]);
+  });
+
+  it("returns an empty array when tools is absent or malformed", () => {
+    const row = buildProxyLogRow({
+      ...baseInput,
+      parsed: {
+        model: "anthropic/claude-sonnet-4.6",
+      },
+    });
+    expect(JSON.parse(row.requestedToolsJson)).toEqual([]);
+  });
+});

apps/backend/src/lib/ai/loggers/ai-proxy-logger.ts

@@ -16,7 +16,13 @@ export function buildProxyLogRow(fields: ProxyLogFields): AiQueryLogEntry {
   const { parsed, apiKey, durationMs, responseStatus, usage, correlationId } = fields;
   const tools = Array.isArray(parsed.tools) ? parsed.tools : [];
   const toolNames = tools
-    .map(t => (t && typeof t === "object" && "name" in t) ? (t as { name: unknown }).name : null)
+    .map((t) => {
+      if (t == null || typeof t !== "object") return null;
+      const obj = t as { name?: unknown, function?: { name?: unknown } };
+      if (typeof obj.function?.name === "string") return obj.function.name;
+      if (typeof obj.name === "string") return obj.name;
+      return null;
+    })
     .filter((n): n is string => typeof n === "string");
   const rawMessages = Array.isArray(parsed.messages) ? parsed.messages : [];
   const messages = typeof parsed.system === "string" && parsed.system.length > 0