Skip to content
Novu logoNovu

Changelog

Latest updates and improvements in the agent communication category.

Follow us on X

All changelog posts

  • LangChain adapter for Novu Connect

    Connect a LangChain or LangGraph agent to Slack, Microsoft Teams, WhatsApp, Telegram, and email, with mapped conversation history and in-channel tool approval on the adapter-managed path.

    Authors:
    Paweł TymczukVictor Yakubu
    Paweł T., Victor Y.
    Langchain adapter for Novu Connect

    The LangChain adapter is now available through @novu/framework/langchain. It gives teams already using LangChain or LangGraph a direct path to Novu Connect without rebuilding their agent for each communication channel.

    Your agent or graph continues to run in your application. Novu Connect handles inbound channel events, conversation context, and delivery of the response back to the user.

    For OpenAI:

    npm install @novu/framework langchain @langchain/core @langchain/openai

    For Anthropic:

    npm install @novu/framework langchain @langchain/core @langchain/anthropic
    Good to know

    This is not limited to just OpenAI and Anthropic, you can use other LangChain provider keys.

    Return a config or invoke your own agent

    The adapter supports two handoff patterns based on how much of your LangChain setup you want it to manage.

    When you return a LangChainAgentConfig from onMessage, the adapter calls createAgent().invoke() in your application, maps ctx.history, and delivers the final assistant response:

    import { agent } from '@novu/framework/langchain';

export const supportBot = agent('support-bot', {
  onMessage: async (_message, ctx) => ({
    model: 'openai:gpt-4o',
    system: 'You are a helpful support agent.',
  }),
});

    If you already invoke a LangChain agent or LangGraph graph yourself, use toLangChainMessages(ctx.history), run your existing invoke() call, and return { messages }. Novu delivers the final assistant message. Tool approval is not managed by the adapter on this bring-your-own invocation path.

    Ask for approval in the channel

    On the config path, needsApproval lets you gate sensitive tools without building a separate approval flow for every channel. When the model calls a gated tool, Novu posts an Approve / Deny card and pauses the turn. After the user responds, the adapter replays the approval cycle from conversation history and continues the agent run.

    import { tool } from '@langchain/core/tools';
import { agent } from '@novu/framework/langchain';
import { z } from 'zod';

const issueRefund = tool(
  async ({ orderId }) => ({ orderId, status: 'refunded' }),
  {
    name: 'issueRefund',
    description: 'Issue a refund for an order',
    schema: z.object({ orderId: z.string() }),
  },
);

export const supportBot = agent('support-bot', {
  onMessage: async () => ({
    model: 'openai:gpt-4o',
    system: 'You are a helpful support agent.',
    tools: [issueRefund],
    needsApproval: (toolCall) => toolCall.name === 'issueRefund',
  }),
});

    This approval flow does not require a separate LangGraph checkpointer. The conversation history holds the information the adapter needs to resume the turn.

    Get started with npx novu connect --runtime langchain, then follow the LangChain quickstart. See the LangChain reference for config returns, custom invocation, approval gating, Next.js setup, and error handling.

  • Vercel AI SDK adapter for Novu Connect

    Bring an existing Vercel AI SDK agent to Slack, Microsoft Teams, WhatsApp, Telegram, and email while keeping the same model, tools, and application code.

    Authors:
    Adam ChmaraVictor Yakubu
    Adam C., Victor Y.
    Vercel AI SDK adapter for Novu Connect

    The Vercel AI SDK adapter is now available through @novu/framework/ai-sdk. Your agent continues to run your application. Novu Connect receives messages from each connected channel, passes the conversation context to your handler, and delivers the response that your handler returns.

    Install @novu/framework with the AI SDK and your model provider:

    npm install @novu/framework ai @ai-sdk/openai

    Use one handler across connected channels

    Return generateText() from onMessage, and the adapter handles the handoff between Novu conversation history and the Vercel AI SDK.

    import { agent, toModelMessages } from '@novu/framework/ai-sdk';
import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';

export const supportBot = agent('support-bot', {
  onMessage: async (_message, ctx) =>
    generateText({
      model: openai('gpt-4o'),
      instructions: 'You are a helpful support agent.',
      messages: toModelMessages(ctx.history),
    }),
});

    toModelMessages(ctx.history) converts the full conversation into AI SDK messages and already includes the current inbound message. After you connect other channel providers, the same handler can reply on Slack, Microsoft Teams, WhatsApp, Telegram, and email.

    Keep tool approval in the conversation

    AI SDK tool loops work through the adapter, including actions and tool calls that require a person to approve them. Set needsApproval: true on a tool, and Novu posts an Approve / Deny card in the conversation any time the tool is called. The turn pauses until the user decides, then resumes with the decision included in the mapped conversation history.

    import { agent, toModelMessages } from '@novu/framework/ai-sdk';
