@get-bb/plugin-sdk 0.4.6 → 0.4.8

package/dist/testing/index.js

@@ -5,13 +5,18 @@ import { join } from "node:path";
 import Database from "better-sqlite3";
 import { CronExpressionParser } from "cron-parser";
 import { Hono } from "hono";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // ../domain/src/plugin-interaction-limits.ts
 var PLUGIN_INTERACTION_MAX_TITLE_LENGTH = 160;
 
 // src/internal/host-policy.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
+
+// ../domain/src/plugin-icon.ts
+function isPluginOwnedIconPath(icon) {
+  return icon.startsWith("./");
+}
 
 // ../domain/src/plugin-cli.ts
 var RESERVED_BB_CLI_COMMANDS = [
@@ -28,6 +33,11 @@ var RESERVED_BB_CLI_COMMANDS = [
   "thread"
 ];
 
+// ../domain/src/provider-fork.ts
+import { z } from "zod";
+var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
+var providerForkSchema = z.enum(PROVIDER_FORK_VALUES);
+
 // src/backend-contract.ts
 var PLUGIN_CLI_OUTPUT_MAX_BYTES = 1024 * 1024;
 
@@ -55,33 +65,34 @@ var PLUGIN_AGENT_SELECTION_MAX_IDS = 256;
 var PLUGIN_AGENT_DYNAMIC_INSTRUCTIONS_MAX_CHARS = 4096;
 var PLUGIN_AGENT_TOOL_PARAMETERS_MAX_BYTES = 128 * 1024;
 var MENTION_PROVIDER_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,63}$/;
 var SETTING_KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var settingsBaseFields = {
-  label: z.string().min(1),
-  description: z.string().min(1).optional()
+  label: z2.string().min(1),
+  description: z2.string().min(1).optional()
 };
-var settingDescriptorSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("string"),
+var settingDescriptorSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("string"),
     ...settingsBaseFields,
-    secret: z.literal(true).optional(),
-    default: z.string().optional()
+    secret: z2.literal(true).optional(),
+    default: z2.string().optional()
   }).strict(),
