@vellumai/assistant 0.11.9-staging.2 → 0.11.9

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

@@ -97,3 +97,24 @@ export function isChannelBotProvider(providerKey: string): boolean {
     providerKey,
   );
 }
+
+/**
+ * Whether a provider key names the user grant of a brand the assistant is
+ * reached through some other way: `slack` beside `slack_channel`, `discord`
+ * beside `discord_channel`. The other half of the question
+ * `isChannelBotProvider` asks.
+ *
+ * The two halves carry the same brand name, so the grant reads as the way to
+ * connect that brand when the bot is. A surface offering people a way to
+ * connect an assistant wants the bot, and wants this to say which keys it is
+ * answering for rather than naming them itself.
+ *
+ * A channel whose bot is its own key has no such pair: `telegram` names the
+ * bot, so nothing is standing beside it to be mistaken for.
+ */
+export function isChannelUserIntegration(providerKey: string): boolean {
+  return Object.entries(CHANNEL_BOT_PROVIDER).some(
+    ([channelId, botProviderKey]) =>
+      channelId === providerKey && botProviderKey !== providerKey,
+  );
+}

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

@@ -1,6 +1,12 @@
 import { describe, expect, test } from "bun:test";
 
-import { CHANNEL_IDS, isChannelId } from "../channels.js";
+import {
+  CHANNEL_BOT_PROVIDER,
+  CHANNEL_IDS,
+  isChannelBotProvider,
+  isChannelUserIntegration,
+  isChannelId,
+} from "../channels.js";
 
 describe("isChannelId", () => {
   test("accepts every canonical channel id", () => {
@@ -34,3 +40,36 @@ describe("isChannelId", () => {
     expect(isChannelId(42)).toBe(false);
   });
 });
+
+describe("isChannelUserIntegration", () => {
+  test("names the grant standing beside a bot of the same brand", () => {
+    expect(isChannelUserIntegration("slack")).toBe(true);
+    expect(isChannelUserIntegration("discord")).toBe(true);
+  });
+
+  test("excludes a channel whose bot is its own key", () => {
+    // `telegram` names the bot, so no second provider carries the brand and
+    // there is nothing to mistake for it.
+    expect(isChannelUserIntegration("telegram")).toBe(false);
+  });
+
+  test("excludes the bots themselves and unrelated providers", () => {
+    expect(isChannelUserIntegration("slack_channel")).toBe(false);
+    expect(isChannelUserIntegration("discord_channel")).toBe(false);
+    expect(isChannelUserIntegration("google")).toBe(false);
+  });
+
+  test("is the complement of isChannelBotProvider over the map", () => {
+    // The two questions partition the brands that have both halves: a key is
+    // one or the other, never both, so a caller picking the wrong one gets an
+    // empty answer rather than a plausible wrong one.
+    for (const [channelId, botProviderKey] of Object.entries(
+      CHANNEL_BOT_PROVIDER,
+    )) {
+      expect(isChannelUserIntegration(channelId)).toBe(
+        channelId !== botProviderKey,
+      );
+      expect(isChannelBotProvider(botProviderKey)).toBe(true);
+    }
+  });
+});

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

@@ -97,3 +97,24 @@ export function isChannelBotProvider(providerKey: string): boolean {
     providerKey,
   );
 }
+
+/**
+ * Whether a provider key names the user grant of a brand the assistant is
+ * reached through some other way: `slack` beside `slack_channel`, `discord`
+ * beside `discord_channel`. The other half of the question
+ * `isChannelBotProvider` asks.
+ *
+ * The two halves carry the same brand name, so the grant reads as the way to
+ * connect that brand when the bot is. A surface offering people a way to
+ * connect an assistant wants the bot, and wants this to say which keys it is
+ * answering for rather than naming them itself.
+ *
+ * A channel whose bot is its own key has no such pair: `telegram` names the
+ * bot, so nothing is standing beside it to be mistaken for.
+ */
+export function isChannelUserIntegration(providerKey: string): boolean {
+  return Object.entries(CHANNEL_BOT_PROVIDER).some(
+    ([channelId, botProviderKey]) =>
+      channelId === providerKey && botProviderKey !== providerKey,
+  );
+}

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

@@ -1,6 +1,12 @@
 import { describe, expect, test } from "bun:test";
 
-import { CHANNEL_IDS, isChannelId } from "../channels.js";
+import {
+  CHANNEL_BOT_PROVIDER,
+  CHANNEL_IDS,
+  isChannelBotProvider,
+  isChannelUserIntegration,
+  isChannelId,
+} from "../channels.js";
 
 describe("isChannelId", () => {
   test("accepts every canonical channel id", () => {
@@ -34,3 +40,36 @@ describe("isChannelId", () => {
     expect(isChannelId(42)).toBe(false);
   });
 });
+
+describe("isChannelUserIntegration", () => {
+  test("names the grant standing beside a bot of the same brand", () => {
+    expect(isChannelUserIntegration("slack")).toBe(true);
+    expect(isChannelUserIntegration("discord")).toBe(true);
+  });
+
+  test("excludes a channel whose bot is its own key", () => {
+    // `telegram` names the bot, so no second provider carries the brand and
+    // there is nothing to mistake for it.
+    expect(isChannelUserIntegration("telegram")).toBe(false);
+  });
+
+  test("excludes the bots themselves and unrelated providers", () => {
+    expect(isChannelUserIntegration("slack_channel")).toBe(false);
+    expect(isChannelUserIntegration("discord_channel")).toBe(false);
+    expect(isChannelUserIntegration("google")).toBe(false);
+  });
+
+  test("is the complement of isChannelBotProvider over the map", () => {
+    // The two questions partition the brands that have both halves: a key is
+    // one or the other, never both, so a caller picking the wrong one gets an
+    // empty answer rather than a plausible wrong one.
+    for (const [channelId, botProviderKey] of Object.entries(
+      CHANNEL_BOT_PROVIDER,
+    )) {
+      expect(isChannelUserIntegration(channelId)).toBe(
+        channelId !== botProviderKey,
+      );
+      expect(isChannelBotProvider(botProviderKey)).toBe(true);
+    }
+  });
+});

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

@@ -97,3 +97,24 @@ export function isChannelBotProvider(providerKey: string): boolean {
     providerKey,
   );
 }
+
+/**
+ * Whether a provider key names the user grant of a brand the assistant is
+ * reached through some other way: `slack` beside `slack_channel`, `discord`
+ * beside `discord_channel`. The other half of the question
+ * `isChannelBotProvider` asks.
+ *
+ * The two halves carry the same brand name, so the grant reads as the way to
+ * connect that brand when the bot is. A surface offering people a way to
+ * connect an assistant wants the bot, and wants this to say which keys it is
+ * answering for rather than naming them itself.
+ *
+ * A channel whose bot is its own key has no such pair: `telegram` names the
+ * bot, so nothing is standing beside it to be mistaken for.
+ */
+export function isChannelUserIntegration(providerKey: string): boolean {
+  return Object.entries(CHANNEL_BOT_PROVIDER).some(
+    ([channelId, botProviderKey]) =>
+      channelId === providerKey && botProviderKey !== providerKey,
+  );
+}

package/openapi.yaml

@@ -2019,6 +2019,103 @@ paths:
                   - userId
                   - authenticated
                 additionalProperties: false
+  /v1/avatar/accent:
+    post:
+      operationId: avatar_accent_post
+      summary: Set avatar accent
+      description:
+        "Set the accent colour over the current avatar as #rrggbb, or null to return to the automatic one (the
+        character's palette colour, or the colour read out of the uploaded image)."
+      tags:
+        - avatar
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                hex:
+                  anyOf:
+                    - type: string
+                    - type: "null"
+              required:
+                - hex
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  kind:
+                    type: string
+                    enum:
+                      - character
+                      - image
+                      - none
+                  traits:
+                    anyOf:
+                      - type: object
+                        properties:
+                          bodyShape:
+                            type: string
+                          eyeStyle:
+                            type: string
+                          color:
+                            type: string
+                        required:
+                          - bodyShape
+                          - eyeStyle
+                          - color
+                        additionalProperties: false
+                      - type: "null"
+                  source:
+                    anyOf:
+                      - type: string
+                        enum:
+                          - builder
+                          - upload
+                          - ai
+                      - type: "null"
+                  image:
+                    anyOf:
+                      - type: object
+                        properties:
+                          updatedAt:
+                            type: string
+                          etag:
+                            type: string
+                        required:
+                          - updatedAt
+                          - etag
+                        additionalProperties: false
+                      - type: "null"
+                  accent:
+                    anyOf:
+                      - type: object
+                        properties:
+                          hex:
+                            type: string
+                          source:
+                            type: string
+                            enum:
+                              - palette
+                              - derived
+                              - custom
+                        required:
+                          - hex
+                          - source
+                        additionalProperties: false
+                      - type: "null"
+                required:
+                  - kind
+                  - traits
+                  - source
+                  - image
+                  - accent
+                additionalProperties: false
   /v1/avatar/character-components:
     get:
       operationId: avatar_charactercomponents_get
@@ -2390,7 +2487,7 @@ paths:
     get:
       operationId: avatar_state_get
       summary: Get avatar state
-      description: Return the authoritative avatar render mode (character, image, or none).
+      description: Return the authoritative avatar render mode (character, image, or none) and its accent colour.
       tags:
         - avatar
       responses:
@@ -2444,11 +2541,29 @@ paths:
                           - etag
                         additionalProperties: false
                       - type: "null"
+                  accent:
+                    anyOf:
+                      - type: object
+                        properties:
+                          hex:
+                            type: string
+                          source:
+                            type: string
+                            enum:
+                              - palette
+                              - derived
+                              - custom
+                        required:
+                          - hex
+                          - source
+                        additionalProperties: false
+                      - type: "null"
                 required:
                   - kind
                   - traits
                   - source
                   - image
+                  - accent
                 additionalProperties: false
   /v1/background-tools:
     get:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.9-staging.2",
+  "version": "0.11.9",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/bun-no-autoserve.test.ts

@@ -0,0 +1,178 @@
+import {
+  chmodSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+
+/**
+ * Guard for `assistant/docker-bun-no-autoserve.js`, the preload that stops
+ * `bun:main` turning a CLI whose default export has a `fetch` method into a
+ * long-lived HTTP server. The image has no Node, so `bunx <pkg>` runs such a
+ * CLI under Bun via the `node` launcher the Dockerfile installs, and without
+ * the shim the process never exits.
+ *
+ * The shim recognizes the implicit call by its `bun:main` caller frame. If a
+ * Bun upgrade renames that frame the shim fails open (every server starts for
+ * real) and these fixtures catch it.
+ */
+
+// Tests run with `assistant/` as the working directory.
+const SHIM_PATH = join(process.cwd(), "docker-bun-no-autoserve.js");
+const DOCKERFILE_PATH = join(process.cwd(), "Dockerfile");
+const LAUNCHER_PATH = join(process.cwd(), "docker-node-launcher.sh");
+const RUN_TIMEOUT_MS = 10_000;
+
+let fixtureDir: string;
+
+function writeFixture(name: string, source: string): string {
+  const path = join(fixtureDir, name);
+  writeFileSync(path, source);
+  return path;
+}
+
+async function runWithShim(
+  fixturePath: string,
+): Promise<{ exitCode: number | null; output: string }> {
+  const proc = Bun.spawn(
+    [process.execPath, `--preload=${SHIM_PATH}`, "run", fixturePath],
+    { stdout: "pipe", stderr: "pipe", windowsHide: true },
+  );
+  const timer = setTimeout(() => {
+    proc.kill();
+  }, RUN_TIMEOUT_MS);
+  try {
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    await proc.exited;
+    return { exitCode: proc.exitCode, output: `${stdout}${stderr}` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+describe("Bun auto-serve shim", () => {
+  beforeAll(() => {
+    fixtureDir = mkdtempSync(join(tmpdir(), "bun-no-autoserve-"));
+  });
+
+  afterAll(() => {
+    rmSync(fixtureDir, { recursive: true, force: true });
+  });
+
+  test("a default export with fetch exits instead of starting a server", async () => {
+    const fixture = writeFixture(
+      "auto-serve.js",
+      'export default { fetch: () => new Response("x") };\n',
+    );
+
+    const { exitCode, output } = await runWithShim(fixture);
+
+    expect(exitCode).toBe(0);
+    expect(output).not.toContain("Started ");
+  });
+
+  test("an explicit Bun.serve call still starts a real server", async () => {
+    const fixture = writeFixture(
+      "explicit-serve.js",
+      [
+        'const server = Bun.serve({ port: 0, fetch: () => new Response("x") });',
+        // Written raw so Bun's console formatting does not colorize the number.
+        'process.stdout.write("port=" + server.port + "\\n");',
+        "server.stop(true);",
+        "",
+      ].join("\n"),
+    );
+
+    const { exitCode, output } = await runWithShim(fixture);
+
+    expect(exitCode).toBe(0);
+    const port = Number(/port=(\d+)/.exec(output)?.[1]);
+    expect(port).toBeGreaterThan(0);
+  });
+
+  test("the Dockerfile installs the node launcher, which preloads the shim", () => {
+    const dockerfile = readFileSync(DOCKERFILE_PATH, "utf8");
+    const launcher = readFileSync(LAUNCHER_PATH, "utf8");
+
+    expect(dockerfile).toContain(
+      "ln -s /app/assistant/docker-node-launcher.sh /usr/local/bin/node",
+    );
+    expect(launcher).toContain(
+      "shim=/app/assistant/docker-bun-no-autoserve.js",
+    );
+    expect(launcher).toContain(
+      'exec /usr/local/bin/bun --preload="$shim" "$@"',
+    );
+  });
+});
+
+// The launcher only falls back to Bun. A Node installed after the image was
+// built (apt, or the persistent Kata apt root) has to win, or Node CLIs keep
+// running under Bun semantics forever.
+describe.skipIf(process.platform === "win32")(
+  "node launcher PATH handoff",
+  () => {
+    let binDir: string;
+
+    function writeStubNode(dir: string, marker: string): void {
+      mkdirSync(dir, { recursive: true });
+      const path = join(dir, "node");
+      writeFileSync(path, `#!/bin/sh\necho ${marker}\n`);
+      chmodSync(path, 0o755);
+    }
+
+    async function runLauncher(
+      path: string,
+    ): Promise<{ exitCode: number | null; output: string }> {
+      const proc = Bun.spawn(["/bin/sh", LAUNCHER_PATH, "--version"], {
+        env: { PATH: path },
+        stdout: "pipe",
+        stderr: "pipe",
+        windowsHide: true,
+      });
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ]);
+      await proc.exited;
+      return { exitCode: proc.exitCode, output: `${stdout}${stderr}` };
+    }
+
+    beforeAll(() => {
+      binDir = mkdtempSync(join(tmpdir(), "node-launcher-"));
+    });
+
+    afterAll(() => {
+      rmSync(binDir, { recursive: true, force: true });
+    });
+
+    test("delegates to a real node found on PATH", async () => {
+      const realDir = join(binDir, "real");
+      writeStubNode(realDir, "REAL_NODE");
+
+      const { exitCode, output } = await runLauncher(realDir);
+
+      expect(exitCode).toBe(0);
+      expect(output).toContain("REAL_NODE");
+    });
+
+    test("ignores Bun's own node shim dir", async () => {
+      const shimDir = join(binDir, "bun-node-deadbeef");
+      writeStubNode(shimDir, "BUN_SHIM");
+
+      const { output } = await runLauncher(shimDir);
+
+      // With no real node anywhere it falls through to the image's bun rather
+      // than running the shim, which is the unpreloaded Bun that hangs.
+      expect(output).not.toContain("BUN_SHIM");
+    });
+  },
+);

package/src/avatar/__tests__/avatar-manifest.test.ts

@@ -30,6 +30,7 @@ describe("avatar-manifest", () => {
         traits: VALID_TRAITS,
         source: "builder",
         image: null,
+        accent: null,
       };
       writeManifest(state, dir);
       expect(readManifest(dir)).toEqual(state);
@@ -41,6 +42,7 @@ describe("avatar-manifest", () => {
         traits: null,
         source: "upload",
         image: { updatedAt: "2024-01-01T00:00:00.000Z", etag: "abc123" },
+        accent: null,
       };
       writeManifest(state, dir);
       expect(readManifest(dir)).toEqual(state);
@@ -63,6 +65,7 @@ describe("avatar-manifest", () => {
           traits: null,
           source: null,
           image: null,
+          accent: null,
         }),
       );
       expect(readManifest(dir)).toBeNull();
@@ -81,6 +84,7 @@ describe("avatar-manifest", () => {
           traits: null,
           source: null,
           image: null,
+          accent: null,
         }),
       );
       expect(readManifest(dir)).toBeNull();
@@ -102,6 +106,7 @@ describe("avatar-manifest", () => {
           traits: { bodyShape: "round" },
           source: null,
           image: null,
+          accent: null,
         }),
       );
       expect(readManifest(dir)).toBeNull();
@@ -115,6 +120,7 @@ describe("avatar-manifest", () => {
           traits: null,
           source: null,
           image: null,
+          accent: null,
         }),
       );
       expect(readManifest(dir)).toBeNull();
@@ -136,6 +142,7 @@ describe("avatar-manifest", () => {
           traits: null,
           source: null,
           image: { updatedAt: "2024-01-01T00:00:00.000Z", etag: "" },
+          accent: null,
         }),
       );
       expect(readManifest(dir)).toBeNull();
@@ -149,6 +156,7 @@ describe("avatar-manifest", () => {
           traits: null,
           source: null,
           image: { etag: "abc123" },
+          accent: null,
         }),
       );
       expect(readManifest(dir)).toBeNull();
@@ -160,6 +168,7 @@ describe("avatar-manifest", () => {
         traits: null,
         source: null,
         image: null,
+        accent: null,
       };
       writeFileSync(join(dir, "avatar.json"), JSON.stringify({ kind: "none" }));
       expect(readManifest(dir)).toEqual(state);
@@ -230,6 +239,7 @@ describe("avatar-manifest", () => {
         traits: null,
         source: null,
         image: null,
+        accent: null,
       });
     });
   });