@jupyternaut/persona 0.0.0 → 0.20.1

package/src/index.ts

@@ -0,0 +1,808 @@
+import { IChatTracker, IChatPanel, IChatCommandRegistry } from '@jupyter/chat';
+
+import {
+  ILayoutRestorer,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+
+import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
+
+import { ICompletionProviderManager } from '@jupyterlab/completer';
+
+import { IDocumentManager } from '@jupyterlab/docmanager';
+
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+
+import { IStatusBar } from '@jupyterlab/statusbar';
+
+import { PathExt } from '@jupyterlab/coreutils';
+
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+
+import { IFormRendererRegistry, settingsIcon } from '@jupyterlab/ui-components';
+
+import {
+  anthropicProvider,
+  createBrowserFetchTool,
+  createDiscoverCommandsTool,
+  createDiscoverSkillsTool,
+  createExecuteCommandTool,
+  createLoadSkillTool,
+  genericProvider,
+  googleProvider,
+  loadSkillsFromPaths,
+  mistralProvider,
+  openaiProvider,
+  AgentManagerFactory,
+  IAgentManagerFactory,
+  IAISettingsModel,
+  IDiffManager,
+  IProviderRegistry,
+  IToolRegistry,
+  ISkillRegistry,
+  ProviderRegistry,
+  SECRETS_NAMESPACE,
+  SkillRegistry,
+  ToolRegistry
+} from '@jupyternaut/agent';
+
+import type { IAISecretsAccess } from '@jupyternaut/agent';
+
+import { DisposableSet } from '@lumino/disposable';
+
+import { IComponentsRendererFactory } from 'jupyter-chat-components';
+
+import { IMcpManager } from 'jupyter-mcp-manager';
+
+import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
+
+import { MentionCommandProvider, SkillsCommandProvider } from './chat-commands';
+
+import { AICompletionProvider } from './completion';
+
+import { CompletionStatusWidget } from './components';
+
+import { DiffManager } from './diff-manager';
+
+import { AISettingsModel } from './models/settings-model';
+
+import { PersonaRegistry } from './persona-registry';
+
+import { CommandIds, IPersonaRegistry, DEFAULT_PERSONA } from './tokens';
+
+import { AISettingsWidget } from './widgets/ai-settings';
+
+namespace Private {
+  let aiSecretsToken: symbol | null = null;
+
+  export function setAISecretsToken(token: symbol | null): void {
+    aiSecretsToken = token;
+  }
+
+  export function createAISecretsAccess(
+    secretsManager?: ISecretsManager
+  ): IAISecretsAccess {
+    return {
+      get isAvailable() {
+        return !!(aiSecretsToken && secretsManager);
+      },
+      async get(id: string): Promise<string | undefined> {
+        if (!aiSecretsToken || !secretsManager) {
+          return;
+        }
+        const secret = await secretsManager.get(
+          aiSecretsToken,
+          SECRETS_NAMESPACE,
+          id
+        );
+        return secret?.value;
+      },
+      async set(id: string, value: string): Promise<void> {
+        if (!aiSecretsToken || !secretsManager) {
+          return;
+        }
+        await secretsManager.set(aiSecretsToken, SECRETS_NAMESPACE, id, {
+          namespace: SECRETS_NAMESPACE,
+          id,
+          value
+        });
+      },
+      async attach(
+        id: string,
+        input: HTMLInputElement,
+        callback?: (value: string) => void
+      ): Promise<void> {
+        if (!aiSecretsToken || !secretsManager) {
+          return;
+        }
+        await secretsManager.attach(
+          aiSecretsToken,
+          SECRETS_NAMESPACE,
+          id,
+          input,
+          callback
+        );
+      }
+    };
+  }
+}
+
+/**
+ * Provider registry plugin
+ */
+const providerRegistryPlugin: JupyterFrontEndPlugin<IProviderRegistry> = {
+  id: '@jupyternaut/persona:provider-registry',
+  description: 'AI provider registry',
+  autoStart: true,
+  provides: IProviderRegistry,
+  activate: () => {
+    return new ProviderRegistry();
+  }
+};
+
+/**
+ * Anthropic provider plugin
+ */
+const anthropicProviderPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:anthropic-provider',
+  description: 'Register Anthropic provider',
+  autoStart: true,
+  requires: [IProviderRegistry],
+  activate: (app: JupyterFrontEnd, providerRegistry: IProviderRegistry) => {
+    providerRegistry.registerProvider(anthropicProvider);
+  }
+};
+
+/**
+ * Google provider plugin
+ */
+const googleProviderPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:google-provider',
+  description: 'Register Google Generative AI provider',
+  autoStart: true,
+  requires: [IProviderRegistry],
+  activate: (app: JupyterFrontEnd, providerRegistry: IProviderRegistry) => {
+    providerRegistry.registerProvider(googleProvider);
+  }
+};
+
+/**
+ * Mistral provider plugin
+ */
+const mistralProviderPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:mistral-provider',
+  description: 'Register Mistral provider',
+  autoStart: true,
+  requires: [IProviderRegistry],
+  activate: (app: JupyterFrontEnd, providerRegistry: IProviderRegistry) => {
+    providerRegistry.registerProvider(mistralProvider);
+  }
+};
+
+/**
+ * OpenAI provider plugin
+ */
+const openaiProviderPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:openai-provider',
+  description: 'Register OpenAI provider',
+  autoStart: true,
+  requires: [IProviderRegistry],
+  activate: (app: JupyterFrontEnd, providerRegistry: IProviderRegistry) => {
+    providerRegistry.registerProvider(openaiProvider);
+  }
+};
+
+/**
+ * Generic provider plugin
+ */
+const genericProviderPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:generic-provider',
+  description: 'Register Generic OpenAI-compatible provider',
+  autoStart: true,
+  requires: [IProviderRegistry],
+  activate: (app: JupyterFrontEnd, providerRegistry: IProviderRegistry) => {
+    providerRegistry.registerProvider(genericProvider);
+  }
+};
+
+/**
+ * Provides the persona handler registry without any IChatTracker dependency,
+ * so it can be consumed by the toolbar factory without creating a plugin cycle.
+ */
+const personaRegistry: JupyterFrontEndPlugin<IPersonaRegistry> = {
+  id: '@jupyternaut/persona:registry',
+  description: 'Registry mapping chat models to their persona handlers',
+  autoStart: true,
+  provides: IPersonaRegistry,
+  requires: [IAISettingsModel],
+  optional: [IProviderRegistry, IDocumentManager],
+  activate: (
+    app: JupyterFrontEnd,
+    settingsModel: IAISettingsModel,
+    providerRegistry?: IProviderRegistry,
+    documentManager?: IDocumentManager
+  ): IPersonaRegistry => {
+    return new PersonaRegistry({
+      persona: DEFAULT_PERSONA,
+      settingsModel,
+      providerRegistry,
+      documentManager
+    });
+  }
+};
+
+/**
+ * Connects the persona handler registry to the chat tracker, creating a
+ * PersonaHandler for each chat widget that is opened.
+ */
+const persona: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:plugin',
+  description: 'Attach persona handlers to chat widgets as they are opened',
+  autoStart: true,
+  requires: [IPersonaRegistry, IAgentManagerFactory, IAISettingsModel],
+  optional: [IChatTracker, IProviderRegistry, IToolRegistry],
+  activate: (
+    app: JupyterFrontEnd,
+    registry: IPersonaRegistry,
+    agentManagerFactory: IAgentManagerFactory,
+    settingsModel: IAISettingsModel,
+    chatTracker: IChatTracker | null,
+    providerRegistry?: IProviderRegistry,
+    toolRegistry?: IToolRegistry
+  ): void => {
+    const attachPersona = (widget: IChatPanel) => {
+      if (registry.get(widget.model)) {
+        return;
+      }
+
+      const agentManager = agentManagerFactory.createAgent({
+        settingsModel,
+        providerRegistry,
+        toolRegistry
+      });
+
+      registry.register(widget.model, agentManager);
+      widget.disposed.connect(() => {
+        registry.unregister(widget.model);
+      });
+    };
+
+    chatTracker?.forEach(widget => attachPersona(widget));
+    chatTracker?.widgetAdded.connect((_, widget) => attachPersona(widget));
+  }
+};
+
+/**
+ * Registers groupedToolCall callbacks to route tool call approval decisions
+ * to the correct persona's agent manager.
+ */
+const chatComponentsCallbacks: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:chat-components-callbacks',
+  description: 'Register chat components callbacks for the persona.',
+  autoStart: true,
+  requires: [IPersonaRegistry],
+  optional: [IChatTracker, IComponentsRendererFactory],
+  activate: (
+    _app: JupyterFrontEnd,
+    personaRegistry: IPersonaRegistry,
+    chatTracker: IChatTracker | null,
+    chatComponentsFactory?: IComponentsRendererFactory
+  ): void => {
+    if (!chatComponentsFactory) {
+      return;
+    }
+
+    const findPersona = (sessionId: string) => {
+      const model = chatTracker?.find(
+        chat => chat.model.name === sessionId
+      )?.model;
+      return model ? personaRegistry.get(model) : undefined;
+    };
+
+    chatComponentsFactory.groupedToolCallCallbacks = {
+      ...chatComponentsFactory.groupedToolCallCallbacks,
+      toolCallPermissionDecision: (
+        sessionId: string,
+        toolCallId: string,
+        optionId: string
+      ) => {
+        const agent = findPersona(sessionId)?.agentManager;
+        if (!agent) {
+          return;
+        }
+        if (optionId === 'approve') {
+          agent.approveToolCall(toolCallId);
+        } else {
+          agent.rejectToolCall(toolCallId);
+        }
+      }
+    };
+  }
+};
+
+/**
+ * Clear chat command plugin.
+ */
+const mentionCommandPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:mention',
+  description: 'Register the Jupyternaut mention chat command.',
+  autoStart: true,
+  requires: [IChatCommandRegistry],
+  activate: (app, registry: IChatCommandRegistry) => {
+    registry.addProvider(new MentionCommandProvider());
+  }
+};
+
+/**
+ * Skills chat command plugin.
+ */
+const skillsCommandPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:skills-command',
+  description: 'Register the /skills chat command.',
+  autoStart: true,
+  requires: [IChatCommandRegistry, ISkillRegistry, IPersonaRegistry],
+  optional: [IChatTracker],
+  activate: (
+    app: JupyterFrontEnd,
+    registry: IChatCommandRegistry,
+    skillRegistry: ISkillRegistry,
+    personaRegistry: IPersonaRegistry,
+    chatTracker: IChatTracker | null
+  ) => {
+    const findModel = (chatName: string) =>
+      chatTracker?.find(c => c.model.name === chatName)?.model;
+
+    const isDefault = (chatName: string) => {
+      const model = findModel(chatName);
+      if (!model) {
+        return false;
+      }
+      const persona = personaRegistry.get(model);
+      return persona ? !persona.requireMention : false;
+    };
+
+    const sendSystemMessage = (chatName: string, body: string) => {
+      const model = findModel(chatName);
+      if (model) {
+        personaRegistry.get(model)?.sendSystemMessage(body);
+      }
+    };
+
+    registry.addProvider(
+      new SkillsCommandProvider({
+        skillRegistry,
+        commands: app.commands,
+        isDefault,
+        sendSystemMessage
+      })
+    );
+  }
+};
+
+/**
+ * A plugin to provide the agent manager factory and completion provider.
+ * These objects require the secrets manager token with the same namespace.
+ */
+const agentManagerFactory: JupyterFrontEndPlugin<IAgentManagerFactory> =
+  SecretsManager.sign(SECRETS_NAMESPACE, token => {
+    Private.setAISecretsToken(token);
+
+    return {
+      id: SECRETS_NAMESPACE,
+      description: 'Provide the AI agent manager',
+      autoStart: true,
+      provides: IAgentManagerFactory,
+      requires: [IAISettingsModel, IProviderRegistry],
+      optional: [
+        ISkillRegistry,
+        ICompletionProviderManager,
+        ISecretsManager,
+        IMcpManager
+      ],
+      activate: (
+        app: JupyterFrontEnd,
+        settingsModel: IAISettingsModel,
+        providerRegistry: IProviderRegistry,
+        skillRegistry?: ISkillRegistry,
+        completionManager?: ICompletionProviderManager,
+        secretsManager?: ISecretsManager,
+        mcpManager?: IMcpManager
+      ): IAgentManagerFactory => {
+        const agentManagerFactory = new AgentManagerFactory({
+          settingsModel,
+          skillRegistry,
+          mcpManager,
+          secretsManager,
+          token
+        });
+
+        // Build the completion provider
+        if (completionManager) {
+          const completionProvider = new AICompletionProvider({
+            settingsModel,
+            providerRegistry,
+            secretsManager,
+            token
+          });
+
+          completionManager.registerInlineProvider(completionProvider);
+        } else {
+          console.info(
+            'Completion provider manager not available, skipping AI completion setup'
+          );
+        }
+
+        return agentManagerFactory;
+      }
+    };
+  });
+
+/**
+ * AI settings panel plugin.
+ */
+const settingsPanelPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:settings-panel',
+  description: 'Provide the AI settings panel',
+  autoStart: true,
+  requires: [IAISettingsModel, IAgentManagerFactory, IProviderRegistry],
+  optional: [
+    ICommandPalette,
+    ILayoutRestorer,
+    ISecretsManager,
+    IThemeManager,
+    ITranslator,
+    IFormRendererRegistry,
+    // This token is not used, but depending on it ensures that the renderer has been
+    // added to the form renderer registry.
+    IMcpManager
+  ],
+  activate: (
+    app: JupyterFrontEnd,
+    settingsModel: IAISettingsModel,
+    agentManagerFactory: IAgentManagerFactory,
+    providerRegistry: IProviderRegistry,
+    palette?: ICommandPalette,
+    restorer?: ILayoutRestorer,
+    secretsManager?: ISecretsManager,
+    themeManager?: IThemeManager,
+    translator?: ITranslator,
+    formRenderer?: IFormRendererRegistry
+  ): void => {
+    const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+    const secretsAccess = Private.createAISecretsAccess(secretsManager);
+
+    // Get the renderer for MCP servers settings
+    const mcpServerRenderer = formRenderer?.getRenderer(
+      'jupyter-mcp-manager:manager.mcpSettings'
+    ).fieldRenderer;
+
+    const settingsWidget = new AISettingsWidget({
+      settingsModel,
+      agentManagerFactory,
+      themeManager,
+      providerRegistry,
+      secretsAccess,
+      trans,
+      mcpServerRenderer
+    });
+    settingsWidget.title.icon = settingsIcon;
+    settingsWidget.title.iconClass = 'jp-ai-settings-icon';
+
+    const open = () => {
+      let widget = Array.from(app.shell.widgets('main')).find(
+        w => w.id === 'jupyternaut-persona-settings'
+      ) as AISettingsWidget | undefined;
+
+      if (!widget) {
+        widget = settingsWidget;
+        app.shell.add(widget, 'main');
+      }
+
+      app.shell.activateById(widget.id);
+    };
+
+    if (restorer) {
+      restorer.add(settingsWidget, settingsWidget.id);
+    }
+
+    app.commands.addCommand(CommandIds.openSettings, {
+      label: trans.__('Jupyternaut Settings'),
+      caption: trans.__('Configure AI providers and behavior'),
+      icon: settingsIcon,
+      iconClass: 'jp-ai-settings-icon',
+      execute: () => {
+        open();
+      },
+      describedBy: {
+        args: {}
+      }
+    });
+
+    if (palette) {
+      palette.addItem({
+        command: CommandIds.openSettings,
+        category: trans.__('AI Assistant')
+      });
+    }
+  }
+};
+
+/**
+ * Built-in completion providers plugin
+ */
+const settingsModel: JupyterFrontEndPlugin<IAISettingsModel> = {
+  id: '@jupyternaut/persona:settings-model',
+  description: 'Provide the AI settings model',
+  autoStart: true,
+  provides: IAISettingsModel,
+  requires: [ISettingRegistry],
+  activate: (
+    app: JupyterFrontEnd,
+    settingRegistry: ISettingRegistry
+  ): IAISettingsModel => {
+    return new AISettingsModel({ settingRegistry });
+  }
+};
+
+/**
+ * Diff manager plugin
+ */
+const diffManager: JupyterFrontEndPlugin<IDiffManager> = {
+  id: '@jupyternaut/persona:diff-manager',
+  description: 'Provide the diff manager for notebook cell diffs',
+  autoStart: true,
+  provides: IDiffManager,
+  requires: [IAISettingsModel],
+  activate: (
+    app: JupyterFrontEnd,
+    settingsModel: IAISettingsModel
+  ): IDiffManager => {
+    return new DiffManager({
+      commands: app.commands,
+      settingsModel
+    });
+  }
+};
+
+/**
+ * Skill registry plugin
+ */
+const skillRegistryPlugin: JupyterFrontEndPlugin<ISkillRegistry> = {
+  id: '@jupyternaut/persona:skill-registry',
+  description: 'Provide the skill registry',
+  autoStart: true,
+  provides: ISkillRegistry,
+  activate: () => {
+    return new SkillRegistry();
+  }
+};
+
+const toolRegistry: JupyterFrontEndPlugin<IToolRegistry> = {
+  id: '@jupyternaut/persona:tool-registry',
+  description: 'Provide the AI tool registry',
+  autoStart: true,
+  optional: [ISkillRegistry],
+  provides: IToolRegistry,
+  activate: (app: JupyterFrontEnd, skillRegistry?: ISkillRegistry) => {
+    const toolRegistry = new ToolRegistry();
+
+    // Add command operation tools
+    const discoverCommandsTool = createDiscoverCommandsTool(app.commands);
+    const executeCommandTool = createExecuteCommandTool(app.commands);
+
+    toolRegistry.add('discover_commands', discoverCommandsTool);
+    toolRegistry.add('execute_command', executeCommandTool);
+    toolRegistry.add('browser_fetch', createBrowserFetchTool());
+    if (skillRegistry) {
+      toolRegistry.add(
+        'discover_skills',
+        createDiscoverSkillsTool(skillRegistry)
+      );
+      toolRegistry.add('load_skill', createLoadSkillTool(skillRegistry));
+    }
+
+    return toolRegistry;
+  }
+};
+
+const completionStatus: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:completion-status',
+  description: 'The completion status displayed in the status bar',
+  autoStart: true,
+  requires: [IAISettingsModel],
+  optional: [IStatusBar, ITranslator],
+  activate: (
+    app: JupyterFrontEnd,
+    settingsModel: IAISettingsModel,
+    statusBar: IStatusBar | null,
+    translator?: ITranslator
+  ) => {
+    if (!statusBar) {
+      return;
+    }
+    const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+    const item = new CompletionStatusWidget({
+      settingsModel,
+      translator: trans
+    });
+    statusBar?.registerStatusItem('completionState', {
+      item,
+      align: 'right',
+      rank: 10
+    });
+  }
+};
+
+/**
+ * Skills plugin: discovers and registers agent skills from the filesystem.
+ */
+const skillsPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:skills',
+  description: 'Discover and register agent skills',
+  autoStart: true,
+  requires: [IAISettingsModel, IDocumentManager, ISkillRegistry],
+  optional: [ICommandPalette, ITranslator],
+  activate: async (
+    app: JupyterFrontEnd,
+    settingsModel: IAISettingsModel,
+    docManager: IDocumentManager,
+    skillRegistry: ISkillRegistry,
+    palette?: ICommandPalette,
+    translator?: ITranslator
+  ) => {
+    const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+    const validateResourcePath = (resourcePath: string): string | null => {
+      if (resourcePath.startsWith('/')) {
+        return null;
+      }
+
+      const normalized = PathExt.normalize(resourcePath);
+      if (normalized.startsWith('..') || normalized === '') {
+        return null;
+      }
+
+      return normalized;
+    };
+
+    let currentSkillsPaths = settingsModel.config.skillsPaths;
+    let currentSkillDisposables = new DisposableSet();
+
+    const loadAndRegister = async () => {
+      const skillsPaths = settingsModel.config.skillsPaths;
+      const skills = await loadSkillsFromPaths(
+        docManager.services.contents,
+        skillsPaths
+      );
+
+      const registrations = skills.map(skill => ({
+        name: skill.name,
+        description: skill.description,
+        instructions: skill.instructions,
+        resources: skill.resources,
+        loadResource: async (resource: string) => {
+          const validatedPath = validateResourcePath(resource);
+          if (validatedPath === null) {
+            return {
+              name: skill.name,
+              resource,
+              error: 'Invalid resource path: path traversal not allowed'
+            };
+          }
+
+          if (!skill.resources.includes(validatedPath)) {
+            return {
+              name: skill.name,
+              resource,
+              error: `Resource not found: ${resource}`
+            };
+          }
+
+          const resourcePath = `${skill.path}/${validatedPath}`;
+          try {
+            const fileModel = await docManager.services.contents.get(
+              resourcePath,
+              {
+                content: true
+              }
+            );
+            if (typeof fileModel.content !== 'string') {
+              return {
+                name: skill.name,
+                resource,
+                error: 'Resource content is not a string'
+              };
+            }
+            return {
+              name: skill.name,
+              resource,
+              content: fileModel.content
+            };
+          } catch (error) {
+            return {
+              name: skill.name,
+              resource,
+              error: `Failed to read resource: ${error}`
+            };
+          }
+        }
+      }));
+
+      currentSkillDisposables.dispose();
+      currentSkillDisposables = new DisposableSet();
+      for (const registration of registrations) {
+        currentSkillDisposables.add(skillRegistry.registerSkill(registration));
+      }
+    };
+
+    app.commands.addCommand(CommandIds.refreshSkills, {
+      label: trans.__('Refresh Agents Skills'),
+      caption: trans.__(
+        'Re-scan the agents skills directory and update the registry'
+      ),
+      execute: async () => {
+        await loadAndRegister();
+      }
+    });
+
+    if (palette) {
+      palette.addItem({
+        command: CommandIds.refreshSkills,
+        category: trans.__('AI Assistant')
+      });
+    }
+
+    loadAndRegister().catch(error =>
+      console.warn('Failed to load skills on activation:', error)
+    );
+
+    settingsModel.stateChanged.connect(() => {
+      const newPaths = settingsModel.config.skillsPaths;
+      if (
+        newPaths.length === currentSkillsPaths.length &&
+        newPaths.every((p, i) => p === currentSkillsPaths[i])
+      ) {
+        return;
+      }
+      currentSkillsPaths = newPaths;
+      loadAndRegister().catch(error =>
+        console.warn('Failed to reload skills:', error)
+      );
+    });
+  }
+};
+
+export default [
+  // Provider registry and builtin providers
+  providerRegistryPlugin,
+  anthropicProviderPlugin,
+  googleProviderPlugin,
+  mistralProviderPlugin,
+  openaiProviderPlugin,
+  genericProviderPlugin,
+  // Agent
+  agentManagerFactory,
+  completionStatus,
+  // Skills
+  skillRegistryPlugin,
+  skillsPlugin,
+  // Tools
+  toolRegistry,
+  // Persona
+  personaRegistry,
+  persona,
+  chatComponentsCallbacks,
+  mentionCommandPlugin,
+  skillsCommandPlugin,
+  // Settings
+  settingsModel,
+  settingsPanelPlugin,
+  // Diff manager (to be removed ?)
+  diffManager
+];
+
+// Export extension points for other extensions to use
+export * from './tokens';
+
+// Export helper functions
+export { processAttachments } from './process-attachments';