@vellumai/assistant 0.11.4-dev.202608192008.2b8f565 → 0.11.4-dev.202608192109.b91153c

package/node_modules/@vellumai/gateway-client/src/http-delivery.ts

@@ -131,7 +131,6 @@ function buildManagedOutboundRequestId(
       chatId: payload.chatId,
       text: normalizedText,
       assistantId: payload.assistantId ?? null,
-      chatAction: payload.chatAction ?? null,
       hasAttachments:
         Array.isArray(payload.attachments) && payload.attachments.length > 0,
       approvalRequestId: payload.approval?.requestId ?? null,
@@ -212,7 +211,6 @@ async function deliverManagedOutboundReply(
         chatId: payload.chatId,
         text: payload.text ?? null,
         assistantId: payload.assistantId ?? null,
-        chatAction: payload.chatAction ?? null,
         hasAttachments,
         sourceUpdateId: callback.sourceUpdateId ?? null,
       },
@@ -325,7 +323,12 @@ export async function deliverChannelReply(
 ): Promise<ChannelDeliveryResult> {
   const managedCallback = parseManagedOutboundCallback(callbackUrl);
   if (managedCallback) {
-    await deliverManagedOutboundReply(managedCallback, payload, bearerToken, log);
+    await deliverManagedOutboundReply(
+      managedCallback,
+      payload,
+      bearerToken,
+      log,
+    );
     return { ok: true };
   }
 
@@ -385,17 +388,7 @@ export async function deliverChannelReply(
     // Response may not be JSON for non-Slack channels; that's fine.
   }
 
-  if (payload.chatAction) {
-    log.debug(
-      { chatId: payload.chatId, callbackUrl, chatAction: payload.chatAction },
-      "Channel action delivered",
-    );
-  } else {
-    log.info(
-      { chatId: payload.chatId, callbackUrl },
-      "Channel reply delivered",
-    );
-  }
+  log.info({ chatId: payload.chatId, callbackUrl }, "Channel reply delivered");
 
   return result;
 }

package/node_modules/@vellumai/gateway-client/src/outbound-contract.ts

@@ -168,7 +168,6 @@ export const ChannelReplyPayloadSchema = z.object({
   assistantId: z.string().optional(),
   attachments: z.array(AttachmentMetadataSchema).optional(),
   approval: ApprovalUIMetadataSchema.optional(),
-  chatAction: z.literal("typing").optional(),
   /**
    * When true, deliver via `chat.postEphemeral` so only the target `user`
    * sees the message.
@@ -180,14 +179,6 @@ export const ChannelReplyPayloadSchema = z.object({
   messageTs: z.string().optional(),
   /** When true, the daemon generates Block Kit blocks from the text before delivery. */
   useBlocks: z.boolean().optional(),
-  /** When provided, add or remove an emoji reaction on a message. */
-  reaction: z
-    .object({
-      action: z.enum(["add", "remove"]),
-      name: z.string(),
-      messageTs: z.string(),
-    })
-    .optional(),
   /** When provided, set or clear the Slack Assistants API thread status. */
   assistantThreadStatus: z
     .object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.4-dev.202608192008.2b8f565",
+  "version": "0.11.4-dev.202608192109.b91153c",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/messaging/providers/__tests__/transport-dispatch.test.ts

@@ -57,8 +57,14 @@ mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({ debug() {}, info() {}, warn() {}, error() {} }),
 }));
 
-const { deliverDirect, isDirectDelivery, getTransportForCallback } =
-  await import("../index.js");
+const {
+  deliverDirect,
+  sendChannelReaction,
+  sendChannelTyping,
+  supportsChannelTyping,
+  isDirectDelivery,
+  getTransportForCallback,
+} = await import("../index.js");
 
 const BASE = "https://gateway.internal";
 
@@ -134,17 +140,14 @@ describe("Slack sub-operation selection", () => {
     expect(opts.threadTs).toBe("1700.9");
   });
 
