okengine 0.22.0 → 0.23.1

package/src/kernel/json-result.ts

@@ -28,6 +28,16 @@ export interface JsonStreamResult {
   ready?: () => Promise<void>;
   /** Set by the kernel to commit journal / Runs after the stream settles. */
   finalize?: () => Promise<void>;
+  /**
+   * Agent result once a streamed `fx.run` settles.
+   * Absent for text and live streams.
+   */
+  result?: Promise<unknown>;
+  /**
+   * Set when iteration parked a durable run, after `[DONE]` is queued.
+   * Finalize commits the journal as sleeping from this.
+   */
+  parked?: { wakeAt: number; label: string };
 }
 
 /**

package/src/kernel/pipeline-tenant.ts

@@ -6,7 +6,7 @@
  * including Store-only apps that never enable `gate.auth.tenant`.
  */
 
-import { tenantScopesForMember } from "../auth/tenants.ts";
+import { tenantRoleForMember, tenantScopesForMember } from "../auth/tenants.ts";
 import type { FlowFailure } from "./errors.ts";
 import type { PipelineDeps } from "./pipeline.ts";
 import type { InvocationContext } from "./hooks.ts";
@@ -41,6 +41,10 @@ export function applyPipelineTenant(
     for (const scope of tenantScopesForMember(tenant.store, result.id, userId)) {
       deps.principals.auth.scopes.add(scope);
     }
+    const role = tenantRoleForMember(tenant.store, result.id, userId);
+    deps.principals.cacheRoles = role ? [role] : [];
+  } else {
+    deps.principals.cacheRoles = [];
   }
   return undefined;
 }

package/src/kernel/pipeline.test.ts

@@ -14,6 +14,7 @@ import { createClockRuntime } from "../elements/clock.ts";
 import { gate } from "../elements/gate.ts";
 import { createRunsRuntime, memoryRunsDriver } from "../runs/index.ts";
 import { oke } from "./app.ts";
+import { HTTP_FRAME_REDACTED } from "./http-frame.ts";
 import { flow, resetFlowSeq } from "./flow.ts";
 import { on, resetBindings } from "./on.ts";
 import { http } from "./triggers.ts";
@@ -196,6 +197,50 @@ describe("pipeline — Unauthorized for anonymous", () => {
   });
 });
 
