@vellumai/assistant 0.12.0-staging.1 → 0.12.0

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -93,9 +93,34 @@ export const CHANNEL_BOT_PROVIDER = {
  * connected" question, for any provider key.
  */
 export function isChannelBotProvider(providerKey: string): boolean {
-  return (Object.values(CHANNEL_BOT_PROVIDER) as readonly string[]).includes(
-    providerKey,
-  );
+  return channelForBotProvider(providerKey) !== undefined;
+}
+
+/**
+ * The provider key holding a channel's bot credential, or `undefined` when
+ * the channel has none, or is not a channel at all. Walks the map's own
+ * entries, so an inherited object property name is never a channel.
+ */
+export function botProviderForChannel(channelId: string): string | undefined {
+  return Object.entries(CHANNEL_BOT_PROVIDER).find(
+    ([id]) => id === channelId,
+  )?.[1];
+}
+
+/**
+ * The channel whose bot credential a provider key holds, or `undefined` when
+ * the key is not a bot's. The inverse of `botProviderForChannel`, for a
+ * surface that has only the provider key in hand and needs to speak in the
+ * channel's vocabulary.
+ */
+export function channelForBotProvider(
+  providerKey: string,
+): keyof typeof CHANNEL_BOT_PROVIDER | undefined {
+  return (
+    Object.entries(CHANNEL_BOT_PROVIDER) as Array<
+      [keyof typeof CHANNEL_BOT_PROVIDER, string]
+    >
+  ).find(([, key]) => key === providerKey)?.[0];
 }
 
 /**

package/node_modules/@vellumai/gateway-client/src/__tests__/plugin-admission-denied-contract.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from "bun:test";
 import {
   ACCESS_DENIED_NOT_APPROVED_REPLY,
   PLUGIN_ADMISSION_DENIED_NOTICE_PATH,
+  PLUGIN_NOTICES_ROUTE_PREFIX,
   PluginAdmissionDeniedNoticeSchema,
 } from "../plugin-admission-denied-contract.js";
 
@@ -19,6 +20,15 @@ describe("plugin admission-denied contract", () => {
     );
   });
 
+  test("the notice lives under the gateway-only notices prefix", () => {
+    // The runtime reserves this prefix for the gateway's service principal,
+    // so a notice posted anywhere else would be reachable by actor clients.
+    expect(PLUGIN_NOTICES_ROUTE_PREFIX).toBe("notices");
+    expect(PLUGIN_ADMISSION_DENIED_NOTICE_PATH).toStartWith(
+      `${PLUGIN_NOTICES_ROUTE_PREFIX}/`,
+    );
+  });
+
   test("round-trips a floor-deny notice", () => {
     const notice = {
       reason: "admission_floor" as const,

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -104,6 +104,7 @@ export type {
 export {
   ACCESS_DENIED_NOT_APPROVED_REPLY,
   PLUGIN_ADMISSION_DENIED_NOTICE_PATH,
+  PLUGIN_NOTICES_ROUTE_PREFIX,
   PluginAdmissionDeniedNoticeSchema,
 } from "./plugin-admission-denied-contract.js";
 

package/node_modules/@vellumai/gateway-client/src/plugin-admission-denied-contract.ts

@@ -22,10 +22,23 @@ export const ACCESS_DENIED_NOT_APPROVED_REPLY =
   "Sorry, you haven't been approved to message this assistant.";
 
 /**
- * Plugin route the gateway posts the notice to, under
+ * Prefix, under `/x/plugins/<plugin>/`, of the routes reserved for notices
+ * the gateway posts to a plugin.
+ *
+ * The runtime serves every path under it to the gateway's service principal
+ * only (`assistant/src/runtime/routes/user-routes.ts`). A notice is the
+ * gateway's own verified decision, and a plugin acts on it without running a
+ * turn, so an authenticated client must not be able to post one: a forged
+ * notice would have the plugin spend its vendor credentials on a recipient
+ * and a message the client chose.
+ */
+export const PLUGIN_NOTICES_ROUTE_PREFIX = "notices";
+
+/**
+ * Plugin route the gateway posts the admission-denied notice to, under
  * `/v1/x/plugins/<plugin>/`. Not a public ingress path.
  */
-export const PLUGIN_ADMISSION_DENIED_NOTICE_PATH = "notices/admission-denied";
+export const PLUGIN_ADMISSION_DENIED_NOTICE_PATH = `${PLUGIN_NOTICES_ROUTE_PREFIX}/admission-denied`;
 
 export const PluginAdmissionDeniedNoticeSchema = z.object({
   reason: z.literal("admission_floor"),

package/node_modules/@vellumai/service-contracts/src/__tests__/channels.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  botProviderForChannel,
   CHANNEL_BOT_PROVIDER,
   CHANNEL_IDS,
+  channelForBotProvider,
   isChannelBotProvider,
   isChannelUserIntegration,
   isChannelId,
@@ -41,6 +43,35 @@ describe("isChannelId", () => {
   });
 });
 
+describe("botProviderForChannel and channelForBotProvider", () => {
+  test("are inverses over every entry of the map", () => {
+    for (const [channelId, botProviderKey] of Object.entries(
+      CHANNEL_BOT_PROVIDER,
+    )) {
+      expect(botProviderForChannel(channelId)).toBe(botProviderKey);
+      expect(channelForBotProvider(botProviderKey)).toBe(
+        channelId as keyof typeof CHANNEL_BOT_PROVIDER,
+      );
+    }
+  });
+
+  test("answer nothing for a channel without a bot, a person's grant, or an unknown key", () => {
+    expect(botProviderForChannel("phone")).toBeUndefined();
+    expect(botProviderForChannel("vellum")).toBeUndefined();
+    expect(botProviderForChannel("not-a-channel")).toBeUndefined();
+    // `slack` is the person's integration standing beside the bot's key.
+    expect(channelForBotProvider("slack")).toBeUndefined();
+    expect(channelForBotProvider("google")).toBeUndefined();
+  });
+
+  test("never resolve an inherited object property as a channel or a key", () => {
+    for (const name of ["constructor", "toString", "__proto__"]) {
+      expect(botProviderForChannel(name)).toBeUndefined();
+      expect(channelForBotProvider(name)).toBeUndefined();
+    }
+  });
+});
+
 describe("isChannelUserIntegration", () => {
   test("names the grant standing beside a bot of the same brand", () => {
     expect(isChannelUserIntegration("slack")).toBe(true);

package/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -93,9 +93,34 @@ export const CHANNEL_BOT_PROVIDER = {
  * connected" question, for any provider key.
  */
 export function isChannelBotProvider(providerKey: string): boolean {
-  return (Object.values(CHANNEL_BOT_PROVIDER) as readonly string[]).includes(
-    providerKey,
-  );
+  return channelForBotProvider(providerKey) !== undefined;
+}
+
+/**
+ * The provider key holding a channel's bot credential, or `undefined` when
+ * the channel has none, or is not a channel at all. Walks the map's own
+ * entries, so an inherited object property name is never a channel.
+ */
+export function botProviderForChannel(channelId: string): string | undefined {
+  return Object.entries(CHANNEL_BOT_PROVIDER).find(
+    ([id]) => id === channelId,
+  )?.[1];
+}
+
+/**
+ * The channel whose bot credential a provider key holds, or `undefined` when
+ * the key is not a bot's. The inverse of `botProviderForChannel`, for a
+ * surface that has only the provider key in hand and needs to speak in the
+ * channel's vocabulary.
+ */
+export function channelForBotProvider(
+  providerKey: string,
+): keyof typeof CHANNEL_BOT_PROVIDER | undefined {
+  return (
+    Object.entries(CHANNEL_BOT_PROVIDER) as Array<
+      [keyof typeof CHANNEL_BOT_PROVIDER, string]
+    >
+  ).find(([, key]) => key === providerKey)?.[0];
 }
 
 /**