omnigateway 0.1.2 → 0.1.4

package/gateway.js

@@ -5866,6 +5866,7 @@ async function* decodeAnthropic(messages) {
   let cacheWriteTokens = 0;
   let outputTokens = 0;
   let stopReason = "endTurn";
+  let terminal = false;
   for await (const msg of messages) {
     const d = json(msg.data);
     if (d === null)
@@ -5931,6 +5932,7 @@ async function* decodeAnthropic(messages) {
         break;
       }
       case "message_stop":
+        terminal = true;
         yield {
           type: "end",
           stopReason,
@@ -5938,6 +5940,7 @@ async function* decodeAnthropic(messages) {
         };
         break;
       case "error": {
+        terminal = true;
         const code = ERROR_TYPE[String(d.error?.type)] ?? "UPSTREAM";
         yield {
           type: "error",
@@ -5951,6 +5954,14 @@ async function* decodeAnthropic(messages) {
         break;
     }
   }
+  if (!terminal) {
+    yield {
+      type: "error",
+      code: "UPSTREAM",
+      message: "upstream stream ended before message_stop",
+      retryable: RETRYABLE.UPSTREAM
+    };
+  }
 }
 
 // packages/providers/src/anthropic/wire.ts
@@ -6063,9 +6074,10 @@ var anthropicAdapter = {
       ["anthropic-version", API_VERSION],
       ["Accept", req.request.stream ? "text/event-stream" : "application/json"]
     ];
+    const betas = new Set(req.request.betas ?? []);
     if (oauth) {
       protocol.push(["Authorization", `Bearer ${req.credentials.accessToken}`]);
-      protocol.push(["anthropic-beta", OAUTH_BETA]);
+      betas.add(OAUTH_BETA);
     } else if (req.credentials.apiKey !== null) {
       protocol.push(["x-api-key", req.credentials.apiKey]);
     } else {
@@ -6073,6 +6085,8 @@ var anthropicAdapter = {
         provider: "anthropic"
       });
     }
+    if (betas.size > 0)
+      protocol.push(["anthropic-beta", [...betas].join(",")]);
     const profile = PROFILES.anthropic;
     const headers = orderHeaders(mergeHeaders(profile.headers, protocol), profile.order);
     const bodyString = signAnthropicBody(JSON.stringify(orderFields(withSystem, BODY_ORDER.anthropic)));
@@ -6290,18 +6304,16 @@ async function* decodeChat(messages) {
   let started = false;
   let textOpen = false;
   let textIndex;
-  let ended = false;
+  let done = false;
   let stopReason = "endTurn";
   let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
   const toolIndex = new Map;
   let nextIndex = 0;
-  const emitEnd = () => {
-    ended = true;
-    return { type: "end", stopReason, usage };
-  };
   for await (const msg of messages) {
-    if (msg.data === "[DONE]")
+    if (msg.data === "[DONE]") {
+      done = true;
       break;
+    }
     const d = json2(msg.data);
     if (d === null)
       continue;
@@ -6356,19 +6368,21 @@ async function* decodeChat(messages) {
     }
     if (typeof choice.finish_reason === "string") {
       stopReason = FINISH[choice.finish_reason] ?? "endTurn";
-      if (textOpen)
-        yield { type: "blockEnd", index: textIndex ?? 0 };
-      for (const index of toolIndex.values())
-        yield { type: "blockEnd", index };
-      yield emitEnd();
     }
   }
-  if (!ended) {
+  if (done) {
     if (textOpen)
       yield { type: "blockEnd", index: textIndex ?? 0 };
     for (const index of toolIndex.values())
       yield { type: "blockEnd", index };
-    yield emitEnd();
+    yield { type: "end", stopReason, usage };
+  } else {
+    yield {
+      type: "error",
+      code: "UPSTREAM",
+      message: "upstream stream ended before [DONE]",
+      retryable: RETRYABLE.UPSTREAM
+    };
   }
 }
 
@@ -6523,6 +6537,7 @@ async function* decodeResponses(messages) {
     return assigned;
   };
   let sawToolCall = false;
+  let terminal = false;
   const ownsBlock = new Set;
   for await (const msg of messages) {
     const d = json3(msg.data);
@@ -6598,6 +6613,7 @@ async function* decodeResponses(messages) {
       }
       case "response.completed":
       case "response.incomplete": {
+        terminal = true;
         const r = d.response ?? {};
         const reason = r.incomplete_details?.reason;
         let stopReason = sawToolCall ? "toolUse" : "endTurn";
@@ -6619,6 +6635,7 @@ async function* decodeResponses(messages) {
       }
       case "response.failed":
       case "error": {
+        terminal = true;
         const err = d.response?.error ?? d.error ?? {};
         const code = ERROR_CODE[String(err.code ?? err.type)] ?? "UPSTREAM";
         yield {
@@ -6633,6 +6650,14 @@ async function* decodeResponses(messages) {
         break;
     }
   }
+  if (!terminal) {
+    yield {
+      type: "error",
+      code: "UPSTREAM",
+      message: "upstream stream ended before response completion",
+      retryable: RETRYABLE.UPSTREAM
+    };
+  }
 }
 
 // packages/providers/src/openai/wire.ts
@@ -22609,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);
@@ -22715,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 });
@@ -22787,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,
@@ -22845,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);
@@ -22897,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) => {
@@ -31442,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) => {
@@ -31473,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) => {
@@ -31527,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),
@@ -33982,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;
@@ -38203,6 +38292,7 @@ async function dispatch(request2, deps, signal) {
   const deadlineAt = startedAt + snapshot.settings.requestDeadlineMs;
   const log = {
     id: crypto.randomUUID(),
+    state: "done",
     at: startedAt,
     apiKeyId: null,
     requestedModel: request2.model,
@@ -38294,6 +38384,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;
@@ -38319,12 +38414,18 @@ async function dispatch(request2, deps, signal) {
               }), dispatchSignal);
               for (const d of result.degradations)
                 log.degradations.push(d);
