omnigateway 0.1.3 → 0.1.5

package/gateway.js

@@ -22634,6 +22634,27 @@ ALTER TABLE credentials ADD COLUMN disabled_reason TEXT;
 ALTER TABLE credentials ADD COLUMN disabled_at INTEGER;
 `;
 
+// packages/store/src/sqlite/migrations/004_request_state.sql
+var _004_request_state_default = `-- Whether a request is still running.
+--
+-- A row used to be written once, after the response stream drained, so a long
+-- stream was invisible for its whole life and the console showed an idle
+-- gateway. A row is now written twice: \`pending\` when dispatch starts, \`done\`
+-- when it finishes.
+--
+-- Existing rows default to 'done'. Every row that predates this migration
+-- describes a request that has already ended, by definition.
+ALTER TABLE request_logs ADD COLUMN state TEXT NOT NULL DEFAULT 'done';
+
+-- \`status\` and \`duration_ms\` stay NOT NULL: making them nullable means a table
+-- rebuild in SQLite, and a pending row's zeros are never read. Readers key off
+-- \`state\` alone.
+--
+-- Partial, because pending rows are a handful at any moment while the table
+-- holds a month of finished ones.
+CREATE INDEX idx_request_logs_pending ON request_logs(state) WHERE state = 'pending';
+`;
+
 // packages/store/src/sqlite/rollup.ts
 function startOfLocalDay(at) {
   const day = new Date(at);
@@ -22740,7 +22761,8 @@ function backfillDaily(db) {
 var MIGRATIONS = [
   { id: 1, sql: _001_init_default },
   { id: 2, sql: _002_usage_daily_default, after: backfillDaily },
-  { id: 3, sql: _003_quota_snapshot_default }
+  { id: 3, sql: _003_quota_snapshot_default },
+  { id: 4, sql: _004_request_state_default }
 ];
 function openDb(path) {
   const db = new Database(path, { create: true });
@@ -22812,6 +22834,7 @@ function createKeyRepo(db) {
 // packages/store/src/sqlite/usage.ts
 var toLog = (r) => ({
   id: r.id,
+  state: r.state === "pending" ? "pending" : "done",
   at: r.at,
   apiKeyId: r.api_key_id,
   requestedModel: r.requested_model,
@@ -22870,37 +22893,78 @@ function label(value) {
   const text = String(value);
   return text.length === 0 ? "unknown" : text;
 }
+var COLUMNS = `(id, state, at, api_key_id, requested_model, resolved_provider, resolved_model,
+                  credential_id, attempts, status, error_code, input_tokens, output_tokens,
+                  cache_read_tokens, cache_write_tokens, ttft_ms, duration_ms, cost_usd,
+                  degradations)`;
+var PLACEHOLDERS = "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
+function values(log, state) {
+  return [
+    log.id,
+    state,
+    log.at,
+    log.apiKeyId,
+    log.requestedModel,
+    log.resolvedProvider,
+    log.resolvedModel,
+    log.credentialId,
+    log.attempts,
+    log.status,
+    log.errorCode,
+    log.inputTokens,
+    log.outputTokens,
+    log.cacheReadTokens,
+    log.cacheWriteTokens,
+    log.ttftMs,
+    log.durationMs,
+    log.costUsd,
+    JSON.stringify(log.degradations)
+  ];
+}
+var COMPLETE = `INSERT INTO request_logs ${COLUMNS} VALUES ${PLACEHOLDERS}
+  ON CONFLICT(id) DO UPDATE SET
+    state = 'done',
+    requested_model = COALESCE(NULLIF(excluded.requested_model, ''), request_logs.requested_model),
+    api_key_id = COALESCE(excluded.api_key_id, request_logs.api_key_id),
+    resolved_provider = excluded.resolved_provider,
+    resolved_model = excluded.resolved_model,
+    credential_id = excluded.credential_id,
+    attempts = excluded.attempts,
+    status = excluded.status,
+    error_code = excluded.error_code,
+    input_tokens = excluded.input_tokens,
+    output_tokens = excluded.output_tokens,
+    cache_read_tokens = excluded.cache_read_tokens,
+    cache_write_tokens = excluded.cache_write_tokens,
+    ttft_ms = excluded.ttft_ms,
+    duration_ms = excluded.duration_ms,
+    cost_usd = excluded.cost_usd,
+    degradations = excluded.degradations`;
 function createUsageRepo(db) {
-  const insert = db.transaction((log) => {
-    db.run(`INSERT INTO request_logs
-           (id, at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
-            attempts, status, error_code, input_tokens, output_tokens, cache_read_tokens,
-            cache_write_tokens, ttft_ms, duration_ms, cost_usd, degradations)
-         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, [
-      log.id,
-      log.at,
-      log.apiKeyId,
-      log.requestedModel,
-      log.resolvedProvider,
-      log.resolvedModel,
-      log.credentialId,
-      log.attempts,
-      log.status,
-      log.errorCode,
-      log.inputTokens,
-      log.outputTokens,
-      log.cacheReadTokens,
-      log.cacheWriteTokens,
-      log.ttftMs,
-      log.durationMs,
-      log.costUsd,
-      JSON.stringify(log.degradations)
-    ]);
-    rollupLog(db, log);
+  const complete = db.transaction((log) => {
+    db.run(COMPLETE, values(log, "done"));
+    const stored = db.query("SELECT * FROM request_logs WHERE id = ?").get(log.id);
+    if (stored !== null)
+      rollupLog(db, toLog(stored));
   });
   return {
+    async begin(log) {
+      db.run(`INSERT INTO request_logs ${COLUMNS} VALUES ${PLACEHOLDERS}`, values(log, "pending"));
+    },
+    async route(id, target) {
+      db.run(`UPDATE request_logs
+            SET resolved_provider = ?, resolved_model = ?, credential_id = ?
+          WHERE id = ? AND state = 'pending'`, [target.provider, target.model, target.credentialId, id]);
+    },
     async append(log) {
-      insert(log);
+      complete(log);
+    },
+    async sweepPending() {
+      const stale = db.query("SELECT * FROM request_logs WHERE state = 'pending'").all().map(toLog);
+      for (const log of stale) {
+        complete({ ...log, status: 499, errorCode: "interrupted", durationMs: 0 });
+      }
+      return stale.length;
     },
     async recent(limit) {
       return db.query("SELECT * FROM request_logs ORDER BY at DESC LIMIT ?").all(limit).map(toLog);
@@ -22922,7 +22986,7 @@ function createUsageRepo(db) {
                   COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens,
                   COALESCE(SUM(cost_usd), 0) AS cost_usd
              FROM ${daily ? "usage_daily" : "request_logs"}
-            WHERE ${timeColumn} >= ? AND ${timeColumn} <= ?
+            WHERE ${daily ? "" : "state = 'done' AND "}${timeColumn} >= ? AND ${timeColumn} <= ?
             GROUP BY key${split === null ? "" : ", split"}
             ORDER BY requests DESC`).all(since, until);
       return rows.map((r) => {
@@ -31467,17 +31531,17 @@ var ElysiaType = {
       elysiaMeta: "ArrayString"
     })).Decode((value) => {
       if (Array.isArray(value)) {
-        let values = [];
+        let values2 = [];
         for (let i = 0;i < value.length; i++) {
           const v = value[i];
           if (typeof v == "string") {
             const t2 = decode4(v, true);
-            Array.isArray(t2) ? values = values.concat(t2) : values.push(t2);
+            Array.isArray(t2) ? values2 = values2.concat(t2) : values2.push(t2);
             continue;
           }
-          values.push(v);
+          values2.push(v);
         }
-        return values;
+        return values2;
       }
       return typeof value == "string" ? decode4(value) : value;
     }).Encode((value) => {
@@ -31498,17 +31562,17 @@ var ElysiaType = {
       elysiaMeta: "ArrayQuery"
     })).Decode((value) => {
       if (Array.isArray(value)) {
-        let values = [];
+        let values2 = [];
         for (let i = 0;i < value.length; i++) {
           const v = value[i];
           if (typeof v == "string") {
             const t2 = decode4(v);
-            Array.isArray(t2) ? values = values.concat(t2) : values.push(t2);
+            Array.isArray(t2) ? values2 = values2.concat(t2) : values2.push(t2);
             continue;
           }
-          values.push(v);
+          values2.push(v);
         }
-        return values;
+        return values2;
       }
       return typeof value == "string" ? decode4(value) : value;
     }).Encode((value) => {
@@ -31552,16 +31616,16 @@ var ElysiaType = {
       sign
     }, v;
   },
-  UnionEnum: (values, options = {}) => {
-    const type = values.every((value) => typeof value == "string") ? { type: "string" } : values.every((value) => typeof value == "number") ? { type: "number" } : values.every((value) => value === null) ? { type: "null" } : {};
-    if (values.some((x) => typeof x == "object" && x !== null))
+  UnionEnum: (values2, options = {}) => {
+    const type = values2.every((value) => typeof value == "string") ? { type: "string" } : values2.every((value) => typeof value == "number") ? { type: "number" } : values2.every((value) => value === null) ? { type: "null" } : {};
+    if (values2.some((x) => typeof x == "object" && x !== null))
       throw new Error("This type does not support objects or arrays");
     return {
-      default: values[0],
+      default: values2[0],
       ...options,
       [Kind]: "UnionEnum",
       ...type,
-      enum: values
+      enum: values2
     };
   },
   NoValidate: (v, enabled = true) => (v.noValidate = enabled, v),
@@ -34007,33 +34071,33 @@ var getSchemaValidator = (s, {
         return v.then((v2) => Check22(v2, true));
       if (v.issues)
         return v;
-      const values = [];
-      return v && typeof v == "object" && values.push(v.value), runCheckers2(value, 0, values, v);
-    }, runCheckers2 = function(value, startIndex, values, lastV) {
+      const values2 = [];
+      return v && typeof v == "object" && values2.push(v.value), runCheckers2(value, 0, values2, v);
+    }, runCheckers2 = function(value, startIndex, values2, lastV) {
       for (let i = startIndex;i < checkers.length; i++) {
         let v = checkers[i].validate(value);
         if (v instanceof Promise)
           return v.then((resolved) => {
             if (resolved.issues)
               return resolved;
-            const nextValues = [...values];
+            const nextValues = [...values2];
             return resolved && typeof resolved == "object" && nextValues.push(resolved.value), runCheckers2(value, i + 1, nextValues, resolved);
           });
         if (v.issues)
           return v;
-        v && typeof v == "object" && values.push(v.value), lastV = v;
+        v && typeof v == "object" && values2.push(v.value), lastV = v;
       }
-      return mergeValues22(values, lastV);
-    }, mergeValues22 = function(values, lastV) {
-      if (!values.length)
+      return mergeValues22(values2, lastV);
+    }, mergeValues22 = function(values2, lastV) {
+      if (!values2.length)
         return { value: lastV };
-      if (values.length === 1)
-        return { value: values[0] };
-      if (values.length === 2)
-        return { value: mergeDeep(values[0], values[1]) };
-      let newValue = mergeDeep(values[0], values[1]);
-      for (let i = 2;i < values.length; i++)
-        newValue = mergeDeep(newValue, values[i]);
+      if (values2.length === 1)
+        return { value: values2[0] };
+      if (values2.length === 2)
+        return { value: mergeDeep(values2[0], values2[1]) };
+      let newValue = mergeDeep(values2[0], values2[1]);
+      for (let i = 2;i < values2.length; i++)
+        newValue = mergeDeep(newValue, values2[i]);
       return { value: newValue };
     };
     var Check2 = Check22, runCheckers = runCheckers2, mergeValues2 = mergeValues22;
@@ -37924,7 +37988,18 @@ function parseDataUrl(url2) {
   return { mediaType: match[1], data: match[2] };
 }
 
-// apps/gateway/src/routes/admin.ts
+// apps/gateway/src/routes/http.ts
+function readCookie(request2, name) {
+  const header = request2.headers.get("cookie");
+  if (header === null)
+    return null;
+  for (const part of header.split(";")) {
+    const [key, ...rest] = part.trim().split("=");
+    if (key === name)
+      return rest.join("=");
+  }
+  return null;
+}
 function sessionCookie(request2, token, maxAge) {
   const secure = new URL(request2.url).protocol === "https:" ? ["Secure"] : [];
   return [
@@ -37936,38 +38011,36 @@ function sessionCookie(request2, token, maxAge) {
     `Max-Age=${maxAge}`
   ].join("; ");
 }
-function readCookie(request2, name) {
-  const header = request2.headers.get("cookie");
-  if (header === null)
-    return null;
-  for (const part of header.split(";")) {
-    const [key, ...rest] = part.trim().split("=");
-    if (key === name)
-      return rest.join("=");
+async function requireAdmin(request2, admin) {
+  const token = readCookie(request2, ADMIN_COOKIE);
+  if (token === null || !await admin.verify(token)) {
+    throw new GatewayError("AUTH", "admin session required");
   }
-  return null;
 }
-async function jsonRecord(request2) {
+async function readJson(request2) {
   try {
-    const body2 = await request2.json();
-    return isRecord3(body2) ? body2 : null;
-  } catch {
-    return null;
+    return await request2.json();
+  } catch (error51) {
+    if (!(error51 instanceof SyntaxError))
+      throw error51;
+    throw new GatewayError("BAD_REQUEST", "invalid JSON body");
   }
 }
+async function readJsonRecord(request2) {
+  const body2 = await readJson(request2);
+  return isRecord3(body2) ? body2 : null;
+}
+function apiErrorResponse(error51) {
+  const gatewayError = error51 instanceof GatewayError ? error51 : new GatewayError("INTERNAL", "internal error");
+  return Response.json({ error: { code: gatewayError.code, message: gatewayError.message } }, { status: HTTP_STATUS[gatewayError.code] });
+}
+function apiErrorHandler(input) {
+  return input.code === "NOT_FOUND" ? undefined : apiErrorResponse(input.error);
+}
+
+// apps/gateway/src/routes/admin.ts
 function adminRoutes(deps) {
-  const app = new Elysia().onError(({ error: error51, set: set2 }) => {
-    const gatewayError = error51 instanceof GatewayError ? error51 : new GatewayError("INTERNAL", "internal error");
-    set2.status = HTTP_STATUS[gatewayError.code];
-    return { error: { code: gatewayError.code, message: gatewayError.message } };
-  });
-  async function requireAdmin(request2) {
-    const token = readCookie(request2, ADMIN_COOKIE);
-    if (token === null || !await deps.admin.verify(token)) {
-      throw new GatewayError("AUTH", "admin session required");
-    }
-  }
-  return app.get("/api/status", async ({ request: request2 }) => {
+  return new Elysia().onError(apiErrorHandler).get("/api/status", async ({ request: request2 }) => {
     const token = readCookie(request2, ADMIN_COOKIE);
     return {
       configured: await deps.admin.isConfigured(),
@@ -37978,7 +38051,7 @@ function adminRoutes(deps) {
       set2.status = 409;
       return { error: { code: "CONFLICT", message: "an admin password is already configured" } };
     }
-    const body2 = await jsonRecord(request2);
+    const body2 = await readJsonRecord(request2);
     if (typeof body2?.password !== "string") {
       throw new GatewayError("BAD_REQUEST", "password is required");
     }
@@ -37998,7 +38071,7 @@ function adminRoutes(deps) {
     set2.headers["set-cookie"] = sessionCookie(request2, token, Math.floor(deps.sessionTtlMs / 1000));
     return { ok: true };
   }).post("/api/login", async ({ request: request2, set: set2 }) => {
-    const body2 = await jsonRecord(request2);
+    const body2 = await readJsonRecord(request2);
     const token = typeof body2?.password === "string" ? await deps.admin.login(body2.password) : null;
     if (token === null)
       throw new GatewayError("AUTH", "invalid password");
@@ -38011,52 +38084,52 @@ function adminRoutes(deps) {
     set2.headers["set-cookie"] = sessionCookie(request2, "", 0);
     return { ok: true };
   }).get("/api/credentials", async ({ request: request2 }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return { credentials: await listCredentials(deps.store) };
   }).get("/api/credentials/health", async ({ request: request2 }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return credentialHealth(deps.store);
   }).patch("/api/credentials/:id", async ({ request: request2, params }) => {
-    await requireAdmin(request2);
-    await patchCredential(deps, params.id, await request2.json());
+    await requireAdmin(request2, deps.admin);
+    await patchCredential(deps, params.id, await readJson(request2));
     return { ok: true };
   }).delete("/api/credentials/:id", async ({ request: request2, params }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     await removeCredential(deps.store, params.id);
     return { ok: true };
   }).get("/api/models", async ({ request: request2 }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return { models: await listModels(deps.store) };
   }).put("/api/models/:id", async ({ request: request2, params }) => {
-    await requireAdmin(request2);
-    await putModel(deps.store, params.id, await request2.json());
+    await requireAdmin(request2, deps.admin);
+    await putModel(deps.store, params.id, await readJson(request2));
     return { ok: true };
   }).delete("/api/models/:id", async ({ request: request2, params }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     await removeModel(deps.store, params.id);
     return { ok: true };
   }).get("/api/keys", async ({ request: request2 }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return { keys: await listKeys(deps.store) };
   }).post("/api/keys", async ({ request: request2 }) => {
-    await requireAdmin(request2);
-    return createKey(deps.store, await request2.json());
+    await requireAdmin(request2, deps.admin);
+    return createKey(deps.store, await readJson(request2));
   }).delete("/api/keys/:id", async ({ request: request2, params }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     await revokeKey(deps.store, params.id);
     return { ok: true };
   }).get("/api/settings", async ({ request: request2 }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return { settings: await getSettings(deps.store) };
   }).put("/api/settings", async ({ request: request2 }) => {
-    await requireAdmin(request2);
-    await putSettings(deps.store, await request2.json());
+    await requireAdmin(request2, deps.admin);
+    await putSettings(deps.store, await readJson(request2));
     return { ok: true };
   }).post("/api/models/:id/dry-run", async ({ request: request2, params }) => {
-    await requireAdmin(request2);
-    return dryRun(deps, params.id, await request2.json());
+    await requireAdmin(request2, deps.admin);
+    return dryRun(deps, params.id, await readJson(request2));
   }).get("/api/usage", async ({ request: request2, query }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return {
       rows: await queryUsage(deps, {
         grain: query.grain,
@@ -38067,70 +38140,29 @@ function adminRoutes(deps) {
       })
     };
   }).get("/api/logs", async ({ request: request2, query }) => {
-    await requireAdmin(request2);
+    await requireAdmin(request2, deps.admin);
     return { logs: await recentLogs(deps.store, query.limit) };
   });
 }
 
 // apps/gateway/src/routes/connect.ts
-function asGatewayError(error51) {
-  if (error51 instanceof GatewayError)
-    return error51;
-  return new GatewayError("INTERNAL", error51 instanceof Error ? error51.message : "internal error");
-}
-function errorResponse(error51) {
-  const gatewayError = asGatewayError(error51);
-  return new Response(JSON.stringify({ error: { code: gatewayError.code, message: gatewayError.message } }), {
-    status: HTTP_STATUS[gatewayError.code],
-    headers: { "content-type": "application/json" }
-  });
-}
-function readCookie2(request2, name) {
-  const header = request2.headers.get("cookie");
-  if (header === null)
-    return null;
-  for (const part of header.split(";")) {
-    const [key, ...rest] = part.trim().split("=");
-    if (key === name)
-      return rest.join("=");
-  }
-  return null;
-}
 function connectRoutes(deps) {
   const flows = createConnectFlows(deps);
-  async function requireAdmin(request2) {
-    const token = readCookie2(request2, ADMIN_COOKIE);
-    if (token === null || !await deps.admin.verify(token)) {
-      throw new GatewayError("AUTH", "admin session required");
-    }
-  }
-  return new Elysia().post("/api/connect/start", async ({ request: request2 }) => {
-    try {
-      await requireAdmin(request2);
-      const body2 = await request2.json();
-      return await flows.start(isRecord3(body2) ? body2.provider : undefined, isRecord3(body2) ? body2.label : undefined);
-    } catch (error51) {
-      return errorResponse(error51);
-    }
+  return new Elysia().onError(apiErrorHandler).post("/api/connect/start", async ({ request: request2 }) => {
+    await requireAdmin(request2, deps.admin);
+    const body2 = await readJsonRecord(request2);
+    return flows.start(body2?.provider, body2?.label);
   }).post("/api/connect/finish", async ({ request: request2 }) => {
-    try {
-      await requireAdmin(request2);
-      const body2 = await request2.json();
-      return await flows.finish(isRecord3(body2) ? body2.flowId : undefined, isRecord3(body2) ? body2.code : undefined);
-    } catch (error51) {
-      return errorResponse(error51);
-    }
+    await requireAdmin(request2, deps.admin);
+    const body2 = await readJsonRecord(request2);
+    return flows.finish(body2?.flowId, body2?.code);
   }).post("/api/connect/poll", async ({ request: request2, set: set2 }) => {
-    try {
-      await requireAdmin(request2);
-      const body2 = await request2.json();
-      const outcome = await flows.poll(isRecord3(body2) ? body2.flowId : undefined);
-      if (outcome.status === "pending")
-        set2.status = 202;
-      return outcome;
-    } catch (error51) {
-      return errorResponse(error51);
-    }
+    await requireAdmin(request2, deps.admin);
+    const body2 = await readJsonRecord(request2);
+    const outcome = await flows.poll(body2?.flowId);
+    if (outcome.status === "pending")
+      set2.status = 202;
+    return outcome;
   });
 }
 
@@ -38169,6 +38201,73 @@ function extractToken(header) {
   return match === null ? value : match[1].trim();
 }
 
+// apps/gateway/src/logging.ts
+function requestLogDefaults(id, at) {
+  return {
+    id,
+    state: "done",
+    at,
+    apiKeyId: null,
+    requestedModel: "",
+    resolvedProvider: null,
+    resolvedModel: null,
+    credentialId: null,
+    attempts: 0,
+    status: 0,
+    errorCode: null,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    ttftMs: null,
+    durationMs: 0,
+    costUsd: 0,
+    degradations: []
+  };
+}
+function newCompletedRequestLog(id, at, overrides) {
+  return { ...requestLogDefaults(id, at), ...overrides, id, state: "done", at };
+}
+function newPendingRequestLog(input) {
+  const { id, at, requestedModel, resolvedProvider, resolvedModel, credentialId } = input;
+  return {
+    ...requestLogDefaults(id, at),
+    requestedModel,
+    resolvedProvider,
+    resolvedModel,
+    credentialId,
+    state: "pending",
+    status: 0
+  };
+}
+function report(what, requestId, error51) {
+  console.error(what, {
+    requestId,
+    reason: error51 instanceof Error ? error51.message : "unknown"
+  });
+}
+async function beginLog(store, log, keyId) {
+  try {
+    await store.usage.begin({ ...log, state: "pending", apiKeyId: keyId });
+  } catch (error51) {
+    report("failed to record request start", log.id, error51);
+  }
+}
+async function routeLog(store, requestId, target) {
+  try {
+    await store.usage.route(requestId, target);
+  } catch (error51) {
+    report("failed to record request route", requestId, error51);
+  }
+}
+async function finishLog(store, log, keyId) {
+  try {
+    await store.usage.append({ ...log, apiKeyId: keyId });
+  } catch (error51) {
+    report("failed to persist request log", log.id, error51);
+  }
+}
+
 // apps/gateway/src/dispatch/attempt.ts
 async function attempt(opts) {
   const { candidate, adapter, http, now, signal, refresh, refreshLeadMs } = opts;
@@ -38222,30 +38321,14 @@ function classify(error51) {
 }
 
 // apps/gateway/src/dispatch/index.ts
-async function dispatch(request2, deps, signal) {
+async function dispatch(request2, deps, signal, requestId) {
   const startedAt = deps.now();
   const snapshot = await deps.snapshots.get(startedAt);
   const deadlineAt = startedAt + snapshot.settings.requestDeadlineMs;
-  const log = {
-    id: crypto.randomUUID(),
-    at: startedAt,
-    apiKeyId: null,
+  const log = newCompletedRequestLog(requestId, startedAt, {
     requestedModel: request2.model,
-    resolvedProvider: null,
-    resolvedModel: null,
-    credentialId: null,
-    attempts: 0,
-    status: 200,
-    errorCode: null,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    ttftMs: null,
-    durationMs: 0,
-    costUsd: 0,
-    degradations: []
-  };
+    status: 0
+  });
   const fail = (code, message) => {
     log.errorCode = code;
     log.status = HTTP_STATUS[code];
@@ -38319,6 +38402,11 @@ async function dispatch(request2, deps, signal) {
           log.credentialId = candidate.credential.id;
           log.resolvedProvider = candidate.target.provider;
           log.resolvedModel = candidate.target.model;
+          await deps.onRoute?.({
+            provider: candidate.target.provider,
+            model: candidate.target.model,
+            credentialId: candidate.credential.id
+          });
           log.inputTokens = 0;
           log.outputTokens = 0;
           log.cacheReadTokens = 0;
@@ -39115,38 +39203,35 @@ function parseOpenAIRequest(body2) {
   return validateRequest(request2);
 }
 
-// apps/gateway/src/logging.ts
-async function finishLog(store, log, keyId) {
-  try {
-    await store.usage.append({ ...log, apiKeyId: keyId });
-  } catch (error51) {
-    console.error("failed to persist request log", {
-      requestId: log.id,
-      reason: error51 instanceof Error ? error51.message : "unknown"
-    });
-  }
-}
-
 // apps/gateway/src/routes/proxy.ts
+var KEEPALIVE_MS = 1e4;
+var KEEPALIVE = Symbol("keepalive");
+function withKeepalive(pending, ms) {
+  let timer;
+  const tick = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(KEEPALIVE), ms);
+  });
+  return Promise.race([pending, tick]).finally(() => clearTimeout(timer));
+}
 var SSE_HEADERS = {
   "content-type": "text/event-stream; charset=utf-8",
   "cache-control": "no-cache, no-transform",
   connection: "keep-alive",
   "x-accel-buffering": "no"
 };
-function errorResponse2(surface, code, message3) {
+function errorResponse(surface, code, message3) {
   const body2 = surface === "anthropic" ? anthropicErrorBody(code, message3) : openaiErrorBody(code, message3);
   return new Response(JSON.stringify(body2), {
     status: HTTP_STATUS[code],
     headers: { "content-type": "application/json" }
   });
 }
-function asGatewayError2(error51) {
+function asGatewayError(error51) {
   if (error51 instanceof GatewayError)
     return error51;
   return new GatewayError("INTERNAL", error51 instanceof Error ? error51.message : "internal error");
 }
-function sseResponse(frames, onDone) {
+function sseResponse(frames, onDone, keepaliveMs) {
   const encoder2 = new TextEncoder;
   let done = null;
   const runOnce = () => {
@@ -39154,10 +39239,19 @@ function sseResponse(frames, onDone) {
       done = onDone();
     return done;
   };
+  let inflight = null;
   const stream2 = new ReadableStream({
     async pull(controller) {
       try {
-        const next = await frames.next();
+        inflight ??= frames.next();
+        const next = await withKeepalive(inflight, keepaliveMs);
+        if (next === KEEPALIVE) {
+          controller.enqueue(encoder2.encode(`: keepalive
+
+`));
+          return;
+        }
+        inflight = null;
         if (next.done === true) {
           controller.close();
           await runOnce();
@@ -39182,7 +39276,9 @@ data: ${data}
 }
 async function handle(deps, rateLimiter, surface, request2) {
   const requestId = deps.requestId();
+  const startedAt = deps.now();
   let keyId = null;
+  let requestedModel = "";
   try {
     const key = await authenticateApiKey(deps.store, apiKeyHeader(request2.headers));
     keyId = key.id;
@@ -39192,11 +39288,31 @@ async function handle(deps, rateLimiter, surface, request2) {
     if (key.modelAllowlist !== null && !key.modelAllowlist.includes(chatRequest.model)) {
       throw new GatewayError("AUTH", `model "${chatRequest.model}" is not allowed for this API key`);
     }
-    const outcome = await dispatch(chatRequest, deps, request2.signal);
-    const log = () => finishLog(deps.store, { ...outcome.log(), id: requestId }, keyId);
+    requestedModel = chatRequest.model;
+    let began = false;
+    const outcome = await dispatch(chatRequest, {
+      ...deps,
+      async onRoute(target) {
+        if (began) {
+          await routeLog(deps.store, requestId, target);
+          return;
+        }
+        began = true;
+        const log2 = newPendingRequestLog({
+          id: requestId,
+          at: startedAt,
+          requestedModel,
+          resolvedProvider: target.provider,
+          resolvedModel: target.model,
+          credentialId: target.credentialId
+        });
+        await beginLog(deps.store, log2, keyId);
+      }
+    }, request2.signal, requestId);
+    const log = () => finishLog(deps.store, outcome.log(), keyId);
     if (chatRequest.stream) {
       const frames = surface === "anthropic" ? anthropicStream(outcome.events, requestId) : openaiStream(outcome.events, requestId, Math.floor(deps.now() / 1000));
-      return sseResponse(frames, log);
+      return sseResponse(frames, log, deps.keepaliveMs);
     }
     const events = [];
     for await (const event of outcome.events)
@@ -39204,7 +39320,7 @@ async function handle(deps, rateLimiter, surface, request2) {
     await log();
     const failure = events.find((e) => e.type === "error");
     if (failure !== undefined)
-      return errorResponse2(surface, failure.code, failure.message);
+      return errorResponse(surface, failure.code, failure.message);
     const collected = collect(events);
     const responseBody = surface === "anthropic" ? anthropicResponse(collected, requestId) : openaiResponse(collected, requestId, Math.floor(deps.now() / 1000));
     return new Response(JSON.stringify(responseBody), {
@@ -39212,35 +39328,21 @@ async function handle(deps, rateLimiter, surface, request2) {
       headers: { "content-type": "application/json" }
     });
   } catch (error51) {
-    const gatewayError = asGatewayError2(error51);
-    await finishLog(deps.store, {
-      id: requestId,
-      at: deps.now(),
-      apiKeyId: keyId,
-      requestedModel: "",
-      resolvedProvider: null,
-      resolvedModel: null,
-      credentialId: null,
-      attempts: 0,
+    const gatewayError = asGatewayError(error51);
+    await finishLog(deps.store, newCompletedRequestLog(requestId, startedAt, {
+      requestedModel,
       status: HTTP_STATUS[gatewayError.code],
-      errorCode: gatewayError.code,
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadTokens: 0,
-      cacheWriteTokens: 0,
-      ttftMs: null,
-      durationMs: 0,
-      costUsd: 0,
-      degradations: []
-    }, keyId);
-    return errorResponse2(surface, gatewayError.code, gatewayError.message);
+      errorCode: gatewayError.code
+    }), keyId);
+    return errorResponse(surface, gatewayError.code, gatewayError.message);
   }
 }
 function proxyRoutes(deps) {
   const rateLimiter = deps.rateLimiter ?? new ApiKeyRateLimiter(deps.now);
   const dispatchDeps = {
     ...deps,
-    snapshots: deps.snapshots ?? createRoutingSnapshotCache(deps.store)
+    snapshots: deps.snapshots ?? createRoutingSnapshotCache(deps.store),
+    keepaliveMs: deps.keepaliveMs ?? KEEPALIVE_MS
   };
   return new Elysia().post("/v1/messages", ({ request: request2 }) => handle(dispatchDeps, rateLimiter, "anthropic", request2)).post("/v1/chat/completions", ({ request: request2 }) => handle(dispatchDeps, rateLimiter, "openai", request2)).get("/v1/models", async ({ request: request2 }) => {
     try {
@@ -39257,12 +39359,12 @@ function proxyRoutes(deps) {
         }))
       });
     } catch (error51) {
-      const gatewayError = asGatewayError2(error51);
-      return errorResponse2("anthropic", gatewayError.code, gatewayError.message);
+      const gatewayError = asGatewayError(error51);
+      return errorResponse("anthropic", gatewayError.code, gatewayError.message);
     }
   }).onError(({ error: error51 }) => {
-    const gatewayError = asGatewayError2(error51);
-    return errorResponse2("anthropic", gatewayError.code, gatewayError.message);
+    const gatewayError = asGatewayError(error51);
+    return errorResponse("anthropic", gatewayError.code, gatewayError.message);
   });
 }
 
@@ -39469,6 +39571,9 @@ var store = await createStore({
   path: config2.databasePath,
   encryptionKey
 });
+var swept = await store.usage.sweepPending();
+if (swept > 0)
+  console.log(`retired ${swept} request(s) interrupted by the last shutdown`);
 var now = () => Date.now();
 var http = nodeHttpClient();
 var refresh = createRefresher({ store, providers: OAUTH_PROVIDERS, http, now });
@@ -39489,7 +39594,7 @@ var stopQuotaPoller = await startQuotaPoller({
   refresh,
   now
 });
-app.listen({ port: config2.port, hostname: config2.host });
+app.listen({ port: config2.port, hostname: config2.host, idleTimeout: 255 });
 console.log(`omnigateway listening on http://${config2.host}:${config2.port}`);
 var shuttingDown = false;
 function exitAfterClosingStore(code) {