@novu/framework 2.11.1 → 2.11.2-alpha.1

package/dist/{esm/index-D6L0Yufw.d.ts → cjs/agent.types-Dqm2VBTO.d.cts}

@@ -1,8 +1,198 @@
 import { ChatElement, Emoji, CardElement } from 'chat';
-import { T as TriggerRecipientsPayload, L as Logger, C as ClientOptions, W as Workflow, H as HealthCheck, e as DiscoverOutput, i as Event, n as ExecuteOutput, d as CodeResult, j as EventTriggerParams, m as Execute, t as WorkflowOptions } from './health-check.types-C-81VaBO.js';
-import { g as Awaitable } from './subscriber.types-CC7F0JO_.js';
-import { S as Schema, a as FromSchema, F as FromSchemaUnvalidated } from './base.schema.types-BApIn9jr.js';
-import './step-resolver.js';
+import { A as Awaitable } from './util.types-DaFfsxgy.cjs';
+
+type AgentErrorDelivery = {
+    statusCode: number;
+    responseBody: string;
+};
+type AgentErrorOptions = {
+    cause?: unknown;
+    delivery?: AgentErrorDelivery;
+};
+/** Turn and handler failures. Delivery failures use {@link AgentDeliveryError}. */
+declare class AgentError extends Error {
+    readonly cause?: unknown;
+    readonly delivery?: AgentErrorDelivery;
+    constructor(message: string, options?: AgentErrorOptions);
+}
+/**
+ * Thrown by `ctx.reply()` and `handle.edit()` when the upstream message delivery
+ * fails — e.g. the configured email provider returns 401, Slack rejects the token,
+ * or Teams rejects the request.
+ *
+ * @example
+ * ```ts
+ * import { AgentDeliveryError } from '@novu/framework';
+ *
+ * try {
+ *   await ctx.reply('Hello!');
+ * } catch (err) {
+ *   if (err instanceof AgentDeliveryError) {
+ *     console.error('Delivery failed:', err.message, err.statusCode);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+declare class AgentDeliveryError extends AgentError {
+    readonly statusCode: number;
+    readonly responseBody: string;
+    constructor(statusCode: number, responseBody: string);
+}
+declare function toAgentError(err: unknown): AgentError;
+
+declare enum ChannelTypeEnum {
+    IN_APP = "in_app",
+    EMAIL = "email",
+    SMS = "sms",
+    CHAT = "chat",
+    PUSH = "push"
+}
+interface IAttachmentOptions {
+    mime: string;
+    file: Buffer;
+    name?: string;
+    channels?: ChannelTypeEnum[];
+    cid?: string;
+    disposition?: string;
+}
+interface ITriggerPayload {
+    attachments?: IAttachmentOptions[];
+    [key: string]: string | string[] | boolean | number | undefined | IAttachmentOptions | IAttachmentOptions[] | Record<string, unknown>;
+}
+interface ISubscriberPayload {
+    subscriberId: string;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    avatar?: string;
+    locale?: string;
+    data?: Record<string, unknown>;
+    channels?: ISubscriberChannel[];
+}
+interface ISubscriberChannel {
+    providerId: ChatProviderIdEnum | PushProviderIdEnum;
+    integrationIdentifier?: string;
+    credentials: IChannelCredentials;
+}
+interface IChannelCredentials {
+    webhookUrl?: string;
+    deviceTokens?: string[];
+}
+interface ITopic {
+    type: 'Topic';
+    topicKey: string;
+    exclude?: string[];
+}
+type TriggerRecipientsPayload = string | ISubscriberPayload | ITopic | ISubscriberPayload[] | ITopic[];
+declare enum TriggerEventStatusEnum {
+    ERROR = "error",
+    NOT_ACTIVE = "trigger_not_active",
+    NO_WORKFLOW_ACTIVE_STEPS = "no_workflow_active_steps_defined",
+    NO_WORKFLOW_STEPS = "no_workflow_steps_defined",
+    PROCESSED = "processed",
+    SUBSCRIBER_MISSING = "subscriber_id_missing",
+    TENANT_MISSING = "no_tenant_found"
+}
+declare enum ChatProviderIdEnum {
+    Slack = "slack",
+    Discord = "discord",
+    MsTeams = "msteams",
+    Mattermost = "mattermost",
+    Ryver = "ryver",
+    Zulip = "zulip",
+    GrafanaOnCall = "grafana-on-call",
+    GetStream = "getstream",
+    RocketChat = "rocket-chat",
+    WhatsAppBusiness = "whatsapp-business",
+    ChatWebhook = "chat-webhook",
+    Telegram = "telegram",
+    Sendblue = "sendblue"
+}
+declare enum PushProviderIdEnum {
+    FCM = "fcm",
+    APNS = "apns",
+    EXPO = "expo",
+    OneSignal = "one-signal",
+    Pushpad = "pushpad",
+    PushWebhook = "push-webhook",
+    PusherBeams = "pusher-beams",
+    AppIO = "appio"
+}
+/**
+ * A preference for a notification delivery workflow.
+ *
+ * This provides a shortcut to setting all channels to the same preference.
+ */
+type WorkflowPreference = {
+    /**
+     * A flag specifying if notification delivery is enabled for the workflow.
+     *
+     * If `true`, notification delivery is enabled by default for all channels.
+     *
+     * This setting can be overridden by the channel preferences.
+     *
+     * @default true
+     */
+    enabled: boolean;
+    /**
+     * A flag specifying if the preference is read-only.
+     *
+     * If `true`, the preference cannot be changed by the Subscriber.
+     *
+     * @default false
+     */
+    readOnly: boolean;
+};
+/** A preference for a notification delivery channel. */
+type ChannelPreference = {
+    /**
+     * A flag specifying if notification delivery is enabled for the channel.
+     *
+     * If `true`, notification delivery is enabled.
+     *
+     * @default true
+     */
+    enabled: boolean;
+};
+type WorkflowPreferences = {
+    /**
+     * A preference for the workflow.
+     *
+     * The values specified here will be used if no preference is specified for a channel.
+     */
+    all: WorkflowPreference;
+    /**
+     * A preference for each notification delivery channel.
+     *
+     * If no preference is specified for a channel, the `all` preference will be used.
+     */
+    channels: Record<ChannelTypeEnum, ChannelPreference>;
+};
+/**
+ * Recursively make all properties of type `T` optional.
+ */
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/** A partial set of workflow preferences. */
+type WorkflowPreferencesPartial = DeepPartial<WorkflowPreferences>;
+
+type Verdict = 'approve' | 'deny';
+interface ToolApprovalRequestPayload {
+    approvalId: string;
+    toolCallId: string;
+    name: string;
+    input?: Record<string, unknown>;
+}
+interface ParsedApprovalAction {
+    approved: boolean;
+    approvalId: string;
+}
+declare function buildApprovalActionId(verdict: Verdict, approvalId: string): string;
+declare function parseApprovalActionId(id: string | undefined): ParsedApprovalAction | null;
 
 declare enum AgentEventEnum {
     ON_MESSAGE = "onMessage",
@@ -64,6 +254,24 @@ interface AgentSubscriber {
     /** Arbitrary custom data attached to the subscriber in Novu. */
     data?: Record<string, unknown>;
 }
+/**
+ * Tool-call details on a tool-related history entry. Which fields are set depends on the
+ * entry's `type` (`tool_approval_request`, `tool_approval_decision`, or `tool_result`).
+ */
+interface AgentToolData {
+    /** Id of the tool call. */
+    toolCallId?: string;
+    /** Name of the tool. */
+    toolName?: string;
+    /** Id linking an approval request to its decision. */
+    approvalId?: string;
+    /** Arguments the tool was called with. */
+    input?: Record<string, unknown>;
+    /** Whether the tool call was approved or denied. */
+    approved?: boolean;
+    /** What the tool returned (or the `execution-denied` marker for a denied call). */
+    output?: unknown;
+}
 /**
  * A single entry in the conversation history.
  * `ctx.history` is an ordered array of these entries — map them to your LLM's
@@ -72,17 +280,22 @@ interface AgentSubscriber {
 interface AgentHistoryEntry {
     /** Message role: `'user'`, `'assistant'`, or `'system'`. */
     role: string;
-    /** Content type: `'text'`, `'card'`, etc. */
+    /**
+     * The kind of entry: `'message'`, `'edit'`, `'signal'`, or a tool-lifecycle event
+     * (`'tool_approval_request'`, `'tool_approval_decision'`, `'tool_result'`).
+     */
     type: string;
     /** Plain-text representation of the message content. */
     content: string;
     richContent?: Record<string, unknown>;
     senderName?: string;
-    /** Present on system entries that carry a Novu signal (e.g. metadata updates). */
+    /** Structured data for `signal` entries (e.g. metadata updates). */
     signalData?: {
         type: string;
         payload?: Record<string, unknown>;
     };
+    /** Tool-call details — set on tool-lifecycle entries (`tool_*`). */
+    toolData?: AgentToolData;
     createdAt: string;
 }
 /** Resolved inbound email domain metadata (present when `platform === 'email'`). */
