omnigateway 0.6.0 → 0.7.0

package/README.md

@@ -182,6 +182,9 @@ Connect an account. The CLI prints a URL to open, and waits:
 omni connect anthropic     # or: openai, kimi, kilo, grok
 ```
 
+An installed [plugin](#plugins) that supplies its own provider is connected the
+same way, under its plugin id.
+
 Every provider also takes a plain API key, if that is what you hold rather than
 a subscription:
 
@@ -741,13 +744,26 @@ and whether the gateway would load it:
 
 ```
 ID       NAME               VERSION  API  SDK     CAPABILITIES                    STATE
-pokemon  Pokémon Companion  1.0.0    1    ^1.0.0  storage,files,net:outbound,…    ok
+pokemon  Pokémon Companion  1.0.0    2    ^1.0.0  storage,files,net:outbound,…    ok
 ```
 
+The API column is the plugin API generation, and it is matched **exactly** — a
+plugin built against an older one is listed with that as its reason rather than
+loaded.
+
 The capabilities a manifest may declare are `storage`, `files`, `net:outbound`,
-`events:request`, `events:limit` and `channels` — the last being namespaced
-topics on the gateway's push socket, which a plugin owns without ever touching a
-connection. Anything a plugin did not declare is absent from what it is handed.
+`events:request`, `events:limit`, `channels` and `provider`. `channels` is
+namespaced topics on the gateway's push socket, which a plugin owns without ever
+touching a connection. `provider` lets a plugin supply a provider of its own —
+the models, the wire format, and optionally the OAuth flow, so
+`omni connect <plugin-id>` works for it exactly as it does for a built-in.
+Anything a plugin did not declare is absent from what it is handed.
+
+`net:outbound` and `provider` each require the manifest to declare `origins`,
+and both are enforced: a plugin's own `fetch` and the requests the gateway makes
+on a provider plugin's behalf are both refused outside them. That is what makes
+`omni plugin verify <id>` worth reading before you install one — where your
+prompts can be sent is in the manifest, not only in the code.
 
 A plugin that would *not* load is listed with the reason rather than hidden,
 because a plugin missing from the console is exactly what you are trying to

package/bin/omni.js

@@ -1687,6 +1687,7 @@ var MIGRATIONS = [
 function openDb(path) {
   const db = new Database(path, { create: true });
   db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA synchronous = NORMAL");
   db.run("PRAGMA foreign_keys = ON");
   db.run("PRAGMA busy_timeout = 5000");
   db.run("CREATE TABLE IF NOT EXISTS migrations (id INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL)");
@@ -1848,6 +1849,18 @@ function estimateInputTokens(request) {
     total += toolTokens(tool);
   return total;
 }
+function estimateInputPrefixes(request) {
+  let tools = 0;
+  for (const tool of request.tools ?? [])
+    tools += toolTokens(tool);
+  let toolsAndSystem = tools;
+  for (const block of request.system ?? [])
+    toolsAndSystem += blockTokens(block);
+  let total = toolsAndSystem;
+  for (const message of request.messages)
+    total += messageTokens(message);
+  return { tools, toolsAndSystem, total };
+}
 function estimateCachedInputTokens(request) {
   let running = 0;
   let cached = 0;
@@ -19054,7 +19067,7 @@ import { basename as basename2, join as join3, resolve as resolve2, sep as sep2
 
 // packages/plugin-api/src/version.ts
 var PLUGIN_API_VERSION = 2;
-var DASHBOARD_SDK_VERSION = "0.1.3";
+var DASHBOARD_SDK_VERSION = "0.1.4";
 // packages/plugin-api/src/manifest.ts
 var CAPABILITIES = [
   "storage",
@@ -20375,47 +20388,77 @@ var PROFILES = {
 Object.setPrototypeOf(PROFILES, null);
 
 // packages/providers/src/sse.ts
+var HOLDBACK = 2;
+var MAX_RECORD_CHARS = 10 * 1024 * 1024;
 async function* parseSse(body) {
   const reader = body.getReader();
   const decoder3 = new TextDecoder;
-  let buf = "";
+  const pending = [];
+  let pendingChars = 0;
+  let tail = "";
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done)
         break;
-      buf += decoder3.decode(value, { stream: true });
-      buf = buf.replaceAll(`\r
-`, `
-`);
-      let sep3 = buf.indexOf(`
-
+      const probe = tail + decoder3.decode(value, { stream: true });
+      let start = 0;
+      let nl = probe.indexOf(`
 `);
