@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/runtime/__tests__/watch-stream-upgrade.test.ts

@@ -1,59 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { RuntimeHttpServer } from "../http-server.js";
-import {
-  mintGatewayToken,
-  requireHttpAuth,
-  upgradeHeaders,
-} from "./runtime-ws-test-utils.js";
-
-describe("Watch capture target through the shared runtime upgrade", () => {
-  let restoreAuth: () => void;
-  beforeEach(() => {
-    restoreAuth = requireHttpAuth();
-  });
-  afterEach(() => restoreAuth());
-
-  function upgrade(params: string) {
-    const runtime = new RuntimeHttpServer();
-    const server = {
-      requestIP: () => ({ address: "127.0.0.1" }),
-      upgrade: mock(() => true),
-    };
-    const response = runtime["handleWatchStreamUpgrade"](
-      new Request(
-        `http://127.0.0.1/v1/watch/stream?token=${mintGatewayToken()}&mimeType=audio/pcm&sampleRate=16000&${params}`,
-        { headers: upgradeHeaders },
-      ),
-      server as unknown as ReturnType<typeof Bun.serve>,
-    );
-    return { response, server };
-  }
-
-  test.each([
-    ["captureWindowId=4242", { kind: "window", windowId: 4242 }],
-    ["captureDisplayId=7", { kind: "display", displayId: 7 }],
-    ["", undefined],
-  ])("preserves the selected target: %s", (params, captureTarget) => {
-    const { response, server } = upgrade(params);
-    expect(response).toBeUndefined();
-    expect(server.upgrade).toHaveBeenCalledWith(expect.any(Request), {
-      data: expect.objectContaining({
-        wsType: "watch-stream",
-        mimeType: "audio/pcm",
-        sampleRate: 16000,
-        captureTarget,
-      }),
-    });
-  });
-
-  test.each([
-    "captureWindowId=abc",
-    "captureDisplayId=-1",
-    "captureWindowId=1&captureDisplayId=2",
-  ])("refuses an invalid target before upgrading: %s", (params) => {
-    const { response, server } = upgrade(params);
-    expect(response?.status).toBe(400);
-    expect(server.upgrade).not.toHaveBeenCalled();
-  });
-});

package/src/runtime/channel-send.ts

