@meetopenbot/notion 0.0.1

package/dist/conversation-history.d.ts

@@ -0,0 +1,10 @@
+import type { ModelMessage } from 'ai';
+/** Cap on model messages (user, assistant, tool); includes tool-call/result pairs. */
+export declare const MAX_HISTORY_MESSAGES = 60;
+/**
+ * Walks persisted `events` in order and builds model messages: user turns, tool call/result
+ * pairs from `client:ui:widget` (Notion Action / Notion Result), and assistant text from
+ * `agent:output`.
+ */
+export declare function buildConversationMessages(events: unknown[], agentId: string, currentUserContent: string): ModelMessage[];
+export declare function trimHistory(messages: ModelMessage[], max: number): ModelMessage[];

package/dist/conversation-history.js

@@ -0,0 +1,164 @@
+/** Cap on model messages (user, assistant, tool); includes tool-call/result pairs. */
+export const MAX_HISTORY_MESSAGES = 60;
+let toolSequence = 0;
+function nextToolCallId() {
+    return `hist-tool-${toolSequence++}`;
+}
+function resetToolIds() {
+    toolSequence = 0;
+}
+function tryParseJson(raw) {
+    const s = raw.trim();
+    if (!s)
+        return '';
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+/** Parses `Input: ...` / `Output: ...` blocks from persisted UI widget bodies. */
+function parseNotionToolBody(body) {
+    const t = body.trim();
+    const outMarker = '\nOutput:';
+    const outIdx = t.indexOf(outMarker);
+    if (outIdx === -1) {
+        const onlyOut = t.match(/^Output:\s*([\s\S]*)$/i);
+        if (onlyOut)
+            return { output: tryParseJson(onlyOut[1]) };
+        const onlyIn = t.match(/^Input:\s*([\s\S]*)$/i);
+        if (onlyIn)
+            return { input: tryParseJson(onlyIn[1]) };
+        return {};
+    }
+    const head = t.slice(0, outIdx);
+    const tail = t.slice(outIdx + outMarker.length);
+    const inMatch = head.match(/^Input:\s*([\s\S]*)$/i);
+    const input = inMatch ? tryParseJson(inMatch[1]) : undefined;
+    const output = tryParseJson(tail);
+    return { input, output };
+}
+function toolOutputFromUnknown(value) {
+    if (value === undefined || value === null) {
+        return { type: 'text', value: '' };
+    }
+    if (typeof value === 'string') {
+        return { type: 'text', value };
+    }
+    return { type: 'json', value: value };
+}
+const ACTION_TITLE = /^Notion Action:\s*(.+)$/i;
+const RESULT_TITLE = /^Notion Result:\s*(.+)$/i;
+function pushToolRound(messages, toolName, input, output) {
+    const toolCallId = nextToolCallId();
+    messages.push({
+        role: 'assistant',
+        content: [
+            {
+                type: 'tool-call',
+                toolCallId,
+                toolName,
+                input,
+            },
+        ],
+    });
+    messages.push({
+        role: 'tool',
+        content: [
+            {
+                type: 'tool-result',
+                toolCallId,
+                toolName,
+                output: toolOutputFromUnknown(output),
+            },
+        ],
+    });
+}
+/**
+ * Walks persisted `events` in order and builds model messages: user turns, tool call/result
+ * pairs from `client:ui:widget` (Notion Action / Notion Result), and assistant text from
+ * `agent:output`.
+ */
+export function buildConversationMessages(events, agentId, currentUserContent) {
+    const list = [];
+    const raw = Array.isArray(events) ? events : [];
+    let pendingToolName;
+    let pendingInput;
+    resetToolIds();
+    for (const item of raw) {
+        const e = item;
+        if (e.type === 'agent:invoke') {
+            const data = e.data;
+            const role = data?.role ?? 'user';
+            const text = data?.content;
+            if (role === 'user' && typeof text === 'string' && text.length > 0) {
+                resetToolIds();
+                list.push({ role: 'user', content: text });
+            }
+        }
+        else if (e.type === 'client:ui:widget' && e.meta?.agentId === agentId) {
+            const d = e.data;
+            if (d.kind !== 'message' || typeof d.body !== 'string' || !d.title)
+                continue;
+            const actionMatch = d.title.match(ACTION_TITLE);
+            if (actionMatch) {
+                const { input } = parseNotionToolBody(d.body);
+                pendingToolName = actionMatch[1].trim();
+                pendingInput = input;
+                continue;
+            }
+            const resultMatch = d.title.match(RESULT_TITLE);
+            if (!resultMatch)
+                continue;
+            const toolName = resultMatch[1].trim();
+            const { input: bodyInput, output } = parseNotionToolBody(d.body);
+            const input = bodyInput !== undefined
+                ? bodyInput
+                : pendingToolName === toolName
+                    ? pendingInput
+                    : undefined;
+            if (output !== undefined) {
+                pushToolRound(list, toolName, input ?? {}, output);
+            }
+            pendingToolName = undefined;
+            pendingInput = undefined;
+        }
+        else if (e.type === 'agent:output' && e.meta?.agentId === agentId) {
+            const text = e.data?.content;
+            if (typeof text === 'string' && text.trim()) {
+                list.push({ role: 'assistant', content: text.trim() });
+            }
+        }
+    }
+    return finalizeCurrentUserTurn(list, currentUserContent);
+}
+/**
+ * Ensures the pending user message is included exactly once (matches storage timing).
+ */
+function userTextContent(msg) {
+    if (msg.role !== 'user')
+        return undefined;
+    const c = msg.content;
+    return typeof c === 'string' ? c : undefined;
+}
+function finalizeCurrentUserTurn(messages, currentUserContent) {
+    const last = messages[messages.length - 1];
+    if (!last) {
+        return [{ role: 'user', content: currentUserContent }];
+    }
+    if (last.role === 'assistant' || last.role === 'tool') {
+        return [...messages, { role: 'user', content: currentUserContent }];
+    }
+    if (last.role === 'user') {
+        if (userTextContent(last) === currentUserContent)
+            return messages;
+        return [...messages, { role: 'user', content: currentUserContent }];
+    }
+    return messages;
+}
+export function trimHistory(messages, max) {
+    if (messages.length <= max)
+        return messages;
+    return messages.slice(messages.length - max);
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        properties: {
+            notionApiKey: {
+                type: "string";
+                description: string;
+                format: "password";
+            };
+            openaiApiKey: {
+                type: "string";
+                description: string;
+                format: "password";
+            };
+        };
+        required: never[];
+    };
+    factory: (context: import("@meetopenbot/plugin-sdk").PluginContext) => (builder: import("melony").MelonyBuilder<import("@meetopenbot/plugin-sdk").OpenBotState, import("@meetopenbot/plugin-sdk").OpenBotEvent>) => void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,162 @@
+import { definePlugin, shouldHandleInvoke, agentOutput, uiWidget, } from '@meetopenbot/plugin-sdk';
+import { generateText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createMCPClient } from '@ai-sdk/mcp';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { buildConversationMessages, trimHistory, MAX_HISTORY_MESSAGES, } from './conversation-history.js';
+export default definePlugin({
+    name: 'Notion Agent',
+    description: 'An agent that can interact with your Notion workspace using the official MCP server.',
+    configSchema: {
+        type: 'object',
+        properties: {
+            notionApiKey: {
+                type: 'string',
+                description: 'Your Notion Internal Integration Token',
+                format: 'password'
+            },
+            openaiApiKey: {
+                type: 'string',
+                description: 'Your OpenAI API Key',
+                format: 'password'
+            },
+        },
+        required: [],
+    },
+    factory: (context) => (builder) => {
+        const openai = createOpenAI({
+            apiKey: context.config.openaiApiKey || process.env.OPENAI_API_KEY,
+        });
+        builder.on('client:ui:widget:response', async function* (event) {
+            if (event.data.widgetId === 'notion-auth-form') {
+                const apiKey = event.data.values?.notionApiKey;
+                if (apiKey) {
+                    await context.storage.createVariable({
+                        key: 'NOTION_TOKEN',
+                        value: apiKey,
+                        secret: true
+                    });
+                    yield agentOutput({
+                        agentId: context.agentId,
+                        content: '✅ Notion API key saved! You can now use the Notion agent. Please try your request again.',
+                        threadId: event.meta?.threadId
+                    });
+                }
+            }
+        });
+        builder.on('agent:invoke', async function* (event, ctx) {
+            if (!shouldHandleInvoke(event, context.agentId))
+                return;
+            const threadId = event.meta?.threadId ?? ctx.state.threadId;
+            const userMessage = event.data.content;
+            const channelId = ctx.state.channelId;
+            // Check for Notion token in config or storage
+            const variables = await context.storage.getVariables();
+            const storedToken = variables['NOTION_TOKEN'];
+            const notionToken = context.config.notionApiKey ||
+                (typeof storedToken === 'string' ? storedToken : storedToken?.value);
+            if (!notionToken) {
+                yield agentOutput({
+                    agentId: context.agentId,
+                    content: 'I need your Notion API key to proceed. Please provide it below:',
+                    threadId
+                });
+                yield uiWidget({
+                    agentId: context.agentId,
+                    widget: {
+                        kind: 'form',
+                        widgetId: 'notion-auth-form',
+                        title: 'Notion Authentication',
+                        fields: [
+                            {
+                                id: 'notionApiKey',
+                                label: 'Notion API Key',
+                                type: 'text',
+                                placeholder: 'secret_...',
+                                required: true
+                            }
+                        ],
+                        submitLabel: 'Save Key'
+                    },
+                    threadId
+                });
+                return;
+            }
+            let conversationMessages = [{ role: 'user', content: userMessage }];
+            if (channelId) {
+                try {
+                    const rawEvents = await context.storage.getEvents({
+                        channelId,
+                        ...(threadId ? { threadId } : {}),
+                    });
+                    conversationMessages = trimHistory(buildConversationMessages(rawEvents, context.agentId, userMessage), MAX_HISTORY_MESSAGES);
+                }
+                catch {
+                    // Fall back to single-turn if history cannot be loaded
+                }
+            }
+            // Initialize the Notion MCP client using stdio transport
+            const mcpClient = await createMCPClient({
+                transport: new StdioClientTransport({
+                    command: 'npx',
+                    args: ['-y', '@notionhq/notion-mcp-server'],
+                    env: {
+                        NOTION_TOKEN: notionToken,
+                        // Pass through path and other essential env vars
+                        PATH: process.env.PATH || '',
+                        HOME: process.env.HOME || '',
+                    },
+                }),
+            });
+            try {
+                // Discover all tools from the Notion MCP server
+                const tools = await mcpClient.tools();
+                const result = await generateText({
+                    model: openai('gpt-4o'),
+                    system: `You are a helpful Notion assistant. You have access to the official Notion MCP tools.
+          Use these tools to search, read, create, and update content in the user's Notion workspace.
+          Always explain what you are doing. If you need a page or database ID, use the search tools first.
+          You may see prior user and assistant turns in the conversation; use them for continuity and follow-ups.`,
+                    messages: conversationMessages,
+                    // @ts-ignore
+                    maxSteps: 10,
+                    tools,
+                });
+                // Log tool usage to the UI using widgets
+                for (const step of result.steps) {
+                    if (step.toolResults) {
+                        for (const toolResult of step.toolResults) {
+                            yield uiWidget({
+                                agentId: context.agentId,
+                                widget: {
+                                    kind: 'message',
+                                    title: `Notion Result: ${toolResult.toolName}`,
+                                    // @ts-ignore
+                                    body: `Input: ${JSON.stringify(toolResult.input, null, 2)}\nOutput: ${JSON.stringify(toolResult.result || toolResult.output, null, 2)}`,
+                                    display: 'collapsed'
+                                },
+                                threadId
+                            });
+                        }
+                    }
+                }
+                yield agentOutput({
+                    agentId: context.agentId,
+                    content: result.text,
+                    threadId,
+                });
+            }
+            catch (error) {
+                yield agentOutput({
+                    agentId: context.agentId,
+                    content: `I encountered an error while communicating with Notion: ${error.message}`,
+                    threadId,
+                });
+            }
+            finally {
+                // Ensure the MCP connection is closed to prevent resource leaks
+                await mcpClient.close();
+            }
+        });
+    },
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@meetopenbot/notion",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Notion agent kind plugin for OpenBot",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "openbot",
+    "plugin",
+    "notion"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@meetopenbot/plugin-sdk": "latest",
+    "@notionhq/client": "latest",
+    "ai": "latest",
+    "@ai-sdk/openai": "latest",
+    "@ai-sdk/mcp": "latest",
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/src/conversation-history.ts

@@ -0,0 +1,209 @@
+import type { JSONValue } from '@ai-sdk/provider';
+import type { ModelMessage } from 'ai';
+import type { ToolResultOutput } from '@ai-sdk/provider-utils';
+
+/** Cap on model messages (user, assistant, tool); includes tool-call/result pairs. */
+export const MAX_HISTORY_MESSAGES = 60;
+
+type StoredEvent = {
+  type: string;
+  data?: Record<string, unknown>;
+  meta?: {
+    agentId?: string;
+    threadId?: string;
+  };
+};
+
+type MessageWidgetData = {
+  kind?: string;
+  title?: string;
+  body?: string;
+};
+
+let toolSequence = 0;
+
+function nextToolCallId(): string {
+  return `hist-tool-${toolSequence++}`;
+}
+
+function resetToolIds(): void {
+  toolSequence = 0;
+}
+
+function tryParseJson(raw: string): unknown {
+  const s = raw.trim();
+  if (!s) return '';
+  try {
+    return JSON.parse(s) as unknown;
+  } catch {
+    return s;
+  }
+}
+
+/** Parses `Input: ...` / `Output: ...` blocks from persisted UI widget bodies. */
+function parseNotionToolBody(body: string): { input?: unknown; output?: unknown } {
+  const t = body.trim();
+  const outMarker = '\nOutput:';
+  const outIdx = t.indexOf(outMarker);
+
+  if (outIdx === -1) {
+    const onlyOut = t.match(/^Output:\s*([\s\S]*)$/i);
+    if (onlyOut) return { output: tryParseJson(onlyOut[1]) };
+    const onlyIn = t.match(/^Input:\s*([\s\S]*)$/i);
+    if (onlyIn) return { input: tryParseJson(onlyIn[1]) };
+    return {};
+  }
+
+  const head = t.slice(0, outIdx);
+  const tail = t.slice(outIdx + outMarker.length);
+  const inMatch = head.match(/^Input:\s*([\s\S]*)$/i);
+  const input = inMatch ? tryParseJson(inMatch[1]) : undefined;
+  const output = tryParseJson(tail);
+  return { input, output };
+}
+
+function toolOutputFromUnknown(value: unknown): ToolResultOutput {
+  if (value === undefined || value === null) {
+    return { type: 'text', value: '' };
+  }
+  if (typeof value === 'string') {
+    return { type: 'text', value };
+  }
+  return { type: 'json', value: value as JSONValue };
+}
+
+const ACTION_TITLE = /^Notion Action:\s*(.+)$/i;
+const RESULT_TITLE = /^Notion Result:\s*(.+)$/i;
+
+function pushToolRound(
+  messages: ModelMessage[],
+  toolName: string,
+  input: unknown,
+  output: unknown
+): void {
+  const toolCallId = nextToolCallId();
+  messages.push({
+    role: 'assistant',
+    content: [
+      {
+        type: 'tool-call',
+        toolCallId,
+        toolName,
+        input,
+      },
+    ],
+  });
+  messages.push({
+    role: 'tool',
+    content: [
+      {
+        type: 'tool-result',
+        toolCallId,
+        toolName,
+        output: toolOutputFromUnknown(output),
+      },
+    ],
+  });
+}
+
+/**
+ * Walks persisted `events` in order and builds model messages: user turns, tool call/result
+ * pairs from `client:ui:widget` (Notion Action / Notion Result), and assistant text from
+ * `agent:output`.
+ */
+export function buildConversationMessages(
+  events: unknown[],
+  agentId: string,
+  currentUserContent: string
+): ModelMessage[] {
+  const list: ModelMessage[] = [];
+  const raw = Array.isArray(events) ? events : [];
+
+  let pendingToolName: string | undefined;
+  let pendingInput: unknown;
+
+  resetToolIds();
+
+  for (const item of raw) {
+    const e = item as StoredEvent;
+
+    if (e.type === 'agent:invoke') {
+      const data = e.data as { content?: string; role?: string } | undefined;
+      const role = data?.role ?? 'user';
+      const text = data?.content;
+      if (role === 'user' && typeof text === 'string' && text.length > 0) {
+        resetToolIds();
+        list.push({ role: 'user', content: text });
+      }
+    } else if (e.type === 'client:ui:widget' && e.meta?.agentId === agentId) {
+      const d = e.data as MessageWidgetData;
+      if (d.kind !== 'message' || typeof d.body !== 'string' || !d.title) continue;
+
+      const actionMatch = d.title.match(ACTION_TITLE);
+      if (actionMatch) {
+        const { input } = parseNotionToolBody(d.body);
+        pendingToolName = actionMatch[1].trim();
+        pendingInput = input;
+        continue;
+      }
+
+      const resultMatch = d.title.match(RESULT_TITLE);
+      if (!resultMatch) continue;
+
+      const toolName = resultMatch[1].trim();
+      const { input: bodyInput, output } = parseNotionToolBody(d.body);
+      const input =
+        bodyInput !== undefined
+          ? bodyInput
+          : pendingToolName === toolName
+            ? pendingInput
+            : undefined;
+
+      if (output !== undefined) {
+        pushToolRound(list, toolName, input ?? {}, output);
+      }
+
+      pendingToolName = undefined;
+      pendingInput = undefined;
+    } else if (e.type === 'agent:output' && e.meta?.agentId === agentId) {
+      const text = (e.data as { content?: string })?.content;
+      if (typeof text === 'string' && text.trim()) {
+        list.push({ role: 'assistant', content: text.trim() });
+      }
+    }
+  }
+
+  return finalizeCurrentUserTurn(list, currentUserContent);
+}
+
+/**
+ * Ensures the pending user message is included exactly once (matches storage timing).
+ */
+function userTextContent(msg: ModelMessage): string | undefined {
+  if (msg.role !== 'user') return undefined;
+  const c = msg.content;
+  return typeof c === 'string' ? c : undefined;
+}
+
+function finalizeCurrentUserTurn(
+  messages: ModelMessage[],
+  currentUserContent: string
+): ModelMessage[] {
+  const last = messages[messages.length - 1];
+  if (!last) {
+    return [{ role: 'user', content: currentUserContent }];
+  }
+  if (last.role === 'assistant' || last.role === 'tool') {
+    return [...messages, { role: 'user', content: currentUserContent }];
+  }
+  if (last.role === 'user') {
+    if (userTextContent(last) === currentUserContent) return messages;
+    return [...messages, { role: 'user', content: currentUserContent }];
+  }
+  return messages;
+}
+
+export function trimHistory(messages: ModelMessage[], max: number): ModelMessage[] {
+  if (messages.length <= max) return messages;
+  return messages.slice(messages.length - max);
+}

package/src/index.ts

@@ -0,0 +1,185 @@
+import {
+  definePlugin,
+  shouldHandleInvoke,
+  agentOutput,
+  uiWidget,
+  type PluginHandlerContext,
+} from '@meetopenbot/plugin-sdk';
+import { generateText } from 'ai';
+import type { ModelMessage } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createMCPClient } from '@ai-sdk/mcp';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import {
+  buildConversationMessages,
+  trimHistory,
+  MAX_HISTORY_MESSAGES,
+} from './conversation-history.js';
+
+export default definePlugin({
+  name: 'Notion Agent',
+  description: 'An agent that can interact with your Notion workspace using the official MCP server.',
+  configSchema: {
+    type: 'object',
+    properties: {
+      notionApiKey: {
+        type: 'string',
+        description: 'Your Notion Internal Integration Token',
+        format: 'password'
+      },
+      openaiApiKey: {
+        type: 'string',
+        description: 'Your OpenAI API Key',
+        format: 'password'
+      },
+    },
+    required: [],
+  },
+  factory: (context) => (builder) => {
+    const openai = createOpenAI({
+      apiKey: context.config.openaiApiKey as string || process.env.OPENAI_API_KEY,
+    });
+
+    builder.on('client:ui:widget:response', async function* (event) {
+      if (event.data.widgetId === 'notion-auth-form') {
+        const apiKey = event.data.values?.notionApiKey as string;
+        if (apiKey) {
+          await context.storage.createVariable({
+            key: 'NOTION_TOKEN',
+            value: apiKey,
+            secret: true
+          });
+          yield agentOutput({
+            agentId: context.agentId,
+            content: '✅ Notion API key saved! You can now use the Notion agent. Please try your request again.',
+            threadId: event.meta?.threadId
+          });
+        }
+      }
+    });
+
+    builder.on('agent:invoke', async function* (event, ctx: PluginHandlerContext) {
+      if (!shouldHandleInvoke(event, context.agentId)) return;
+
+      const threadId = event.meta?.threadId ?? ctx.state.threadId;
+      const userMessage = event.data.content;
+      const channelId = ctx.state.channelId;
+
+      // Check for Notion token in config or storage
+      const variables = await context.storage.getVariables();
+      const storedToken = variables['NOTION_TOKEN'];
+      const notionToken = (context.config.notionApiKey as string) ||
+        (typeof storedToken === 'string' ? storedToken : storedToken?.value);
+
+      if (!notionToken) {
+        yield agentOutput({
+          agentId: context.agentId,
+          content: 'I need your Notion API key to proceed. Please provide it below:',
+          threadId
+        });
+        yield uiWidget({
+          agentId: context.agentId,
+          widget: {
+            kind: 'form',
+            widgetId: 'notion-auth-form',
+            title: 'Notion Authentication',
+            fields: [
+              {
+                id: 'notionApiKey',
+                label: 'Notion API Key',
+                type: 'text',
+                placeholder: 'secret_...',
+                required: true
+              }
+            ],
+            submitLabel: 'Save Key'
+          },
+          threadId
+        });
+        return;
+      }
+
+      let conversationMessages: ModelMessage[] = [{ role: 'user', content: userMessage }];
+      if (channelId) {
+        try {
+          const rawEvents = await context.storage.getEvents({
+            channelId,
+            ...(threadId ? { threadId } : {}),
+          });
+          conversationMessages = trimHistory(
+            buildConversationMessages(rawEvents, context.agentId, userMessage),
+            MAX_HISTORY_MESSAGES
+          );
+        } catch {
+          // Fall back to single-turn if history cannot be loaded
+        }
+      }
+
+      // Initialize the Notion MCP client using stdio transport
+      const mcpClient = await createMCPClient({
+        transport: new StdioClientTransport({
+          command: 'npx',
+          args: ['-y', '@notionhq/notion-mcp-server'],
+          env: {
+            NOTION_TOKEN: notionToken,
+            // Pass through path and other essential env vars
+            PATH: process.env.PATH || '',
+            HOME: process.env.HOME || '',
+          },
+        }),
+      });
+
+      try {
+        // Discover all tools from the Notion MCP server
+        const tools = await mcpClient.tools();
+
+        const result = await generateText({
+          model: openai('gpt-4o'),
+          system: `You are a helpful Notion assistant. You have access to the official Notion MCP tools.
+          Use these tools to search, read, create, and update content in the user's Notion workspace.
+          Always explain what you are doing. If you need a page or database ID, use the search tools first.
+          You may see prior user and assistant turns in the conversation; use them for continuity and follow-ups.`,
+          messages: conversationMessages,
+          // @ts-ignore
+          maxSteps: 10,
+          tools,
+        });
+
+        // Log tool usage to the UI using widgets
+        for (const step of result.steps) {
+          if (step.toolResults) {
+            for (const toolResult of step.toolResults) {
+              yield uiWidget({
+                agentId: context.agentId,
+                widget: {
+                  kind: 'message',
+                  title: `Notion Result: ${toolResult.toolName}`,
+                  // @ts-ignore
+                  body: `Input: ${JSON.stringify(toolResult.input, null, 2)}\nOutput: ${JSON.stringify(toolResult.result || (toolResult as any).output, null, 2)}`,
+                  display: 'collapsed'
+                },
+                threadId
+              });
+            }
+          }
+        }
+
+        yield agentOutput({
+          agentId: context.agentId,
+          content: result.text,
+          threadId,
+        });
+
+      } catch (error: any) {
+        yield agentOutput({
+          agentId: context.agentId,
+          content: `I encountered an error while communicating with Notion: ${error.message}`,
+          threadId,
+        });
+      } finally {
+        // Ensure the MCP connection is closed to prevent resource leaks
+        await mcpClient.close();
+      }
+    });
+  },
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}