-  test("reaction routes to sendSlackReaction, not the text path", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/slack`,
-      payload({
-        reaction: {
-          action: "add",
-          name: "white_check_mark",
-          messageTs: "1700.5",
-        },
-      }),
-    );
+  test("sendChannelReaction reaches Slack without touching the text path", async () => {
+    await sendChannelReaction(`${BASE}/deliver/slack`, {
+      chatId: "C1",
+      messageId: "1700.5",
+      emoji: "white_check_mark",
+      action: "add",
+    });
+
     expect(slack.sendSlackReaction).toHaveBeenCalledTimes(1);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
@@ -164,12 +167,11 @@ describe("Slack sub-operation selection", () => {
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
-  test("a typing payload to Slack falls through to deliver (no typing capability)", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/slack`,
-      payload({ chatAction: "typing", text: "hi" }),
-    );
-    expect(slack.sendSlackReply).toHaveBeenCalledTimes(1);
+  test("sendChannelTyping resolves quietly for a channel with no typing capability", async () => {
+    const result = await sendChannelTyping(`${BASE}/deliver/slack`, "C1");
+
+    expect(result).toEqual({ ok: true });
+    expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
   test("slackStream routes to sendSlackStreamOp ahead of the text path", async () => {
@@ -191,22 +193,35 @@ describe("Slack sub-operation selection", () => {
 });
 
 describe("capability gating across channels", () => {
-  test("a reaction payload to Telegram falls through to deliver (no sendReaction)", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/telegram`,
-      payload({
-        text: "hi",
-        reaction: { action: "add", name: "x", messageTs: "1" },
-      }),
-    );
-    expect(telegram.sendTelegramReply).toHaveBeenCalledTimes(1);
+  test("a channel with no reaction capability resolves quietly", async () => {
+    // Slack is the only channel that implements it, because the only producer
+    // is Slack's own acknowledgement fallback. A channel without the method
+    // is not a failed delivery, so nothing is attempted and nothing throws.
+    const target = {
+      chatId: "C1",
+      messageId: "1",
+      emoji: "eyes",
+      action: "add",
+    } as const;
+    expect(
+      await sendChannelReaction(`${BASE}/deliver/telegram`, target),
+    ).toEqual({ ok: true });
+    expect(telegram.sendTelegramReply).not.toHaveBeenCalled();
   });
 
-  test("typing to Telegram routes to its typing indicator", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/telegram`,
-      payload({ chatAction: "typing" }),
-    );
+  test("the typing capability is read from the transport, not the channel name", () => {
+    // The heartbeat gate in background-dispatch asks this rather than testing
+    // `sourceChannel === "telegram"`, so a channel that implements the method
+    // starts showing an indicator without a caller being changed.
+    expect(supportsChannelTyping(`${BASE}/deliver/telegram`)).toBe(true);
+    expect(supportsChannelTyping(`${BASE}/deliver/discord`)).toBe(true);
+    expect(supportsChannelTyping(`${BASE}/deliver/slack`)).toBe(false);
+    expect(supportsChannelTyping(`${BASE}/deliver/whatsapp`)).toBe(false);
+  });
+
+  test("sendChannelTyping reaches Telegram's typing indicator", async () => {
+    await sendChannelTyping(`${BASE}/deliver/telegram`, "123");
+
     expect(telegram.sendTelegramTypingIndicator).toHaveBeenCalledTimes(1);
   });
 
@@ -244,15 +259,10 @@ describe("capability gating across channels", () => {
     });
   });
 
-  test("a typing payload to Discord falls through to deliver (no sendTyping)", async () => {
-    // Only the Telegram heartbeat produces `chatAction: "typing"`, and it is
-    // gated on sourceChannel === "telegram", so Discord can never receive one.
-    // The transport implements no sendTyping, so this falls through.
-    await deliverDirect(
-      `${BASE}/deliver/discord`,
-      payload({ chatAction: "typing", text: "hi" }),
-    );
-    expect(discord.sendDiscordReply).toHaveBeenCalledTimes(1);
+  test("sendChannelTyping reaches Discord's typing indicator", async () => {
+    await sendChannelTyping(`${BASE}/deliver/discord`, "999");
+
+    expect(discord.sendDiscordTypingIndicator).toHaveBeenCalledTimes(1);
   });
 
   test("a Slack-only stream payload to Discord falls through to deliver", async () => {

package/src/messaging/providers/channel-transport.ts

@@ -15,6 +15,15 @@ export interface CallbackContext {
   readonly params: Readonly<Record<string, string>>;
 }
 
+/** The message an emoji reaction lands on, and what to do there. */
+export interface ReactionTarget {
+  readonly chatId: string;
+  /** The target message, in the channel's own id space. */
+  readonly messageId: string;
+  readonly emoji: string;
+  readonly action: "add" | "remove";
+}
+
 /**
  * Direct outbound delivery for one channel, wrapping the channel's provider-API
  * send functions behind a uniform surface. Transports are registered statically
@@ -35,16 +44,26 @@ export interface ChannelTransport {
     payload: ChannelReplyPayload,
   ): Promise<ChannelDeliveryResult>;
 
-  /** Send a typing indicator. Routed when `payload.chatAction === "typing"`. */
-  sendTyping?(
-    ctx: CallbackContext,
-    payload: ChannelReplyPayload,
-  ): Promise<ChannelDeliveryResult>;
+  /**
+   * Show that the assistant is working, in whatever form the channel has.
+   *
+   * Takes the place and nothing else, because that is all it needs. A channel
+   * without the affordance omits the method, so implementing it is the whole
+   * of declaring the capability.
+   */
+  typing?(ctx: CallbackContext, chatId: string): Promise<ChannelDeliveryResult>;
 
-  /** Add an emoji reaction. Routed when `payload.reaction` is set. */
-  sendReaction?(
+  /**
+   * Add or remove one of the assistant's own emoji reactions on a message.
+   *
+   * `messageId` is the target's id in the channel's own space, the same way
+   * `chatId` is: Slack spells it as a timestamp, Discord and Telegram as ids.
+   * Nothing outside the channel reads it, so nothing outside needs a shared
+   * spelling for it.
+   */
+  react?(
     ctx: CallbackContext,
-    payload: ChannelReplyPayload,
+    target: ReactionTarget,
   ): Promise<ChannelDeliveryResult>;
 
   /** Update an assistant-thread status surface. Routed when `payload.assistantThreadStatus` is set. */

package/src/messaging/providers/discord/send.ts

@@ -210,3 +210,19 @@ export async function sendDiscordAttachments(
     totalCount: attachments.length,
   };
 }
+
+/**
+ * Show the Discord typing indicator in a channel.
+ *
+ * Discord expires it after about ten seconds, so a caller that wants it to
+ * persist re-sends on a timer rather than clearing it; there is no stop route.
+ */
+export async function sendDiscordTypingIndicator(
+  target: DiscordSendTarget,
+): Promise<void> {
+  await callDiscordApi(
+    "POST",
+    `/channels/${encodeURIComponent(target.channelId)}/typing`,
+    {},
+  );
+}

package/src/messaging/providers/discord/transport.ts

@@ -7,7 +7,11 @@ import type {
 } from "../channel-transport.js";
 import { openDiscordDmChannel } from "./api.js";
 import type { DiscordSendTarget } from "./send.js";
-import { sendDiscordAttachments, sendDiscordReply } from "./send.js";
+import {
+  sendDiscordAttachments,
+  sendDiscordReply,
+  sendDiscordTypingIndicator,
+} from "./send.js";
 
 const log = getLogger("discord-transport");
 
@@ -43,6 +47,12 @@ async function sendTarget(
 export const discordTransport: ChannelTransport = {
   channel: "discord",
 
+  async typing(ctx, chatId) {
+    await sendDiscordTypingIndicator(await sendTarget(ctx, chatId));
+    log.debug({ chatId }, "Discord typing indicator delivered (direct)");
+    return { ok: true };
+  },
+
   async deliver(ctx, payload) {
     const { chatId, text, attachments, approval } = payload;
     const target = await sendTarget(ctx, chatId);

package/src/messaging/providers/index.ts

@@ -16,7 +16,11 @@ import type {
 import { a2aTransport } from "./a2a/transport.js";
 import type { DirectDeliveryChannel } from "./callback-routing.js";
 import { channelForCallback } from "./callback-routing.js";
-import type { CallbackContext, ChannelTransport } from "./channel-transport.js";
+import type {
+  CallbackContext,
+  ChannelTransport,
+  ReactionTarget,
+} from "./channel-transport.js";
 import { discordTransport } from "./discord/transport.js";
 import { slackTransport } from "./slack/transport.js";
 import { telegramTransport } from "./telegram-bot/transport.js";
@@ -45,6 +49,52 @@ export function getTransportForCallback(
   return channel ? TRANSPORTS[channel] : undefined;
 }
 
+/**
+ * Whether the channel this callback addresses can show a working indicator.
+ *
+ * Asks the transport rather than the channel id, so a channel that gains the
+ * method starts being asked without a caller being told about it.
+ */
+export function supportsChannelTyping(callbackUrl: string): boolean {
+  return getTransportForCallback(callbackUrl)?.typing !== undefined;
+}
+
+/**
+ * Show that the assistant is working on the channel this callback addresses.
+ *
+ * Resolves to nothing when the channel has no such affordance, which is the
+ * ordinary case rather than a failure: the indicator is decoration, and a
+ * channel that cannot show one is not degraded by its absence.
+ */
+export async function sendChannelTyping(
+  callbackUrl: string,
+  chatId: string,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.typing) {
+    return { ok: true };
+  }
+  return transport.typing(callbackContext(callbackUrl), chatId);
+}
+
+/**
+ * Add or remove one of the assistant's own reactions on a message.
+ *
+ * Resolves to nothing when the channel has none, the same as typing: a
+ * reaction is an acknowledgement, and a channel that cannot show one is not a
+ * failed delivery.
+ */
+export async function sendChannelReaction(
+  callbackUrl: string,
+  target: ReactionTarget,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.react) {
+    return { ok: true };
+  }
+  return transport.react(callbackContext(callbackUrl), target);
+}
+
 function callbackContext(callbackUrl: string): CallbackContext {
   const params: Record<string, string> = {};
   try {
@@ -74,9 +124,9 @@ export function isDirectDelivery(callbackUrl: string): boolean {
  * Deliver a channel reply directly to the provider API, bypassing the gateway
  * HTTP proxy. Callers MUST check `isDirectDelivery()` first.
  *
- * Sub-operations (reaction, thread status, typing) route to the transport's
- * optional method when both the payload field and the method are present;
- * otherwise the reply is delivered as text / approval / attachments.
+ * Sub-operations (reaction, thread status) route to the transport's optional
+ * method when both the payload field and the method are present; otherwise
+ * the reply is delivered as text / approval / attachments.
  */
 export async function deliverDirect(
   callbackUrl: string,
@@ -93,14 +143,8 @@ export async function deliverDirect(
   if (payload.slackStream && transport.streamReply) {
     return transport.streamReply(ctx, payload);
   }
-  if (payload.reaction && transport.sendReaction) {
-    return transport.sendReaction(ctx, payload);
-  }
   if (payload.assistantThreadStatus && transport.setThreadStatus) {
     return transport.setThreadStatus(ctx, payload);
   }
-  if (payload.chatAction === "typing" && transport.sendTyping) {
-    return transport.sendTyping(ctx, payload);
-  }
   return transport.deliver(ctx, payload);
 }

package/src/messaging/providers/slack/transport.ts

@@ -54,16 +54,12 @@ export const slackTransport: ChannelTransport = {
     return { ok: true, ts: sentTs };
   },
 
-  async sendReaction(_ctx, payload) {
-    const reaction = payload.reaction;
-    if (!reaction) {
-      return { ok: true };
-    }
+  async react(_ctx, target) {
     await sendSlackReaction(
-      payload.chatId,
-      reaction.name,
-      reaction.messageTs,
-      reaction.action,
+      target.chatId,
+      target.emoji,
+      target.messageId,
+      target.action,
     );
     return { ok: true };
   },

package/src/messaging/providers/telegram-bot/send.test.ts

@@ -272,10 +272,7 @@ describe("telegramTransport topic targeting", () => {
   });
 
   test("typing indicators target the topic", async () => {
-    await telegramTransport.sendTyping!(
-      topicCtx,
-      payload({ chatAction: "typing" }),
-    );
+    await telegramTransport.typing!(topicCtx, "123");
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendChatAction", {
       chat_id: "123",
@@ -291,10 +288,7 @@ describe("telegramTransport topic targeting", () => {
     };
 
     await telegramTransport.deliver(bareCtx, payload({ useBlocks: false }));
-    await telegramTransport.sendTyping!(
-      bareCtx,
-      payload({ chatAction: "typing" }),
-    );
+    await telegramTransport.typing!(bareCtx, "123");
 
     expect(callTelegramBotApiMock).toHaveBeenCalledWith("sendMessage", {
       chat_id: "123",

package/src/messaging/providers/telegram-bot/transport.ts

@@ -67,12 +67,9 @@ export const telegramTransport: ChannelTransport = {
     return { ok: true };
   },
 
-  async sendTyping(ctx, payload) {
-    await sendTelegramTypingIndicator(payload.chatId, threadOptions(ctx));
-    log.debug(
-      { chatId: payload.chatId },
-      "Telegram typing indicator delivered (direct)",
-    );
+  async typing(ctx, chatId) {
+    await sendTelegramTypingIndicator(chatId, threadOptions(ctx));
+    log.debug({ chatId }, "Telegram typing indicator delivered (direct)");
     return { ok: true };
   },
 };

package/src/providers/inference/__tests__/adapter-factory-openai-compatible.test.ts

@@ -74,6 +74,36 @@ describe("adapter factory", () => {
     ).toBe(true);
   });
 
+  test("openai-compatible round-trips thinking as reasoning_content", () => {
+    const adapter = buildProviderAdapter("openai-compatible", {
+      apiKey: "test-key",
+      model: "deepseek-reasoner",
+      streamTimeoutMs: 60_000,
+      baseURL: "https://example.com/v1",
+      useNativeWebSearch: false,
+    });
+    expect(adapter).toBeInstanceOf(OpenAIChatCompletionsProvider);
+    expect(
+      (adapter as unknown as { assistantReasoningField?: string })
+        .assistantReasoningField,
+    ).toBe("reasoning_content");
+  });
+
+  test("litellm round-trips thinking as reasoning_content", () => {
+    const adapter = buildProviderAdapter("litellm", {
+      apiKey: "test-key",
+      model: "deepseek-reasoner",
+      streamTimeoutMs: 60_000,
+      baseURL: "https://example.com/v1",
+      useNativeWebSearch: false,
+    });
+    expect(adapter).toBeInstanceOf(OpenAIChatCompletionsProvider);
+    expect(
+      (adapter as unknown as { assistantReasoningField?: string })
+        .assistantReasoningField,
+    ).toBe("reasoning_content");
+  });
+
   test("backfills placeholder content after an aborted empty assistant turn", async () => {
     const adapter = buildProviderAdapter("openai-compatible", {
       apiKey: "test-key",

package/src/providers/inference/adapter-factory.ts

@@ -131,6 +131,9 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       providerName: "litellm",
       providerLabel: "LiteLLM",
       streamTimeoutMs,
+      // Replay thinking as `reasoning_content` so DeepSeek-compatible
+      // thinking-mode upstreams accept follow-up requests that include tools.
+      assistantReasoningField: "reasoning_content",
       // Generic OpenAI-compat proxies may front a strict backend (vLLM,
       // DeepSeek, Portkey). Backfill empty assistant turns so the request
       // satisfies `content or tool_calls must be set`.
@@ -144,6 +147,9 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       providerName: "openai-compatible",
       providerLabel: "OpenAI-compatible",
       streamTimeoutMs,
+      // Replay thinking as `reasoning_content` so DeepSeek-compatible
+      // thinking-mode endpoints accept follow-up requests that include tools.
+      assistantReasoningField: "reasoning_content",
       // Custom endpoints (Portkey, vLLM, LM Studio, DeepSeek-compat) often
       // reject `{ role: "assistant", content: null }` after a Stop mid-stream
       // or a reasoning-only turn. Same guard as OpenRouter and Vercel AI