-      while (sep3 !== -1) {
-        const record2 = buf.slice(0, sep3);
-        buf = buf.slice(sep3 + 2);
+      while (nl !== -1) {
+        const end = separatorEnd(probe, nl);
+        if (end === -1) {
+          nl = probe.indexOf(`
+`, nl + 1);
+          continue;
+        }
+        refuseIfOversized(pendingChars + (nl - start));
+        pending.push(probe.slice(start, nl));
+        const record2 = pending.join("");
+        pending.length = 0;
+        pendingChars = 0;
         const msg = parseRecord(record2);
         if (msg)
           yield msg;
-        sep3 = buf.indexOf(`
-
-`);
-      }
-    }
-    const tail = parseRecord(buf.replaceAll(`\r
-`, `
-`));
-    if (tail)
-      yield tail;
+        start = end;
+        nl = probe.indexOf(`
+`, end);
+      }
+      const keep2 = Math.min(HOLDBACK, probe.length - start);
+      const settled = probe.slice(start, probe.length - keep2);
+      if (settled.length > 0) {
+        pending.push(settled);
+        pendingChars += settled.length;
+      }
+      tail = probe.slice(probe.length - keep2);
+      refuseIfOversized(pendingChars + tail.length);
+    }
+    const last = parseRecord(pending.join("") + tail);
+    if (last)
+      yield last;
   } finally {
     reader.releaseLock();
   }
 }