+describe("pipeline — HTTP wire frame", () => {
+  test("fetch stores query, headers, and status beside the body", async () => {
+    resetBindings();
+    resetFlowSeq();
+
+    on(
+      http.get("/tasks", { out: z.object({ ok: z.literal(true) }) }).public(),
+      flow("tasks.list", {
+        do: () => ({ ok: true as const }),
+      }),
+    );
+
+    const runs = createRunsRuntime({ driver: memoryRunsDriver });
+    await runs.open();
+    const app = oke({
+      name: "http-frame",
+      gate: { policies: [gate.public] },
+      runs,
+      env: "test",
+    });
+    await app.boot({ env: "test", gates: [gate.public], runs });
+
+    const res = await app.fetch(
+      new Request("http://localhost/tasks?limit=20", {
+        headers: { accept: "application/json", cookie: "sid=secret" },
+      }),
+    );
+    expect(res.status).toBe(200);
+
+    const event = (await runs.all()).find((row) => row.flow === "tasks.list");
+    expect(event?.input).toBeUndefined();
+    expect(event?.http).toMatchObject({
+      request: {
+        method: "GET",
+        path: "/tasks",
+        query: { limit: "20" },
+        headers: { cookie: HTTP_FRAME_REDACTED, accept: "application/json" },
+      },
+      response: { status: 200 },
+    });
+    await app.bootResult?.close();
+  });
+});
+
 describe("pipeline — evaluated gates on the run", () => {
   test("recorded run contains evaluated chain, not just declared names", async () => {
     resetBindings();

package/src/kernel/pipeline.ts

@@ -37,6 +37,11 @@ export interface PrincipalBag {
   readonly tenant: {
     id: string | null;
   };
+  /**
+   * Membership role names for the tier-1 cache key.
+   * Gates do not read this field.
+   */
+  cacheRoles?: string[];
 }
 
 /** Resolved identity from auth middleware / test harness. */

package/src/kernel/signal-tx.ts

@@ -0,0 +1,28 @@
+/**
+ * Ambient signal transaction for `fx.store().transaction`.
+ *
+ * Emits inside the callback stage on {@link SignalTransaction} and publish
+ * only after the SQL transaction commits.
+ */
+
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { SignalTransaction } from "../drivers/signal-types.ts";
+
+const storage = new AsyncLocalStorage<SignalTransaction>();
+
+/**
+ * The signal transaction wrapping the current async frame, if any.
+ */
+export function currentSignalTransaction(): SignalTransaction | undefined {
+  return storage.getStore();
+}
+
+/**
+ * Run `fn` with `tx` as the ambient signal transaction.
+ *
+ * @param tx - Open signal transaction
+ * @param fn - Body
+ */
+export function runInSignalTransaction<T>(tx: SignalTransaction, fn: () => Promise<T>): Promise<T> {
+  return storage.run(tx, fn);
+}

package/src/kernel/sse-id.ts

@@ -0,0 +1,32 @@
+/**
+ * SSE id carried on a live agent event without changing its JSON payload.
+ *
+ * The follow log stores a seq. The live `fx.run` frame for that row uses the
+ * same seq as `id:` so a client can resume with `Last-Event-ID`.
+ */
+
+const sseIdBrand: unique symbol = Symbol.for("oke.sse.id");
+
+/**
+ * Copy `value` and attach an SSE id the encoder writes as `id:`.
+ * The id is not enumerable, so it is not part of the JSON payload.
+ *
+ * @param value - Event object
+ * @param id - SSE id (the stored log seq)
+ */
+export function withSseId<T extends object>(value: T, id: string): T {
+  const copy: T = { ...value };
+  Object.defineProperty(copy, sseIdBrand, { value: id, enumerable: false });
+  return copy;
+}
+
+/**
+ * SSE id attached by {@link withSseId}, if any.
+ *
+ * @param value - Stream chunk
+ */
+export function readSseId(value: unknown): string | undefined {
+  if (typeof value !== "object" || value === null) return undefined;
+  const id = (value as { readonly [sseIdBrand]?: unknown })[sseIdBrand];
+  return typeof id === "string" ? id : undefined;
+}

package/src/kernel/store-transaction.test.ts

@@ -0,0 +1,95 @@
+/**
+ * `fx.store().transaction` publishes signal emits only after commit.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { SqlConnection } from "../drivers/types.ts";
+import { memorySignalDriver } from "../drivers/signal-memory.ts";
+import { signal } from "../elements/signal.ts";
+import { store } from "../elements/store.ts";
+import { createSqlStoreHandle } from "../elements/store/sql-session.ts";
+import type { StoreRuntime } from "../elements/store/runtime.ts";
+import { createFxContext } from "./fx.ts";
+import type { SignalRuntime } from "../elements/signal/runtime.ts";
+
+function fakeSql(): SqlConnection {
+  return {
+    driverId: "memory",
+    role: "primary",
+    async query() {
+      return [];
+    },
+    async exec() {
+      return { changes: 1 };
+    },
+    async transaction(fn) {
+      return fn(this);
+    },
+    async close() {},
+  };
+}
+
+describe("fx.store().transaction", () => {
+  test("commit publishes the staged emit; rollback drops it", async () => {
+    const ping = signal.once("ping");
+    const signals = new Map([[ping.name, ping]]);
+    const bus = await memorySignalDriver.open({ signals });
+    const got: unknown[] = [];
+    await bus.subscribe("ping", "c", async (message) => {
+      got.push(message.payload);
+    });
+    const signalRuntime: SignalRuntime = {
+      driverId: "memory",
+      get bus() {
+        return bus;
+      },
+      declarations: signals,
+      register(decl) {
+        signals.set(decl.name, decl);
+      },
+      async start() {
+        return bus;
+      },
+      emit: (name, payload, options) => bus.emit(name, payload, options),
+      deadLetters: (name) => bus.deadLetters(name),
+      live: (name, opts) => bus.live(name, opts),
+      checkLiveResume: (name, afterId) => bus.checkLiveResume(name, afterId),
+      async close() {
+        await bus.close();
+      },
+    };
+    const notes = { name: "notes" };
+    const storeRuntime = {
+      async open() {
+        return createSqlStoreHandle("sql:db", {
+          connection: fakeSql(),
+          classifications: new Map(),
+          routedRole: "primary",
+        });
+      },
+    } as unknown as StoreRuntime;
+    const db = store.sql("db");
+    const { fx } = createFxContext({
+      flow: "notes.write",
+      effects: { writes: ["sql:notes", "sql:db"], emits: ["ping"] },
+      storeRuntime,
+      signalRuntime,
+    });
+
+    await fx.store(db).transaction(async (tx) => {
+      await tx.insert(notes).values({ id: "1" });
+      await fx.emit(ping, { id: "1" });
+    });
+    await bus.drain();
+    expect(got).toEqual([{ id: "1" }]);
+
+    await expect(
+      fx.store(db).transaction(async () => {
+        await fx.emit(ping, { id: "no" });
+        throw new Error("nope");
+      }),
+    ).rejects.toThrow("nope");
+    await bus.drain();
+    expect(got).toEqual([{ id: "1" }]);
+  });
+});

package/src/manifest/diff.ts

@@ -52,6 +52,7 @@ const EFFECT_KEYS = [
   "secrets",
   "calls",
   "fetches",
+  "decides",
 ] as const;
 
 /** Isolation strength: higher = stronger tenant separation. */

package/src/manifest/types.ts

@@ -58,6 +58,12 @@ export type AuthApiKeysResourceRef = "auth:api-keys";
  */
 export type AuthTenantsResourceRef = "auth:tenants";
 
+/**
+ * Agent-run journal capability for approval routes.
+ * Not a store facet — the journal driver owns the rows.
+ */
+export type JournalRunsResourceRef = "journal:runs";
+
 /**
  * Dead-letter / live-stream read capability — not a store facet.
  * Declare on `effects.reads` (never `writes`).
@@ -101,8 +107,10 @@ export interface Effects {
     | AuthApiKeysResourceRef
     | AuthTenantsResourceRef
   >;
-  /** Store writes, plus `"auth:api-keys"` / `"auth:tenants"` for `fx.auth` mutations. */
-  writes?: Array<ResourceRef | AuthApiKeysResourceRef | AuthTenantsResourceRef>;
+  /** Store writes, plus `"auth:api-keys"` / `"auth:tenants"` and `"journal:runs"`. */
+  writes?: Array<
+    ResourceRef | AuthApiKeysResourceRef | AuthTenantsResourceRef | JournalRunsResourceRef
+  >;
   /** Emitted signals. */
   emits?: SignalRef[];
   /** Channel template sends (irreversible). */
@@ -123,6 +131,8 @@ export interface Effects {
    * Hostname only (e.g. `"api.stripe.com"`), never a full URL.
    */
   fetches?: FetchHostRef[];
+  /** Decision refs from `fx.decide` (irreversible, nondeterministic). */
+  decides?: string[];
 }
 
 /** Embedding model ref for `effects.embeds` / `fx.embed` (model name). */
@@ -475,6 +485,8 @@ export interface AiPrompt {
   version?: number;
   evals?: string;
   budget?: AiBudget;
+  /** `1` sends one schema-mismatch follow-up. Default `0`. */
+  repair?: 0 | 1;
   /** Ordered recovery chain of logical model names. */
   via?: string[];
   /** Per-command deadline (`"30s"` or milliseconds). */
@@ -487,7 +499,10 @@ export interface AiPrompt {
 /** Bounded agent whose tools are flows. */
 export interface AiAgent {
   tools?: FlowRef[];
+  /** Tools that park for human approval. The predicate stays in author code. */
+  approvals?: Record<string, true>;
   maxSteps?: number;
+  maxDepth?: number;
   model?: string;
   budget?: AiBudget;
 }
@@ -514,9 +529,21 @@ export interface Ai {
   models?: Record<string, AiModel>;
   prompts?: Record<string, AiPrompt>;
   agents?: Record<string, AiAgent>;
+  decisions?: Record<string, AiDecision>;
   mcpServers?: Record<string, AiMcpServer>;
 }
 
+/** A declared decision. The predicate and locale function stay in author code. */
+export interface AiDecision {
+  mode: "review" | "abstain";
+  review?: string;
+  model?: string;
+  driverId?: "openrouter" | "typesafe";
+  questions: string[];
+  evals?: string;
+  autonomy?: { maxError: number; audit: number; risk?: number };
+}
+
 /** Per-table metadata on a Manifest {@link Plugin}. */
 export interface PluginTable {
   plane?: string;

package/src/mcp/ai-tools.test.ts

@@ -0,0 +1,202 @@
+/**
+ * Read-only AI and decision MCP tools.
+ *
+ * Same authorization shape as `oke.traces.*`: one of the declared scopes,
+ * no confirmation, and no resolve or promote tool.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { createSessionStore } from "../auth/sessions.ts";
+import { Redacted } from "../kernel/redacted.ts";
+import type { Manifest } from "../manifest/types.ts";
+import { authorizeToolCall } from "./authorization.ts";
+import { mintMcpSession, authenticateMcpRequest } from "./session.ts";
+import { createToolRuntime, type McpContext } from "./tools.ts";
+
+const SECRET = "mcp-ai-secret";
+
+const runA = {
+  id: "run-a",
+  agent: "support",
+  tenant: "acme",
+  status: "interrupted",
+};
+const runB = {
+  id: "run-b",
+  agent: "support",
+  tenant: "other",
+  status: "finished",
+};
+
+describe("MCP AI and decision tools", () => {
+  test("traces scope cannot read agent runs, and there is no resolve tool", () => {
+    expect(
+      authorizeToolCall("oke.ai.runs.list", {}, ["mcp:traces:read"], { confirmed: true }).ok,
+    ).toBe(false);
+    const resolve = authorizeToolCall("oke.ai.approvals.resolve", {}, ["console:*"]);
+    expect(resolve.ok).toBe(false);
+    if (resolve.ok) return;
+    expect(resolve.reason).toBe("unknown-tool");
+    const promote = authorizeToolCall("oke.decisions.promote", {}, ["mcp:*"]);
+    expect(promote.ok).toBe(false);
+    if (promote.ok) return;
+    expect(promote.reason).toBe("unknown-tool");
+    expect(
+      authorizeToolCall("oke.ai.runs.list", {}, ["console:runs:read"], { confirmed: true }).ok,
+    ).toBe(true);
+  });
+
+  test("a tenant token sees only its tenant; an operator token sees every tenant", async () => {
+    const runtime = createToolRuntime({
+      getManifest: () => ({ oke: "1.0", app: "skyport" }) as Manifest,
+      listRuns: async () => [],
+      listAgentRuns: async () => [runA, runB],
+      getAgentRun: async (runId) => {
+        const run = [runA, runB].find((row) => row.id === runId);
+        if (!run) return undefined;
+        return { run, events: [{ seq: 1, event: { type: "RUN_FINISHED" } }] };
+      },
+      listApprovals: async () => [
+        { id: "a", tenant: "acme", tool: "refund" },
+        { id: "b", tenant: "other", tool: "refund" },
+      ],
+      listDecisions: async () => [
+        { name: "triage", tenant: "acme", state: "learning", pending: 1, drift: false },
+        { name: "other-call", tenant: "other", state: "learning", pending: 0, drift: false },
+      ],
+    });
+    const store = createSessionStore();
+    const issued = await mintMcpSession({
+      store,
+      secret: SECRET,
+      principalId: "op",
+      scopes: ["mcp:ai:read", "mcp:decisions:read"],
+      tenantId: "acme",
+    });
+    const requester = await authenticateMcpRequest(store, SECRET, issued.accessToken);
+
+    const listed = await runtime.callTool(requester, "oke.ai.runs.list", {});
+    expect(listed.ok).toBe(true);
+    if (!listed.ok) return;
+    const runs = (listed.data.content as { runs: { id: string }[] }).runs;
+    expect(runs.map((row) => row.id)).toEqual(["run-a"]);
+
+    const foreign = await runtime.callTool(requester, "oke.ai.runs.get", { runId: "run-b" });
+    expect(foreign.ok).toBe(false);
+    const namedOther = await runtime.callTool(requester, "oke.ai.runs.list", { tenant: "other" });
+    expect(namedOther.ok).toBe(true);
+    if (!namedOther.ok) return;
+    expect((namedOther.data.content as { runs: unknown[] }).runs).toEqual([]);
+    expect(foreign.ok).toBe(false);
+
+    const got = await runtime.callTool(requester, "oke.ai.runs.get", {
+      runId: "run-a",
+      tenant: "acme",
+    });
+    expect(got.ok).toBe(true);
+    if (!got.ok) return;
+    expect((got.data.content as { events: { seq: number }[] }).events[0]?.seq).toBe(1);
+
+    const approvals = await runtime.callTool(requester, "oke.ai.approvals.list", {
+      tenant: "acme",
+    });
+    expect(approvals.ok).toBe(true);
+    if (!approvals.ok) return;
+    expect(
+      (approvals.data.content as { rows: { id: string }[] }).rows.map((row) => row.id),
+    ).toEqual(["a"]);
+
+    const decisions = await runtime.callTool(requester, "oke.decisions.list", {});
+    expect(decisions.ok).toBe(true);
+    if (!decisions.ok) return;
+    expect(
+      (decisions.data.content as { decisions: { name: string }[] }).decisions.map(
+        (row) => row.name,
+      ),
+    ).toEqual(["triage"]);
+
+    const operatorIssued = await mintMcpSession({
+      store,
+      secret: SECRET,
+      principalId: "root",
+      scopes: ["mcp:*"],
+    });
+    const operator = await authenticateMcpRequest(store, SECRET, operatorIssued.accessToken);
+    const allRuns = await runtime.callTool(operator, "oke.ai.runs.list", {});
+    expect(allRuns.ok).toBe(true);
+    if (!allRuns.ok) return;
+    expect((allRuns.data.content as { runs: { id: string }[] }).runs.map((row) => row.id)).toEqual([
+      "run-a",
+      "run-b",
+    ]);
+    const otherApprovals = await runtime.callTool(operator, "oke.ai.approvals.list", {
+      tenant: "other",
+    });
+    expect(otherApprovals.ok).toBe(true);
+    if (!otherApprovals.ok) return;
+    expect(
+      (otherApprovals.data.content as { rows: { id: string }[] }).rows.map((row) => row.id),
+    ).toEqual(["b"]);
+  });
+
+  test("every AI tool masks PII fields and redacted secrets", async () => {
+    const secret = Redacted.of("sk-live");
+    const manifest = {
+      oke: "1.0",
+      app: "skyport",
+      stores: {
+        app: {
+          tables: {
+            people: { columns: { email: { pii: true }, apiKey: { sensitive: true } } },
+          },
+        },
+      },
+    } as unknown as Manifest;
+    const ctx: McpContext = {
+      getManifest: () => manifest,
+      listRuns: async () => [],
+      listAgentRuns: async () => [
+        {
+          id: "run-a",
+          tenant: "acme",
+          args: { email: "a@b.co", apiKey: secret },
+          trail: [{ args: { email: "a@b.co" } }],
+        },
+      ],
+      getAgentRun: async () => ({
+        run: { id: "run-a", tenant: "acme", args: { email: "a@b.co", apiKey: secret } },
+        events: [{ seq: 1, event: { type: "CUSTOM", value: { email: "a@b.co", apiKey: secret } } }],
+      }),
+      listApprovals: async () => [
+        { id: "a", tenant: "acme", args: { email: "a@b.co", apiKey: secret } },
+      ],
+      listDecisions: async () => [
+        { name: "triage", tenant: "acme", input: { email: "a@b.co", apiKey: secret } },
+      ],
+    };
+    const runtime = createToolRuntime(ctx);
+    const store = createSessionStore();
+    const issued = await mintMcpSession({
+      store,
+      secret: SECRET,
+      principalId: "op",
+      scopes: ["mcp:ai:read", "mcp:decisions:read"],
+      tenantId: "acme",
+    });
+    const requester = await authenticateMcpRequest(store, SECRET, issued.accessToken);
+    const blobs = [
+      await runtime.callTool(requester, "oke.ai.runs.list", {}),
+      await runtime.callTool(requester, "oke.ai.runs.get", { runId: "run-a" }),
+      await runtime.callTool(requester, "oke.ai.approvals.list", {}),
+      await runtime.callTool(requester, "oke.decisions.list", {}),
+    ];
+    for (const result of blobs) {
+      expect(result.ok).toBe(true);
+      if (!result.ok) continue;
+      const text = JSON.stringify(result.data.content);
+      expect(text).not.toContain("a@b.co");
+      expect(text).not.toContain("sk-live");
+      expect(text).toContain("[redacted]");
+    }
+  });
+});

package/src/mcp/authorization.ts

@@ -133,6 +133,72 @@ export const MCP_TOOL_POLICIES: readonly McpToolPolicy[] = [
     },
     params: [{ name: "runId", maxLength: 128 }],
   },
+  {
+    name: "oke.ai.runs.list",
+    scopes: ["mcp:ai:read", "console:runs:read"],
+    mutability: "read",
+    description: "List agent runs as inert data. Approvals stay in the Console.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "integer", minimum: 1, maximum: 200 },
+        tenant: { type: "string" },
+      },
+      additionalProperties: false,
+    },
+    params: [
+      { name: "limit", maxLength: 3 },
+      { name: "tenant", maxLength: 128 },
+    ],
+  },
+  {
+    name: "oke.ai.runs.get",
+    scopes: ["mcp:ai:read", "console:runs:read"],
+    mutability: "read",
+    description: "Return one agent run record and its follow events as inert data.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: { type: "string", minLength: 1 },
+        tenant: { type: "string" },
+      },
+      required: ["runId"],
+      additionalProperties: false,
+    },
+    params: [
+      { name: "runId", maxLength: 128 },
+      { name: "tenant", maxLength: 128 },
+    ],
+  },
+  {
+    name: "oke.ai.approvals.list",
+    scopes: ["mcp:ai:read", "console:runs:read"],
+    mutability: "read",
+    description: "List pending tool approvals as inert data. Resolve stays in the Console.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tenant: { type: "string" },
+      },
+      additionalProperties: false,
+    },
+    params: [{ name: "tenant", maxLength: 128 }],
+  },
+  {
+    name: "oke.decisions.list",
+    scopes: ["mcp:decisions:read", "console:runs:read"],
+    mutability: "read",
+    description:
+      "List decisions with state, pending count, certificate metrics, and drift. Promote stays in the CLI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tenant: { type: "string" },
+      },
+      additionalProperties: false,
+    },
+    params: [{ name: "tenant", maxLength: 128 }],
+  },
   {
     name: "oke.action.invoke",
     scopes: ["mcp:action:invoke", "console:flows:invoke"],

package/src/mcp/docs-server.ts

@@ -16,7 +16,9 @@ import { asData } from "./data.ts";
 import { defaultDocsContentDir, loadDocsIndex, type DocsIndex } from "./docs-index.ts";
 import { createDocsToolRuntime } from "./docs-tools.ts";
 import {
-  MCP_PROTOCOL_VERSION,
+  acceptsMcpProtocolVersion,
+  negotiateMcpProtocolVersion,
+  protocolVersionOf,
   parseJsonRpcRequest,
   parseToolsCallParams,
   rpcError,
@@ -94,10 +96,18 @@ export async function createDocsMcpServer(
 
     switch (rpc.method) {
       case "initialize": {
+        const requested = protocolVersionOf(rpc.params);
+        const protocolVersion = negotiateMcpProtocolVersion(requested);
+        if (protocolVersion === undefined) {
+          return jsonRpcHttp(
+            rpcError(id, RpcErrorCode.invalidParams, "unsupported protocol version"),
+            400,
+          );
+        }
         const sessionId = newMcpTransportSessionId();
         transportSessions.add(sessionId);
         const result: McpInitializeResult = {
-          protocolVersion: MCP_PROTOCOL_VERSION,
+          protocolVersion,
           capabilities: { tools: { listChanged: false } },
           serverInfo: { name: "okengine-docs-mcp", version },
           sessionId,
@@ -124,6 +134,13 @@ export async function createDocsMcpServer(
         );
       }
       case "tools/call": {
+        const requested = protocolVersionOf(rpc.params);
+        if (requested !== undefined && !acceptsMcpProtocolVersion(requested)) {
+          return jsonRpcHttp(
+            rpcError(id, RpcErrorCode.invalidParams, "unsupported protocol version"),
+            400,
+          );
+        }
         const call = parseToolsCallParams(rpc.params);
         if (!call.ok) {
           return jsonRpcHttp(rpcError(id, RpcErrorCode.invalidParams, call.message), 400);