omnigateway 0.1.2 → 0.1.4

package/bin/omni.js

@@ -608,6 +608,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)
@@ -673,6 +674,7 @@ async function* decodeAnthropic(messages) {
         break;
       }
       case "message_stop":
+        terminal = true;
         yield {
           type: "end",
           stopReason,
@@ -680,6 +682,7 @@ async function* decodeAnthropic(messages) {
         };
         break;
       case "error": {
+        terminal = true;
         const code = ERROR_TYPE[String(d.error?.type)] ?? "UPSTREAM";
         yield {
           type: "error",
@@ -693,6 +696,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
@@ -805,9 +816,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 {
@@ -815,6 +827,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)));
@@ -1032,18 +1046,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;
@@ -1098,19 +1110,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
+    };
   }
 }
 
@@ -1265,6 +1279,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);
@@ -1340,6 +1355,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";
@@ -1361,6 +1377,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 {
@@ -1375,6 +1392,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
@@ -17310,6 +17335,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);
@@ -17416,7 +17462,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 });
@@ -17488,6 +17535,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,
@@ -17546,37 +17594,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);
@@ -17598,7 +17687,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) => {
@@ -18077,21 +18166,21 @@ function parse5(argv, options = {}) {
     throw new UsageError(error51 instanceof Error ? error51.message : "could not parse arguments");
   }
 }
-function stringFlag(values, name) {
-  const value = values[name];
+function stringFlag(values2, name) {
+  const value = values2[name];
   return typeof value === "string" ? value : undefined;
 }
-function boolFlag(values, name) {
-  return values[name] === true;
+function boolFlag(values2, name) {
+  return values2[name] === true;
 }
-function listFlag(values, name) {
-  const value = values[name];
+function listFlag(values2, name) {
+  const value = values2[name];
   if (Array.isArray(value))
     return value.filter((entry) => typeof entry === "string");
   return typeof value === "string" ? [value] : undefined;
 }
-function numberFlag(values, name) {
-  const raw = stringFlag(values, name);
+function numberFlag(values2, name) {
+  const raw = stringFlag(values2, name);
   if (raw === undefined)
     return;
   const value = Number(raw);