+function refuseIfOversized(chars) {
+  if (chars <= MAX_RECORD_CHARS)
+    return;
+  throw new GatewayError("UPSTREAM", `upstream SSE record exceeded ${MAX_RECORD_CHARS} characters`, { gatewayAuthored: true });
+}
+function separatorEnd(text, at) {
+  const next = text.charCodeAt(at + 1);
+  if (next === 10)
+    return at + 2;
+  if (next === 13 && text.charCodeAt(at + 2) === 10)
+    return at + 3;
+  return -1;
+}
 function parseRecord(record2) {
   let event = "message";
   const data = [];
-  for (const line of record2.split(`
+  for (const rawLine of record2.split(`
 `)) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
     if (line.length === 0 || line.startsWith(":"))
       continue;
     const colon = line.indexOf(":");
@@ -20891,7 +20934,7 @@ async function* decodeAnthropic(messages, opts = {}) {
       case "message_delta": {
         const reason = d.delta?.stop_reason;
         if (typeof reason === "string") {
-          const mapped = STOP_REASON[reason];
+          const mapped = Object.hasOwn(STOP_REASON, reason) ? STOP_REASON[reason] : undefined;
           if (mapped === undefined) {
             yield protocolError(`unrecognized Anthropic stop reason "${reason}"`);
             return;
@@ -20921,7 +20964,7 @@ async function* decodeAnthropic(messages, opts = {}) {
         terminal = true;
         const type = String(d.error?.type);
         const message = String(d.error?.message ?? "upstream error");
-        const code = isFingerprintRefusal(type, message) ? "FINGERPRINT_REFUSED" : ERROR_TYPE[type] ?? "UPSTREAM";
+        const code = isFingerprintRefusal(type, message) ? "FINGERPRINT_REFUSED" : (Object.hasOwn(ERROR_TYPE, type) ? ERROR_TYPE[type] : undefined) ?? "UPSTREAM";
         yield { type: "error", code, message, retryable: RETRYABLE[code] };
         break;
       }
@@ -21127,14 +21170,15 @@ function addAutoCacheBreakpoints(body, req, note2) {
   let markedPrefix = 0;
   const worthAMarker = (prefix) => prefix - markedPrefix >= AUTO_CACHE_MIN_TOKENS;
   let stablePrefixMarked = false;
-  const toolsPrefix = estimateInputTokens({ ...req, messages: [], system: [] });
+  const prefixes = estimateInputPrefixes(req);
+  const toolsPrefix = prefixes.tools;
   const lastTool = body.tools?.at(-1);
   if (lastTool !== undefined && worthAMarker(toolsPrefix)) {
     lastTool.cache_control = { type: "ephemeral" };
     markedPrefix = toolsPrefix;
     stablePrefixMarked = true;
   }
-  const systemPrefix = estimateInputTokens({ ...req, messages: [] });
+  const systemPrefix = prefixes.toolsAndSystem;
   const lastSystem = body.system?.at(-1);
   if (lastSystem !== undefined && worthAMarker(systemPrefix)) {
     lastSystem.cache_control = { type: "ephemeral" };
@@ -21143,7 +21187,7 @@ function addAutoCacheBreakpoints(body, req, note2) {
   }
   if (stablePrefixMarked)
     note2("anthropic:cache-breakpoint-added");
-  if (!worthAMarker(estimateInputTokens(req)))
+  if (!worthAMarker(prefixes.total))
     return;
   const lastHistory = lastCacheableHistoryBlock(body.messages);
   if (lastHistory === undefined)
@@ -21438,7 +21482,18 @@ async function* decodeCustomChat(messages) {
       }
     }
     if (typeof choice.finish_reason === "string") {
-      stopReason = CHAT_FINISH[choice.finish_reason] ?? "endTurn";
+      const reason = choice.finish_reason;
+      const mapped = Object.hasOwn(CHAT_FINISH, reason) ? CHAT_FINISH[reason] : undefined;
+      if (mapped === undefined) {
+        yield {
+          type: "error",
+          code: "UPSTREAM",
+          message: `unrecognized custom endpoint finish reason "${reason}"`,
+          retryable: false
+        };
+        return;
+      }
+      stopReason = mapped;
     }
   }
   if (done) {
@@ -21462,6 +21517,32 @@ var RESPONSES_ERROR_CODE = {
   context_length_exceeded: "BAD_REQUEST",
   content_policy_violation: "CONTENT_FILTER"
 };
+var KNOWN_RESPONSES_EVENTS = new Set([
+  "response.created",
+  "response.queued",
+  "response.in_progress",
+  "response.output_item.added",
+  "response.output_item.done",
+  "response.content_part.added",
+  "response.content_part.done",
+  "response.output_text.delta",
+  "response.output_text.done",
+  "response.output_text.annotation.added",
+  "response.refusal.delta",
+  "response.refusal.done",
+  "response.reasoning_summary_part.added",
+  "response.reasoning_summary_part.done",
+  "response.reasoning_summary_text.delta",
+  "response.reasoning_summary_text.done",
+  "response.reasoning_text.delta",
+  "response.reasoning_text.done",
+  "response.function_call_arguments.delta",
+  "response.function_call_arguments.done",
+  "response.completed",
+  "response.incomplete",
+  "response.failed",
+  "error"
+]);
 async function* decodeCustomResponses(messages) {
   const indices = new Map;
   let next = 0;
@@ -21478,6 +21559,17 @@ async function* decodeCustomResponses(messages) {
   let terminal = false;
   const ownsBlock = new Set;
   for await (const msg of messages) {
+    if (msg.data === "[DONE]")
+      continue;
+    if (!KNOWN_RESPONSES_EVENTS.has(msg.event)) {
+      yield {
+        type: "error",
+        code: "UPSTREAM",
+        message: `unrecognized custom endpoint stream event "${msg.event}"`,
+        retryable: false
+      };
+      return;
+    }
     const d = json3(msg.data);
     if (d === null)
       continue;
@@ -21559,6 +21651,15 @@ async function* decodeCustomResponses(messages) {
           stopReason = "maxTokens";
         else if (reason === "content_filter")
           stopReason = "contentFilter";
+        else if (reason !== undefined || msg.event === "response.incomplete" || r.status !== undefined && r.status !== "completed") {
+          yield {
+            type: "error",
+            code: "UPSTREAM",
+            message: reason !== undefined ? `unrecognized custom endpoint incomplete reason "${String(reason)}"` : r.status !== undefined && r.status !== "incomplete" ? `custom endpoint reported terminal response status "${String(r.status)}"` : "custom endpoint reported the response incomplete without a reason",
+            retryable: false
+          };
+          break;
+        }
         yield {
           type: "end",
           stopReason,
@@ -21570,7 +21671,8 @@ async function* decodeCustomResponses(messages) {
       case "error": {
         terminal = true;
         const err = d.response?.error ?? d.error ?? {};
-        const code = RESPONSES_ERROR_CODE[String(err.code ?? err.type)] ?? "UPSTREAM";
+        const raw = String(err.code ?? err.type);
+        const code = (Object.hasOwn(RESPONSES_ERROR_CODE, raw) ? RESPONSES_ERROR_CODE[raw] : undefined) ?? "UPSTREAM";
         yield {
           type: "error",
           code,
@@ -22023,6 +22125,15 @@ async function* decodeGrokResponses(messages) {
           stopReason = "maxTokens";
         else if (reason === "content_filter")
           stopReason = "contentFilter";
+        else if (reason !== undefined || msg.event === "response.incomplete" || r.status !== undefined && r.status !== "completed") {
+          yield {
+            type: "error",
+            code: "UPSTREAM",
+            message: reason !== undefined ? `unrecognized xAI incomplete reason "${String(reason)}"` : r.status !== undefined && r.status !== "incomplete" ? `xAI reported terminal response status "${String(r.status)}"` : "xAI reported the response incomplete without a reason",
+            retryable: false
+          };
+          break;
+        }
         yield {
           type: "end",
           stopReason,
@@ -22034,7 +22145,8 @@ async function* decodeGrokResponses(messages) {
       case "error": {
         terminal = true;
         const err = d.response?.error ?? d.error ?? {};
-        const code = ERROR_CODE[String(err.code ?? err.type)] ?? "UPSTREAM";
+        const raw = String(err.code ?? err.type);
+        const code = (Object.hasOwn(ERROR_CODE, raw) ? ERROR_CODE[raw] : undefined) ?? "UPSTREAM";
         yield {
           type: "error",
           code,
@@ -22450,7 +22562,18 @@ async function* decodeKiloChat(messages) {
       }
     }
     if (typeof choice.finish_reason === "string") {
-      stopReason = FINISH[choice.finish_reason] ?? "endTurn";
+      const reason = choice.finish_reason;
+      const mapped = Object.hasOwn(FINISH, reason) ? FINISH[reason] : undefined;
+      if (mapped === undefined) {
+        yield {
+          type: "error",
+          code: "UPSTREAM",
+          message: `unrecognized Kilo finish reason "${reason}"`,
+          retryable: false
+        };
+        return;
+      }
+      stopReason = mapped;
     }
   }
   if (done) {
@@ -22737,7 +22860,18 @@ async function* decodeChat(messages) {
       }
     }
     if (typeof choice.finish_reason === "string") {
-      stopReason = FINISH2[choice.finish_reason] ?? "endTurn";
+      const reason = choice.finish_reason;
+      const mapped = Object.hasOwn(FINISH2, reason) ? FINISH2[reason] : undefined;
+      if (mapped === undefined) {
+        yield {
+          type: "error",
+          code: "UPSTREAM",
+          message: `unrecognized Kimi finish reason "${reason}"`,
+          retryable: false
+        };
+        return;
+      }
+      stopReason = mapped;
     }
   }
   if (done) {
@@ -22895,6 +23029,32 @@ var ERROR_CODE2 = {
   context_length_exceeded: "BAD_REQUEST",
   content_policy_violation: "CONTENT_FILTER"
 };
+var KNOWN_EVENTS3 = new Set([
+  "response.created",
+  "response.queued",
+  "response.in_progress",
+  "response.output_item.added",
+  "response.output_item.done",
+  "response.content_part.added",
+  "response.content_part.done",
+  "response.output_text.delta",
+  "response.output_text.done",
+  "response.output_text.annotation.added",
+  "response.refusal.delta",
+  "response.refusal.done",
+  "response.reasoning_summary_part.added",
+  "response.reasoning_summary_part.done",
+  "response.reasoning_summary_text.delta",
+  "response.reasoning_summary_text.done",
+  "response.reasoning_text.delta",
+  "response.reasoning_text.done",
+  "response.function_call_arguments.delta",
+  "response.function_call_arguments.done",
+  "response.completed",
+  "response.incomplete",
+  "response.failed",
+  "error"
+]);
 function json7(data) {
   try {
     const v = JSON.parse(data);
@@ -22919,6 +23079,17 @@ async function* decodeResponses(messages) {
   let terminal = false;
   const ownsBlock = new Set;
   for await (const msg of messages) {
+    if (msg.data === "[DONE]")
+      continue;
+    if (!KNOWN_EVENTS3.has(msg.event)) {
+      yield {
+        type: "error",
+        code: "UPSTREAM",
+        message: `unrecognized OpenAI stream event "${msg.event}"`,
+        retryable: false
+      };
+      return;
+    }
     const d = json7(msg.data);
     if (d === null)
       continue;
@@ -23000,6 +23171,15 @@ async function* decodeResponses(messages) {
           stopReason = "maxTokens";
         else if (reason === "content_filter")
           stopReason = "contentFilter";
+        else if (reason !== undefined || msg.event === "response.incomplete" || r.status !== undefined && r.status !== "completed") {
+          yield {
+            type: "error",
+            code: "UPSTREAM",
+            message: reason !== undefined ? `unrecognized OpenAI incomplete reason "${String(reason)}"` : r.status !== undefined && r.status !== "incomplete" ? `OpenAI reported terminal response status "${String(r.status)}"` : "OpenAI reported the response incomplete without a reason",
+            retryable: false
+          };
+          break;
+        }
         yield {
           type: "end",
           stopReason,
@@ -23011,7 +23191,8 @@ async function* decodeResponses(messages) {
       case "error": {
         terminal = true;
         const err = d.response?.error ?? d.error ?? {};
-        const code = ERROR_CODE2[String(err.code ?? err.type)] ?? "UPSTREAM";
+        const raw = String(err.code ?? err.type);
+        const code = (Object.hasOwn(ERROR_CODE2, raw) ? ERROR_CODE2[raw] : undefined) ?? "UPSTREAM";
         yield {
           type: "error",
           code,
@@ -27579,7 +27760,7 @@ function atomicWriteFile(path, contents, ops) {
 }
 
 // apps/cli/src/run.ts
-var VERSION = "0.0.0";
+var VERSION = "0.7.0";
 async function run(argv, writer, options = {}) {
   const wants = (...flags) => argv.some((token) => flags.includes(token));
   if (wants("--version")) {