@@ -1,316 +0,0 @@
-/**
- * A model-directed text send to a channel chat, through the channel's
- * transport, recorded after the channel acknowledges it.
- *
- * This is the one send implementation per addressable channel. The
- * messaging tool's channel branch and the `channels send` route both call
- * it, so a send costs the same and leaves the same record whichever door it
- * came through. The transport owns the routing: the caller names a neutral
- * target, the transport resolves it into its own callback context, and
- * nothing here switches on a channel's name.
- *
- * Nothing is written before the channel acknowledges. The record carries
- * every id the text became, so a failed send leaves no row that reads as
- * something the assistant said, and a reaction, edit, or delete naming any
- * chunk resolves to the row; the inbound binding a transport asks for is
- * written after the same acknowledgement, so a failed send does not move
- * where the chat's next message lands. A send into the sending turn's own
- * chat and thread writes no row: its tool call and result already sit in
- * that conversation's history, and a second assistant row beside the tool
- * pair would break history repair.
- */
-
-import { type ChannelId, isChannelId } from "../channels/types.js";
-import type {
-  ProactiveAddress,
-  ProactiveTarget,
-} from "../messaging/providers/channel-transport.js";
-import { getTransportForChannel } from "../messaging/providers/index.js";
-import { resolveProactiveHomeConversation } from "../notifications/conversation-pairing.js";
-import { recordDeliveredChannelPost } from "../notifications/delivered-post-record.js";
-import { getConversation } from "../persistence/conversation-crud.js";
-import { syncMessageToDisk } from "../persistence/conversation-disk-view.js";
-import { getOrCreateConversation } from "../persistence/conversation-key-store.js";
-import { buildScopedConversationKey } from "../persistence/delivery-crud.js";
-import {
-  normalizeExternalThreadId,
-  upsertOutboundBinding,
-} from "../persistence/external-conversation-store.js";
-import { getLogger } from "../util/logger.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "./assistant-scope.js";
-import { publishConversationListChanged } from "./sync/resource-sync-events.js";
-
-const log = getLogger("channel-send");
-
-/**
- * The turn a send is made from, as a snapshot taken when the turn started:
- * the channel it arrived on, the chat, and the thread. Read from the turn
- * rather than from the live binding, which a concurrent inbound can rewrite
- * while the send runs. A caller with no turn (a script) names only the
- * conversation it acts for, and the home comparison decides on its own.
- */
-export interface ChannelSendSender {
-  readonly conversationId: string;
-  readonly executionChannel?: string;
-  readonly requesterChatId?: string;
-  readonly sourceThreadId?: string;
-}
-
-export interface ChannelSendParams {
-  readonly channel: string;
-  readonly target: ProactiveTarget;
-  readonly text: string;
-  /** Ask the channel for its rich rendering of the text, where it has one. */
-  readonly renderRichly?: boolean;
-  /** The assistant the send acts for; absent or `self` is this assistant. */
-  readonly assistantId?: string;
-  readonly sender?: ChannelSendSender;
-}
-
-export interface ChannelSendResult {
-  readonly channel: ChannelId;
-  /** The chat the post landed in, in the channel's own id space. */
-  readonly chatId: string;
-  /** The thread the post landed in, absent when it is not in one. */
-  readonly threadId?: string;
-  /** Every id the channel acknowledged for the text, in send order; never empty. */
-  readonly messageIds: readonly string[];
-  /** The id of the final post, the one a later edit or withdrawal addresses. */
-  readonly lastMessageId: string;
-  /** The conversation the post was recorded in, absent when it was not. */
-  readonly recordedIn?: string;
-}
-
-/** The channel cannot be reached from a named target. */
-export class ChannelNotAddressableError extends Error {
-  constructor(
-    readonly channel: string,
-    reason: string,
-  ) {
-    super(`Channel "${channel}" ${reason}.`);
-    this.name = "ChannelNotAddressableError";
-  }
-}
-
-/**
- * The transport ran but the channel did not acknowledge the send. A success
- * that names no message id counts: an id is what makes the post addressable
- * afterwards, and without one there is nothing to record.
- */
-export class ChannelSendFailedError extends Error {
-  constructor(
-    readonly channel: ChannelId,
-    reason = "did not acknowledge the send",
-  ) {
-    super(`Channel "${channel}" ${reason}.`);
-    this.name = "ChannelSendFailedError";
-  }
-}
-
-/**
- * Whether a channel's transport declares it can be addressed from a named
- * chat. A channel with no transport, or one that only answers on an inbound
- * callback, is not.
- */
-export function isProactivelyAddressable(channel: string): boolean {
-  return getTransportForChannel(channel)?.addressFor !== undefined;
-}
-
-/**
- * Deliver `text` to `target` on `channel` and record what was sent.
- *
- * Throws {@link ChannelNotAddressableError} before any delivery when the
- * channel or the target shape cannot be addressed, and
- * {@link ChannelSendFailedError} when the transport reports no
- * acknowledgement or no message id. A binding or recording failure never
- * fails the send: the message is already out.
- */
-export async function sendChannelText(
-  params: ChannelSendParams,
-): Promise<ChannelSendResult> {
-  const { channel, target, text } = params;
-  if (!isChannelId(channel)) {
-    throw new ChannelNotAddressableError(channel, "is not a channel");
-  }
-  const transport = getTransportForChannel(channel);
-  if (!transport?.addressFor) {
-    throw new ChannelNotAddressableError(
-      channel,
-      "cannot be addressed from a named chat",
-    );
-  }
-  const address = transport.addressFor(target);
-  if (!address) {
-    throw new ChannelNotAddressableError(channel, "cannot address that chat");
-  }
-
-  const result = await transport.deliver(address.ctx, {
-    chatId: address.chatId,
-    text,
-    ...(params.renderRichly ? { renderRichly: true } : {}),
-    ...(params.assistantId ? { assistantId: params.assistantId } : {}),
-  });
-  if (!result.ok) {
-    throw new ChannelSendFailedError(channel);
-  }
-  const messageIds = result.messageIds ?? (result.ts ? [result.ts] : []);
-  const lastMessageId = result.ts ?? messageIds[messageIds.length - 1];
-  if (!lastMessageId) {
-    throw new ChannelSendFailedError(channel, "acknowledged no message id");
-  }
-
-  const actsForSelf =
-    !params.assistantId || params.assistantId === DAEMON_INTERNAL_ASSISTANT_ID;
-  if (transport.bindsChatOnProactiveSend && actsForSelf) {
-    bindChatForNextInbound(channel, address);
-  }
-
-  const recordedIn = await recordProactivePost({
-    channel,
-    address,
-    text,
-    messageIds,
-    sender: params.sender,
-  });
-
-  return {
-    channel,
-    chatId: address.chatId,
-    ...(address.threadId ? { threadId: address.threadId } : {}),
-    messageIds,
-    lastMessageId,
-    ...(recordedIn ? { recordedIn } : {}),
-  };
-}
-
-/**
- * Bind the chat's inbound conversation to the delivered chat and thread, so
- * the next message from there resolves to the conversation ingress uses for
- * it. The key is the one ingress builds, thread-scoped where the channel
- * scopes conversations by thread, so a topic's replies continue the topic's
- * conversation. Runs after acknowledgement: the message is out, so the
- * binding it asks for is owed. Best effort: a binding failure must not fail
- * the send.
- */
-function bindChatForNextInbound(
-  channel: ChannelId,
-  address: ProactiveAddress,
-): void {
-  try {
-    const { conversationId, created } = getOrCreateConversation(
-      buildScopedConversationKey(channel, address.chatId, address.threadId),
-    );
-    // Published before the binding, not after: the conversation exists as
-    // soon as it is minted, the record that follows finds it rather than
-    // minting it, and a binding that throws must not leave a conversation
-    // holding a real message out of the list.
-    if (created) {
-      publishConversationListChanged("created");
-    }
-    upsertOutboundBinding({
-      conversationId,
-      sourceChannel: channel,
-      externalChatId: address.chatId,
-      externalThreadId: address.threadId ?? null,
-    });
-  } catch (e) {
-    log.warn(
-      {
-        err: e,
-        channel,
-        externalChatId: address.chatId,
-        externalThreadId: address.threadId,
-      },
-      "Failed to bind the chat's inbound conversation after the send",
-    );
-  }
-}
-
-/**
- * Record the acknowledged post where the chat's proactive posts live, so
- * the chat's own conversation and `recall` can see what was sent from
- * elsewhere. The row names the thread the post landed in, as the transport
- * resolved it. Returns the conversation it was recorded in, or `undefined`
- * when nothing was recorded: the send went into the sending turn's own chat
- * and thread, or the home is the sender.
- */
-async function recordProactivePost(params: {
-  channel: ChannelId;
-  address: ProactiveAddress;
-  text: string;
-  messageIds: readonly string[];
-  sender: ChannelSendSender | undefined;
-}): Promise<string | undefined> {
-  const { channel, address, sender } = params;
-  const [firstId, ...restIds] = params.messageIds;
-  if (!firstId) {
-    return undefined;
-  }
-  try {
-    if (
-      sender &&
-      isSendIntoOwnChat(sender, channel, address.chatId, address.threadId)
-    ) {
-      return undefined;
-    }
-    const home = await resolveProactiveHomeConversation({
-      sourceChannel: channel,
-      externalChatId: address.chatId,
-      threadId: address.threadId,
-      source: "notification",
-      conversationType: "background",
-      title: `Messages to ${address.chatId}`,
-    });
-    if (home.conversationId === sender?.conversationId) {
-      return undefined;
-    }
-    const recorded = await recordDeliveredChannelPost({
-      conversationId: home.conversationId,
-      channel,
-      externalChatId: address.chatId,
-      ...(address.threadId ? { threadId: address.threadId } : {}),
-      text: params.text,
-      providerMessageId: firstId,
-      ...(restIds.length > 0 ? { additionalProviderMessageIds: restIds } : {}),
-      ...(sender ? { crossPostedFrom: sender.conversationId } : {}),
-    });
-    const homeConversation = getConversation(home.conversationId);
-    if (homeConversation) {
-      syncMessageToDisk(
-        home.conversationId,
-        recorded.messageId,
-        homeConversation.createdAt,
-      );
-    }
-    return home.conversationId;
-  } catch (e) {
-    log.warn(
-      { err: e, channel, externalChatId: address.chatId },
-      "Failed to record the sent message in the chat's conversation",
-    );
-    return undefined;
-  }
-}
-
-/**
- * True when the delivered chat and thread are the ones the sending turn
- * arrived in. Thread ids compare in the binding store's normalized form, so
- * an absent thread on both sides matches and a thread-less delivery never
- * matches a turn that arrived in a thread.
- */
-function isSendIntoOwnChat(
-  sender: ChannelSendSender,
-  channel: ChannelId,
-  chatId: string,
-  deliveredThreadId: string | undefined,
-): boolean {
-  if (!sender.executionChannel || !sender.requesterChatId) {
-    return false;
-  }
-  return (
-    sender.executionChannel === channel &&
-    sender.requesterChatId === chatId &&
-    normalizeExternalThreadId(sender.sourceThreadId) ===
-      normalizeExternalThreadId(deliveredThreadId)
-  );
-}