+              let terminal = false;
+              const pending = [];
               for await (const event of result.events) {
                 if (event.type === "blockDelta" && !committed) {
                   committed = true;
                   log.ttftMs = deps.now() - startedAt;
+                  for (const buffered of pending)
+                    yield buffered;
+                  pending.length = 0;
                 }
                 if (event.type === "end") {
+                  terminal = true;
                   log.inputTokens = event.usage.inputTokens;
                   log.outputTokens = event.usage.outputTokens;
                   log.cacheReadTokens = event.usage.cacheReadTokens;
@@ -38332,6 +38433,7 @@ async function dispatch(request2, deps, signal) {
                   log.costUsd = priceOf(candidate, event.usage);
                 }
                 if (event.type === "error") {
+                  terminal = true;
                   if (!committed && RETRYABLE[event.code]) {
                     throw new GatewayError(event.code, event.message);
                   }
@@ -38348,7 +38450,21 @@ async function dispatch(request2, deps, signal) {
                   log.durationMs = deps.now() - startedAt;
                   return;
                 }
-                yield event;
+                if (!committed && event.type !== "end") {
+                  pending.push(event);
+                } else {
+                  if (!committed) {
+                    for (const buffered of pending)
+                      yield buffered;
+                    pending.length = 0;
+                  }
+                  yield event;
+                }
+                if (event.type === "end")
+                  break;
+              }
+              if (!terminal) {
+                throw new GatewayError("UPSTREAM", "upstream stream ended without a terminal event");
               }
               await persistHealth(recordSuccess(healthFor(candidate), {
                 settings: snapshot.settings,
@@ -38602,6 +38718,7 @@ var chunk = (id, created, model, choice, usage) => ({
 async function* openaiStream(events, requestId, created) {
   let model = "";
   let roleSent = false;
+  let completed = false;
   const toolIndex = new Map;
   const emit = (data) => ({ event: "message", data: JSON.stringify(data) });
   for await (const event of events) {
@@ -38663,6 +38780,7 @@ async function* openaiStream(events, requestId, created) {
       case "blockEnd":
         break;
       case "end":
+        completed = true;
         yield emit(chunk(requestId, created, model, { index: 0, delta: {}, finish_reason: FINISH2[event.stopReason] }, {
           prompt_tokens: event.usage.inputTokens,
           completion_tokens: event.usage.outputTokens,
@@ -38676,7 +38794,8 @@ async function* openaiStream(events, requestId, created) {
       }
     }
   }
-  yield { event: "message", data: "[DONE]" };
+  if (completed)
+    yield { event: "message", data: "[DONE]" };
 }
 function openaiResponse(collected, requestId, created) {
   const text = collected.content.flatMap((b) => b.type === "text" ? [b.text] : []).join("");
@@ -38855,7 +38974,14 @@ function toIrReasoning(thinking, effort) {
       return { mode: "off" };
   }
 }
-function parseAnthropicRequest(body2) {
+function readBetas(headers) {
+  const raw = headers?.get("anthropic-beta");
+  if (raw === undefined || raw === null)
+    return [];
+  const names = raw.split(",").map((name) => name.trim()).filter((name) => name.length > 0);
+  return [...new Set(names)];
+}
+function parseAnthropicRequest(body2, headers) {
   if (typeof body2 !== "object" || body2 === null) {
     throw new GatewayError("BAD_REQUEST", "request body must be a JSON object");
   }
@@ -38896,6 +39022,9 @@ function parseAnthropicRequest(body2) {
   const extras = extraFields(body2, KNOWN);
   if (extras !== undefined)
     request2.vendor = { anthropic: extras };
+  const betas = readBetas(headers);
+  if (betas.length > 0)
+    request2.betas = betas;
   return validateRequest(request2);
 }
 
@@ -39057,18 +39186,44 @@ function parseOpenAIRequest(body2) {
 }
 
 // apps/gateway/src/logging.ts
+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) {
-    console.error("failed to persist request log", {
-      requestId: log.id,
-      reason: error51 instanceof Error ? error51.message : "unknown"
-    });
+    report("failed to persist request log", log.id, error51);
   }
 }
 
 // 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",
@@ -39087,7 +39242,7 @@ function asGatewayError2(error51) {
     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 = () => {
@@ -39095,10 +39250,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();
@@ -39123,21 +39287,54 @@ 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;
     rateLimiter.consume(key.id, key.rateLimitPerMin);
     const body2 = await request2.json();
-    const chatRequest = surface === "anthropic" ? parseAnthropicRequest(body2) : parseOpenAIRequest(body2);
+    const chatRequest = surface === "anthropic" ? parseAnthropicRequest(body2, request2.headers) : parseOpenAIRequest(body2);
     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);
+    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;
+        await beginLog(deps.store, {
+          id: requestId,
+          at: startedAt,
+          apiKeyId: keyId,
+          requestedModel,
+          resolvedProvider: target.provider,
+          resolvedModel: target.model,
+          credentialId: target.credentialId,
+          attempts: 0,
+          status: 0,
+          errorCode: null,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          ttftMs: null,
+          durationMs: 0,
+          costUsd: 0,
+          degradations: []
+        }, keyId);
+      }
+    }, request2.signal);
     const log = () => finishLog(deps.store, { ...outcome.log(), id: requestId }, 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)
@@ -39156,9 +39353,10 @@ async function handle(deps, rateLimiter, surface, request2) {
     const gatewayError = asGatewayError2(error51);
     await finishLog(deps.store, {
       id: requestId,
-      at: deps.now(),
+      state: "done",
+      at: startedAt,
       apiKeyId: keyId,
-      requestedModel: "",
+      requestedModel,
       resolvedProvider: null,
       resolvedModel: null,
       credentialId: null,
@@ -39181,7 +39379,8 @@ 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 {
@@ -39410,6 +39609,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 });
@@ -39430,7 +39632,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) {