import { openai } from '@ai-sdk/openai';
import { generateText, tool } from 'ai';
import { z } from 'zod';

export const supportBot = agent('support-bot', {
  onMessage: async (_message, ctx) =>
    generateText({
      model: openai('gpt-4o'),
      messages: toModelMessages(ctx.history),
      tools: {
        issueRefund: tool({
          inputSchema: z.object({ orderId: z.string() }),
          needsApproval: true,
          execute: async ({ orderId }) => refund(orderId),
        }),
      },
    }),
});

    You can also use MCP tools through the AI SDK MCP client on the custom-code path. Your application creates the client and supplies its credentials, while Novu Connect handles the conversation and channel delivery.

    Get started with npx novu connect --runtime ai-sdk, then follow the AI SDK quickstart. See the AI SDK reference for return types, tool approval, MCP tools, streaming updates, and error handling.

  • Novu Chat SDK Adapter

    Bring your Chat SDK agent to Slack, Teams, WhatsApp, Telegram, and email: deliver multi-channel notifications from one trigger, resolve every channel to one unified subscriber, and drop in React connect components to put channels in front of your end-customers.

    Author:Dima Grossman
    Dima Grossman

    The @novu/chat-sdk-adapter is now available. Wire it into your Chat SDK app and Novu manages credentials, identity, and delivery across Slack, Microsoft Teams, WhatsApp, Telegram, and email.

    npm install @novu/chat-sdk-adapter

    Multi-channel notifications from one trigger

    Define a workflow once in Novu with the channels you want, then fire a single trigger from any handler. Novu fans out to every step — Slack, email, WhatsApp, and more — and routes replies back through the same agent loop, so proactive notifications and conversational replies share one handler set.

    const ctx = getNovuContext(thread);

// One trigger delivers to every channel in the workflow.
await ctx.trigger("order-shipped", {
  payload: { orderId: "1234", trackingUrl: "https://example.com/track/1234" },
});

    One unified subscriber across every channel

    Every channel resolves to a single Novu subscriber mapped to your own user, so your agent always knows who it's talking to — with email, phone, locale, custom data, and the canonical conversation history available inside any handler.

    const ctx = getNovuContext(thread);

const subscriber = await ctx.getSubscriber(); // email, phone, locale, custom data
const history = await ctx.getHistory();       // canonical transcript — ideal for LLM context

    Expose channels to end-customers with connect components

    Drop the prebuilt SlackConnectButton from @novu/react into your app so your end-customers can install and connect their own Slack workspace to your agent — OAuth, credentials, and Slack Connect handled by Novu. Microsoft Teams and Telegram connect buttons are in pre-release.

    import { SlackConnectButton } from '@novu/react';

<SlackConnectButton
  integrationIdentifier={integrationIdentifier}
  connectionIdentifier={`${subscriberId}:${integrationIdentifier}:${agent.identifier}`}
  connectionMode="subscriber"
  connectLabel={`Install ${agent.name} ↗`}
  connectedLabel="Connected to Slack"
  onConnectSuccess={handleSlackOAuthSuccess}
/>

    Get started with npx novu connect --runtime chat-sdk, or read the connect components docs.

  • In-conversation MCP authorization and message queues

    Connect external MCPs during the conversation and process incoming messages one at a time for a more predictable chat experience.

    Author:Dima Grossman
    Dima Grossman

    Connecting external MCPs is now part of the conversation itself, instead of a separate setup step. When an agent needs access to a tool, it can prompt the user to connect it right at that moment and then continue the original request once access is granted. This makes the experience feel much more natural and reduces the friction of getting started with tool-powered workflows.

    We also introduced session-level tool access, so connected tools are available only where they are relevant. That gives users a clearer sense of control over what an agent can use during a conversation, while helping keep tool usage focused on the task at hand.

    Conversation queue

    We also improved how conversations behave when several messages arrive quickly. Messages are now processed in order, one at a time, instead of competing in parallel. This creates a more predictable experience in fast-moving chats and helps reduce confusing or out-of-sequence responses.

    Each queued message gets its own ⏳ indicator, and the indicator is removed when the message is processed.