@@ -150,6 +363,7 @@ type MessageContent = string | ChatElement;
 interface ReplyContent {
     markdown?: string;
     card?: CardElement;
+    toolApprovalCard?: ToolApprovalCard;
     files?: FileRef[];
 }
 /**
@@ -166,6 +380,89 @@ interface AgentAction {
     /** Platform-native message ID of the message containing the clicked button/action. */
     sourceMessageId?: string;
 }
+/**
+ * A tool call that requires user approval before it runs.
+ * Pass this to `ctx.toolApproval.request()` when your agent wants to gate a tool.
+ */
+interface AgentToolCall {
+    id: string;
+    name: string;
+    input?: Record<string, unknown>;
+}
+/**
+ * Presentation descriptor for Novu's built-in tool-approval card. Returned by the
+ * injected `approvalCard()` helper. Novu renders it natively on Slack and as a
+ * portable fallback elsewhere; Approve/Deny action ids are always supplied by Novu.
+ *
+ * Channel mapping (self-hosted):
+ * - **Slack (native card):** `icon`, `title`, `subtitle`, `body`, `approveLabel`, `denyLabel`
+ * - **Other channels (portable card):** `title`, `subtitle`, `approveLabel`, `denyLabel`
+ *
+ * `icon` and `body` are ignored on non-Slack channels — the portable fallback has no
+ * card image or body block. Catalog icons are 32×32; custom `https://` URLs should match.
+ */
+interface ToolApprovalCard {
+    type: 'tool-approval-card';
+    /** Slack only. Catalog id (`'stripe'`), `https://` URL, or omit to auto-match the tool name. Use 32×32 px for custom URLs. */
+    icon?: string;
+    /** All channels. Card title. Defaults to `Tool approval required`. */
+    title?: string;
+    /** All channels. Card subtitle; auto-generated from the tool name/input when omitted. */
+    subtitle?: string;
+    /** Slack only. Optional markdown body (e.g. argument preview). Not shown on portable fallback. */
+    body?: string;
+    /** All channels. Approve button label. Defaults to `Approve`. */
+    approveLabel?: string;
+    /** All channels. Deny button label. Defaults to `Deny`. */
+    denyLabel?: string;
+}
+/**
+ * Returned by `ctx.toolApproval.request()`. Return it from `onMessage` to post
+ * an approval card and end the turn until the user approves or denies.
+ */
+declare class PendingApproval {
+    readonly __novuPendingApproval: true;
+}
+/** Optional customization for tool approval messages. */
+interface ToolApprovalConfig {
+    /**
+     * Build the approval message shown while waiting for a decision.
+     *
+     * Return `approvalCard(...)` for Novu's channel-adaptive card (native on Slack,
+     * fallback elsewhere), or return a string/`Card` to take full control (portable
+     * on every channel). Use the provided `actionIds` on your own buttons.
+     */
+    renderApproval?: (args: {
+        toolCall: AgentToolCall;
+        actionIds: {
+            approve: string;
+            deny: string;
+        };
+        approvalCard: (overrides?: Omit<ToolApprovalCard, 'type'>) => ToolApprovalCard;
+    }) => MessageContent | ToolApprovalCard;
+}
+/** Passed to `onToolApproval` when the user clicks Approve or Deny. */
+interface ToolApprovalDecision {
+    /** The tool that was awaiting approval. */
+    toolCall: AgentToolCall;
+    /** `true` if the user approved, `false` if they denied. */
+    approved: boolean;
+    /**
+     * Handle to the approval message. When you register `onToolApproval`, you own
+     * card cleanup — call `edit()` or `delete()` as needed. When the framework
+     * handles the approval click, the card is deleted for you.
+     */
+    approvalMessage: ReplyHandle;
+}
+/** Controls on `ctx.toolApproval` for gating tool calls. */
+interface ToolApprovalControl {
+    /**
+     * Post an approval message and pause the turn.
+     * Return the result (`return ctx.toolApproval.request(...)`) from `onMessage`
+     * to end the turn until the user decides.
+     */
+    request(toolCall: AgentToolCall): Promise<PendingApproval>;
+}
 /** An emoji reaction added to or removed from a message. */
 interface AgentReaction {
     /** Platform-native ID of the message that was reacted to. */
@@ -192,8 +489,10 @@ interface ReplyHandle {
     edit(content: MessageContent, options?: {
         files?: FileRef[];
     }): Promise<ReplyHandle>;
+    /** Delete this message from the platform. Removes the rendered message only — history is preserved. */
+    delete(): Promise<void>;
 }
-interface AgentContextBase {
+interface AgentHandlerContext {
     /** Live state of the current conversation, including persisted metadata. */
     readonly conversation: AgentConversation;
     /**
@@ -227,6 +526,15 @@ interface AgentContextBase {
     reply(content: MessageContent, options?: {
         files?: FileRef[];
     }): Promise<ReplyHandle>;
+    /**
+     * Gate tool calls that need user approval before they run.
+     *
+     * @example
+     *   if (needsApproval(toolCall)) {
+     *     return ctx.toolApproval.request(toolCall);
+     *   }
+     */
+    readonly toolApproval: ToolApprovalControl;
     /**
      * Mark the conversation as resolved. Optionally provide a summary for the resolution record.
      * Triggers the `onResolve` handler if one is registered.
@@ -285,25 +593,49 @@ interface AgentContextBase {
      *   await ctx.reply('Done!');
      */
     addReaction(messageId: string, emojiName: Emoji): void;
+    /**
+     * Delete a platform message by id. Queued and flushed with the next `ctx.reply()`,
+     * or automatically when the handler completes (same batching as `ctx.addReaction()`).
+     * Deletes the rendered message only — conversation history is preserved.
+     *
+     * @example
+     *   ctx.deleteMessage(ctx.action!.sourceMessageId!);
+     *   await ctx.reply('Processing…');
+     */
+    deleteMessage(messageId: string): void;
+    /**
+     * Control the typing / "Thinking…" status for the current turn.
+     * Posts immediately (like `reply()`), updating the indicator Novu already shows on inbound.
+     *
+     * @example
+     *   await ctx.typing('Searching the docs…'); // set / replace the status text
+     *   await ctx.typing();                       // reset to the default "Thinking…"
+     *   await ctx.typing.stop();                  // clear it for this turn
+     *
+     * Behaviour is best-effort per platform: custom text shows on Slack-like platforms,
+     * a generic typing bubble on others, and is a no-op where there is no typing channel
+     * (e.g. email). A normal turn that ends with `ctx.reply()` clears the status automatically.
+     */
+    typing: TypingControl;
 }
 /** Context passed to the `onMessage` handler. */
-interface AgentMessageContext extends AgentContextBase {
+interface AgentMessageContext extends AgentHandlerContext {
     readonly event: 'onMessage';
 }
 /** Context passed to the `onAction` handler. */
-interface AgentActionContext extends AgentContextBase {
+interface AgentActionContext extends AgentHandlerContext {
     readonly event: 'onAction';
     /** The button click or interactive action that triggered this handler. */
     readonly action: AgentAction;
 }
 /** Context passed to the `onReaction` handler. */
-interface AgentReactionContext extends AgentContextBase {
+interface AgentReactionContext extends AgentHandlerContext {
     readonly event: 'onReaction';
     /** The emoji reaction that triggered this handler. */
     readonly reaction: AgentReaction;
 }
 /** Context passed to the `onResolve` handler. */
-interface AgentResolveContext extends AgentContextBase {
+interface AgentResolveContext extends AgentHandlerContext {
     readonly event: 'onResolve';
 }
 type AgentContext = AgentMessageContext | AgentActionContext | AgentReactionContext | AgentResolveContext;
@@ -346,10 +678,41 @@ interface AgentHandlers {
      *   `ctx.subscriber` and `ctx.conversation`.
      */
     onResolve?: (ctx: AgentResolveContext) => Awaitable<MessageContent | void>;
+    /**
+     * Fires when the user approves or denies a tool call you previously gated with
+     * `ctx.toolApproval.request()`.
+     *
+     * @param decision - The tool, the user's verdict, and a handle to the approval message.
+     * @param ctx - Conversation context (history, subscriber, metadata, reply/trigger methods).
+     *
+     * Run the tool (or skip it), then return a reply or call `ctx.reply()` directly.
+     * Register this handler whenever you call `ctx.toolApproval.request()` in `onMessage`.
+     */
+    onToolApproval?: (decision: ToolApprovalDecision, ctx: AgentActionContext) => Awaitable<MessageContent | void>;
+    /**
+     * Optional turn failure handler. Return `{ suppress: true }` to skip user notification,
+     * return message content for a custom user reply, or return nothing to auto-report
+     * `{ error: true }` to Novu (generic end-user copy delivered by the API).
+     */
+    onError?: (error: AgentError, ctx: AgentMessageContext | AgentActionContext | AgentReactionContext | AgentResolveContext) => Awaitable<AgentErrorResult>;
+    /**
+     * Customize how approval messages look. Omit to use the built-in Approve/Deny card.
+     */
+    toolApproval?: ToolApprovalConfig;
 }
+type AgentErrorSuppress = {
+    suppress: true;
+};
+type AgentErrorResult = MessageContent | void | AgentErrorSuppress;
 interface Agent {
     id: string;
     handlers: AgentHandlers;
+    /**
+     * @internal Set by `agent()` / ai-sdk registration. True when the application
+     * author registered `onToolApproval` (full manual card cleanup). False when
+     * only a framework wrapper handles approval clicks (auto-delete after handler).
+     */
+    userOnToolApproval?: boolean;
 }
 interface AgentBridgeRequest {
     version: number;
@@ -398,6 +761,17 @@ type TriggerSignal = {
     payload?: Record<string, unknown>;
 };
 type Signal = MetadataSignal | TriggerSignal;
+/** The outcome of a tool call, reported back so it's saved in the conversation history. */
+type ToolResult = {
+    /** Id of the tool call this result belongs to. */
+    toolCallId: string;
+    /** Name of the tool. */
+    toolName?: string;
+    /** What the tool returned (or the `execution-denied` marker for a denied call). */
+    output: unknown;
+    /** Optional human-readable summary shown in the conversation timeline. */
+    preview?: string;
+};
 /** In-place edit of a previously posted agent message. Identified by platform message id. */
 interface EditPayload {
     messageId: string;
@@ -408,6 +782,24 @@ interface AddReactionPayload {
     messageId: string;
     emojiName: Emoji;
 }
+/** Delete a previously posted platform message. Removes the rendered message only — history is preserved. */
+interface DeleteMessagePayload {
+    messageId: string;
+}
+/**
+ * Per-turn typing/status control op sent on the reply contract.
+ * - `{ status?: string }` — set/replace the status; omit `status` for the default "Thinking…".
+ * - `'stop'` — clear the status for this turn.
+ */
+type TypingOp = {
+    status?: string;
+} | 'stop';
+/**
+ * `ctx.typing` surface: a callable that sets/updates the status, plus `.stop()` to clear it.
+ */
+type TypingControl = ((status?: string) => Promise<void>) & {
+    stop: () => Promise<void>;
+};
 interface AgentReplyPayload {
     conversationId: string;
     integrationIdentifier: string;
@@ -417,7 +809,13 @@ interface AgentReplyPayload {
         summary?: string;
     };
     signals?: Signal[];
+    toolResults?: ToolResult[];
+    toolApprovalRequest?: ToolApprovalRequestPayload;
     addReactions?: AddReactionPayload[];
+    deleteMessages?: DeleteMessagePayload[];
+    typing?: TypingOp;
+    /** Bridge reports a real turn failure; Novu delivers generic user copy. */
+    error?: true;
 }
 /** Shape returned by /agents/:id/reply when a reply or edit was delivered. */
 interface SentMessageInfo {
@@ -425,185 +823,4 @@ interface SentMessageInfo {
     platformThreadId: string;
 }
 
-/**
- * Thrown by `ctx.reply()` and `handle.edit()` when the upstream message delivery
- * fails — e.g. the configured email provider returns 401, Slack rejects the token,
- * or Teams rejects the request.
- *
- * `message` is always a short, human-readable summary.
- * `responseBody` preserves the raw upstream body for debugging.
- *
- * @example
- * ```ts
- * import { AgentDeliveryError } from '@novu/framework';
- *
- * try {
- *   await ctx.reply('Hello!');
- * } catch (err) {
- *   if (err instanceof AgentDeliveryError) {
- *     console.error('Delivery failed:', err.message);
- *     return;
- *   }
- *   throw err;
- * }
- * ```
- */
-declare class AgentDeliveryError extends Error {
-    readonly statusCode: number;
-    readonly responseBody: string;
-    constructor(statusCode: number, responseBody: string);
-}
-
-/**
- * Define a new conversational agent.
- *
- * @param agentId - Unique identifier matching the agent entity created in Novu (e.g. 'wine-bot')
- * @param handlers - Handler functions for agent events
- */
-declare function agent(agentId: string, handlers: AgentHandlers): Agent;
-
-declare class Client {
-    private discoveredWorkflows;
-    private discoverWorkflowPromises;
-    private registeredAgents;
-    private templateEngine;
-    secretKey: string;
-    apiUrl: string;
-    version: string;
-    strictAuthentication: boolean;
-    verbose: boolean;
-    logger: Logger;
-    constructor(options?: ClientOptions);
-    private buildOptions;
-    private log;
-    /**
-     * Adds workflows to the client.
-     *
-     * A locking mechanism is used to ensure that duplicate workflows are not added.
-     *
-     * @param workflows - The workflows to add.
-     */
-    addWorkflows(workflows: Array<Workflow>): Promise<void>;
-    addAgents(agents: Array<Agent>): void;
-    getAgent(agentId: string): Agent | undefined;
-    private addWorkflow;
-    healthCheck(): HealthCheck;
-    private getWorkflow;
-    private getStep;
-    private getRegisteredWorkflows;
-    discover(): DiscoverOutput;
-    /**
-     * Mocks data based on the given schema.
-     * The `default` value in the schema is used as the base data.
-     * If no `default` value is provided, the data is generated using JSONSchemaFaker.
-     *
-     * @param schema
-     * @returns mocked data
-     */
-    private mock;
-    private validate;
-    private throwInvalidProvider;
-    private throwInvalidStep;
-    private throwInvalidEvent;
-    private executeStepFactory;
-    private shouldSanitize;
-    private shouldSkip;
-    executeWorkflow(event: Event): Promise<ExecuteOutput>;
-    private createExecutionPayload;
-    private prettyPrintExecute;
-    private executeProviders;
-    private previewProvider;
-    private executeProvider;
-    private executeStep;
-    private compileControls;
-    /**
-     * Preprocesses standalone translation patterns.
-     * Transforms {{t.key}} to [T:key] placeholder (not Liquid syntax, passes through unchanged).
-     */
-    private preprocessTranslationPatterns;
-    /**
-     * Preprocesses translation keys used as filter arguments.
-     * Transforms 't.key' to '[T:key]' placeholder (not Liquid syntax, passes through unchanged).
-     * Example: pluralize: 't.apple', 't.apples' → pluralize: '[T:apple]', '[T:apples]'
-     */
-    private preprocessFilterTranslationArgs;
-    /**
-     * Post-processes placeholders back to translation markers after Liquid render.
-     * Transforms [T:key] back to {{t.key}} for the translation service.
-     */
-    private postprocessTranslationMarkers;
-    /**
-     * Create the controls for a step, taking both the event controls and the default controls into account
-     *
-     * @param step The step to create the controls for
-     * @param event The event that triggered the step
-     * @returns The controls for the step
-     */
-    private createStepControls;
-    private previewStep;
-    private constructStepForPreview;
-    private extractMockDataForPreviousSteps;
-    private previewRequiredStep;
-    private getStepState;
-    private getStepCode;
-    private getWorkflowCode;
-    getCode(workflowId: string, stepId?: string): CodeResult;
-}
-
-interface ServeHandlerOptions {
-    client?: Client;
-    workflows?: Array<Workflow>;
-    agents?: Array<Agent>;
-}
-type INovuRequestHandlerOptions<Input extends any[] = any[], Output = any> = ServeHandlerOptions & {
-    frameworkName: string;
-    client?: Client;
-    workflows?: Array<Workflow>;
-    agents?: Array<Agent>;
-    handler: Handler<Input, Output>;
-};
-type Handler<Input extends any[] = any[], Output = any> = (...args: Input) => HandlerResponse<Output>;
-type HandlerResponse<Output = any> = {
-    body: () => Awaitable<any>;
-    headers: (key: string) => Awaitable<string | null | undefined>;
-    method: () => Awaitable<string>;
-    queryString?: (key: string, url: URL) => Awaitable<string | null | undefined>;
-    url: () => Awaitable<URL>;
-    transformResponse: (res: IActionResponse<string>) => Output;
-    waitUntil?: (promise: Promise<unknown>) => void;
-};
-type IActionResponse<TBody extends string = string> = {
-    status: number;
-    headers: Record<string, string>;
-    body: TBody;
-};
-declare class NovuRequestHandler<Input extends any[] = any[], Output = any> {
-    readonly frameworkName: string;
-    readonly handler: Handler<Input, Output>;
-    readonly client: Client;
-    private readonly hmacEnabled;
-    private readonly http;
-    private readonly workflows;
-    private readonly agents;
-    constructor(options: INovuRequestHandlerOptions<Input, Output>);
-    createHandler(): (...args: Input) => Promise<Output>;
-    private getStaticHeaders;
-    private createResponse;
-    private createError;
-    private handleAction;
-    private getPostActionMap;
-    triggerAction(triggerEvent: EventTriggerParams): () => Promise<IActionResponse<string>>;
-    private getGetActionMap;
-    private handlePostAction;
-    private handleGetAction;
-    private runAgentHandler;
-    private handleError;
-    private validateHmac;
-}
-
-/**
- * Define a new notification workflow.
- */
-declare function workflow<T_PayloadSchema extends Schema, T_ControlSchema extends Schema, T_EnvSchema extends Schema, T_PayloadValidated extends Record<string, unknown> = FromSchema<T_PayloadSchema>, T_PayloadUnvalidated extends Record<string, unknown> = FromSchemaUnvalidated<T_PayloadSchema>, T_Controls extends Record<string, unknown> = FromSchema<T_ControlSchema>, T_Env extends Record<string, unknown> = FromSchema<T_EnvSchema>>(workflowId: string, execute: Execute<T_PayloadValidated, T_Controls, T_Env>, workflowOptions?: WorkflowOptions<T_PayloadSchema, T_ControlSchema, T_EnvSchema>): Workflow<T_PayloadUnvalidated>;
-
-export { type Agent as A, Client as C, type EditPayload as E, type FileRef as F, type INovuRequestHandlerOptions as I, type MessageContent as M, NovuRequestHandler as N, type ReplyContent as R, type ServeHandlerOptions as S, type TriggerSignal as T, type AgentAction as a, type AgentActionContext as b, type AgentAttachment as c, type AgentBridgeRequest as d, type AgentContext as e, type AgentConversation as f, AgentDeliveryError as g, AgentEventEnum as h, type AgentHandlers as i, type AgentHistoryEntry as j, type AgentMessage as k, type AgentMessageAuthor as l, type AgentMessageContext as m, type AgentPlatformContext as n, type AgentReaction as o, type AgentReactionContext as p, type AgentReplyPayload as q, type AgentResolveContext as r, type AgentSubscriber as s, type MetadataSignal as t, type ReplyHandle as u, type SentMessageInfo as v, type Signal as w, agent as x, workflow as y };
+export { type Agent as A, type ToolApprovalRequestPayload as B, AgentEventEnum as C, type TypingControl as D, type ToolApprovalControl as E, type FileRef as F, type AgentBridgeRequest as G, type AgentReplyPayload as H, type ITriggerPayload as I, type DeleteMessagePayload as J, type EditPayload as K, type MetadataSignal as L, type MessageContent as M, type ReplyContent as N, type Signal as O, type ParsedApprovalAction as P, type TriggerSignal as Q, type ReplyHandle as R, type SentMessageInfo as S, type ToolApprovalCard as T, buildApprovalActionId as U, parseApprovalActionId as V, type WorkflowPreferencesPartial as W, type AgentAction as a, type AgentActionContext as b, type AgentAttachment as c, type AgentContext as d, type AgentConversation as e, AgentDeliveryError as f, AgentError as g, type AgentHandlerContext as h, type AgentHandlers as i, type AgentHistoryEntry as j, type AgentMessage as k, type AgentMessageAuthor as l, type AgentMessageContext as m, type AgentPlatformContext as n, type AgentReaction as o, type AgentReactionContext as p, type AgentResolveContext as q, type AgentSubscriber as r, type AgentToolCall as s, type ToolApprovalConfig as t, type ToolApprovalDecision as u, toAgentError as v, type TriggerRecipientsPayload as w, type ISubscriberPayload as x, TriggerEventStatusEnum as y, type ToolResult as z };