@everworker/oneringai 0.4.3 → 0.4.5

package/dist/index.cjs

@@ -9992,15 +9992,16 @@ var init_PDFHandler = __esm({
         const unpdf = await getUnpdf();
         const pieces = [];
         let pieceIndex = 0;
+        const data = new Uint8Array(buffer);
         let metadata = {};
         const includeMetadata = options.formatOptions?.pdf?.includeMetadata !== false;
         if (includeMetadata) {
           try {
-            metadata = await unpdf.getMeta(buffer);
+            metadata = await unpdf.getMeta(data);
           } catch {
           }
         }
-        const textResult = await unpdf.extractText(buffer, { mergePages: false });
+        const textResult = await unpdf.extractText(data, { mergePages: false });
         const pages = textResult?.pages || textResult?.text ? Array.isArray(textResult.text) ? textResult.text : [textResult.text] : [];
         const requestedPages = options.pages;
         const pageEntries = pages.map((text, i) => ({ text, pageNum: i + 1 }));
@@ -10053,7 +10054,7 @@ var init_PDFHandler = __esm({
         }
         if (options.extractImages !== false) {
           try {
-            const imagesResult = await unpdf.extractImages(buffer, {});
+            const imagesResult = await unpdf.extractImages(data, {});
             const images = imagesResult?.images || [];
             for (const img of images) {
               if (!img.data) continue;
@@ -10286,6 +10287,475 @@ init_Connector();
 init_ScopedConnectorRegistry();
 init_StorageRegistry();
 
+// src/core/ToolCatalogRegistry.ts
+init_Logger();
+var ToolCatalogRegistry = class {
+  /** Category definitions: name → definition */
+  static _categories = /* @__PURE__ */ new Map();
+  /** Tools per category: category name → tool entries */
+  static _tools = /* @__PURE__ */ new Map();
+  /** Whether built-in tools have been registered */
+  static _initialized = false;
+  /** Lazy-loaded ConnectorTools module. null = not attempted, false = failed */
+  static _connectorToolsModule = null;
+  // --- Built-in category descriptions ---
+  static BUILTIN_DESCRIPTIONS = {
+    filesystem: "Read, write, edit, search, and list files and directories",
+    shell: "Execute bash/shell commands",
+    web: "Fetch and process web content",
+    code: "Execute JavaScript code in sandboxed VM",
+    json: "Parse, query, and transform JSON data",
+    desktop: "Screenshot, mouse, keyboard, and window desktop automation",
+    "custom-tools": "Create, save, load, and test custom tool definitions",
+    routines: "Generate and manage agent routines",
+    other: "Miscellaneous tools"
+  };
+  // ========================================================================
+  // Static Helpers (DRY)
+  // ========================================================================
+  /**
+   * Convert a hyphenated or plain name to a display name.
+   * E.g., 'custom-tools' → 'Custom Tools', 'filesystem' → 'Filesystem'
+   */
+  static toDisplayName(name) {
+    return name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  }
+  /**
+   * Parse a connector category name, returning the connector name or null.
+   * E.g., 'connector:github' → 'github', 'filesystem' → null
+   */
+  static parseConnectorCategory(category) {
+    return category.startsWith("connector:") ? category.slice("connector:".length) : null;
+  }
+  /**
+   * Get the ConnectorTools module (lazy-loaded, cached).
+   * Returns null if ConnectorTools is not available.
+   * Uses false sentinel to prevent retrying after first failure.
+   *
+   * NOTE: The dynamic require() path fails in bundled environments (Meteor, Webpack).
+   * Call setConnectorToolsModule() at app startup to inject the module explicitly.
+   */
+  static getConnectorToolsModule() {
+    if (this._connectorToolsModule === null) {
+      try {
+        this._connectorToolsModule = __require("../../tools/connector/ConnectorTools.js");
+      } catch {
+        this._connectorToolsModule = false;
+      }
+    }
+    return this._connectorToolsModule || null;
+  }
+  /**
+   * Explicitly set the ConnectorTools module reference.
+   *
+   * Use this in bundled environments (Meteor, Webpack, etc.) where the lazy
+   * require('../../tools/connector/ConnectorTools.js') fails due to path resolution.
+   *
+   * @example
+   * ```typescript
+   * import { ToolCatalogRegistry, ConnectorTools } from '@everworker/oneringai';
+   * ToolCatalogRegistry.setConnectorToolsModule({ ConnectorTools });
+   * ```
+   */
+  static setConnectorToolsModule(mod) {
+    this._connectorToolsModule = mod;
+  }
+  // ========================================================================
+  // Registration
+  // ========================================================================
+  /**
+   * Register a tool category.
+   * If the category already exists, updates its metadata.
+   * @throws Error if name is empty or whitespace
+   */
+  static registerCategory(def) {
+    if (!def.name || !def.name.trim()) {
+      throw new Error("[ToolCatalogRegistry] Category name cannot be empty");
+    }
+    this._categories.set(def.name, def);
+    if (!this._tools.has(def.name)) {
+      this._tools.set(def.name, []);
+    }
+  }
+  /**
+   * Register multiple tools in a category.
+   * The category is auto-created if it doesn't exist (with a generic description).
+   * @throws Error if category name is empty or whitespace
+   */
+  static registerTools(category, tools) {
+    if (!category || !category.trim()) {
+      throw new Error("[ToolCatalogRegistry] Category name cannot be empty");
+    }
+    if (!this._categories.has(category)) {
+      this._categories.set(category, {
+        name: category,
+        displayName: this.toDisplayName(category),
+        description: this.BUILTIN_DESCRIPTIONS[category] ?? `Tools in the ${category} category`
+      });
+    }
+    const existing = this._tools.get(category) ?? [];
+    const existingNames = new Set(existing.map((t) => t.name));
+    const newTools = tools.filter((t) => !existingNames.has(t.name));
+    const updated = existing.map((t) => {
+      const replacement = tools.find((nt) => nt.name === t.name);
+      return replacement ?? t;
+    });
+    this._tools.set(category, [...updated, ...newTools]);
+  }
+  /**
+   * Register a single tool in a category.
+   */
+  static registerTool(category, tool) {
+    this.registerTools(category, [tool]);
+  }
+  /**
+   * Unregister a category and all its tools.
+   */
+  static unregisterCategory(category) {
+    const hadCategory = this._categories.delete(category);
+    this._tools.delete(category);
+    return hadCategory;
+  }
+  /**
+   * Unregister a single tool from a category.
+   */
+  static unregisterTool(category, toolName) {
+    const tools = this._tools.get(category);
+    if (!tools) return false;
+    const idx = tools.findIndex((t) => t.name === toolName);
+    if (idx === -1) return false;
+    tools.splice(idx, 1);
+    return true;
+  }
+  // ========================================================================
+  // Query
+  // ========================================================================
+  /**
+   * Get all registered categories.
+   */
+  static getCategories() {
+    this.ensureInitialized();
+    return Array.from(this._categories.values());
+  }
+  /**
+   * Get a single category by name.
+   */
+  static getCategory(name) {
+    this.ensureInitialized();
+    return this._categories.get(name);
+  }
+  /**
+   * Check if a category exists.
+   */
+  static hasCategory(name) {
+    this.ensureInitialized();
+    return this._categories.has(name);
+  }
+  /**
+   * Get all tools in a category.
+   */
+  static getToolsInCategory(category) {
+    this.ensureInitialized();
+    return this._tools.get(category) ?? [];
+  }
+  /**
+   * Get all catalog tools across all categories.
+   */
+  static getAllCatalogTools() {
+    this.ensureInitialized();
+    const all = [];
+    for (const tools of this._tools.values()) {
+      all.push(...tools);
+    }
+    return all;
+  }
+  /**
+   * Find a tool by name across all categories.
+   */
+  static findTool(name) {
+    this.ensureInitialized();
+    for (const [category, tools] of this._tools) {
+      const entry = tools.find((t) => t.name === name);
+      if (entry) return { category, entry };
+    }
+    return void 0;
+  }
+  // ========================================================================
+  // Filtering
+  // ========================================================================
+  /**
+   * Filter categories by scope.
+   */
+  static filterCategories(scope) {
+    const all = this.getCategories();
+    if (!scope) return all;
+    return all.filter((cat) => this.isCategoryAllowed(cat.name, scope));
+  }
+  /**
+   * Check if a category is allowed by a scope.
+   */
+  static isCategoryAllowed(name, scope) {
+    if (!scope) return true;
+    if (Array.isArray(scope)) {
+      return scope.includes(name);
+    }
+    if ("include" in scope) {
+      return scope.include.includes(name);
+    }
+    if ("exclude" in scope) {
+      return !scope.exclude.includes(name);
+    }
+    return true;
+  }
+  // ========================================================================
+  // Connector Discovery
+  // ========================================================================
+  /**
+   * Discover all connector categories with their tools.
+   * Calls ConnectorTools.discoverAll() and filters by scope/identities.
+   *
+   * @param options - Optional filtering
+   * @returns Array of connector category info
+   */
+  static discoverConnectorCategories(options) {
+    const mod = this.getConnectorToolsModule();
+    if (!mod) return [];
+    try {
+      const discovered = mod.ConnectorTools.discoverAll();
+      const results = [];
+      for (const [connectorName, tools] of discovered) {
+        const catName = `connector:${connectorName}`;
+        if (options?.scope && !this.isCategoryAllowed(catName, options.scope)) {
+          continue;
+        }
+        if (options?.identities?.length) {
+          const hasIdentity = options.identities.some((id) => id.connector === connectorName);
+          if (!hasIdentity) continue;
+        }
+        const preRegistered = this.getCategory(catName);
+        results.push({
+          name: catName,
+          displayName: preRegistered?.displayName ?? this.toDisplayName(connectorName),
+          description: preRegistered?.description ?? `API tools for ${connectorName}`,
+          toolCount: tools.length,
+          tools
+        });
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Resolve tools for a specific connector category.
+   *
+   * @param category - Category name in 'connector:<name>' format
+   * @returns Array of resolved tools with names
+   */
+  static resolveConnectorCategoryTools(category) {
+    const connectorName = this.parseConnectorCategory(category);
+    if (!connectorName) return [];
+    const mod = this.getConnectorToolsModule();
+    if (!mod) return [];
+    try {
+      const tools = mod.ConnectorTools.for(connectorName);
+      return tools.map((t) => ({ tool: t, name: t.definition.function.name }));
+    } catch {
+      return [];
+    }
+  }
+  // ========================================================================
+  // Resolution
+  // ========================================================================
+  /**
+   * Resolve tool names to ToolFunction[].
+   *
+   * Searches registered categories and (optionally) connector tools.
+   * Used by app-level executors (e.g., V25's OneRingAgentExecutor).
+   *
+   * @param toolNames - Array of tool names to resolve
+   * @param options - Resolution options
+   * @returns Resolved tool functions (skips unresolvable names with warning)
+   */
+  static resolveTools(toolNames, options) {
+    this.ensureInitialized();
+    const resolved = [];
+    const missing = [];
+    for (const name of toolNames) {
+      const found = this.findTool(name);
+      if (found) {
+        const tool = this.resolveEntryTool(found.entry, options?.context);
+        if (tool) {
+          resolved.push(tool);
+          continue;
+        }
+      }
+      if (options?.includeConnectors) {
+        const connectorTool = this.findConnectorTool(name);
+        if (connectorTool) {
+          resolved.push(connectorTool);
+          continue;
+        }
+      }
+      missing.push(name);
+    }
+    if (missing.length > 0) {
+      exports.logger.warn(
+        { missing, resolved: resolved.length, total: toolNames.length },
+        `[ToolCatalogRegistry.resolveTools] Could not resolve ${missing.length} tool(s): ${missing.join(", ")}`
+      );
+    }
+    return resolved;
+  }
+  /**
+   * Resolve tools grouped by connector name.
+   *
+   * Tools with a `connectorName` go into `byConnector`; all others go into `plain`.
+   * Supports factory-based tool creation via `createTool` when context is provided.
+   *
+   * @param toolNames - Array of tool names to resolve
+   * @param context - Optional context passed to createTool factories
+   * @param options - Resolution options
+   * @returns Grouped tools: plain + byConnector map
+   */
+  static resolveToolsGrouped(toolNames, context, options) {
+    this.ensureInitialized();
+    const plain = [];
+    const byConnector = /* @__PURE__ */ new Map();
+    for (const name of toolNames) {
+      const found = this.findTool(name);
+      if (found) {
+        const entry = found.entry;
+        const tool = this.resolveEntryTool(entry, context);
+        if (!tool) continue;
+        if (entry.connectorName) {
+          const list = byConnector.get(entry.connectorName) ?? [];
+          list.push(tool);
+          byConnector.set(entry.connectorName, list);
+        } else {
+          plain.push(tool);
+        }
+        continue;
+      }
+      if (options?.includeConnectors) {
+        const connectorTool = this.findConnectorTool(name);
+        if (connectorTool) {
+          plain.push(connectorTool);
+          continue;
+        }
+      }
+    }
+    return { plain, byConnector };
+  }
+  /**
+   * Resolve a tool from a CatalogToolEntry, using factory if available.
+   * Returns null if neither tool nor createTool is available.
+   */
+  static resolveEntryTool(entry, context) {
+    if (entry.createTool && context) {
+      try {
+        return entry.createTool(context);
+      } catch (e) {
+        exports.logger.warn(`[ToolCatalogRegistry] Factory failed for '${entry.name}': ${e}`);
+        return null;
+      }
+    }
+    return entry.tool ?? null;
+  }
+  /**
+   * Search connector tools by name (uses lazy accessor).
+   */
+  static findConnectorTool(name) {
+    const mod = this.getConnectorToolsModule();
+    if (!mod) return void 0;
+    try {
+      const allConnectorTools = mod.ConnectorTools.discoverAll();
+      for (const [, tools] of allConnectorTools) {
+        for (const tool of tools) {
+          if (tool.definition.function.name === name) {
+            return tool;
+          }
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  // ========================================================================
+  // Built-in initialization
+  // ========================================================================
+  /**
+   * Ensure built-in tools from registry.generated.ts are registered.
+   * Called lazily on first query.
+   *
+   * In ESM environments, call `initializeFromRegistry(toolRegistry)` explicitly
+   * from your app startup instead of relying on auto-initialization.
+   */
+  static ensureInitialized() {
+    if (this._initialized) return;
+    this._initialized = true;
+    try {
+      const mod = __require("../../tools/registry.generated.js");
+      const registry = mod?.toolRegistry ?? mod?.default?.toolRegistry;
+      if (Array.isArray(registry)) {
+        this.registerFromToolRegistry(registry);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Explicitly initialize from the generated tool registry.
+   * Call this at app startup in ESM environments where lazy require() doesn't work.
+   *
+   * @example
+   * ```typescript
+   * import { toolRegistry } from './tools/registry.generated.js';
+   * ToolCatalogRegistry.initializeFromRegistry(toolRegistry);
+   * ```
+   */
+  static initializeFromRegistry(registry) {
+    this._initialized = true;
+    this.registerFromToolRegistry(registry);
+  }
+  /**
+   * Internal: register tools from a tool registry array.
+   */
+  static registerFromToolRegistry(registry) {
+    for (const entry of registry) {
+      const category = entry.category;
+      if (!this._categories.has(category)) {
+        this.registerCategory({
+          name: category,
+          displayName: this.toDisplayName(category),
+          description: this.BUILTIN_DESCRIPTIONS[category] ?? `Built-in ${category} tools`
+        });
+      }
+      const catalogEntry = {
+        tool: entry.tool,
+        name: entry.name,
+        displayName: entry.displayName,
+        description: entry.description,
+        safeByDefault: entry.safeByDefault,
+        requiresConnector: entry.requiresConnector
+      };
+      const existing = this._tools.get(category) ?? [];
+      if (!existing.some((t) => t.name === catalogEntry.name)) {
+        existing.push(catalogEntry);
+        this._tools.set(category, existing);
+      }
+    }
+  }
+  /**
+   * Reset the registry. Primarily for testing.
+   */
+  static reset() {
+    this._categories.clear();
+    this._tools.clear();
+    this._initialized = false;
+    this._connectorToolsModule = null;
+  }
+};
+
 // src/core/BaseAgent.ts
 init_Connector();
 
@@ -10323,6 +10793,14 @@ var DEFAULT_ALLOWLIST = [
   "user_info_get",
   "user_info_remove",
   "user_info_clear",
+  // TODO tools (user-specific data - safe)
+  "todo_add",
+  "todo_update",
+  "todo_remove",
+  // Tool catalog tools (browsing and loading — safe)
+  "tool_catalog_search",
+  "tool_catalog_load",
+  "tool_catalog_unload",
   // Meta-tools (internal coordination)
   "_start_planning",
   "_modify_plan",
@@ -11637,6 +12115,17 @@ var ToolManager = class extends eventemitter3.EventEmitter {
     if (!toolNames) return [];
     return Array.from(toolNames).map((name) => this.registry.get(name)).filter((reg) => reg.enabled).sort((a, b) => b.priority - a.priority).map((reg) => reg.tool);
   }
+  /**
+   * Get all registered tool names in a category.
+   * Used by ToolCatalogPlugin for bulk enable/disable.
+   */
+  getByCategory(category) {
+    const names = [];
+    for (const [name, reg] of this.registry) {
+      if (reg.category === category) names.push(name);
+    }
+    return names;
+  }
   /**
    * Get tool registration info
    */
@@ -15802,7 +16291,35 @@ User info is automatically shown in context \u2014 no need to call user_info_get
 
 **Important:** Do not store sensitive information (passwords, tokens, PII) in user info. It is not encrypted and may be accessible to other parts of the system. Always follow best practices for security.
 
-**Rules after each user message:** If the user provides new information about themselves, update user info accordingly. If they ask to change or remove existing information, do that as well. Always keep user info up to date with the latest information provided by the user. Learn about the user proactively!`;
+**Rules after each user message:** If the user provides new information about themselves, update user info accordingly. If they ask to change or remove existing information, do that as well. Always keep user info up to date with the latest information provided by the user. Learn about the user proactively!
+
+## TODO Management
+
+TODOs are stored alongside user info and shown in a separate "Current TODOs" section in context.
+
+**Tools:**
+- \`todo_add(title, description?, people?, dueDate?, tags?)\`: Create a new TODO item
+- \`todo_update(id, title?, description?, people?, dueDate?, tags?, status?)\`: Update an existing TODO
+- \`todo_remove(id)\`: Delete a TODO item
+
+**Proactive creation \u2014 be helpful:**
+- If the user's message implies an action item, task, or deadline \u2192 ask "Would you like me to create a TODO for this?"
+- If the user explicitly says "remind me", "track this", "don't forget" \u2192 create a TODO immediately without asking.
+- When discussing plans with deadlines or deliverables \u2192 suggest relevant TODOs.
+- When the user mentions other people involved \u2192 include them in the \`people\` field.
+- Suggest appropriate tags based on context (e.g. "work", "personal", "urgent").
+
+**Reminder rules:**
+- Check the \`_todo_last_reminded\` entry in user info. If its value is NOT today's date (YYYY-MM-DD) AND there are overdue or soon-due items (within 2 days), proactively remind the user ONCE at the start of the conversation, then set \`_todo_last_reminded\` to today's date via \`user_info_set\`.
+- Do NOT remind again in the same day unless the user explicitly asks about their TODOs.
+- When reminding, prioritize: overdue items first, then items due today, then items due tomorrow.
+- If the user asks about their TODOs or schedule, always answer regardless of reminder status.
+- After completing a TODO, mark it as done via \`todo_update(id, status: 'done')\`. Suggest marking items done when context indicates completion.
+
+**Cleanup rules:**
+- Completed TODOs older than 48 hours (check updatedAt of done items) \u2192 auto-delete via \`todo_remove\` without asking.
+- Overdue pending TODOs (past due > 7 days) \u2192 ask the user: "This TODO is overdue by X days \u2014 still relevant or should I remove it?"
+- Run cleanup checks at the same time as reminders (once per day, using \`_todo_last_reminded\` marker).`;
 var userInfoSetDefinition = {
   type: "function",
   function: {
@@ -15879,6 +16396,102 @@ var userInfoClearDefinition = {
     }
   }
 };
+var todoAddDefinition = {
+  type: "function",
+  function: {
+    name: "todo_add",
+    description: "Create a new TODO item for the user. Returns the generated todo ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Short title for the TODO (required)"
+        },
+        description: {
+          type: "string",
+          description: "Optional detailed description"
+        },
+        people: {
+          type: "array",
+          items: { type: "string" },
+          description: "People involved besides the current user (optional)"
+        },
+        dueDate: {
+          type: "string",
+          description: "Due date in ISO format YYYY-MM-DD (optional)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Categorization tags (optional, e.g. "work", "personal", "urgent")'
+        }
+      },
+      required: ["title"]
+    }
+  }
+};
+var todoUpdateDefinition = {
+  type: "function",
+  function: {
+    name: "todo_update",
+    description: "Update an existing TODO item. Only provided fields are changed.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'The todo ID (e.g. "todo_a1b2c3")'
+        },
+        title: {
+          type: "string",
+          description: "New title"
+        },
+        description: {
+          type: "string",
+          description: "New description (pass empty string to clear)"
+        },
+        people: {
+          type: "array",
+          items: { type: "string" },
+          description: "New people list (replaces existing)"
+        },
+        dueDate: {
+          type: "string",
+          description: "New due date in ISO format YYYY-MM-DD (pass empty string to clear)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "New tags list (replaces existing)"
+        },
+        status: {
+          type: "string",
+          enum: ["pending", "done"],
+          description: "New status"
+        }
+      },
+      required: ["id"]
+    }
+  }
+};
+var todoRemoveDefinition = {
+  type: "function",
+  function: {
+    name: "todo_remove",
+    description: "Delete a TODO item.",
+    parameters: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'The todo ID to remove (e.g. "todo_a1b2c3")'
+        }
+      },
+      required: ["id"]
+    }
+  }
+};
 function validateKey2(key) {
   if (typeof key !== "string") return "Key must be a string";
   const trimmed = key.trim();
@@ -15902,6 +16515,37 @@ function buildStorageContext(toolContext) {
   if (toolContext?.userId) return { userId: toolContext.userId };
   return void 0;
 }
+var TODO_KEY_PREFIX = "todo_";
+var INTERNAL_KEY_PREFIX = "_";
+function isTodoEntry(entry) {
+  return entry.id.startsWith(TODO_KEY_PREFIX);
+}
+function isInternalEntry(entry) {
+  return entry.id.startsWith(INTERNAL_KEY_PREFIX);
+}
+function generateTodoId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 6; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `${TODO_KEY_PREFIX}${id}`;
+}
+function renderTodoEntry(entry) {
+  const val = entry.value;
+  const checkbox = val.status === "done" ? "[x]" : "[ ]";
+  const parts = [];
+  if (val.dueDate) parts.push(`due: ${val.dueDate}`);
+  if (val.people && val.people.length > 0) parts.push(`people: ${val.people.join(", ")}`);
+  const meta = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+  const tags = val.tags && val.tags.length > 0 ? ` [${val.tags.join(", ")}]` : "";
+  let line = `- ${checkbox} ${entry.id}: ${val.title}${meta}${tags}`;
+  if (val.description) {
+    line += `
+  ${val.description}`;
+  }
+  return line;
+}
 function formatValue(value) {
   if (value === null) return "null";
   if (typeof value === "string") return value;
@@ -15969,7 +16613,10 @@ var UserInfoPluginNextGen = class {
       this.createUserInfoSetTool(),
       this.createUserInfoGetTool(),
       this.createUserInfoRemoveTool(),
-      this.createUserInfoClearTool()
+      this.createUserInfoClearTool(),
+      this.createTodoAddTool(),
+      this.createTodoUpdateTool(),
+      this.createTodoRemoveTool()
     ];
   }
   destroy() {
@@ -16040,9 +16687,38 @@ var UserInfoPluginNextGen = class {
    * Render entries as markdown for context injection
    */
   renderContent() {
-    const sorted = Array.from(this._entries.values()).sort((a, b) => a.createdAt - b.createdAt);
-    return sorted.map((entry) => `### ${entry.id}
-${formatValue(entry.value)}`).join("\n\n");
+    const userEntries = [];
+    const todoEntries = [];
+    for (const entry of this._entries.values()) {
+      if (isTodoEntry(entry)) {
+        todoEntries.push(entry);
+      } else if (!isInternalEntry(entry)) {
+        userEntries.push(entry);
+      }
+    }
+    const sections = [];
+    if (userEntries.length > 0) {
+      userEntries.sort((a, b) => a.createdAt - b.createdAt);
+      sections.push(
+        userEntries.map((entry) => `### ${entry.id}
+${formatValue(entry.value)}`).join("\n\n")
+      );
+    }
+    if (todoEntries.length > 0) {
+      todoEntries.sort((a, b) => {
+        const aVal = a.value;
+        const bVal = b.value;
+        if (aVal.status !== bVal.status) return aVal.status === "pending" ? -1 : 1;
+        if (aVal.dueDate && bVal.dueDate) return aVal.dueDate.localeCompare(bVal.dueDate);
+        if (aVal.dueDate) return -1;
+        if (bVal.dueDate) return 1;
+        return a.createdAt - b.createdAt;
+      });
+      sections.push(
+        "## Current TODOs\n" + todoEntries.map(renderTodoEntry).join("\n")
+      );
+    }
+    return sections.join("\n\n");
   }
   /**
    * Resolve storage instance (lazy singleton)
@@ -16223,6 +16899,619 @@ ${formatValue(entry.value)}`).join("\n\n");
       describeCall: () => "clear user info"
     };
   }
+  // ============================================================================
+  // TODO Tool Factories
+  // ============================================================================
+  createTodoAddTool() {
+    return {
+      definition: todoAddDefinition,
+      execute: async (args, context) => {
+        this.assertNotDestroyed();
+        await this.ensureInitialized();
+        const userId = context?.userId ?? this.userId;
+        const title = args.title;
+        if (!title || typeof title !== "string" || title.trim().length === 0) {
+          return { error: "Title is required" };
+        }
+        if (this._entries.size >= this.maxEntries) {
+          return { error: `Maximum number of entries reached (${this.maxEntries})` };
+        }
+        let todoId = generateTodoId();
+        while (this._entries.has(todoId)) {
+          todoId = generateTodoId();
+        }
+        const todoValue = {
+          type: "todo",
+          title: title.trim(),
+          description: args.description ? String(args.description).trim() : void 0,
+          people: Array.isArray(args.people) ? args.people.filter((p) => typeof p === "string") : void 0,
+          dueDate: typeof args.dueDate === "string" && args.dueDate.trim() ? args.dueDate.trim() : void 0,
+          tags: Array.isArray(args.tags) ? args.tags.filter((t) => typeof t === "string") : void 0,
+          status: "pending"
+        };
+        const valueSize = calculateValueSize(todoValue);
+        let currentTotal = 0;
+        for (const e of this._entries.values()) {
+          currentTotal += calculateValueSize(e.value);
+        }
+        if (currentTotal + valueSize > this.maxTotalSize) {
+          return { error: `Total size would exceed maximum (${this.maxTotalSize} bytes)` };
+        }
+        const now = Date.now();
+        const entry = {
+          id: todoId,
+          value: todoValue,
+          valueType: "object",
+          description: title.trim(),
+          createdAt: now,
+          updatedAt: now
+        };
+        this._entries.set(todoId, entry);
+        this._tokenCache = null;
+        await this.persistToStorage(userId);
+        return {
+          success: true,
+          message: `TODO '${title.trim()}' created`,
+          id: todoId,
+          todo: todoValue
+        };
+      },
+      permission: { scope: "always", riskLevel: "low" },
+      describeCall: (args) => `add todo '${args.title}'`
+    };
+  }
+  createTodoUpdateTool() {
+    return {
+      definition: todoUpdateDefinition,
+      execute: async (args, context) => {
+        this.assertNotDestroyed();
+        await this.ensureInitialized();
+        const userId = context?.userId ?? this.userId;
+        const id = args.id;
+        if (!id || typeof id !== "string") {
+          return { error: "Todo ID is required" };
+        }
+        const entry = this._entries.get(id);
+        if (!entry || !isTodoEntry(entry)) {
+          return { error: `TODO '${id}' not found` };
+        }
+        const currentValue = entry.value;
+        const updatedValue = { ...currentValue };
+        if (typeof args.title === "string" && args.title.trim()) {
+          updatedValue.title = args.title.trim();
+        }
+        if (args.description !== void 0) {
+          updatedValue.description = typeof args.description === "string" && args.description.trim() ? args.description.trim() : void 0;
+        }
+        if (args.people !== void 0) {
+          updatedValue.people = Array.isArray(args.people) ? args.people.filter((p) => typeof p === "string") : void 0;
+        }
+        if (args.dueDate !== void 0) {
+          updatedValue.dueDate = typeof args.dueDate === "string" && args.dueDate.trim() ? args.dueDate.trim() : void 0;
+        }
+        if (args.tags !== void 0) {
+          updatedValue.tags = Array.isArray(args.tags) ? args.tags.filter((t) => typeof t === "string") : void 0;
+        }
+        if (args.status === "pending" || args.status === "done") {
+          updatedValue.status = args.status;
+        }
+        const valueSize = calculateValueSize(updatedValue);
+        let currentTotal = 0;
+        for (const e of this._entries.values()) {
+          currentTotal += calculateValueSize(e.value);
+        }
+        const existingSize = calculateValueSize(currentValue);
+        if (currentTotal - existingSize + valueSize > this.maxTotalSize) {
+          return { error: `Total size would exceed maximum (${this.maxTotalSize} bytes)` };
+        }
+        const now = Date.now();
+        const updatedEntry = {
+          ...entry,
+          value: updatedValue,
+          description: updatedValue.title,
+          updatedAt: now
+        };
+        this._entries.set(id, updatedEntry);
+        this._tokenCache = null;
+        await this.persistToStorage(userId);
+        return {
+          success: true,
+          message: `TODO '${id}' updated`,
+          id,
+          todo: updatedValue
+        };
+      },
+      permission: { scope: "always", riskLevel: "low" },
+      describeCall: (args) => `update todo '${args.id}'`
+    };
+  }
+  createTodoRemoveTool() {
+    return {
+      definition: todoRemoveDefinition,
+      execute: async (args, context) => {
+        this.assertNotDestroyed();
+        await this.ensureInitialized();
+        const userId = context?.userId ?? this.userId;
+        const id = args.id;
+        if (!id || typeof id !== "string") {
+          return { error: "Todo ID is required" };
+        }
+        const entry = this._entries.get(id);
+        if (!entry || !isTodoEntry(entry)) {
+          return { error: `TODO '${id}' not found` };
+        }
+        this._entries.delete(id);
+        this._tokenCache = null;
+        await this.persistToStorage(userId);
+        return {
+          success: true,
+          message: `TODO '${id}' removed`,
+          id
+        };
+      },
+      permission: { scope: "always", riskLevel: "low" },
+      describeCall: (args) => `remove todo '${args.id}'`
+    };
+  }
+};
+
+// src/core/context-nextgen/plugins/ToolCatalogPluginNextGen.ts
+init_Logger();
+var DEFAULT_MAX_LOADED = 10;
+var TOOL_CATALOG_INSTRUCTIONS = `## Tool Catalog
+
+You have access to a dynamic tool catalog. Not all tools are loaded at once \u2014 use these metatools to discover and load what you need:
+
+**tool_catalog_search** \u2014 Browse available tool categories and search for specific tools.
+  - No params \u2192 list all available categories with descriptions
+  - \`category\` \u2192 list tools in that category
+  - \`query\` \u2192 keyword search across categories and tools
+
+**tool_catalog_load** \u2014 Load a category's tools so you can use them.
+  - Tools become available immediately after loading.
+  - If you need tools from a category, load it first.
+
+**tool_catalog_unload** \u2014 Unload a category to free token budget.
+  - Unloaded tools are no longer sent to you.
+  - Use when you're done with a category.
+
+**Best practices:**
+- Search first to find the right category before loading.
+- Unload categories you no longer need to keep context lean.
+- Categories marked [LOADED] are already available.`;
+var catalogSearchDefinition = {
+  type: "function",
+  function: {
+    name: "tool_catalog_search",
+    description: "Search the tool catalog. No params lists categories. Use category to list tools in it, or query to keyword-search.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Keyword to search across category names, descriptions, and tool names"
+        },
+        category: {
+          type: "string",
+          description: "Category name to list its tools"
+        }
+      }
+    }
+  }
+};
+var catalogLoadDefinition = {
+  type: "function",
+  function: {
+    name: "tool_catalog_load",
+    description: "Load all tools from a category so they become available for use.",
+    parameters: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          description: "Category name to load"
+        }
+      },
+      required: ["category"]
+    }
+  }
+};
+var catalogUnloadDefinition = {
+  type: "function",
+  function: {
+    name: "tool_catalog_unload",
+    description: "Unload a category to free token budget. Tools from this category will no longer be available.",
+    parameters: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          description: "Category name to unload"
+        }
+      },
+      required: ["category"]
+    }
+  }
+};
+var ToolCatalogPluginNextGen = class extends BasePluginNextGen {
+  name = "tool_catalog";
+  /** category name → array of tool names that were loaded */
+  _loadedCategories = /* @__PURE__ */ new Map();
+  /** Reference to the ToolManager for registering/disabling tools */
+  _toolManager = null;
+  /** Cached connector categories — discovered once in setToolManager() */
+  _connectorCategories = null;
+  /** Whether this plugin has been destroyed */
+  _destroyed = false;
+  /** WeakMap cache for tool definition token estimates */
+  _toolTokenCache = /* @__PURE__ */ new WeakMap();
+  _config;
+  constructor(config) {
+    super();
+    this._config = {
+      maxLoadedCategories: DEFAULT_MAX_LOADED,
+      ...config
+    };
+  }
+  // ========================================================================
+  // Plugin Interface
+  // ========================================================================
+  getInstructions() {
+    return TOOL_CATALOG_INSTRUCTIONS;
+  }
+  async getContent() {
+    const categories = this.getAllowedCategories();
+    if (categories.length === 0 && this.getConnectorCategories().length === 0) return null;
+    const lines = ["## Tool Catalog"];
+    lines.push("");
+    const loaded = Array.from(this._loadedCategories.keys());
+    if (loaded.length > 0) {
+      lines.push(`**Loaded:** ${loaded.join(", ")}`);
+    }
+    lines.push(`**Available categories:** ${categories.length}`);
+    for (const cat of categories) {
+      const tools = ToolCatalogRegistry.getToolsInCategory(cat.name);
+      const marker = this._loadedCategories.has(cat.name) ? " [LOADED]" : "";
+      lines.push(`- **${cat.displayName}** (${tools.length} tools)${marker}: ${cat.description}`);
+    }
+    for (const cc of this.getConnectorCategories()) {
+      const marker = this._loadedCategories.has(cc.name) ? " [LOADED]" : "";
+      lines.push(`- **${cc.displayName}** (${cc.toolCount} tools)${marker}: ${cc.description}`);
+    }
+    const content = lines.join("\n");
+    this.updateTokenCache(this.estimator.estimateTokens(content));
+    return content;
+  }
+  getContents() {
+    return {
+      loadedCategories: Array.from(this._loadedCategories.entries()).map(([name, tools]) => ({
+        category: name,
+        toolCount: tools.length,
+        tools
+      }))
+    };
+  }
+  getTools() {
+    const plugin = this;
+    const searchTool = {
+      definition: catalogSearchDefinition,
+      execute: async (args) => {
+        return plugin.executeSearch(args.query, args.category);
+      }
+    };
+    const loadTool = {
+      definition: catalogLoadDefinition,
+      execute: async (args) => {
+        return plugin.executeLoad(args.category);
+      }
+    };
+    const unloadTool = {
+      definition: catalogUnloadDefinition,
+      execute: async (args) => {
+        return plugin.executeUnload(args.category);
+      }
+    };
+    return [searchTool, loadTool, unloadTool];
+  }
+  isCompactable() {
+    return this._loadedCategories.size > 0;
+  }
+  async compact(targetTokensToFree) {
+    if (!this._toolManager || this._loadedCategories.size === 0) return 0;
+    const categoriesByLastUsed = this.getCategoriesSortedByLastUsed();
+    let freed = 0;
+    for (const category of categoriesByLastUsed) {
+      if (freed >= targetTokensToFree) break;
+      const toolNames = this._loadedCategories.get(category);
+      if (!toolNames) continue;
+      const toolTokens = this.estimateToolDefinitionTokens(toolNames);
+      this._toolManager.setEnabled(toolNames, false);
+      this._loadedCategories.delete(category);
+      freed += toolTokens;
+      exports.logger.debug(
+        { category, toolCount: toolNames.length, freed: toolTokens },
+        `[ToolCatalogPlugin] Compacted category '${category}'`
+      );
+    }
+    this.invalidateTokenCache();
+    return freed;
+  }
+  getState() {
+    return {
+      loadedCategories: Array.from(this._loadedCategories.keys())
+    };
+  }
+  restoreState(state) {
+    if (!state || typeof state !== "object") return;
+    const s = state;
+    if (!Array.isArray(s.loadedCategories) || s.loadedCategories.length === 0) return;
+    for (const category of s.loadedCategories) {
+      if (typeof category !== "string" || !category) continue;
+      const result = this.executeLoad(category);
+      if (result.error) {
+        exports.logger.warn(
+          { category, error: result.error },
+          `[ToolCatalogPlugin] Failed to restore category '${category}'`
+        );
+      }
+    }
+    this.invalidateTokenCache();
+  }
+  destroy() {
+    this._loadedCategories.clear();
+    this._toolManager = null;
+    this._connectorCategories = null;
+    this._destroyed = true;
+  }
+  // ========================================================================
+  // Public API
+  // ========================================================================
+  /**
+   * Set the ToolManager reference. Called by AgentContextNextGen after plugin registration.
+   */
+  setToolManager(tm) {
+    this._toolManager = tm;
+    this._connectorCategories = ToolCatalogRegistry.discoverConnectorCategories({
+      scope: this._config.categoryScope,
+      identities: this._config.identities
+    });
+    if (this._config.autoLoadCategories?.length) {
+      for (const category of this._config.autoLoadCategories) {
+        const result = this.executeLoad(category);
+        if (result.error) {
+          exports.logger.warn(
+            { category, error: result.error },
+            `[ToolCatalogPlugin] Failed to auto-load category '${category}'`
+          );
+        }
+      }
+    }
+  }
+  /** Get list of currently loaded category names */
+  get loadedCategories() {
+    return Array.from(this._loadedCategories.keys());
+  }
+  // ========================================================================
+  // Metatool Implementations
+  // ========================================================================
+  executeSearch(query, category) {
+    if (this._destroyed) return { error: "Plugin destroyed" };
+    if (category) {
+      if (ToolCatalogRegistry.parseConnectorCategory(category) !== null) {
+        return this.searchConnectorCategory(category);
+      }
+      if (!ToolCatalogRegistry.hasCategory(category)) {
+        return { error: `Category '${category}' not found. Use tool_catalog_search with no params to see available categories.` };
+      }
+      if (!ToolCatalogRegistry.isCategoryAllowed(category, this._config.categoryScope)) {
+        return { error: `Category '${category}' is not available for this agent.` };
+      }
+      const tools = ToolCatalogRegistry.getToolsInCategory(category);
+      const loaded = this._loadedCategories.has(category);
+      return {
+        category,
+        loaded,
+        tools: tools.map((t) => ({
+          name: t.name,
+          displayName: t.displayName,
+          description: t.description,
+          safeByDefault: t.safeByDefault
+        }))
+      };
+    }
+    if (query) {
+      return this.keywordSearch(query);
+    }
+    const categories = this.getAllowedCategories();
+    const connectorCats = this.getConnectorCategories();
+    const result = [];
+    for (const cat of categories) {
+      const tools = ToolCatalogRegistry.getToolsInCategory(cat.name);
+      result.push({
+        name: cat.name,
+        displayName: cat.displayName,
+        description: cat.description,
+        toolCount: tools.length,
+        loaded: this._loadedCategories.has(cat.name)
+      });
+    }
+    for (const cc of connectorCats) {
+      result.push({
+        name: cc.name,
+        displayName: cc.displayName,
+        description: cc.description,
+        toolCount: cc.toolCount,
+        loaded: this._loadedCategories.has(cc.name)
+      });
+    }
+    return { categories: result };
+  }
+  executeLoad(category) {
+    if (this._destroyed) return { error: "Plugin destroyed" };
+    if (!this._toolManager) {
+      return { error: "ToolManager not connected. Plugin not properly initialized." };
+    }
+    if (!ToolCatalogRegistry.isCategoryAllowed(category, this._config.categoryScope)) {
+      return { error: `Category '${category}' is not available for this agent.` };
+    }
+    if (this._loadedCategories.has(category)) {
+      const toolNames2 = this._loadedCategories.get(category);
+      return { loaded: toolNames2.length, tools: toolNames2, alreadyLoaded: true };
+    }
+    if (this._loadedCategories.size >= this._config.maxLoadedCategories) {
+      return {
+        error: `Maximum loaded categories (${this._config.maxLoadedCategories}) reached. Unload a category first.`,
+        loaded: Array.from(this._loadedCategories.keys())
+      };
+    }
+    const isConnector = ToolCatalogRegistry.parseConnectorCategory(category) !== null;
+    let tools;
+    if (isConnector) {
+      tools = ToolCatalogRegistry.resolveConnectorCategoryTools(category);
+    } else {
+      const entries = ToolCatalogRegistry.getToolsInCategory(category);
+      if (entries.length === 0) {
+        return { error: `Category '${category}' has no tools or does not exist.` };
+      }
+      tools = entries.filter((e) => e.tool != null).map((e) => ({ tool: e.tool, name: e.name }));
+    }
+    if (tools.length === 0) {
+      return { error: `No tools found for category '${category}'.` };
+    }
+    const toolNames = [];
+    for (const { tool, name } of tools) {
+      const existing = this._toolManager.getRegistration(name);
+      if (existing) {
+        this._toolManager.setEnabled([name], true);
+      } else {
+        this._toolManager.register(tool, { category, source: `catalog:${category}` });
+      }
+      toolNames.push(name);
+    }
+    this._loadedCategories.set(category, toolNames);
+    this.invalidateTokenCache();
+    exports.logger.debug(
+      { category, toolCount: toolNames.length, tools: toolNames },
+      `[ToolCatalogPlugin] Loaded category '${category}'`
+    );
+    return { loaded: toolNames.length, tools: toolNames };
+  }
+  executeUnload(category) {
+    if (this._destroyed) return { error: "Plugin destroyed" };
+    if (!this._toolManager) {
+      return { error: "ToolManager not connected." };
+    }
+    const toolNames = this._loadedCategories.get(category);
+    if (!toolNames) {
+      return { unloaded: 0, message: `Category '${category}' is not loaded.` };
+    }
+    this._toolManager.setEnabled(toolNames, false);
+    this._loadedCategories.delete(category);
+    this.invalidateTokenCache();
+    exports.logger.debug(
+      { category, toolCount: toolNames.length },
+      `[ToolCatalogPlugin] Unloaded category '${category}'`
+    );
+    return { unloaded: toolNames.length };
+  }
+  // ========================================================================
+  // Helpers
+  // ========================================================================
+  getAllowedCategories() {
+    return ToolCatalogRegistry.filterCategories(this._config.categoryScope);
+  }
+  /**
+   * Get connector categories from cache (populated once in setToolManager).
+   */
+  getConnectorCategories() {
+    return this._connectorCategories ?? [];
+  }
+  keywordSearch(query) {
+    const lq = query.toLowerCase();
+    const results = [];
+    for (const cat of this.getAllowedCategories()) {
+      const catMatch = cat.name.toLowerCase().includes(lq) || cat.displayName.toLowerCase().includes(lq) || cat.description.toLowerCase().includes(lq);
+      const tools = ToolCatalogRegistry.getToolsInCategory(cat.name);
+      const matchingTools = tools.filter(
+        (t) => t.name.toLowerCase().includes(lq) || t.displayName.toLowerCase().includes(lq) || t.description.toLowerCase().includes(lq)
+      );
+      if (catMatch || matchingTools.length > 0) {
+        results.push({
+          category: cat.name,
+          categoryDisplayName: cat.displayName,
+          tools: (catMatch ? tools : matchingTools).map((t) => ({
+            name: t.name,
+            displayName: t.displayName,
+            description: t.description
+          }))
+        });
+      }
+    }
+    for (const cc of this.getConnectorCategories()) {
+      if (cc.name.toLowerCase().includes(lq) || cc.displayName.toLowerCase().includes(lq) || cc.description.toLowerCase().includes(lq)) {
+        results.push({
+          category: cc.name,
+          categoryDisplayName: cc.displayName,
+          tools: cc.tools.map((t) => ({
+            name: t.definition.function.name,
+            displayName: t.definition.function.name.replace(/_/g, " "),
+            description: t.definition.function.description || ""
+          }))
+        });
+      }
+    }
+    return { query, results, totalMatches: results.length };
+  }
+  searchConnectorCategory(category) {
+    const connectorName = ToolCatalogRegistry.parseConnectorCategory(category);
+    const tools = ToolCatalogRegistry.resolveConnectorCategoryTools(category);
+    const loaded = this._loadedCategories.has(category);
+    return {
+      category,
+      loaded,
+      connectorName,
+      tools: tools.map((t) => ({
+        name: t.name,
+        description: t.tool.definition.function.description || ""
+      }))
+    };
+  }
+  getCategoriesSortedByLastUsed() {
+    if (!this._toolManager) return Array.from(this._loadedCategories.keys());
+    const categoryLastUsed = [];
+    for (const [category, toolNames] of this._loadedCategories) {
+      let maxLastUsed = 0;
+      for (const name of toolNames) {
+        const reg = this._toolManager.getRegistration(name);
+        if (reg?.metadata?.lastUsed) {
+          const ts = reg.metadata.lastUsed instanceof Date ? reg.metadata.lastUsed.getTime() : 0;
+          if (ts > maxLastUsed) maxLastUsed = ts;
+        }
+      }
+      categoryLastUsed.push({ category, lastUsed: maxLastUsed });
+    }
+    categoryLastUsed.sort((a, b) => a.lastUsed - b.lastUsed);
+    return categoryLastUsed.map((c) => c.category);
+  }
+  estimateToolDefinitionTokens(toolNames) {
+    let total = 0;
+    for (const name of toolNames) {
+      const reg = this._toolManager?.getRegistration(name);
+      if (reg) {
+        const defObj = reg.tool.definition;
+        const cached = this._toolTokenCache.get(defObj);
+        if (cached !== void 0) {
+          total += cached;
+        } else {
+          const defStr = JSON.stringify(defObj);
+          const tokens = this.estimator.estimateTokens(defStr);
+          this._toolTokenCache.set(defObj, tokens);
+          total += tokens;
+        }
+      }
+    }
+    return total;
+  }
 };
 
 // src/core/context-nextgen/AgentContextNextGen.ts
@@ -16878,7 +18167,8 @@ var DEFAULT_FEATURES = {
   workingMemory: true,
   inContextMemory: true,
   persistentInstructions: false,
-  userInfo: false
+  userInfo: false,
+  toolCatalog: false
 };
 var DEFAULT_CONFIG2 = {
   responseReserve: 4096,
@@ -16950,6 +18240,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
       strategy: config.strategy ?? DEFAULT_CONFIG2.strategy,
       features: { ...DEFAULT_FEATURES, ...config.features },
       agentId: config.agentId ?? this.generateId(),
+      toolCategories: config.toolCategories,
       storage: config.storage
     };
     this._systemPrompt = config.systemPrompt;
@@ -17005,6 +18296,16 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
         ...uiConfig
       }));
     }
+    if (features.toolCatalog) {
+      const tcConfig = configs.toolCatalog;
+      const plugin = new ToolCatalogPluginNextGen({
+        categoryScope: this._config.toolCategories,
+        identities: this._identities,
+        ...tcConfig
+      });
+      this.registerPlugin(plugin);
+      plugin.setToolManager(this._tools);
+    }
     this.validateStrategyDependencies(this._compactionStrategy);
   }
   /**
@@ -24726,7 +26027,9 @@ var ROUTINE_KEYS = {
   /** Running fold accumulator (ICM) */
   FOLD_ACCUMULATOR: "__fold_accumulator",
   /** Prefix for large dep results stored in WM findings tier */
-  WM_DEP_FINDINGS_PREFIX: "findings/__dep_result_"
+  WM_DEP_FINDINGS_PREFIX: "findings/__dep_result_",
+  /** Prefix for auto-stored task outputs (set by output contracts) */
+  TASK_OUTPUT_PREFIX: "__task_output_"
 };
 function resolveTemplates(text, inputs, icmPlugin) {
   return text.replace(/\{\{(\w+)\.(\w+)\}\}/g, (_match, namespace, key) => {
@@ -24751,13 +26054,45 @@ function resolveTemplates(text, inputs, icmPlugin) {
 function resolveTaskTemplates(task, inputs, icmPlugin) {
   const resolvedDescription = resolveTemplates(task.description, inputs, icmPlugin);
   const resolvedExpectedOutput = task.expectedOutput ? resolveTemplates(task.expectedOutput, inputs, icmPlugin) : task.expectedOutput;
-  if (resolvedDescription === task.description && resolvedExpectedOutput === task.expectedOutput) {
+  let resolvedControlFlow = task.controlFlow;
+  if (task.controlFlow && "source" in task.controlFlow) {
+    const flow = task.controlFlow;
+    const source = flow.source;
+    if (typeof source === "string") {
+      const r = resolveTemplates(source, inputs, icmPlugin);
+      if (r !== source) {
+        resolvedControlFlow = { ...flow, source: r };
+      }
+    } else if (source) {
+      let changed = false;
+      const resolved = { ...source };
+      if (resolved.task) {
+        const r = resolveTemplates(resolved.task, inputs, icmPlugin);
+        if (r !== resolved.task) {
+          resolved.task = r;
+          changed = true;
+        }
+      }
+      if (resolved.key) {
+        const r = resolveTemplates(resolved.key, inputs, icmPlugin);
+        if (r !== resolved.key) {
+          resolved.key = r;
+          changed = true;
+        }
+      }
+      if (changed) {
+        resolvedControlFlow = { ...flow, source: resolved };
+      }
+    }
+  }
+  if (resolvedDescription === task.description && resolvedExpectedOutput === task.expectedOutput && resolvedControlFlow === task.controlFlow) {
     return task;
   }
   return {
     ...task,
     description: resolvedDescription,
-    expectedOutput: resolvedExpectedOutput
+    expectedOutput: resolvedExpectedOutput,
+    controlFlow: resolvedControlFlow
   };
 }
 function validateAndResolveInputs(parameters, inputs) {
@@ -24825,17 +26160,6 @@ function cleanFoldKeys(icmPlugin) {
   cleanMapKeys(icmPlugin);
   icmPlugin.delete(ROUTINE_KEYS.FOLD_ACCUMULATOR);
 }
-async function readSourceArray(flow, flowType, icmPlugin, wmPlugin) {
-  const sourceValue = await readMemoryValue(flow.sourceKey, icmPlugin, wmPlugin);
-  if (!Array.isArray(sourceValue)) {
-    return {
-      completed: false,
-      error: `${flowType} sourceKey "${flow.sourceKey}" is not an array (got ${typeof sourceValue})`
-    };
-  }
-  const maxIter = Math.min(sourceValue.length, flow.maxIterations ?? sourceValue.length, HARD_MAX_ITERATIONS);
-  return { array: sourceValue, maxIter };
-}
 function prepareSubRoutine(tasks, parentTaskName) {
   const subRoutine = resolveSubRoutine(tasks, parentTaskName);
   return {
@@ -24870,10 +26194,141 @@ async function withTimeout(promise, timeoutMs, label) {
     clearTimeout(timer);
   }
 }
-async function handleMap(agent, flow, task, inputs) {
+var COMMON_ARRAY_FIELDS = ["data", "items", "results", "entries", "list", "records", "values", "elements"];
+function extractByPath(value, path6) {
+  let current = value;
+  if (typeof current === "string") {
+    try {
+      current = JSON.parse(current);
+    } catch {
+      return void 0;
+    }
+  }
+  const segments = path6.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  for (const segment of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function tryCoerceToArray(value) {
+  if (value === void 0 || value === null) return value;
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed;
+      if (typeof parsed === "object" && parsed !== null) {
+        value = parsed;
+      } else {
+        return value;
+      }
+    } catch {
+      return value;
+    }
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const field of COMMON_ARRAY_FIELDS) {
+      const candidate = value[field];
+      if (Array.isArray(candidate)) return candidate;
+    }
+  }
+  return value;
+}
+async function llmExtractArray(agent, rawValue) {
+  const serialized = typeof rawValue === "string" ? rawValue : JSON.stringify(rawValue);
+  const truncated = serialized.length > 8e3 ? serialized.slice(0, 8e3) + "\n...(truncated)" : serialized;
+  const response = await agent.runDirect(
+    [
+      "Extract a JSON array from the data below for iteration.",
+      "Return ONLY a valid JSON array. No explanation, no markdown fences, no extra text.",
+      "If the data contains a list in any format (JSON, markdown, numbered list, comma-separated), convert it to a JSON array of items.",
+      "",
+      "Data:",
+      truncated
+    ].join("\n"),
+    { temperature: 0, maxOutputTokens: 4096 }
+  );
+  const text = response.output_text?.trim() ?? "";
+  const cleaned = text.replace(/^```(?:json|JSON)?\s*\n?/, "").replace(/\n?\s*```$/, "").trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch (parseErr) {
+    throw new Error(`LLM returned invalid JSON: ${parseErr.message}. Raw: "${text.slice(0, 200)}"`);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error(`LLM extraction produced ${typeof parsed}, expected array`);
+  }
+  return parsed;
+}
+async function resolveFlowSource(flow, flowType, agent, execution, icmPlugin, wmPlugin) {
+  const log = exports.logger.child({ fn: "resolveFlowSource", flowType });
+  const source = flow.source;
+  const lookups = [];
+  if (typeof source === "string") {
+    lookups.push({ key: source, label: `key "${source}"` });
+  } else if (source.task) {
+    lookups.push({
+      key: `${ROUTINE_KEYS.TASK_OUTPUT_PREFIX}${source.task}`,
+      path: source.path,
+      label: `task output "${source.task}"`
+    });
+    if (execution) {
+      const depTask = execution.plan.tasks.find((t) => t.name === source.task);
+      if (depTask) {
+        lookups.push({
+          key: `${ROUTINE_KEYS.DEP_RESULT_PREFIX}${depTask.id}`,
+          path: source.path,
+          label: `dep result "${source.task}"`
+        });
+      }
+    }
+  } else if (source.key) {
+    lookups.push({ key: source.key, path: source.path, label: `key "${source.key}"` });
+  }
+  if (lookups.length === 0) {
+    return { completed: false, error: `${flowType}: source has no task, key, or string value` };
+  }
+  let rawValue;
+  let resolvedVia;
+  for (const { key, path: path6, label } of lookups) {
+    const value2 = await readMemoryValue(key, icmPlugin, wmPlugin);
+    if (value2 !== void 0) {
+      rawValue = path6 ? extractByPath(value2, path6) : value2;
+      resolvedVia = label;
+      break;
+    }
+  }
+  if (rawValue === void 0) {
+    const tried = lookups.map((l) => l.label).join(", ");
+    return { completed: false, error: `${flowType}: source not found (tried: ${tried})` };
+  }
+  log.debug({ resolvedVia }, "Source value found");
+  let value = tryCoerceToArray(rawValue);
+  if (!Array.isArray(value)) {
+    log.info({ resolvedVia, valueType: typeof value }, "Source not an array, attempting LLM extraction");
+    try {
+      value = await llmExtractArray(agent, rawValue);
+      log.info({ extractedLength: value.length }, "LLM extraction succeeded");
+    } catch (err) {
+      return {
+        completed: false,
+        error: `${flowType}: source value is not an array and LLM extraction failed: ${err.message}`
+      };
+    }
+  }
+  const arr = value;
+  if (arr.length === 0) {
+    log.warn("Source array is empty");
+  }
+  const maxIter = Math.min(arr.length, flow.maxIterations ?? arr.length, HARD_MAX_ITERATIONS);
+  return { array: arr, maxIter };
+}
+async function handleMap(agent, flow, task, inputs, execution) {
   const { icmPlugin, wmPlugin } = getPlugins(agent);
   const log = exports.logger.child({ controlFlow: "map", task: task.name });
-  const sourceResult = await readSourceArray(flow, "Map", icmPlugin, wmPlugin);
+  const sourceResult = await resolveFlowSource(flow, "Map", agent, execution, icmPlugin, wmPlugin);
   if ("completed" in sourceResult) return sourceResult;
   const { array: array3, maxIter } = sourceResult;
   const results = [];
@@ -24911,10 +26366,10 @@ async function handleMap(agent, flow, task, inputs) {
   log.info({ resultCount: results.length }, "Map completed");
   return { completed: true, result: results };
 }
-async function handleFold(agent, flow, task, inputs) {
+async function handleFold(agent, flow, task, inputs, execution) {
   const { icmPlugin, wmPlugin } = getPlugins(agent);
   const log = exports.logger.child({ controlFlow: "fold", task: task.name });
-  const sourceResult = await readSourceArray(flow, "Fold", icmPlugin, wmPlugin);
+  const sourceResult = await resolveFlowSource(flow, "Fold", agent, execution, icmPlugin, wmPlugin);
   if ("completed" in sourceResult) return sourceResult;
   const { array: array3, maxIter } = sourceResult;
   let accumulator = flow.initialValue;
@@ -25005,13 +26460,13 @@ async function handleUntil(agent, flow, task, inputs) {
   }
   return { completed: false, error: `Until loop: maxIterations (${flow.maxIterations}) exceeded` };
 }
-async function executeControlFlow(agent, task, inputs) {
+async function executeControlFlow(agent, task, inputs, execution) {
   const flow = task.controlFlow;
   switch (flow.type) {
     case "map":
-      return handleMap(agent, flow, task, inputs);
+      return handleMap(agent, flow, task, inputs, execution);
     case "fold":
-      return handleFold(agent, flow, task, inputs);
+      return handleFold(agent, flow, task, inputs, execution);
     case "until":
       return handleUntil(agent, flow, task, inputs);
     default:
@@ -25040,7 +26495,26 @@ function defaultSystemPrompt(definition) {
   );
   return parts.join("\n");
 }
-function defaultTaskPrompt(task) {
+function getOutputContracts(execution, currentTask) {
+  const contracts = [];
+  for (const task of execution.plan.tasks) {
+    if (task.status !== "pending" || !task.controlFlow) continue;
+    const flow = task.controlFlow;
+    if (flow.type === "until") continue;
+    const source = flow.source;
+    const sourceTaskName = typeof source === "string" ? void 0 : source.task;
+    if (sourceTaskName === currentTask.name) {
+      contracts.push({
+        storageKey: `${ROUTINE_KEYS.TASK_OUTPUT_PREFIX}${currentTask.name}`,
+        format: "array",
+        consumingTaskName: task.name,
+        flowType: flow.type
+      });
+    }
+  }
+  return contracts;
+}
+function defaultTaskPrompt(task, execution) {
   const parts = [];
   parts.push(`## Current Task: ${task.name}`, "");
   parts.push(task.description, "");
@@ -25065,6 +26539,21 @@ function defaultTaskPrompt(task) {
     parts.push("Review the plan overview and dependency results before starting.");
     parts.push("");
   }
+  if (execution) {
+    const contracts = getOutputContracts(execution, task);
+    if (contracts.length > 0) {
+      parts.push("### Output Storage");
+      for (const contract of contracts) {
+        parts.push(
+          `A downstream task ("${contract.consumingTaskName}") will ${contract.flowType} over your results.`,
+          `Store your result as a JSON ${contract.format} using:`,
+          `  context_set("${contract.storageKey}", <your JSON ${contract.format}>)`,
+          "Each array element should represent one item to process independently.",
+          ""
+        );
+      }
+    }
+  }
   parts.push("After completing the work, store key results in memory once, then respond with a text summary (no more tool calls).");
   return parts.join("\n");
 }
@@ -25221,8 +26710,8 @@ var DEP_CLEANUP_CONFIG = {
   wmPrefixes: [ROUTINE_KEYS.DEP_RESULT_PREFIX, ROUTINE_KEYS.WM_DEP_FINDINGS_PREFIX]
 };
 var FULL_CLEANUP_CONFIG = {
-  icmPrefixes: ["__routine_", ROUTINE_KEYS.DEP_RESULT_PREFIX, "__map_", "__fold_"],
-  wmPrefixes: [ROUTINE_KEYS.DEP_RESULT_PREFIX, ROUTINE_KEYS.WM_DEP_FINDINGS_PREFIX]
+  icmPrefixes: ["__routine_", ROUTINE_KEYS.DEP_RESULT_PREFIX, "__map_", "__fold_", ROUTINE_KEYS.TASK_OUTPUT_PREFIX],
+  wmPrefixes: [ROUTINE_KEYS.DEP_RESULT_PREFIX, ROUTINE_KEYS.WM_DEP_FINDINGS_PREFIX, ROUTINE_KEYS.TASK_OUTPUT_PREFIX]
 };
 async function injectRoutineContext(agent, execution, definition, currentTask) {
   const { icmPlugin, wmPlugin } = getPlugins(agent);
@@ -25333,7 +26822,8 @@ async function executeRoutine(options) {
   execution.startedAt = Date.now();
   execution.lastUpdatedAt = Date.now();
   const buildSystemPrompt = prompts?.system ?? defaultSystemPrompt;
-  const buildTaskPrompt = prompts?.task ?? defaultTaskPrompt;
+  const userTaskPromptBuilder = prompts?.task ?? defaultTaskPrompt;
+  const buildTaskPrompt = (task) => userTaskPromptBuilder(task, execution);
   const buildValidationPrompt = prompts?.validation ?? defaultValidationPrompt;
   let agent;
   const registeredHooks = [];
@@ -25424,7 +26914,7 @@ async function executeRoutine(options) {
         const { icmPlugin } = getPlugins(agent);
         if (getTask().controlFlow) {
           try {
-            const cfResult = await executeControlFlow(agent, getTask(), resolvedInputs);
+            const cfResult = await executeControlFlow(agent, getTask(), resolvedInputs, execution);
             if (cfResult.completed) {
               execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "completed");
               execution.plan.tasks[taskIndex].result = { success: true, output: cfResult.result };
@@ -25574,6 +27064,261 @@ async function executeRoutine(options) {
   }
 }
 
+// src/core/createExecutionRecorder.ts
+init_Logger();
+function truncate(value, maxLen) {
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  if (!str) return "";
+  return str.length > maxLen ? str.slice(0, maxLen) + "...(truncated)" : str;
+}
+function safeCall(fn, prefix) {
+  try {
+    const result = fn();
+    if (result && typeof result.catch === "function") {
+      result.catch((err) => {
+        exports.logger.debug({ error: err.message }, `${prefix} async error`);
+      });
+    }
+  } catch (err) {
+    exports.logger.debug({ error: err.message }, `${prefix} sync error`);
+  }
+}
+function createExecutionRecorder(options) {
+  const { storage, executionId, logPrefix = "[Recorder]", maxTruncateLength = 500 } = options;
+  const log = exports.logger.child({ executionId });
+  let currentTaskName = "(unknown)";
+  function pushStep(step) {
+    safeCall(() => storage.pushStep(executionId, step), `${logPrefix} pushStep`);
+  }
+  function heartbeat() {
+    safeCall(
+      () => storage.update(executionId, { lastActivityAt: Date.now() }),
+      `${logPrefix} heartbeat`
+    );
+  }
+  const hooks = {
+    "before:llm": (ctx) => {
+      pushStep({
+        timestamp: Date.now(),
+        taskName: currentTaskName,
+        type: "llm.start",
+        data: { iteration: ctx.iteration }
+      });
+      return {};
+    },
+    "after:llm": (ctx) => {
+      pushStep({
+        timestamp: Date.now(),
+        taskName: currentTaskName,
+        type: "llm.complete",
+        data: {
+          iteration: ctx.iteration,
+          duration: ctx.duration,
+          tokens: ctx.response?.usage
+        }
+      });
+      return {};
+    },
+    "before:tool": (ctx) => {
+      pushStep({
+        timestamp: Date.now(),
+        taskName: currentTaskName,
+        type: "tool.start",
+        data: {
+          toolName: ctx.toolCall.function.name,
+          args: truncate(ctx.toolCall.function.arguments, maxTruncateLength)
+        }
+      });
+      return {};
+    },
+    "after:tool": (ctx) => {
+      pushStep({
+        timestamp: Date.now(),
+        taskName: currentTaskName,
+        type: "tool.call",
+        data: {
+          toolName: ctx.toolCall.function.name,
+          args: truncate(ctx.toolCall.function.arguments, maxTruncateLength),
+          result: truncate(ctx.result?.content, maxTruncateLength),
+          error: ctx.result?.error ? true : void 0
+        }
+      });
+      return {};
+    },
+    "after:execution": () => {
+      pushStep({
+        timestamp: Date.now(),
+        taskName: currentTaskName,
+        type: "iteration.complete"
+      });
+    },
+    "pause:check": () => {
+      heartbeat();
+      return { shouldPause: false };
+    }
+  };
+  const onTaskStarted = (task, execution) => {
+    currentTaskName = task.name;
+    const now = Date.now();
+    safeCall(
+      () => storage.updateTask(executionId, task.name, {
+        status: "in_progress",
+        startedAt: now,
+        attempts: task.attempts
+      }),
+      `${logPrefix} onTaskStarted`
+    );
+    pushStep({
+      timestamp: now,
+      taskName: task.name,
+      type: "task.started",
+      data: { taskId: task.id }
+    });
+    if (task.controlFlow) {
+      pushStep({
+        timestamp: now,
+        taskName: task.name,
+        type: "control_flow.started",
+        data: { flowType: task.controlFlow.type }
+      });
+    }
+    safeCall(
+      () => storage.update(executionId, {
+        progress: execution.progress,
+        lastActivityAt: now
+      }),
+      `${logPrefix} onTaskStarted progress`
+    );
+  };
+  const onTaskComplete = (task, execution) => {
+    const now = Date.now();
+    safeCall(
+      () => storage.updateTask(executionId, task.name, {
+        status: "completed",
+        completedAt: now,
+        attempts: task.attempts,
+        result: task.result ? {
+          success: true,
+          output: truncate(task.result.output, maxTruncateLength),
+          validationScore: task.result.validationScore,
+          validationExplanation: task.result.validationExplanation
+        } : void 0
+      }),
+      `${logPrefix} onTaskComplete`
+    );
+    pushStep({
+      timestamp: now,
+      taskName: task.name,
+      type: "task.completed",
+      data: {
+        taskId: task.id,
+        validationScore: task.result?.validationScore
+      }
+    });
+    if (task.controlFlow) {
+      pushStep({
+        timestamp: now,
+        taskName: task.name,
+        type: "control_flow.completed",
+        data: { flowType: task.controlFlow.type }
+      });
+    }
+    safeCall(
+      () => storage.update(executionId, {
+        progress: execution.progress,
+        lastActivityAt: now
+      }),
+      `${logPrefix} onTaskComplete progress`
+    );
+  };
+  const onTaskFailed = (task, execution) => {
+    const now = Date.now();
+    safeCall(
+      () => storage.updateTask(executionId, task.name, {
+        status: "failed",
+        completedAt: now,
+        attempts: task.attempts,
+        result: task.result ? {
+          success: false,
+          error: task.result.error,
+          validationScore: task.result.validationScore,
+          validationExplanation: task.result.validationExplanation
+        } : void 0
+      }),
+      `${logPrefix} onTaskFailed`
+    );
+    pushStep({
+      timestamp: now,
+      taskName: task.name,
+      type: "task.failed",
+      data: {
+        taskId: task.id,
+        error: task.result?.error,
+        attempts: task.attempts
+      }
+    });
+    safeCall(
+      () => storage.update(executionId, {
+        progress: execution.progress,
+        lastActivityAt: now
+      }),
+      `${logPrefix} onTaskFailed progress`
+    );
+  };
+  const onTaskValidation = (task, result, _execution) => {
+    pushStep({
+      timestamp: Date.now(),
+      taskName: task.name,
+      type: "task.validation",
+      data: {
+        taskId: task.id,
+        isComplete: result.isComplete,
+        completionScore: result.completionScore,
+        explanation: truncate(result.explanation, maxTruncateLength)
+      }
+    });
+  };
+  const finalize = async (execution, error) => {
+    const now = Date.now();
+    try {
+      if (error || !execution) {
+        await storage.update(executionId, {
+          status: "failed",
+          error: error?.message ?? "Unknown error",
+          completedAt: now,
+          lastActivityAt: now
+        });
+        if (error) {
+          await storage.pushStep(executionId, {
+            timestamp: now,
+            taskName: currentTaskName,
+            type: "execution.error",
+            data: { error: error.message }
+          });
+        }
+      } else {
+        await storage.update(executionId, {
+          status: execution.status,
+          progress: execution.progress,
+          error: execution.error,
+          completedAt: execution.completedAt ?? now,
+          lastActivityAt: now
+        });
+      }
+    } catch (err) {
+      log.error({ error: err.message }, `${logPrefix} finalize error`);
+    }
+  };
+  return {
+    hooks,
+    onTaskStarted,
+    onTaskComplete,
+    onTaskFailed,
+    onTaskValidation,
+    finalize
+  };
+}
+
 // src/core/index.ts
 init_constants();
 (class {
@@ -38898,6 +40643,38 @@ var InMemoryHistoryStorage = class {
     this.summaries = state.summaries ? [...state.summaries] : [];
   }
 };
+
+// src/domain/entities/RoutineExecutionRecord.ts
+function createTaskSnapshots(definition) {
+  return definition.tasks.map((task) => ({
+    taskId: task.id ?? task.name,
+    name: task.name,
+    description: task.description,
+    status: "pending",
+    attempts: 0,
+    maxAttempts: task.maxAttempts ?? 3,
+    controlFlowType: task.controlFlow?.type
+  }));
+}
+function createRoutineExecutionRecord(definition, connectorName, model, trigger) {
+  const now = Date.now();
+  const executionId = `rexec-${now}-${Math.random().toString(36).substr(2, 9)}`;
+  return {
+    executionId,
+    routineId: definition.id,
+    routineName: definition.name,
+    status: "running",
+    progress: 0,
+    tasks: createTaskSnapshots(definition),
+    steps: [],
+    taskCount: definition.tasks.length,
+    connectorName,
+    model,
+    startedAt: now,
+    lastActivityAt: now,
+    trigger: trigger ?? { type: "manual" }
+  };
+}
 function getDefaultBaseDirectory3() {
   const platform2 = process.platform;
   if (platform2 === "win32") {
@@ -44741,6 +46518,7 @@ __export(tools_exports, {
   createEditMeetingTool: () => createEditMeetingTool,
   createExecuteJavaScriptTool: () => createExecuteJavaScriptTool,
   createFindMeetingSlotsTool: () => createFindMeetingSlotsTool,
+  createGenerateRoutine: () => createGenerateRoutine,
   createGetMeetingTranscriptTool: () => createGetMeetingTranscriptTool,
   createGetPRTool: () => createGetPRTool,
   createGitHubReadFileTool: () => createGitHubReadFileTool,
@@ -44749,6 +46527,9 @@ __export(tools_exports, {
   createImageGenerationTool: () => createImageGenerationTool,
   createListDirectoryTool: () => createListDirectoryTool,
   createMeetingTool: () => createMeetingTool,
+  createMicrosoftListFilesTool: () => createMicrosoftListFilesTool,
+  createMicrosoftReadFileTool: () => createMicrosoftReadFileTool,
+  createMicrosoftSearchFilesTool: () => createMicrosoftSearchFilesTool,
   createPRCommentsTool: () => createPRCommentsTool,
   createPRFilesTool: () => createPRFilesTool,
   createReadFileTool: () => createReadFileTool,
@@ -44781,14 +46562,18 @@ __export(tools_exports, {
   desktopWindowList: () => desktopWindowList,
   developerTools: () => developerTools,
   editFile: () => editFile,
+  encodeSharingUrl: () => encodeSharingUrl,
   executeInVM: () => executeInVM,
   executeJavaScript: () => executeJavaScript,
   expandTilde: () => expandTilde,
   formatAttendees: () => formatAttendees,
+  formatFileSize: () => formatFileSize,
   formatRecipients: () => formatRecipients,
+  generateRoutine: () => generateRoutine,
   getAllBuiltInTools: () => getAllBuiltInTools,
   getBackgroundOutput: () => getBackgroundOutput,
   getDesktopDriver: () => getDesktopDriver,
+  getDrivePrefix: () => getDrivePrefix,
   getMediaOutputHandler: () => getMediaOutputHandler,
   getMediaStorage: () => getMediaStorage,
   getToolByName: () => getToolByName,
@@ -44802,7 +46587,9 @@ __export(tools_exports, {
   hydrateCustomTool: () => hydrateCustomTool,
   isBlockedCommand: () => isBlockedCommand,
   isExcludedExtension: () => isExcludedExtension,
+  isMicrosoftFileUrl: () => isMicrosoftFileUrl,
   isTeamsMeetingUrl: () => isTeamsMeetingUrl,
+  isWebUrl: () => isWebUrl,
   jsonManipulator: () => jsonManipulator,
   killBackgroundProcess: () => killBackgroundProcess,
   listDirectory: () => listDirectory,
@@ -44813,6 +46600,7 @@ __export(tools_exports, {
   parseRepository: () => parseRepository,
   readFile: () => readFile5,
   resetDefaultDriver: () => resetDefaultDriver,
+  resolveFileEndpoints: () => resolveFileEndpoints,
   resolveMeetingId: () => resolveMeetingId,
   resolveRepository: () => resolveRepository,
   setMediaOutputHandler: () => setMediaOutputHandler,
@@ -49065,6 +50853,87 @@ async function resolveMeetingId(connector, input, prefix, effectiveUserId, effec
     subject: meetings.value[0].subject
   };
 }
+var DEFAULT_MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024;
+var DEFAULT_FILE_SIZE_LIMITS = {
+  ".pptx": 100 * 1024 * 1024,
+  // 100 MB — presentations are image-heavy
+  ".ppt": 100 * 1024 * 1024,
+  ".odp": 100 * 1024 * 1024
+};
+function getFileSizeLimit(ext, overrides, defaultLimit) {
+  const merged = { ...DEFAULT_FILE_SIZE_LIMITS, ...overrides };
+  return merged[ext.toLowerCase()] ?? defaultLimit ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+}
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".docx",
+  ".pptx",
+  ".xlsx",
+  ".csv",
+  ".pdf",
+  ".odt",
+  ".odp",
+  ".ods",
+  ".rtf",
+  ".html",
+  ".htm",
+  ".txt",
+  ".md",
+  ".json",
+  ".xml",
+  ".yaml",
+  ".yml"
+]);
+function encodeSharingUrl(webUrl) {
+  const base64 = Buffer.from(webUrl, "utf-8").toString("base64").replace(/=+$/, "").replace(/\//g, "_").replace(/\+/g, "-");
+  return `u!${base64}`;
+}
+function isWebUrl(source) {
+  return /^https?:\/\//i.test(source.trim());
+}
+function isMicrosoftFileUrl(source) {
+  try {
+    const url2 = new URL(source.trim());
+    const host = url2.hostname.toLowerCase();
+    return host.endsWith(".sharepoint.com") || host.endsWith(".sharepoint-df.com") || host === "onedrive.live.com" || host === "1drv.ms";
+  } catch {
+    return false;
+  }
+}
+function getDrivePrefix(userPrefix, options) {
+  if (options?.siteId) return `/sites/${options.siteId}/drive`;
+  if (options?.driveId) return `/drives/${options.driveId}`;
+  return `${userPrefix}/drive`;
+}
+function resolveFileEndpoints(source, drivePrefix) {
+  const trimmed = source.trim();
+  if (isWebUrl(trimmed)) {
+    const token = encodeSharingUrl(trimmed);
+    return {
+      metadataEndpoint: `/shares/${token}/driveItem`,
+      contentEndpoint: `/shares/${token}/driveItem/content`,
+      isSharedUrl: true
+    };
+  }
+  if (trimmed.startsWith("/")) {
+    const path6 = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+    return {
+      metadataEndpoint: `${drivePrefix}/root:${path6}:`,
+      contentEndpoint: `${drivePrefix}/root:${path6}:/content`,
+      isSharedUrl: false
+    };
+  }
+  return {
+    metadataEndpoint: `${drivePrefix}/items/${trimmed}`,
+    contentEndpoint: `${drivePrefix}/items/${trimmed}/content`,
+    isSharedUrl: false
+  };
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
 
 // src/tools/microsoft/createDraftEmail.ts
 function createDraftEmailTool(connector, userId) {
@@ -49770,16 +51639,539 @@ EXAMPLES:
   };
 }
 
+// src/tools/microsoft/readFile.ts
+function createMicrosoftReadFileTool(connector, userId, config) {
+  const reader = DocumentReader.create();
+  const defaultLimit = config?.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+  const sizeOverrides = config?.fileSizeLimits;
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "read_file",
+        description: `Read a file from Microsoft OneDrive or SharePoint and return its content as **markdown text**.
+
+Use this tool when you need to read the contents of a document stored in OneDrive or SharePoint. The file is downloaded and automatically converted to clean markdown \u2014 you will never receive raw binary data.
+
+**Supported formats:** .docx, .pptx, .xlsx, .csv, .pdf, .odt, .odp, .ods, .rtf, .html, .txt, .md, .json, .xml, .yaml
+**Not supported:** .doc, .xls, .ppt (legacy Office formats), images, videos, executables.
+
+**The \`source\` parameter is flexible \u2014 you can provide any of these:**
+- A SharePoint or OneDrive **web URL**: \`https://contoso.sharepoint.com/sites/team/Shared Documents/report.docx\`
+- A OneDrive **sharing link**: \`https://1drv.ms/w/s!AmVg...\`
+- A **file path** within the drive: \`/Documents/Q4 Report.docx\`
+- A Graph API **item ID**: \`01ABCDEF123456\`
+
+When given a web URL, the tool automatically resolves it to the correct Graph API call \u2014 no need to manually extract drive or item IDs.
+
+**Maximum file size:** 50 MB (100 MB for presentations). For larger files, use the search or list tools to find smaller alternatives.
+
+**Returns:** The file content as markdown text, along with metadata (filename, size, MIME type, webUrl). For spreadsheets, each sheet becomes a markdown table. For presentations, each slide becomes a section.`,
+        parameters: {
+          type: "object",
+          properties: {
+            source: {
+              type: "string",
+              description: 'The file to read. Accepts a web URL (SharePoint/OneDrive link), a file path within the drive (e.g., "/Documents/report.docx"), or a Graph API item ID.'
+            },
+            driveId: {
+              type: "string",
+              description: "Optional drive ID. Omit to use the default drive. Only needed when accessing a specific non-default drive."
+            },
+            siteId: {
+              type: "string",
+              description: "Optional SharePoint site ID. Use this instead of driveId to access files in a specific SharePoint site's default drive."
+            },
+            targetUser: {
+              type: "string",
+              description: `User ID or email (e.g., "user@contoso.com"). Only needed with application-only (client_credentials) auth to specify which user's drive to access.`
+            }
+          },
+          required: ["source"]
+        }
+      },
+      blocking: true,
+      timeout: 6e4
+    },
+    describeCall: (args) => {
+      const src = args.source.length > 80 ? args.source.slice(0, 77) + "..." : args.source;
+      return `Read: ${src}`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Read a file from OneDrive/SharePoint via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
+      if (!args.source || !args.source.trim()) {
+        return {
+          success: false,
+          error: 'The "source" parameter is required. Provide a file URL, path, or item ID.'
+        };
+      }
+      if (isWebUrl(args.source) && !isMicrosoftFileUrl(args.source)) {
+        return {
+          success: false,
+          error: `The URL "${args.source}" does not appear to be a SharePoint or OneDrive link. This tool only supports URLs from *.sharepoint.com, onedrive.live.com, or 1drv.ms. For other URLs, use the web_fetch tool instead.`
+        };
+      }
+      try {
+        const userPrefix = getUserPathPrefix(connector, args.targetUser);
+        const drivePrefix = getDrivePrefix(userPrefix, {
+          siteId: args.siteId,
+          driveId: args.driveId
+        });
+        const { metadataEndpoint, contentEndpoint, isSharedUrl } = resolveFileEndpoints(
+          args.source,
+          drivePrefix
+        );
+        const metadataQueryParams = isSharedUrl ? {} : { "$select": "id,name,size,file,folder,webUrl,parentReference" };
+        const metadata = await microsoftFetch(connector, metadataEndpoint, {
+          userId: effectiveUserId,
+          accountId: effectiveAccountId,
+          queryParams: metadataQueryParams
+        });
+        if (metadata.folder) {
+          return {
+            success: false,
+            error: `"${metadata.name}" is a folder, not a file. Use the list_files tool to browse folder contents.`
+          };
+        }
+        const ext = getExtension(metadata.name);
+        const sizeLimit = getFileSizeLimit(ext, sizeOverrides, defaultLimit);
+        if (metadata.size > sizeLimit) {
+          return {
+            success: false,
+            filename: metadata.name,
+            sizeBytes: metadata.size,
+            error: `File "${metadata.name}" is ${formatFileSize(metadata.size)}, which exceeds the ${formatFileSize(sizeLimit)} limit for ${ext || "this file type"}. Consider downloading a smaller version or using the search tool to find an alternative.`
+          };
+        }
+        if (ext && !SUPPORTED_EXTENSIONS.has(ext) && !FormatDetector.isBinaryDocumentFormat(ext)) {
+          return {
+            success: false,
+            filename: metadata.name,
+            mimeType: metadata.file?.mimeType,
+            error: `File format "${ext}" is not supported for text extraction. Supported formats: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
+          };
+        }
+        const response = await connector.fetch(
+          contentEndpoint,
+          { method: "GET" },
+          effectiveUserId,
+          effectiveAccountId
+        );
+        if (!response.ok) {
+          throw new MicrosoftAPIError(response.status, response.statusText, await response.text());
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const result = await reader.read(
+          { type: "buffer", buffer, filename: metadata.name },
+          { extractImages: false }
+        );
+        if (!result.success) {
+          return {
+            success: false,
+            filename: metadata.name,
+            error: `Failed to convert "${metadata.name}" to markdown: ${result.error ?? "unknown error"}`
+          };
+        }
+        const markdown = mergeTextPieces(result.pieces);
+        if (!markdown || markdown.trim().length === 0) {
+          return {
+            success: true,
+            filename: metadata.name,
+            sizeBytes: metadata.size,
+            mimeType: metadata.file?.mimeType,
+            webUrl: metadata.webUrl,
+            markdown: "*(empty document \u2014 no text content found)*"
+          };
+        }
+        return {
+          success: true,
+          filename: metadata.name,
+          sizeBytes: metadata.size,
+          mimeType: metadata.file?.mimeType,
+          webUrl: metadata.webUrl,
+          markdown
+        };
+      } catch (error) {
+        if (error instanceof MicrosoftAPIError) {
+          if (error.status === 404) {
+            return {
+              success: false,
+              error: `File not found. Check that the source "${args.source}" is correct and you have access.`
+            };
+          }
+          if (error.status === 403 || error.status === 401) {
+            return {
+              success: false,
+              error: `Access denied. The connector may not have sufficient permissions (Files.Read or Sites.Read.All required).`
+            };
+          }
+        }
+        return {
+          success: false,
+          error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+function getExtension(filename) {
+  const dot = filename.lastIndexOf(".");
+  if (dot < 0) return "";
+  return filename.slice(dot).toLowerCase();
+}
+
+// src/tools/microsoft/listFiles.ts
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+var SELECT_FIELDS = "id,name,size,lastModifiedDateTime,file,folder,webUrl";
+function createMicrosoftListFilesTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "list_files",
+        description: `List files and folders in a Microsoft OneDrive or SharePoint directory.
+
+Use this tool to browse the contents of a folder, discover available files before reading them, or search within a specific folder. Returns file/folder metadata (name, size, type, last modified, URL) \u2014 **never returns file contents**.
+
+**The \`path\` parameter is flexible \u2014 you can provide:**
+- A **folder path** within the drive: \`/Documents/Projects\` or \`/\` for root
+- A SharePoint/OneDrive **folder URL**: \`https://contoso.sharepoint.com/sites/team/Shared Documents/Projects\`
+- Omit entirely to list the root of the drive
+
+**Optional search:** Use the \`search\` parameter to filter by filename within the folder tree. This uses Microsoft's server-side search (fast, works across subfolders).
+
+**Tip:** To read a file's content after finding it, use the read_file tool with the file's webUrl or id from these results.`,
+        parameters: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: 'Folder path (e.g., "/Documents/Projects") or a web URL to a SharePoint/OneDrive folder. Omit to list root.'
+            },
+            driveId: {
+              type: "string",
+              description: "Optional drive ID for a specific non-default drive."
+            },
+            siteId: {
+              type: "string",
+              description: "Optional SharePoint site ID to access that site's default document library."
+            },
+            search: {
+              type: "string",
+              description: "Optional search query to filter results by filename or content. Searches within the specified folder and all subfolders."
+            },
+            limit: {
+              type: "number",
+              description: `Maximum number of items to return (default: ${DEFAULT_LIMIT}, max: ${MAX_LIMIT}).`
+            },
+            targetUser: {
+              type: "string",
+              description: "User ID or email. Only needed with application-only (client_credentials) auth."
+            }
+          }
+        }
+      },
+      blocking: true,
+      timeout: 3e4
+    },
+    describeCall: (args) => {
+      const loc = args.path || "/";
+      const suffix = args.search ? ` (search: "${args.search}")` : "";
+      return `List: ${loc}${suffix}`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `List files in OneDrive/SharePoint via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
+      const limit = Math.min(Math.max(1, args.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
+      try {
+        const userPrefix = getUserPathPrefix(connector, args.targetUser);
+        const drivePrefix = getDrivePrefix(userPrefix, {
+          siteId: args.siteId,
+          driveId: args.driveId
+        });
+        let endpoint;
+        if (args.search) {
+          const folderBase = args.path && !isWebUrl(args.path) ? `${drivePrefix}/root:${normalizePath(args.path)}:` : drivePrefix;
+          endpoint = `${folderBase}/search(q='${encodeSearchQuery(args.search)}')`;
+        } else if (args.path) {
+          if (isWebUrl(args.path)) {
+            const token = encodeSharingUrl(args.path.trim());
+            endpoint = `/shares/${token}/driveItem/children`;
+          } else {
+            const path6 = normalizePath(args.path);
+            endpoint = path6 === "/" ? `${drivePrefix}/root/children` : `${drivePrefix}/root:${path6}:/children`;
+          }
+        } else {
+          endpoint = `${drivePrefix}/root/children`;
+        }
+        const queryParams = {
+          "$top": limit,
+          "$select": SELECT_FIELDS
+        };
+        if (!args.search) {
+          queryParams["$orderby"] = "name asc";
+        }
+        const data = await microsoftFetch(connector, endpoint, {
+          userId: effectiveUserId,
+          accountId: effectiveAccountId,
+          queryParams
+        });
+        const items = (data.value || []).map(mapDriveItem);
+        return {
+          success: true,
+          items,
+          totalCount: items.length,
+          hasMore: !!data["@odata.nextLink"]
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to list files: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+function mapDriveItem(item) {
+  return {
+    name: item.name,
+    type: item.folder ? "folder" : "file",
+    size: item.size,
+    sizeFormatted: formatFileSize(item.size),
+    mimeType: item.file?.mimeType,
+    lastModified: item.lastModifiedDateTime,
+    webUrl: item.webUrl,
+    id: item.id,
+    childCount: item.folder?.childCount
+  };
+}
+function normalizePath(path6) {
+  let p = path6.trim();
+  if (!p.startsWith("/")) p = "/" + p;
+  if (p.endsWith("/") && p.length > 1) p = p.slice(0, -1);
+  return p;
+}
+function encodeSearchQuery(query) {
+  return query.replace(/\\/g, "\\\\").replace(/'/g, "''");
+}
+
+// src/tools/microsoft/searchFiles.ts
+var DEFAULT_LIMIT2 = 25;
+var MAX_LIMIT2 = 100;
+function createMicrosoftSearchFilesTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "search_files",
+        description: `Search for files across Microsoft OneDrive and SharePoint.
+
+Use this tool when you need to **find** files by name, content, or metadata across all of the user's OneDrive and SharePoint sites. This is a powerful full-text search \u2014 it searches inside document content, not just filenames.
+
+**Supports Microsoft's KQL (Keyword Query Language):**
+- Simple text: \`"quarterly report"\`
+- By filename: \`filename:budget.xlsx\`
+- By author: \`author:"Jane Smith"\`
+- By date: \`lastModifiedTime>2024-01-01\`
+- Combined: \`project proposal filetype:docx\`
+
+**Filter by file type:** Use the \`fileTypes\` parameter (e.g., \`["docx", "pdf"]\`) to restrict results to specific formats.
+
+**Limit to a SharePoint site:** Provide the \`siteId\` parameter to search only within a specific site.
+
+**Returns:** A list of matching files with name, path, site, snippet (text preview), size, and webUrl. Does NOT return file contents \u2014 use the read_file tool to read a specific result.
+
+**Tip:** Start with a broad search, then use read_file on the most relevant results.`,
+        parameters: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: 'Search query. Supports plain text and KQL syntax (e.g., "budget report", "filename:spec.docx", "author:john filetype:pptx").'
+            },
+            siteId: {
+              type: "string",
+              description: "Optional SharePoint site ID to limit search to a specific site."
+            },
+            fileTypes: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Optional file type filter. Array of extensions without dots (e.g., ["docx", "pdf", "xlsx"]).'
+            },
+            limit: {
+              type: "number",
+              description: `Maximum number of results (default: ${DEFAULT_LIMIT2}, max: ${MAX_LIMIT2}).`
+            },
+            targetUser: {
+              type: "string",
+              description: "User ID or email. Only needed with application-only (client_credentials) auth."
+            }
+          },
+          required: ["query"]
+        }
+      },
+      blocking: true,
+      timeout: 3e4
+    },
+    describeCall: (args) => {
+      const types = args.fileTypes?.length ? ` [${args.fileTypes.join(",")}]` : "";
+      return `Search: "${args.query}"${types}`;
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Search files in OneDrive/SharePoint via ${connector.displayName}`
+    },
+    execute: async (args, context) => {
+      const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
+      const limit = Math.min(Math.max(1, args.limit ?? DEFAULT_LIMIT2), MAX_LIMIT2);
+      try {
+        if (args.siteId) {
+          return await searchViaDriveEndpoint(
+            connector,
+            args,
+            limit,
+            effectiveUserId,
+            effectiveAccountId
+          );
+        }
+        let queryString = args.query;
+        if (args.fileTypes?.length) {
+          const typeFilter = args.fileTypes.map((t) => `filetype:${t.replace(/^\./, "")}`).join(" OR ");
+          queryString = `(${queryString}) (${typeFilter})`;
+        }
+        const searchRequest = {
+          requests: [
+            {
+              entityTypes: ["driveItem"],
+              query: { queryString },
+              from: 0,
+              size: limit,
+              fields: [
+                "id",
+                "name",
+                "size",
+                "webUrl",
+                "lastModifiedDateTime",
+                "parentReference",
+                "file"
+              ]
+            }
+          ]
+        };
+        const data = await microsoftFetch(connector, "/search/query", {
+          method: "POST",
+          body: searchRequest,
+          userId: effectiveUserId,
+          accountId: effectiveAccountId
+        });
+        const container = data.value?.[0]?.hitsContainers?.[0];
+        if (!container?.hits?.length) {
+          return {
+            success: true,
+            results: [],
+            totalCount: 0,
+            hasMore: false
+          };
+        }
+        const results = container.hits.map((hit) => {
+          const resource = hit.resource;
+          return {
+            name: resource.name,
+            path: resource.parentReference?.path?.replace(/\/drive\/root:/, "") || void 0,
+            site: resource.parentReference?.siteId || void 0,
+            snippet: hit.summary || void 0,
+            size: resource.size,
+            sizeFormatted: formatFileSize(resource.size),
+            webUrl: resource.webUrl,
+            id: resource.id,
+            lastModified: resource.lastModifiedDateTime
+          };
+        });
+        return {
+          success: true,
+          results,
+          totalCount: container.total,
+          hasMore: container.moreResultsAvailable
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Search failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+async function searchViaDriveEndpoint(connector, args, limit, effectiveUserId, effectiveAccountId) {
+  const drivePrefix = `/sites/${args.siteId}/drive`;
+  const escapedQuery = args.query.replace(/'/g, "''");
+  const endpoint = `${drivePrefix}/root/search(q='${escapedQuery}')`;
+  const data = await microsoftFetch(connector, endpoint, {
+    userId: effectiveUserId,
+    accountId: effectiveAccountId,
+    queryParams: {
+      "$top": limit,
+      "$select": "id,name,size,webUrl,lastModifiedDateTime,parentReference,file"
+    }
+  });
+  let items = data.value || [];
+  if (args.fileTypes?.length) {
+    const extSet = new Set(args.fileTypes.map((t) => t.replace(/^\./, "").toLowerCase()));
+    items = items.filter((item) => {
+      const ext = item.name.split(".").pop()?.toLowerCase();
+      return ext && extSet.has(ext);
+    });
+  }
+  const results = items.map((item) => ({
+    name: item.name,
+    path: item.parentReference?.path?.replace(/\/drive\/root:/, "") || void 0,
+    site: item.parentReference?.siteId || void 0,
+    snippet: void 0,
+    size: item.size,
+    sizeFormatted: formatFileSize(item.size),
+    webUrl: item.webUrl,
+    id: item.id,
+    lastModified: item.lastModifiedDateTime
+  }));
+  return {
+    success: true,
+    results,
+    totalCount: results.length,
+    hasMore: !!data["@odata.nextLink"]
+  };
+}
+
 // src/tools/microsoft/register.ts
 function registerMicrosoftTools() {
   ConnectorTools.registerService("microsoft", (connector, userId) => {
     return [
+      // Email
       createDraftEmailTool(connector, userId),
       createSendEmailTool(connector, userId),
+      // Meetings
       createMeetingTool(connector, userId),
       createEditMeetingTool(connector, userId),
       createGetMeetingTranscriptTool(connector, userId),
-      createFindMeetingSlotsTool(connector, userId)
+      createFindMeetingSlotsTool(connector, userId),
+      // Files (OneDrive / SharePoint)
+      createMicrosoftReadFileTool(connector, userId),
+      createMicrosoftListFilesTool(connector, userId),
+      createMicrosoftSearchFilesTool(connector, userId)
     ];
   });
 }
@@ -51133,6 +53525,311 @@ function createCustomToolTest() {
 }
 var customToolTest = createCustomToolTest();
 
+// src/tools/routines/resolveStorage.ts
+init_StorageRegistry();
+function buildStorageContext3(toolContext) {
+  const global2 = exports.StorageRegistry.getContext();
+  if (global2) return global2;
+  if (toolContext?.userId) return { userId: toolContext.userId };
+  return void 0;
+}
+function resolveRoutineDefinitionStorage(explicit, toolContext) {
+  if (explicit) return explicit;
+  const factory = exports.StorageRegistry.get("routineDefinitions");
+  if (factory) {
+    return factory(buildStorageContext3(toolContext));
+  }
+  return new FileRoutineDefinitionStorage();
+}
+
+// src/tools/routines/generateRoutine.ts
+var TOOL_DESCRIPTION = `Generate and save a complete routine definition to persistent storage. A routine is a reusable, parameterized workflow template composed of tasks with dependencies, control flow, and validation.
+
+## Routine Structure
+
+A routine definition has these fields:
+- **name** (required): Human-readable name (e.g., "Research and Summarize Topic")
+- **description** (required): What this routine accomplishes
+- **version**: Semver string for tracking evolution (e.g., "1.0.0")
+- **author**: Creator name or identifier
+- **tags**: Array of strings for categorization and filtering (e.g., ["research", "analysis"])
+- **instructions**: Additional text injected into the agent's system prompt when executing this routine. Use for behavioral guidance, tone, constraints.
+- **parameters**: Array of input parameters that make the routine reusable. Each has: name, description, required (default false), default. Use {{param.NAME}} in task descriptions/expectedOutput to reference them.
+- **requiredTools**: Tool names that must be available before starting (e.g., ["web_fetch", "memory_store"])
+- **requiredPlugins**: Plugin names that must be enabled (e.g., ["working_memory"])
+- **concurrency**: { maxParallelTasks: number, strategy: "fifo"|"priority"|"shortest-first", failureMode?: "fail-fast"|"continue"|"fail-all" }
+- **allowDynamicTasks**: If true, the LLM can add/modify tasks during execution (default: false)
+- **tasks** (required): Array of TaskInput objects defining the workflow steps
+
+## Task Structure
+
+Each task in the tasks array has:
+- **name** (required): Unique name within the routine (used for dependency references)
+- **description** (required): What this task should accomplish \u2014 the agent uses this as its goal
+- **dependsOn**: Array of task names that must complete before this task starts (e.g., ["Gather Data", "Validate Input"])
+- **suggestedTools**: Tool names the agent should prefer for this task (advisory, not enforced)
+- **expectedOutput**: Description of what the task should produce \u2014 helps the agent know when it's done
+- **maxAttempts**: Max retry count on failure (default: 3)
+- **condition**: Execute only if a condition is met (see Conditions below)
+- **controlFlow**: Map, fold, or until loop (see Control Flow below)
+- **validation**: Completion validation settings (see Validation below)
+- **execution**: { parallel?: boolean, maxConcurrency?: number, priority?: number, maxIterations?: number }
+- **metadata**: Arbitrary key-value pairs for extensions
+
+## Control Flow Types
+
+Tasks can have a controlFlow field for iteration patterns:
+
+### map \u2014 Iterate over an array, run sub-tasks per element
+\`\`\`json
+{
+  "type": "map",
+  "source": { "task": "Fetch Items" },
+  "tasks": [
+    { "name": "Process Item", "description": "Process {{map.item}} ({{map.index}}/{{map.total}})" }
+  ],
+  "resultKey": "processed_items",
+  "maxIterations": 100,
+  "iterationTimeoutMs": 30000
+}
+\`\`\`
+
+### fold \u2014 Accumulate a result across array elements
+\`\`\`json
+{
+  "type": "fold",
+  "source": { "key": "data_points", "path": "results" },
+  "tasks": [
+    { "name": "Merge Entry", "description": "Merge {{map.item}} into {{fold.accumulator}}" }
+  ],
+  "initialValue": "",
+  "resultKey": "merged_result",
+  "maxIterations": 50
+}
+\`\`\`
+
+### until \u2014 Loop until a condition is met
+\`\`\`json
+{
+  "type": "until",
+  "tasks": [
+    { "name": "Refine Draft", "description": "Improve the current draft based on feedback" }
+  ],
+  "condition": { "memoryKey": "quality_score", "operator": "greater_than", "value": 80, "onFalse": "skip" },
+  "maxIterations": 5,
+  "iterationKey": "refinement_round"
+}
+\`\`\`
+
+### Source field
+The \`source\` field in map/fold can be:
+- A string: direct memory key lookup (e.g., "my_items")
+- \`{ task: "TaskName" }\`: resolves the output of a completed dependency task
+- \`{ key: "memoryKey" }\`: direct memory key lookup
+- \`{ key: "memoryKey", path: "data.items" }\`: memory key with JSON path extraction
+
+### Sub-routine tasks
+Tasks inside controlFlow.tasks have the same shape as regular tasks (name, description, dependsOn, suggestedTools, etc.) but execute within the control flow context.
+
+## Template Placeholders
+
+Use these in task descriptions and expectedOutput:
+- \`{{param.NAME}}\` \u2014 routine parameter value
+- \`{{map.item}}\` \u2014 current element in map/fold iteration
+- \`{{map.index}}\` \u2014 current 0-based iteration index
+- \`{{map.total}}\` \u2014 total number of elements
+- \`{{fold.accumulator}}\` \u2014 current accumulated value in fold
+
+## Task Conditions
+
+Execute a task conditionally based on memory state:
+\`\`\`json
+{
+  "memoryKey": "user_preference",
+  "operator": "equals",
+  "value": "detailed",
+  "onFalse": "skip"
+}
+\`\`\`
+
+Operators: "exists", "not_exists", "equals", "contains", "truthy", "greater_than", "less_than"
+onFalse actions: "skip" (mark skipped), "fail" (mark failed), "wait" (block until condition met)
+
+## Validation
+
+Enable completion validation to verify task quality:
+\`\`\`json
+{
+  "skipReflection": false,
+  "completionCriteria": [
+    "Response contains at least 3 specific examples",
+    "All requested sections are present"
+  ],
+  "minCompletionScore": 80,
+  "requiredMemoryKeys": ["result_data"],
+  "mode": "strict"
+}
+\`\`\`
+
+By default, skipReflection is true (validation auto-passes). Set to false and provide completionCriteria to enable LLM self-reflection validation.
+
+## Best Practices
+
+1. **Task naming**: Use clear, action-oriented names (e.g., "Research Topic", "Generate Summary"). Names are used in dependsOn references.
+2. **Dependency chaining**: Build pipelines by having each task depend on the previous one. Independent tasks can run in parallel.
+3. **Control flow vs sequential**: Use map/fold when iterating over dynamic data. Use sequential tasks for fixed multi-step workflows.
+4. **Parameters**: Define parameters for any value that should vary between executions. Always provide a description.
+5. **Instructions**: Use the instructions field for behavioral guidance that applies to all tasks in the routine.
+6. **Keep tasks focused**: Each task should have a single clear goal. Break complex work into multiple dependent tasks.
+7. **Expected output**: Always specify expectedOutput \u2014 it helps the agent know when it's done and what format to produce.`;
+function createGenerateRoutine(storage) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "generate_routine",
+        description: TOOL_DESCRIPTION,
+        parameters: {
+          type: "object",
+          properties: {
+            definition: {
+              type: "object",
+              description: "Complete routine definition input",
+              properties: {
+                name: { type: "string", description: "Human-readable routine name" },
+                description: { type: "string", description: "What this routine accomplishes" },
+                version: { type: "string", description: 'Semver version string (e.g., "1.0.0")' },
+                author: { type: "string", description: "Creator name or identifier" },
+                tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
+                instructions: { type: "string", description: "Additional instructions injected into system prompt during execution" },
+                parameters: {
+                  type: "array",
+                  description: "Input parameters for reusable routines",
+                  items: {
+                    type: "object",
+                    properties: {
+                      name: { type: "string", description: "Parameter name (referenced as {{param.name}})" },
+                      description: { type: "string", description: "Human-readable description" },
+                      required: { type: "boolean", description: "Whether this parameter must be provided (default: false)" },
+                      default: { description: "Default value when not provided" }
+                    },
+                    required: ["name", "description"]
+                  }
+                },
+                requiredTools: { type: "array", items: { type: "string" }, description: "Tool names that must be available" },
+                requiredPlugins: { type: "array", items: { type: "string" }, description: "Plugin names that must be enabled" },
+                concurrency: {
+                  type: "object",
+                  description: "Concurrency settings for parallel task execution",
+                  properties: {
+                    maxParallelTasks: { type: "number", description: "Maximum tasks running in parallel" },
+                    strategy: { type: "string", enum: ["fifo", "priority", "shortest-first"], description: "Task selection strategy" },
+                    failureMode: { type: "string", enum: ["fail-fast", "continue", "fail-all"], description: "How to handle failures in parallel" }
+                  },
+                  required: ["maxParallelTasks", "strategy"]
+                },
+                allowDynamicTasks: { type: "boolean", description: "Allow LLM to add/modify tasks during execution (default: false)" },
+                tasks: {
+                  type: "array",
+                  description: "Array of task definitions forming the workflow",
+                  items: {
+                    type: "object",
+                    properties: {
+                      name: { type: "string", description: "Unique task name (used in dependsOn references)" },
+                      description: { type: "string", description: "What this task should accomplish" },
+                      dependsOn: { type: "array", items: { type: "string" }, description: "Task names that must complete first" },
+                      suggestedTools: { type: "array", items: { type: "string" }, description: "Preferred tool names for this task" },
+                      expectedOutput: { type: "string", description: "Description of expected task output" },
+                      maxAttempts: { type: "number", description: "Max retries on failure (default: 3)" },
+                      condition: {
+                        type: "object",
+                        description: "Conditional execution based on memory state",
+                        properties: {
+                          memoryKey: { type: "string", description: "Memory key to check" },
+                          operator: { type: "string", enum: ["exists", "not_exists", "equals", "contains", "truthy", "greater_than", "less_than"] },
+                          value: { description: "Value to compare against" },
+                          onFalse: { type: "string", enum: ["skip", "fail", "wait"], description: "Action when condition is false" }
+                        },
+                        required: ["memoryKey", "operator", "onFalse"]
+                      },
+                      controlFlow: {
+                        type: "object",
+                        description: "Control flow for iteration (map, fold, or until)",
+                        properties: {
+                          type: { type: "string", enum: ["map", "fold", "until"], description: "Control flow type" },
+                          source: { description: 'Source data: string key, { task: "name" }, { key: "key" }, or { key: "key", path: "json.path" }' },
+                          tasks: { type: "array", description: "Sub-routine tasks to execute per iteration", items: { type: "object" } },
+                          resultKey: { type: "string", description: "Memory key for collected results" },
+                          initialValue: { description: "Starting accumulator value (fold only)" },
+                          condition: { type: "object", description: "Exit condition (until only)" },
+                          maxIterations: { type: "number", description: "Cap on iterations" },
+                          iterationKey: { type: "string", description: "Memory key for iteration index (until only)" },
+                          iterationTimeoutMs: { type: "number", description: "Timeout per iteration in ms" }
+                        },
+                        required: ["type", "tasks"]
+                      },
+                      validation: {
+                        type: "object",
+                        description: "Completion validation settings",
+                        properties: {
+                          skipReflection: { type: "boolean", description: "Set to false to enable LLM self-reflection validation" },
+                          completionCriteria: { type: "array", items: { type: "string" }, description: "Natural language criteria for completion" },
+                          minCompletionScore: { type: "number", description: "Minimum score (0-100) to pass (default: 80)" },
+                          requiredMemoryKeys: { type: "array", items: { type: "string" }, description: "Memory keys that must exist after completion" },
+                          mode: { type: "string", enum: ["strict", "warn"], description: "Validation failure mode (default: strict)" },
+                          requireUserApproval: { type: "string", enum: ["never", "uncertain", "always"], description: "When to ask user for approval" },
+                          customValidator: { type: "string", description: "Custom validation hook name" }
+                        }
+                      },
+                      execution: {
+                        type: "object",
+                        description: "Execution settings",
+                        properties: {
+                          parallel: { type: "boolean", description: "Can run in parallel with other parallel tasks" },
+                          maxConcurrency: { type: "number", description: "Max concurrent sub-work" },
+                          priority: { type: "number", description: "Higher = executed first" },
+                          maxIterations: { type: "number", description: "Max LLM iterations per task (default: 50)" }
+                        }
+                      },
+                      metadata: { type: "object", description: "Arbitrary key-value metadata" }
+                    },
+                    required: ["name", "description"]
+                  }
+                },
+                metadata: { type: "object", description: "Arbitrary routine-level metadata" }
+              },
+              required: ["name", "description", "tasks"]
+            }
+          },
+          required: ["definition"]
+        }
+      }
+    },
+    permission: { scope: "session", riskLevel: "medium" },
+    execute: async (args, context) => {
+      try {
+        const userId = context?.userId;
+        const s = resolveRoutineDefinitionStorage(storage, context);
+        const routineDefinition = createRoutineDefinition(args.definition);
+        await s.save(userId, routineDefinition);
+        return {
+          success: true,
+          id: routineDefinition.id,
+          name: routineDefinition.name,
+          storagePath: s.getPath(userId)
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    },
+    describeCall: (args) => args.definition?.name ?? "routine"
+  };
+}
+var generateRoutine = createGenerateRoutine();
+
 // src/tools/registry.generated.ts
 var toolRegistry = [
   {
@@ -51360,6 +54057,15 @@ var toolRegistry = [
     tool: jsonManipulator,
     safeByDefault: true
   },
+  {
+    name: "generate_routine",
+    exportName: "generateRoutine",
+    displayName: "Generate Routine",
+    category: "routines",
+    description: "Complete routine definition input",
+    tool: generateRoutine,
+    safeByDefault: false
+  },
   {
     name: "bash",
     exportName: "bash",
@@ -51789,6 +54495,127 @@ REMEMBER: Keep it conversational, ask one question at a time, and only output th
   }
 };
 
+// src/infrastructure/scheduling/SimpleScheduler.ts
+var SimpleScheduler = class {
+  timers = /* @__PURE__ */ new Map();
+  _isDestroyed = false;
+  schedule(id, spec, callback) {
+    if (this._isDestroyed) throw new Error("Scheduler has been destroyed");
+    if (spec.cron) {
+      throw new Error(
+        `SimpleScheduler does not support cron expressions. Use a cron-capable scheduler implementation (e.g. node-cron, croner) or convert to intervalMs.`
+      );
+    }
+    if (this.timers.has(id)) {
+      this.cancel(id);
+    }
+    if (spec.intervalMs != null) {
+      const timer = setInterval(() => {
+        try {
+          const result = callback();
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+      }, spec.intervalMs);
+      this.timers.set(id, { timer, type: "interval" });
+    } else if (spec.once != null) {
+      const delay = Math.max(0, spec.once - Date.now());
+      const timer = setTimeout(() => {
+        this.timers.delete(id);
+        try {
+          const result = callback();
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+      }, delay);
+      this.timers.set(id, { timer, type: "timeout" });
+    } else {
+      throw new Error("ScheduleSpec must have at least one of: cron, intervalMs, once");
+    }
+    return {
+      id,
+      cancel: () => this.cancel(id)
+    };
+  }
+  cancel(id) {
+    const entry = this.timers.get(id);
+    if (!entry) return;
+    if (entry.type === "interval") {
+      clearInterval(entry.timer);
+    } else {
+      clearTimeout(entry.timer);
+    }
+    this.timers.delete(id);
+  }
+  cancelAll() {
+    for (const [id] of this.timers) {
+      this.cancel(id);
+    }
+  }
+  has(id) {
+    return this.timers.has(id);
+  }
+  destroy() {
+    if (this._isDestroyed) return;
+    this.cancelAll();
+    this._isDestroyed = true;
+  }
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
+};
+
+// src/infrastructure/triggers/EventEmitterTrigger.ts
+var EventEmitterTrigger = class {
+  listeners = /* @__PURE__ */ new Map();
+  _isDestroyed = false;
+  /**
+   * Register a listener for an event. Returns an unsubscribe function.
+   */
+  on(event, callback) {
+    if (this._isDestroyed) throw new Error("EventEmitterTrigger has been destroyed");
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return () => {
+      this.listeners.get(event)?.delete(callback);
+    };
+  }
+  /**
+   * Emit an event to all registered listeners.
+   */
+  emit(event, payload) {
+    if (this._isDestroyed) return;
+    const callbacks = this.listeners.get(event);
+    if (!callbacks) return;
+    for (const cb of callbacks) {
+      try {
+        const result = cb(payload);
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  destroy() {
+    if (this._isDestroyed) return;
+    this.listeners.clear();
+    this._isDestroyed = true;
+  }
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
+};
+
 exports.AGENT_DEFINITION_FORMAT_VERSION = AGENT_DEFINITION_FORMAT_VERSION;
 exports.AIError = AIError;
 exports.APPROVAL_STATE_VERSION = APPROVAL_STATE_VERSION;
@@ -51825,6 +54652,7 @@ exports.DefaultCompactionStrategy = DefaultCompactionStrategy;
 exports.DependencyCycleError = DependencyCycleError;
 exports.DocumentReader = DocumentReader;
 exports.ErrorHandler = ErrorHandler;
+exports.EventEmitterTrigger = EventEmitterTrigger;
 exports.ExecutionContext = ExecutionContext;
 exports.ExternalDependencyHandler = ExternalDependencyHandler;
 exports.FileAgentDefinitionStorage = FileAgentDefinitionStorage;
@@ -51890,6 +54718,7 @@ exports.ScrapeProvider = ScrapeProvider;
 exports.SearchProvider = SearchProvider;
 exports.SerperProvider = SerperProvider;
 exports.Services = Services;
+exports.SimpleScheduler = SimpleScheduler;
 exports.SpeechToText = SpeechToText;
 exports.StrategyRegistry = StrategyRegistry;
 exports.StreamEventType = StreamEventType;
@@ -51905,6 +54734,8 @@ exports.TavilyProvider = TavilyProvider;
 exports.TextToSpeech = TextToSpeech;
 exports.TokenBucketRateLimiter = TokenBucketRateLimiter;
 exports.ToolCallState = ToolCallState;
+exports.ToolCatalogPluginNextGen = ToolCatalogPluginNextGen;
+exports.ToolCatalogRegistry = ToolCatalogRegistry;
 exports.ToolExecutionError = ToolExecutionError;
 exports.ToolExecutionPipeline = ToolExecutionPipeline;
 exports.ToolManager = ToolManager;
@@ -51968,6 +54799,7 @@ exports.createEditFileTool = createEditFileTool;
 exports.createEditMeetingTool = createEditMeetingTool;
 exports.createEstimator = createEstimator;
 exports.createExecuteJavaScriptTool = createExecuteJavaScriptTool;
+exports.createExecutionRecorder = createExecutionRecorder;
 exports.createFileAgentDefinitionStorage = createFileAgentDefinitionStorage;
 exports.createFileContextStorage = createFileContextStorage;
 exports.createFileCustomToolStorage = createFileCustomToolStorage;
@@ -51985,6 +54817,9 @@ exports.createListDirectoryTool = createListDirectoryTool;
 exports.createMeetingTool = createMeetingTool;
 exports.createMessageWithImages = createMessageWithImages;
 exports.createMetricsCollector = createMetricsCollector;
+exports.createMicrosoftListFilesTool = createMicrosoftListFilesTool;
+exports.createMicrosoftReadFileTool = createMicrosoftReadFileTool;
+exports.createMicrosoftSearchFilesTool = createMicrosoftSearchFilesTool;
 exports.createPRCommentsTool = createPRCommentsTool;
 exports.createPRFilesTool = createPRFilesTool;
 exports.createPlan = createPlan;
@@ -51992,11 +54827,13 @@ exports.createProvider = createProvider;
 exports.createReadFileTool = createReadFileTool;
 exports.createRoutineDefinition = createRoutineDefinition;
 exports.createRoutineExecution = createRoutineExecution;
+exports.createRoutineExecutionRecord = createRoutineExecutionRecord;
 exports.createSearchCodeTool = createSearchCodeTool;
 exports.createSearchFilesTool = createSearchFilesTool;
 exports.createSendEmailTool = createSendEmailTool;
 exports.createSpeechToTextTool = createSpeechToTextTool;
 exports.createTask = createTask;
+exports.createTaskSnapshots = createTaskSnapshots;
 exports.createTextMessage = createTextMessage;
 exports.createTextToSpeechTool = createTextToSpeechTool;
 exports.createVideoProvider = createVideoProvider;
@@ -52026,6 +54863,7 @@ exports.detectServiceFromURL = detectServiceFromURL;
 exports.developerTools = developerTools;
 exports.documentToContent = documentToContent;
 exports.editFile = editFile;
+exports.encodeSharingUrl = encodeSharingUrl;
 exports.evaluateCondition = evaluateCondition;
 exports.executeRoutine = executeRoutine;
 exports.extractJSON = extractJSON;
@@ -52035,6 +54873,7 @@ exports.findConnectorByServiceTypes = findConnectorByServiceTypes;
 exports.forPlan = forPlan;
 exports.forTasks = forTasks;
 exports.formatAttendees = formatAttendees;
+exports.formatFileSize = formatFileSize;
 exports.formatPluginDisplayName = formatPluginDisplayName;
 exports.formatRecipients = formatRecipients;
 exports.generateEncryptionKey = generateEncryptionKey;
@@ -52054,6 +54893,7 @@ exports.getConnectorTools = getConnectorTools;
 exports.getCredentialsSetupURL = getCredentialsSetupURL;
 exports.getDesktopDriver = getDesktopDriver;
 exports.getDocsURL = getDocsURL;
+exports.getDrivePrefix = getDrivePrefix;
 exports.getImageModelInfo = getImageModelInfo;
 exports.getImageModelsByVendor = getImageModelsByVendor;
 exports.getImageModelsWithFeature = getImageModelsWithFeature;
@@ -52103,6 +54943,7 @@ exports.isBlockedCommand = isBlockedCommand;
 exports.isErrorEvent = isErrorEvent;
 exports.isExcludedExtension = isExcludedExtension;
 exports.isKnownService = isKnownService;
+exports.isMicrosoftFileUrl = isMicrosoftFileUrl;
 exports.isOutputTextDelta = isOutputTextDelta;
 exports.isReasoningDelta = isReasoningDelta;
 exports.isReasoningDone = isReasoningDone;
@@ -52118,6 +54959,7 @@ exports.isToolCallArgumentsDelta = isToolCallArgumentsDelta;
 exports.isToolCallArgumentsDone = isToolCallArgumentsDone;
 exports.isToolCallStart = isToolCallStart;
 exports.isVendor = isVendor;
+exports.isWebUrl = isWebUrl;
 exports.killBackgroundProcess = killBackgroundProcess;
 exports.listConnectorsByServiceTypes = listConnectorsByServiceTypes;
 exports.listDirectory = listDirectory;
@@ -52138,6 +54980,8 @@ exports.registerScrapeProvider = registerScrapeProvider;
 exports.resetDefaultDriver = resetDefaultDriver;
 exports.resolveConnector = resolveConnector;
 exports.resolveDependencies = resolveDependencies;
+exports.resolveFileEndpoints = resolveFileEndpoints;
+exports.resolveFlowSource = resolveFlowSource;
 exports.resolveMaxContextTokens = resolveMaxContextTokens;
 exports.resolveMeetingId = resolveMeetingId;
 exports.resolveModelCapabilities = resolveModelCapabilities;