package/src/runtime/routes/__tests__/apps-refresh-route.test.ts

@@ -1,205 +0,0 @@
-/**
- * Tests for POST apps/:id/refresh (apps_refresh) in the shared route table.
- *
- * `mock.module` is process-global in Bun. Stubs delegate to the real
- * implementations unless this file's tests are running.
- */
-
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-import type { CompileResult } from "../../../bundler/app-compiler.js";
-
-let mockActive = false;
-beforeAll(() => {
-  mockActive = true;
-});
-afterAll(() => {
-  mockActive = false;
-});
-
-const realCompiler = { ...(await import("../../../bundler/app-compiler.js")) };
-const realNotify = {
-  ...(await import("../../../daemon/app-change-notify.js")),
-};
-
-const compileApp = mock(
-  async (
-    _appDir: Parameters<typeof realCompiler.compileApp>[0],
-  ): Promise<CompileResult> => ({
-    ok: true,
-    errors: [],
-    warnings: [],
-    durationMs: 11,
-  }),
-);
-const notifyAppSurfacesChanged = mock(
-  (..._args: Parameters<typeof realNotify.notifyAppSurfacesChanged>) => {},
-);
-
-mock.module("../../../bundler/app-compiler.js", () => ({
-  ...realCompiler,
-  compileApp: (...args: Parameters<typeof realCompiler.compileApp>) => {
-    if (!mockActive) {
-      return realCompiler.compileApp(...args);
-    }
-    return compileApp(...args);
-  },
-}));
-
-mock.module("../../../daemon/app-change-notify.js", () => ({
-  ...realNotify,
-  notifyAppSurfacesChanged: (
-    ...args: Parameters<typeof realNotify.notifyAppSurfacesChanged>
-  ) => {
-    if (!mockActive) {
-      return realNotify.notifyAppSurfacesChanged(...args);
-    }
-    return notifyAppSurfacesChanged(...args);
-  },
-}));
-
-const { createApp } = await import("../../../apps/app-store.js");
-const { getWorkspacePluginsDir } = await import("../../../util/platform.js");
-const { ROUTES } = await import("../app-management-routes.js");
-
-function findHandler(operationId: string) {
-  const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route) {
-    throw new Error(`Route ${operationId} not found`);
-  }
-  return route.handler;
-}
-
-const handleRefreshApp = findHandler("apps_refresh");
-
-let workspaceDir: string;
-let previousWorkspaceDir: string | undefined;
-
-beforeEach(() => {
-  previousWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-  workspaceDir = join(
-    tmpdir(),
-    `vellum-apps-refresh-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
-  compileApp.mockClear();
-  notifyAppSurfacesChanged.mockClear();
-  compileApp.mockResolvedValue({
-    ok: true,
-    errors: [],
-    warnings: [],
-    durationMs: 11,
-  });
-});
-
-afterEach(() => {
-  rmSync(workspaceDir, { recursive: true, force: true });
-  if (previousWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceDir;
-  }
-});
-
-describe("apps_refresh route", () => {
-  test("is registered on the shared app-management ROUTES table", () => {
-    expect(typeof handleRefreshApp).toBe("function");
-  });
-
-  test("compiles a workspace app and notifies surfaces", async () => {
-    const created = createApp({
-      name: "Budget",
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-
-    const result = await handleRefreshApp({
-      pathParams: { id: created.id },
-    });
-
-    expect(compileApp).toHaveBeenCalled();
-    expect(notifyAppSurfacesChanged).toHaveBeenCalledWith(created.id, {
-      fileChange: true,
-    });
-    expect(result).toEqual({
-      ok: true,
-      appId: created.id,
-      name: "Budget",
-      compiled: true,
-      compile_duration_ms: 11,
-    });
-  });
-
-  test("compiles a plugin app in place", async () => {
-    const pluginName = `charts-${Math.random().toString(36).slice(2, 8)}`;
-    const pluginDir = join(getWorkspacePluginsDir(), pluginName);
-    mkdirSync(join(pluginDir, "apps", "viewer"), { recursive: true });
-    writeFileSync(
-      join(pluginDir, "package.json"),
-      JSON.stringify({ name: pluginName, version: "1.0.0" }),
-    );
-    writeFileSync(join(pluginDir, "apps", "viewer", "index.html"), "<h1></h1>");
-    const pluginAppId = `plugins~${pluginName}~viewer`;
-
-    const result = await handleRefreshApp({
-      pathParams: { id: pluginAppId },
-    });
-
-    expect(compileApp).toHaveBeenCalledWith(
-      join(pluginDir, "apps", "viewer"),
-    );
-    expect(notifyAppSurfacesChanged).toHaveBeenCalledWith(pluginAppId, {
-      fileChange: true,
-    });
-    expect(result).toMatchObject({
-      ok: true,
-      appId: pluginAppId,
-      name: "viewer",
-      compiled: true,
-    });
-  });
-
-  test("returns compile errors without throwing", async () => {
-    const created = createApp({
-      name: "Budget",
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-    compileApp.mockImplementationOnce(async () => ({
-      ok: false,
-      errors: [{ text: "Could not resolve foo" }],
-      warnings: [],
-      durationMs: 4,
-    }));
-
-    const result = await handleRefreshApp({
-      pathParams: { id: created.id },
-    });
-
-    expect(result).toMatchObject({
-      compiled: false,
-      compile_errors: [{ text: "Could not resolve foo" }],
-    });
-    expect(notifyAppSurfacesChanged).toHaveBeenCalled();
-  });
-
-  test("throws not found for an unknown app", async () => {
-    await expect(
-      handleRefreshApp({ pathParams: { id: "missing" } }),
-    ).rejects.toMatchObject({
-      statusCode: 404,
-    });
-  });
-});

package/src/runtime/routes/__tests__/channel-send-routes.test.ts

@@ -1,127 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// The route is a thin door over the send function: it validates the body
-// against its declared schema and maps the function's refusals onto route
-// errors, so the CLI and the messaging tool share one seam.
-
-const sendCalls: Array<Record<string, unknown>> = [];
-let sendImpl: (params: Record<string, unknown>) => Promise<unknown> = async (
-  params,
-) => ({
-  channel: params.channel,
-  chatId: "C123",
-  messageIds: ["1700000000.000100"],
-  lastMessageId: "1700000000.000100",
-  recordedIn: "home-1",
-});
-
-class ChannelNotAddressableError extends Error {}
-class ChannelSendFailedError extends Error {}
-
-mock.module("../../channel-send.js", () => ({
-  ChannelNotAddressableError,
-  ChannelSendFailedError,
-  sendChannelText: async (params: Record<string, unknown>) => {
-    sendCalls.push(params);
-    return sendImpl(params);
-  },
-}));
-
-const { ROUTES } = await import("../channel-send-routes.js");
-const { BadGatewayError, BadRequestError } = await import("../errors.js");
-
-const route = ROUTES.find((r) => r.operationId === "channels_send_post")!;
-
-beforeEach(() => {
-  sendCalls.length = 0;
-});
-
-describe("POST channels/send", () => {
-  test("is registered as a chat write for actor principals", () => {
-    expect(route).toBeDefined();
-    expect(route.endpoint).toBe("channels/send");
-    expect(route.method).toBe("POST");
-    expect(route.policy?.requiredScopes).toEqual(["chat.write"]);
-  });
-
-  test("hands a valid body to the send function and returns its result", async () => {
-    const body = {
-      channel: "slack",
-      target: { kind: "chat", chatId: "C123", threadId: "1690000000.000001" },
-      text: "hello",
-      renderRichly: true,
-    };
-    const result = await route.handler({ body });
-    expect(sendCalls).toEqual([body]);
-    expect(result).toMatchObject({
-      channel: "slack",
-      messageIds: ["1700000000.000100"],
-      recordedIn: "home-1",
-    });
-  });
-
-  test("names no sending turn, so a caller cannot claim a send was its own chat's", async () => {
-    await route.handler({
-      body: {
-        channel: "slack",
-        target: { kind: "chat", chatId: "C123" },
-        text: "hello",
-        sender: {
-          conversationId: "conv-A",
-          executionChannel: "slack",
-          requesterChatId: "C123",
-        },
-      },
-    });
-    expect(sendCalls).toHaveLength(1);
-    expect(sendCalls[0]).not.toHaveProperty("sender");
-  });
-
-  test("rejects a malformed body before calling the send function", async () => {
-    await expect(
-      route.handler({
-        body: { channel: "slack", target: { kind: "chat" }, text: "" },
-      }),
-    ).rejects.toBeInstanceOf(BadRequestError);
-    await expect(
-      route.handler({
-        body: {
-          channel: "not-a-channel",
-          target: { kind: "chat", chatId: "C1" },
-          text: "hi",
-        },
-      }),
-    ).rejects.toBeInstanceOf(BadRequestError);
-    expect(sendCalls).toEqual([]);
-  });
-
-  test("maps the send function's refusals onto route errors", async () => {
-    sendImpl = async () => {
-      throw new ChannelNotAddressableError(
-        'Channel "email" is not addressable',
-      );
-    };
-    await expect(
-      route.handler({
-        body: {
-          channel: "email",
-          target: { kind: "chat", chatId: "x" },
-          text: "hi",
-        },
-      }),
-    ).rejects.toBeInstanceOf(BadRequestError);
-
-    sendImpl = async () => {
-      throw new ChannelSendFailedError("not acknowledged");
-    };
-    await expect(
-      route.handler({
-        body: {
-          channel: "slack",
-          target: { kind: "chat", chatId: "C1" },
-          text: "hi",
-        },
-      }),
-    ).rejects.toBeInstanceOf(BadGatewayError);
-  });
-});