@get-bb/plugin-sdk 0.4.87 → 0.4.94

package/dist/internal/host-policy.js

@@ -1421,6 +1421,11 @@ function isStandardSchema(value) {
   const standard = Reflect.get(value, "~standard");
   return typeof standard === "object" && standard !== null && Reflect.get(standard, "version") === 1 && typeof Reflect.get(standard, "vendor") === "string" && typeof Reflect.get(standard, "validate") === "function";
 }
+var rpcDescriptionSchema = z4.string().trim().min(1).max(4096).optional().transform((value) => value ?? null);
+var rpcPublicationOptionsSchema = z4.object({
+  experimental_discoverable: z4.boolean().default(false),
+  experimental_description: rpcDescriptionSchema
+}).strict();
 function readRpcMethodContract(method, value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(
@@ -1439,7 +1444,59 @@ function readRpcMethodContract(method, value) {
       `rpc method "${method}" output must be a Standard Schema v1 validator`
     );
   }
-  return { input, output };
+  const description = rpcDescriptionSchema.parse(
+    Reflect.get(value, "experimental_description")
+  );
+  return description === null ? { input, output } : { input, output, experimental_description: description };
+}
+function readRpcPublicationOptions(value) {
+  return rpcPublicationOptionsSchema.parse(value ?? {});
+}
+function publishedRpcSchema(schema, direction) {
+  const converter = schema["~standard"].jsonSchema;
+  if (converter === void 0 || typeof converter[direction] !== "function") {
+    throw new Error(
+      "discoverable RPC requires Standard JSON Schema export support"
+    );
+  }
+  const serialized = JSON.stringify(
+    converter[direction]({ target: "draft-2020-12" })
+  );
+  if (serialized === void 0 || new TextEncoder().encode(serialized).byteLength > 128 * 1024) {
+    throw new Error("published RPC schema must be JSON and at most 128 KiB");
+  }
+  const result = z4.record(z4.string(), jsonValueSchema).parse(JSON.parse(serialized));
+  const inspect = (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) inspect(item);
+      return;
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if ((key === "$ref" || key === "$dynamicRef") && typeof item === "string" && !item.startsWith("#")) {
+        throw new Error("published RPC schemas must use local references");
+      }
+      inspect(item);
+    }
+  };
+  inspect(result);
+  return result;
+}
+function publishRpcMethod(method, contract, options) {
+  if (!options.experimental_discoverable) return null;
+  try {
+    return {
+      method,
+      registrationDescription: options.experimental_description,
+      methodDescription: contract.experimental_description ?? null,
+      inputSchema: publishedRpcSchema(contract.input, "input"),
+      outputSchema: publishedRpcSchema(contract.output, "output")
+    };
+  } catch (error) {
+    throw new Error(
+      `rpc method "${method}" cannot be published: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
 }
 function isZodSchemaLike(value) {
   return typeof value === "object" && value !== null && typeof value.safeParse === "function";
@@ -2115,13 +2172,14 @@ function normalizeWebSocketRouteRegistration(path, handler, opts, existingRoutes
   }
   return { path, auth };
 }
-function normalizeRpcRegistration(contract, handlers, registered) {
+function normalizeRpcRegistration(contract, handlers, registered, options) {
   if (typeof contract !== "object" || contract === null || Array.isArray(contract)) {
     throw new Error("rpc.register contract must be an object");
   }
   if (typeof handlers !== "object" || handlers === null || Array.isArray(handlers)) {
     throw new Error("rpc.register handlers must be an object");
   }
+  const publicationOptions = readRpcPublicationOptions(options);
   const pending = [];
   const contractEntries = Object.entries(contract);
   const contractNames = new Set(contractEntries.map(([name]) => name));
@@ -2149,6 +2207,7 @@ function normalizeRpcRegistration(contract, handlers, registered) {
     pending.push([
       name,
       {
+        publication: publishRpcMethod(name, methodContract, publicationOptions),
         inputSchema: methodContract.input,
         outputSchema: methodContract.output,
         handler
@@ -2730,6 +2789,8 @@ export {
   providerAlreadyRegisteredMessage,
   providerIconRefusalMessage,
   providerWithoutBridgeMessage,
+  publishRpcMethod,
+  readRpcPublicationOptions,
   registerSettingDescriptors,
   runPluginStorageMigrations,
   storePluginHook,