-  z.object({
-    type: z.literal("boolean"),
+  z2.object({
+    type: z2.literal("boolean"),
     ...settingsBaseFields,
-    default: z.boolean().optional()
+    default: z2.boolean().optional()
   }).strict(),
-  z.object({
-    type: z.literal("select"),
+  z2.object({
+    type: z2.literal("select"),
     ...settingsBaseFields,
-    options: z.array(z.string().min(1)).min(1),
-    default: z.string().optional()
+    options: z2.array(z2.string().min(1)).min(1),
+    default: z2.string().optional()
   }).strict(),
-  z.object({
-    type: z.literal("project"),
+  z2.object({
+    type: z2.literal("project"),
     ...settingsBaseFields,
-    default: z.string().optional()
+    default: z2.string().optional()
   }).strict()
 ]);
 function registerSettingDescriptors(target, added) {
@@ -186,6 +197,171 @@ function normalizeMentionProviderTriggers(providerId, triggers) {
   }
   return normalized;
 }
+var PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS = 80;
+var PLUGIN_PROVIDER_PERMISSION_MODE_VALUES = [
+  "accept-edits",
+  "auto",
+  "full"
+];
+var PLUGIN_PROVIDER_REASONING_LEVEL_VALUES = [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "ultracode",
+  "max",
+  "ultra"
+];
+var PLUGIN_PROVIDER_COMPOSER_ACTION_VALUES = [
+  "plan",
+  "goal"
+];
+function validateProviderRelativePath(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`provider ${label} must be a non-blank relative path`);
+  }
+  if (value.includes("\\")) {
+    throw new Error(
+      `provider ${label} must use "/" separators, got ${JSON.stringify(value)}`
+    );
+  }
+  if (value.startsWith("/")) {
+    throw new Error(
+      `provider ${label} must be relative, got ${JSON.stringify(value)}`
+    );
+  }
+  if (value.split("/").some((segment) => segment === "..")) {
+    throw new Error(
+      `provider ${label} must not escape the plugin directory, got ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
+function validateProviderLiteralArray(args) {
+  const { providerId, field, value, allowed, requireNonEmpty } = args;
+  if (!Array.isArray(value)) {
+    throw new Error(`provider "${providerId}" ${field} must be an array`);
+  }
+  if (requireNonEmpty && value.length === 0) {
+    throw new Error(
+      `provider "${providerId}" ${field} must include at least one entry`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || !allowed.includes(entry)) {
+      throw new Error(
+        `provider "${providerId}" ${field} entry ${JSON.stringify(entry)} is invalid; use one of ${allowed.join(", ")}`
+      );
+    }
+    const literal = entry;
+    if (seen.has(literal)) {
+      throw new Error(
+        `provider "${providerId}" ${field} entry ${JSON.stringify(entry)} is duplicated`
+      );
+    }
+    seen.add(literal);
+    normalized.push(literal);
+  }
+  return Object.freeze(normalized);
+}
+function validatePluginProviderDeclaration(declaration) {
+  if (typeof declaration !== "object" || declaration === null) {
+    throw new Error("provider declaration must be an object");
+  }
+  const id = declaration.id;
+  if (typeof id !== "string" || !PROVIDER_ID_PATTERN.test(id)) {
+    throw new Error(
+      `invalid provider id ${JSON.stringify(id)} \u2014 use 2-64 lowercase letters, digits, and "-", starting with a letter or digit`
+    );
+  }
+  const displayName = typeof declaration.displayName === "string" ? declaration.displayName.trim() : "";
+  if (displayName.length === 0 || displayName.length > PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS) {
+    throw new Error(
+      `provider "${id}" displayName must be 1-${PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS} non-blank characters`
+    );
+  }
+  let icon;
+  if (declaration.icon !== void 0) {
+    if (typeof declaration.icon !== "string" || declaration.icon.trim() === "") {
+      throw new Error(
+        `provider "${id}" icon must be a non-blank string \u2014 a named host glyph ("Zap") or a plugin-relative path ("./icons/agent.svg")`
+      );
+    }
+    if (isPluginOwnedIconPath(declaration.icon)) {
+      icon = validateProviderRelativePath(declaration.icon, `"${id}" icon`);
+    } else if (/[/\\]/u.test(declaration.icon)) {
+      throw new Error(
+        `provider "${id}" icon looks like a path but does not start with "./" \u2014 use "./icons/agent.svg" for a plugin file, or a bare host glyph name like "Zap"`
+      );
+    } else {
+      icon = declaration.icon;
+    }
+  }
+  const capabilities = declaration.capabilities;
+  if (typeof capabilities !== "object" || capabilities === null) {
+    throw new Error(`provider "${id}" capabilities must be an object`);
+  }
+  const booleanCapabilityFields = [
+    "supportsServiceTier",
+    "supportsNativeUserQuestion",
+    "supportsManualCompaction",
+    "supportsThreadArchive",
+    "supportsThreadRename",
+    "supportsWorkflows"
+  ];
+  for (const field of booleanCapabilityFields) {
+    if (typeof capabilities[field] !== "boolean") {
+      throw new Error(
+        `provider "${id}" capabilities.${field} must be a boolean`
+      );
+    }
+  }
+  if (!PROVIDER_FORK_VALUES.includes(capabilities.fork)) {
+    throw new Error(
+      `provider "${id}" capabilities.fork must be one of ${PROVIDER_FORK_VALUES.join(", ")}`
+    );
+  }
+  const normalizedCapabilities = Object.freeze({
+    supportsServiceTier: capabilities.supportsServiceTier,
+    supportsNativeUserQuestion: capabilities.supportsNativeUserQuestion,
+    fork: capabilities.fork,
+    supportsManualCompaction: capabilities.supportsManualCompaction,
+    supportsThreadArchive: capabilities.supportsThreadArchive,
+    supportsThreadRename: capabilities.supportsThreadRename,
+    supportsWorkflows: capabilities.supportsWorkflows,
+    permissionModes: validateProviderLiteralArray({
+      providerId: id,
+      field: "capabilities.permissionModes",
+      value: capabilities.permissionModes,
+      allowed: PLUGIN_PROVIDER_PERMISSION_MODE_VALUES,
+      requireNonEmpty: true
+    }),
+    reasoningLevels: validateProviderLiteralArray({
+      providerId: id,
+      field: "capabilities.reasoningLevels",
+      value: capabilities.reasoningLevels,
+      allowed: PLUGIN_PROVIDER_REASONING_LEVEL_VALUES,
+      requireNonEmpty: true
+    })
+  });
+  const composerActions = validateProviderLiteralArray({
+    providerId: id,
+    field: "composerActions",
+    value: declaration.composerActions,
+    allowed: PLUGIN_PROVIDER_COMPOSER_ACTION_VALUES,
+    requireNonEmpty: false
+  });
+  return Object.freeze({
+    id,
+    displayName,
+    ...icon === void 0 ? {} : { icon },
+    capabilities: normalizedCapabilities,
+    composerActions
+  });
+}
 function isStandardSchema(value) {
   if (typeof value !== "object" || value === null) return false;
   const standard = Reflect.get(value, "~standard");
@@ -214,6 +390,143 @@ function readRpcMethodContract(method, value) {
 function isZodSchemaLike(value) {
   return typeof value === "object" && value !== null && typeof value.safeParse === "function";
 }
+var SINGLE_SCHEMA_KEYWORDS = [
+  "additionalItems",
+  "additionalProperties",
+  "contains",
+  "contentSchema",
+  "else",
+  "if",
+  "items",
+  "not",
+  "propertyNames",
+  "then",
+  "unevaluatedItems",
+  "unevaluatedProperties"
+];
+var SCHEMA_ARRAY_KEYWORDS = [
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "prefixItems"
+];
+var SCHEMA_MAP_KEYWORDS = [
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  "patternProperties",
+  "properties"
+];
+function isJsonSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeJsonPointerToken(token) {
+  return token.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function resolveLocalJsonSchemaReference(document, anchors, reference) {
+  if (!reference.startsWith("#")) return void 0;
+  let pointer;
+  try {
+    pointer = decodeURIComponent(reference.slice(1));
+  } catch {
+    return void 0;
+  }
+  if (pointer.length === 0) return document;
+  if (!pointer.startsWith("/")) return anchors.get(pointer);
+  let current = document;
+  for (const encodedToken of pointer.slice(1).split("/")) {
+    const token = decodeJsonPointerToken(encodedToken);
+    if (Array.isArray(current)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) return void 0;
+      current = current[Number(token)];
+      continue;
+    }
+    if (!isJsonSchemaObject(current) || !Object.hasOwn(current, token)) {
+      return void 0;
+    }
+    current = current[token];
+  }
+  return current;
+}
+function forEachJsonSchemaChild(schema, visit) {
+  for (const keyword of SINGLE_SCHEMA_KEYWORDS) {
+    const child = schema[keyword];
+    if (Array.isArray(child)) {
+      for (const entry of child) visit(entry);
+    } else {
+      visit(child);
+    }
+  }
+  for (const keyword of SCHEMA_ARRAY_KEYWORDS) {
+    const children = schema[keyword];
+    if (!Array.isArray(children)) continue;
+    for (const child of children) visit(child);
+  }
+  for (const keyword of SCHEMA_MAP_KEYWORDS) {
+    const children = schema[keyword];
+    if (!isJsonSchemaObject(children)) continue;
+    for (const child of Object.values(children)) visit(child);
+  }
+  const dependencies = schema.dependencies;
+  if (isJsonSchemaObject(dependencies)) {
+    for (const dependency of Object.values(dependencies)) {
+      if (!Array.isArray(dependency)) visit(dependency);
+    }
+  }
+}
+function assertNoRecursiveJsonSchemaReferences(schema, subject) {
+  if (!isJsonSchemaObject(schema)) return;
+  const document = schema;
+  const anchors = /* @__PURE__ */ new Map();
+  const indexed = /* @__PURE__ */ new Set();
+  function indexAnchors(candidate) {
+    if (!isJsonSchemaObject(candidate) || indexed.has(candidate)) return;
+    indexed.add(candidate);
+    for (const keyword of ["$anchor", "$dynamicAnchor"]) {
+      const anchor = candidate[keyword];
+      if (typeof anchor === "string") anchors.set(anchor, candidate);
+    }
+    for (const keyword of ["$id", "id"]) {
+      const id = candidate[keyword];
+      if (typeof id === "string" && /^#[^/]+$/.test(id)) {
+        anchors.set(id.slice(1), candidate);
+      }
+    }
+    forEachJsonSchemaChild(candidate, indexAnchors);
+  }
+  indexAnchors(document);
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(candidate, viaReference) {
+    if (typeof candidate === "boolean" || !isJsonSchemaObject(candidate)) {
+      return;
+    }
+    if (visiting.has(candidate)) {
+      throw new Error(
+        `${subject} contains recursive JSON Schema ${viaReference?.keyword ?? "$ref"} ${JSON.stringify(viaReference?.value ?? "#")}`
+      );
+    }
+    if (visited.has(candidate)) return;
+    visiting.add(candidate);
+    for (const keyword of ["$ref", "$recursiveRef", "$dynamicRef"]) {
+      const reference = candidate[keyword];
+      if (typeof reference === "string" && reference.startsWith("#")) {
+        const target = resolveLocalJsonSchemaReference(
+          document,
+          anchors,
+          reference
+        );
+        if (target !== void 0) {
+          visit(target, { keyword, value: reference });
+        }
+      }
+    }
+    forEachJsonSchemaChild(candidate, visit);
+    visiting.delete(candidate);
+    visited.add(candidate);
+  }
+  visit(schema);
+}
 function summarizeParseIssues(error) {
   const issues = error?.issues;
   if (Array.isArray(issues) && issues.length > 0) {
@@ -244,6 +557,56 @@ function enforcePluginCliOutputLimit(result, jsonOutput) {
     error
   } : { exitCode: 1, stdout: "", stderr: error.message, error };
 }
+function adoptHttpRouteResponse(value) {
+  if (value instanceof Response) return value;
+  if (!isResponseLike(value)) {
+    throw new Error("http route handler must return a Response");
+  }
+  const status = value.status;
+  const isNullBodyStatus = status === 101 || status === 204 || status === 205 || status === 304;
+  const init = {
+    status,
+    statusText: typeof value.statusText === "string" ? value.statusText : "",
+    headers: new Headers(value.headers)
+  };
+  if (isNullBodyStatus || value.body === null) {
+    return new Response(null, init);
+  }
+  return new Response(adoptBodyStream(value), init);
+}
+function adoptBodyStream(value) {
+  const source = value.body;
+  if (!isReadableStreamLike(source)) {
+    return new ReadableStream({
+      async start(controller) {
+        controller.enqueue(new Uint8Array(await value.arrayBuffer()));
+        controller.close();
+      }
+    });
+  }
+  const reader = source.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value: chunk } = await reader.read();
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(chunk);
+    },
+    async cancel(reason) {
+      await reader.cancel(reason);
+    }
+  });
+}
+function isReadableStreamLike(value) {
+  return value !== null && typeof value === "object" && typeof value.getReader === "function";
+}
+function isResponseLike(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.status === "number" && typeof candidate.headers === "object" && candidate.headers !== null && typeof candidate.arrayBuffer === "function" && typeof candidate.clone === "function";
+}
 
 // src/testing/fake-sdk.ts
 function withSpawnAttribution(pluginId, args) {
@@ -540,6 +903,10 @@ function normalizeAgentToolParameters(args) {
       `configure() output.tools[${index}].parameters must have root type "object"`
     );
   }
+  assertNoRecursiveJsonSchemaReferences(
+    parameters,
+    `configure() output.tools[${index}].parameters`
+  );
   return parameters;
 }
 function normalizeAgentConfigurationIds(args) {
@@ -929,6 +1296,7 @@ function createFakePluginHostInternal(options, sharedState) {
     }
   };
   const agentTools = [];
+  const providerRegistrations = [];
   let agentConfigurationProvider = null;
   let instructionProvider = null;
   const agents = {
@@ -956,6 +1324,25 @@ function createFakePluginHostInternal(options, sharedState) {
       }
       instructionProvider = provider;
     },
+    experimental_registerProvider(declaration) {
+      assertLive();
+      const normalized = validatePluginProviderDeclaration(declaration);
+      if (providerRegistrations.some((existing) => existing.id === normalized.id)) {
+        throw new Error(
+          `Provider "${normalized.id}" is already registered; a plugin cannot shadow an existing provider.`
+        );
+      }
+      providerRegistrations.push(normalized);
+      let disposed2 = false;
+      const dispose = () => {
+        if (disposed2) return;
+        disposed2 = true;
+        const index = providerRegistrations.indexOf(normalized);
+        if (index !== -1) providerRegistrations.splice(index, 1);
+      };
+      disposeHooks.push(dispose);
+      return { dispose };
+    },
     registerTool(tool) {
       assertLive();
       const name = tool?.name;
@@ -1001,7 +1388,7 @@ function createFakePluginHostInternal(options, sharedState) {
       let parse;
       if (isZodSchemaLike(parameters)) {
         try {
-          inputSchema = z2.toJSONSchema(parameters, {
+          inputSchema = z3.toJSONSchema(parameters, {
             io: "input"
           });
         } catch (error) {
@@ -1028,6 +1415,10 @@ function createFakePluginHostInternal(options, sharedState) {
           `tool "${name}" parameters must be a zod schema or a JSON-schema object`
         );
       }
+      assertNoRecursiveJsonSchemaReferences(
+        inputSchema,
+        `tool "${name}" parameters`
+      );
       const record = {
         name,
         description: tool.description,
@@ -1182,7 +1573,90 @@ function createFakePluginHostInternal(options, sharedState) {
     });
   }
   const sharedPortDeclarations = [];
+  const hostRpcCalls = [];
+  const hostWorkerExitSubscriptions = [];
+  const hostSignalSubscriptions = [];
   const hosts = {
+    experimental_client({ contract, experimental_signals }) {
+      return {
+        async call(method, input, callOptions) {
+          assertLive();
+          const methodContract = contract[method];
+          if (methodContract === void 0) {
+            throw new Error(`unknown host rpc method "${String(method)}"`);
+          }
+          if (typeof callOptions !== "object" || callOptions === null || typeof callOptions.hostId !== "string" || callOptions.hostId.length === 0) {
+            throw new Error(
+              `host rpc method "${String(method)}" requires a host id`
+            );
+          }
+          if (callOptions.signal?.aborted) {
+            throw Object.assign(new Error("Host plugin call was cancelled"), {
+              name: "AbortError"
+            });
+          }
+          const validatedInput = normalizeRpcJsonResult(
+            await validateRpcValue(methodContract.input, input, "input")
+          );
+          const call = {
+            method: String(method),
+            input: validatedInput,
+            hostId: callOptions.hostId,
+            ...callOptions.signal === void 0 ? {} : { signal: callOptions.signal }
+          };
+          hostRpcCalls.push(call);
+          if (options.experimental_callHostRpc === void 0) {
+            throw new Error(
+              `fake plugin host has no experimental_callHostRpc stub for "${String(method)}"`
+            );
+          }
+          const rawOutput = await options.experimental_callHostRpc(call);
+          const validatedOutput = await validateRpcValue(
+            methodContract.output,
+            rawOutput,
+            "output"
+          );
+          return normalizeRpcJsonResult(validatedOutput);
+        },
+        experimental_onWorkerExit(handler) {
+          assertLive();
+          if (typeof handler !== "function") {
+            throw new Error("host worker exit subscription requires a handler");
+          }
+          hostWorkerExitSubscriptions.push(handler);
+          let subscribed = true;
+          return () => {
+            if (!subscribed) return;
+            subscribed = false;
+            const index = hostWorkerExitSubscriptions.indexOf(handler);
+            if (index >= 0) hostWorkerExitSubscriptions.splice(index, 1);
+          };
+        },
+        experimental_onSignal(signal, handler) {
+          assertLive();
+          const descriptor = experimental_signals?.[signal];
+          if (typeof signal !== "string" || signal.length === 0 || typeof descriptor !== "object" || descriptor === null || !isStandardSchema(descriptor.payload)) {
+            throw new Error(`unknown host signal "${String(signal)}"`);
+          }
+          if (typeof handler !== "function") {
+            throw new Error("host signal subscription requires a handler");
+          }
+          const record = {
+            signal,
+            payloadSchema: descriptor.payload,
+            handler
+          };
+          hostSignalSubscriptions.push(record);
+          let subscribed = true;
+          return () => {
+            if (!subscribed) return;
+            subscribed = false;
+            const index = hostSignalSubscriptions.indexOf(record);
+            if (index >= 0) hostSignalSubscriptions.splice(index, 1);
+          };
+        }
+      };
+    },
     async ensureSharedPortTunnel(hostId) {
       assertLive();
       if (hostId.trim().length === 0) {
@@ -1289,6 +1763,8 @@ function createFakePluginHostInternal(options, sharedState) {
     if (cleanupStorage) {
       rmSync(storageRoot, { recursive: true, force: true });
     }
+    hostWorkerExitSubscriptions.splice(0);
+    hostSignalSubscriptions.splice(0);
     invalidated = true;
   }
   const harness = {
@@ -1306,6 +1782,7 @@ function createFakePluginHostInternal(options, sharedState) {
     realtimeSignals,
     needsConfigurationMessages,
     sharedPortDeclarations,
+    experimental_hostRpcCalls: hostRpcCalls,
     sdk: sdkHarness,
     registrations: {
       settingsDescriptors,
@@ -1335,7 +1812,8 @@ function createFakePluginHostInternal(options, sharedState) {
           "thread.deleted": threadEventHandlers["thread.deleted"].length
         };
       },
-      mentionProviders
+      mentionProviders,
+      providerRegistrations
     },
     get pendingInteractions() {
       return [...pendingInteractions].map(([id, pending]) => ({
@@ -1343,6 +1821,35 @@ function createFakePluginHostInternal(options, sharedState) {
         ...pending.request
       }));
     },
+    async experimental_emitHostWorkerExit(hostId) {
+      assertLive();
+      if (hostId.trim().length === 0) {
+        throw new Error("host worker exit hostId must be non-empty");
+      }
+      for (const handler of [...hostWorkerExitSubscriptions]) {
+        await handler({ hostId });
+      }
+    },
+    async experimental_emitHostSignal(hostId, signal, payload) {
+      assertLive();
+      if (hostId.trim().length === 0) {
+        throw new Error("host signal hostId must be non-empty");
+      }
+      const subscriptions = hostSignalSubscriptions.filter(
+        (subscription) => subscription.signal === signal
+      );
+      for (const subscription of subscriptions) {
+        const normalized = normalizeRpcJsonResult(
+          await validateRpcValue(subscription.payloadSchema, payload, "input")
+        );
+        const parsed = await validateRpcValue(
+          subscription.payloadSchema,
+          normalized,
+          "input"
+        );
+        await subscription.handler({ hostId, payload: parsed });
+      }
+    },
     submitInteraction(id, value) {
       const pending = pendingInteractions.get(id);
       if (!pending) throw new Error(`no pending interaction "${id}"`);
@@ -1455,11 +1962,7 @@ function createFakePluginHostInternal(options, sharedState) {
       const app = new Hono();
       app.on(route.method, route.path, async (context) => {
         try {
-          const response = await route.handler(context);
-          if (!(response instanceof Response)) {
-            throw new Error("http route handler must return a Response");
-          }
-          return response;
+          return adoptHttpRouteResponse(await route.handler(context));
         } catch (error) {
           const message = errorMessage(error);
           emitLog(