@get-bb/plugin-sdk 0.4.88 → 0.4.94

package/dist/testing/index.js

@@ -1456,6 +1456,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(
@@ -1474,7 +1479,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";
@@ -2140,13 +2197,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));
@@ -2174,6 +2232,7 @@ function normalizeRpcRegistration(contract, handlers, registered) {
     pending.push([
       name,
       {
+        publication: publishRpcMethod(name, methodContract, publicationOptions),
         inputSchema: methodContract.input,
         outputSchema: methodContract.output,
         handler
@@ -3045,12 +3104,13 @@ function createFakePluginHostInternal(options, sharedState) {
   };
   const rpcHandlers = /* @__PURE__ */ new Map();
   const rpc = {
-    register(contract, handlers) {
+    register(contract, handlers, registrationOptions) {
       assertLive();
       for (const [name, record] of normalizeRpcRegistration(
         contract,
         handlers,
-        rpcHandlers
+        rpcHandlers,
+        registrationOptions
       )) {
         rpcHandlers.set(name, record);
       }
@@ -3642,6 +3702,11 @@ function createFakePluginHostInternal(options, sharedState) {
       settingsDescriptors,
       httpRoutes,
       websocketRoutes,
+      get experimental_publishedRpcMethods() {
+        return [...rpcHandlers.values()].flatMap(
+          (record) => record.publication === null ? [] : [record.publication]
+        );
+      },
       get rpcMethods() {
         return [...rpcHandlers.keys()];
       },
@@ -4251,6 +4316,7 @@ function makeMessageDispatchHookContext(overrides = {}) {
     },
     attempt: "start-turn",
     queuedMessage: null,
+    experimental_submission: null,
     origin: null,
     originPluginId: null,
     startedOnBehalfOf: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-bb/plugin-sdk",
-  "version": "0.4.88",
+  "version": "0.4.94",
   "homepage": "https://github.com/get-bb/bb#readme",
   "bugs": {
     "url": "https://github.com/get-bb/bb/issues"