@everworker/oneringai 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -2,11 +2,11 @@
 
 var crypto2 = require('crypto');
 var jose = require('jose');
-var fs15 = require('fs');
+var fs16 = require('fs');
 var eventemitter3 = require('eventemitter3');
-var path3 = require('path');
-var os = require('os');
-var OpenAI2 = require('openai');
+var path2 = require('path');
+var os2 = require('os');
+var OpenAI3 = require('openai');
 var Anthropic = require('@anthropic-ai/sdk');
 var genai = require('@google/genai');
 require('zod/v3');
@@ -14,7 +14,7 @@ var z4mini = require('zod/v4-mini');
 var z = require('zod/v4');
 var process2 = require('process');
 var stream = require('stream');
-var fs14 = require('fs/promises');
+var fs15 = require('fs/promises');
 var simpleIcons = require('simple-icons');
 var child_process = require('child_process');
 var util = require('util');
@@ -44,15 +44,15 @@ function _interopNamespace(e) {
 }
 
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
-var fs15__namespace = /*#__PURE__*/_interopNamespace(fs15);
-var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var OpenAI2__default = /*#__PURE__*/_interopDefault(OpenAI2);
+var fs16__namespace = /*#__PURE__*/_interopNamespace(fs16);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
+var OpenAI3__default = /*#__PURE__*/_interopDefault(OpenAI3);
 var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
 var z4mini__namespace = /*#__PURE__*/_interopNamespace(z4mini);
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
 var process2__default = /*#__PURE__*/_interopDefault(process2);
-var fs14__namespace = /*#__PURE__*/_interopNamespace(fs14);
+var fs15__namespace = /*#__PURE__*/_interopNamespace(fs15);
 var simpleIcons__namespace = /*#__PURE__*/_interopNamespace(simpleIcons);
 var TurndownService__default = /*#__PURE__*/_interopDefault(TurndownService);
 var vm__namespace = /*#__PURE__*/_interopNamespace(vm);
@@ -631,7 +631,7 @@ var init_JWTBearer = __esm({
           this.privateKey = config.privateKey;
         } else if (config.privateKeyPath) {
           try {
-            this.privateKey = fs15__namespace.readFileSync(config.privateKeyPath, "utf8");
+            this.privateKey = fs16__namespace.readFileSync(config.privateKeyPath, "utf8");
           } catch (error) {
             throw new Error(`Failed to read private key from ${config.privateKeyPath}: ${error.message}`);
           }
@@ -1281,11 +1281,11 @@ var init_Logger = __esm({
        */
       initFileStream(filePath) {
         try {
-          const dir = path3__namespace.dirname(filePath);
-          if (!fs15__namespace.existsSync(dir)) {
-            fs15__namespace.mkdirSync(dir, { recursive: true });
+          const dir = path2__namespace.dirname(filePath);
+          if (!fs16__namespace.existsSync(dir)) {
+            fs16__namespace.mkdirSync(dir, { recursive: true });
           }
-          this.fileStream = fs15__namespace.createWriteStream(filePath, {
+          this.fileStream = fs16__namespace.createWriteStream(filePath, {
             flags: "a",
             // append mode
             encoding: "utf8"
@@ -14555,12 +14555,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs18, exportName) {
+    function addFormats(ajv, list, fs17, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs18[f]);
+        ajv.addFormat(f, fs17[f]);
     }
     module.exports = exports$1 = formatsPlugin;
     Object.defineProperty(exports$1, "__esModule", { value: true });
@@ -14573,7 +14573,7 @@ var require_windows = __commonJS({
   "node_modules/isexe/windows.js"(exports$1, module) {
     module.exports = isexe;
     isexe.sync = sync;
-    var fs18 = __require("fs");
+    var fs17 = __require("fs");
     function checkPathExt(path6, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -14591,19 +14591,19 @@ var require_windows = __commonJS({
       }
       return false;
     }
-    function checkStat(stat5, path6, options) {
-      if (!stat5.isSymbolicLink() && !stat5.isFile()) {
+    function checkStat(stat6, path6, options) {
+      if (!stat6.isSymbolicLink() && !stat6.isFile()) {
         return false;
       }
       return checkPathExt(path6, options);
     }
     function isexe(path6, options, cb) {
-      fs18.stat(path6, function(er, stat5) {
-        cb(er, er ? false : checkStat(stat5, path6, options));
+      fs17.stat(path6, function(er, stat6) {
+        cb(er, er ? false : checkStat(stat6, path6, options));
       });
     }
     function sync(path6, options) {
-      return checkStat(fs18.statSync(path6), path6, options);
+      return checkStat(fs17.statSync(path6), path6, options);
     }
   }
 });
@@ -14613,22 +14613,22 @@ var require_mode = __commonJS({
   "node_modules/isexe/mode.js"(exports$1, module) {
     module.exports = isexe;
     isexe.sync = sync;
-    var fs18 = __require("fs");
+    var fs17 = __require("fs");
     function isexe(path6, options, cb) {
-      fs18.stat(path6, function(er, stat5) {
-        cb(er, er ? false : checkStat(stat5, options));
+      fs17.stat(path6, function(er, stat6) {
+        cb(er, er ? false : checkStat(stat6, options));
       });
     }
     function sync(path6, options) {
-      return checkStat(fs18.statSync(path6), options);
+      return checkStat(fs17.statSync(path6), options);
     }
-    function checkStat(stat5, options) {
-      return stat5.isFile() && checkMode(stat5, options);
+    function checkStat(stat6, options) {
+      return stat6.isFile() && checkMode(stat6, options);
     }
-    function checkMode(stat5, options) {
-      var mod = stat5.mode;
-      var uid = stat5.uid;
-      var gid = stat5.gid;
+    function checkMode(stat6, options) {
+      var mod = stat6.mode;
+      var uid = stat6.uid;
+      var gid = stat6.gid;
       var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
       var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
       var u = parseInt("100", 8);
@@ -14902,16 +14902,16 @@ var require_shebang_command = __commonJS({
 // node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports$1, module) {
-    var fs18 = __require("fs");
+    var fs17 = __require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs18.openSync(command, "r");
-        fs18.readSync(fd, buffer, 0, size, 0);
-        fs18.closeSync(fd);
+        fd = fs17.openSync(command, "r");
+        fs17.readSync(fd, buffer, 0, size, 0);
+        fs17.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -15089,8 +15089,8 @@ var DEFAULT_ALLOWLIST = [
   "context_list",
   // Persistent instructions tools
   "instructions_set",
-  "instructions_append",
-  "instructions_get",
+  "instructions_remove",
+  "instructions_list",
   "instructions_clear",
   // Meta-tools (internal coordination)
   "_start_planning",
@@ -16020,13 +16020,26 @@ var ToolManager = class extends eventemitter3.EventEmitter {
   pipeline;
   /** Optional tool context for execution (set by agent before runs) */
   _toolContext;
-  constructor() {
+  /** Hard timeout for tool execution (0 = disabled) */
+  _toolExecutionTimeout;
+  constructor(config) {
     super();
+    this._toolExecutionTimeout = config?.toolExecutionTimeout ?? 0;
     this.namespaceIndex.set("default", /* @__PURE__ */ new Set());
     this.toolLogger = exports.logger.child({ component: "ToolManager" });
     this.pipeline = new ToolExecutionPipeline();
     this.pipeline.use(new ResultNormalizerPlugin());
   }
+  /**
+   * Get or set the hard tool execution timeout in milliseconds.
+   * 0 = disabled (relies on tool's own timeout).
+   */
+  get toolExecutionTimeout() {
+    return this._toolExecutionTimeout;
+  }
+  set toolExecutionTimeout(value) {
+    this._toolExecutionTimeout = Math.max(0, value);
+  }
   /**
    * Access the execution pipeline for plugin management.
    *
@@ -16524,7 +16537,7 @@ var ToolManager = class extends eventemitter3.EventEmitter {
     const startTime = Date.now();
     exports.metrics.increment("tool.executed", 1, { tool: toolName });
     try {
-      const result = await breaker.execute(async () => {
+      const executionPromise = breaker.execute(async () => {
         const toolWithContext = {
           ...registration.tool,
           execute: async (pipelineArgs) => {
@@ -16533,6 +16546,7 @@ var ToolManager = class extends eventemitter3.EventEmitter {
         };
         return await this.pipeline.execute(toolWithContext, args);
       });
+      const result = this._toolExecutionTimeout > 0 ? await this.withHardTimeout(executionPromise, toolName, this._toolExecutionTimeout) : await executionPromise;
       const duration = Date.now() - startTime;
       this.recordExecution(toolName, duration, true);
       const resultSummary = this.summarizeResult(result);
@@ -16595,6 +16609,29 @@ var ToolManager = class extends eventemitter3.EventEmitter {
     return this.list();
   }
   // ==========================================================================
+  // Hard Timeout
+  // ==========================================================================
+  /**
+   * Wrap a promise with a hard timeout safety net.
+   * If the promise doesn't resolve within the timeout, throws ToolExecutionError.
+   */
+  async withHardTimeout(promise, toolName, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new ToolExecutionError(
+          toolName,
+          `Tool execution hard timeout after ${timeoutMs}ms (safety net - tool's own timeout may have failed)`
+        ));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ==========================================================================
   // Circuit Breaker Management
   // ==========================================================================
   /**
@@ -19653,10 +19690,10 @@ function getDefaultBaseDirectory() {
   if (platform2 === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
     if (appData) {
-      return path3.join(appData, "oneringai", "agents");
+      return path2.join(appData, "oneringai", "agents");
     }
   }
-  return path3.join(os.homedir(), ".oneringai", "agents");
+  return path2.join(os2.homedir(), ".oneringai", "agents");
 }
 function sanitizeAgentId(agentId) {
   return agentId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || "default";
@@ -19664,22 +19701,45 @@ function sanitizeAgentId(agentId) {
 var FilePersistentInstructionsStorage = class {
   directory;
   filePath;
+  legacyFilePath;
   agentId;
   constructor(config) {
     this.agentId = config.agentId;
     const sanitizedId = sanitizeAgentId(config.agentId);
     const baseDir = config.baseDirectory ?? getDefaultBaseDirectory();
-    const filename = config.filename ?? "custom_instructions.md";
-    this.directory = path3.join(baseDir, sanitizedId);
-    this.filePath = path3.join(this.directory, filename);
+    const filename = config.filename ?? "custom_instructions.json";
+    this.directory = path2.join(baseDir, sanitizedId);
+    this.filePath = path2.join(this.directory, filename);
+    this.legacyFilePath = path2.join(this.directory, "custom_instructions.md");
   }
   /**
-   * Load instructions from file
+   * Load instruction entries from file.
+   * Falls back to legacy .md file migration if JSON not found.
    */
   async load() {
     try {
-      const content = await fs15.promises.readFile(this.filePath, "utf-8");
-      return content.trim() || null;
+      const raw = await fs16.promises.readFile(this.filePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.version === 2 && Array.isArray(data.entries)) {
+        return data.entries.length > 0 ? data.entries : null;
+      }
+      return null;
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+        throw error;
+      }
+    }
+    try {
+      const content = await fs16.promises.readFile(this.legacyFilePath, "utf-8");
+      const trimmed = content.trim();
+      if (!trimmed) return null;
+      const now = Date.now();
+      return [{
+        id: "legacy_instructions",
+        content: trimmed,
+        createdAt: now,
+        updatedAt: now
+      }];
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
         return null;
@@ -19688,44 +19748,56 @@ var FilePersistentInstructionsStorage = class {
     }
   }
   /**
-   * Save instructions to file
-   * Creates directory if it doesn't exist
+   * Save instruction entries to file as JSON.
+   * Creates directory if it doesn't exist.
+   * Cleans up legacy .md file if present.
    */
-  async save(content) {
+  async save(entries) {
     await this.ensureDirectory();
+    const data = {
+      version: 2,
+      entries
+    };
     const tempPath = `${this.filePath}.tmp`;
     try {
-      await fs15.promises.writeFile(tempPath, content, "utf-8");
-      await fs15.promises.rename(tempPath, this.filePath);
+      await fs16.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+      await fs16.promises.rename(tempPath, this.filePath);
     } catch (error) {
       try {
-        await fs15.promises.unlink(tempPath);
+        await fs16.promises.unlink(tempPath);
       } catch {
       }
       throw error;
     }
+    await this.removeLegacyFile();
   }
   /**
-   * Delete instructions file
+   * Delete instructions file (and legacy .md if exists)
    */
   async delete() {
     try {
-      await fs15.promises.unlink(this.filePath);
+      await fs16.promises.unlink(this.filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
       }
     }
+    await this.removeLegacyFile();
   }
   /**
-   * Check if instructions file exists
+   * Check if instructions file exists (JSON or legacy .md)
    */
   async exists() {
     try {
-      await fs15.promises.access(this.filePath);
+      await fs16.promises.access(this.filePath);
       return true;
     } catch {
-      return false;
+      try {
+        await fs16.promises.access(this.legacyFilePath);
+        return true;
+      } catch {
+        return false;
+      }
     }
   }
   /**
@@ -19745,65 +19817,86 @@ var FilePersistentInstructionsStorage = class {
    */
   async ensureDirectory() {
     try {
-      await fs15.promises.mkdir(this.directory, { recursive: true });
+      await fs16.promises.mkdir(this.directory, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
       }
     }
   }
+  /**
+   * Remove legacy .md file if it exists
+   */
+  async removeLegacyFile() {
+    try {
+      await fs16.promises.unlink(this.legacyFilePath);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+        console.warn(`Failed to remove legacy instructions file: ${this.legacyFilePath}`);
+      }
+    }
+  }
 };
 
 // src/core/context-nextgen/plugins/PersistentInstructionsPluginNextGen.ts
-var DEFAULT_MAX_LENGTH = 5e4;
+var DEFAULT_MAX_TOTAL_LENGTH = 5e4;
+var DEFAULT_MAX_ENTRIES = 50;
+var KEY_MAX_LENGTH = 100;
+var KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var PERSISTENT_INSTRUCTIONS_INSTRUCTIONS = `Persistent Instructions are stored on disk and survive across sessions.
+Each instruction is a keyed entry that can be independently managed.
 
 **To modify:**
-- \`instructions_set(content)\`: Replace all instructions
-- \`instructions_append(section)\`: Add a section
-- \`instructions_clear(confirm: true)\`: Remove all (destructive!)
+- \`instructions_set(key, content)\`: Add or update a single instruction by key
+- \`instructions_remove(key)\`: Remove a single instruction by key
+- \`instructions_list()\`: List all instructions with keys and content
+- \`instructions_clear(confirm: true)\`: Remove all instructions (destructive!)
 
 **Use for:** Agent personality, user preferences, learned rules, guidelines.`;
 var instructionsSetDefinition = {
   type: "function",
   function: {
     name: "instructions_set",
-    description: `Set or replace all custom instructions. Persists across sessions.
-IMPORTANT: This replaces ALL existing instructions.`,
+    description: `Add or update a single persistent instruction by key. Persists across sessions.
+If the key exists, it will be updated. If not, a new entry is created.`,
     parameters: {
       type: "object",
       properties: {
+        key: {
+          type: "string",
+          description: "Unique key for the instruction (alphanumeric, dash, underscore; max 100 chars)"
+        },
         content: {
           type: "string",
-          description: "Full instructions content (markdown supported)"
+          description: "Instruction content (markdown supported)"
         }
       },
-      required: ["content"]
+      required: ["key", "content"]
     }
   }
 };
-var instructionsAppendDefinition = {
+var instructionsRemoveDefinition = {
   type: "function",
   function: {
-    name: "instructions_append",
-    description: "Append a section to existing instructions.",
+    name: "instructions_remove",
+    description: "Remove a single persistent instruction by key.",
     parameters: {
       type: "object",
       properties: {
-        section: {
+        key: {
           type: "string",
-          description: "Section to append (will add newlines before)"
+          description: "Key of the instruction to remove"
         }
       },
-      required: ["section"]
+      required: ["key"]
     }
   }
 };
-var instructionsGetDefinition = {
+var instructionsListDefinition = {
   type: "function",
   function: {
-    name: "instructions_get",
-    description: "Get current custom instructions.",
+    name: "instructions_list",
+    description: "List all persistent instructions with their keys and content.",
     parameters: {
       type: "object",
       properties: {},
@@ -19815,7 +19908,7 @@ var instructionsClearDefinition = {
   type: "function",
   function: {
     name: "instructions_clear",
-    description: "Clear all custom instructions (DESTRUCTIVE). Requires confirmation.",
+    description: "Clear all persistent instructions (DESTRUCTIVE). Requires confirmation.",
     parameters: {
       type: "object",
       properties: {
@@ -19828,13 +19921,22 @@ var instructionsClearDefinition = {
     }
   }
 };
+function validateKey(key) {
+  if (typeof key !== "string") return "Key must be a string";
+  const trimmed = key.trim();
+  if (trimmed.length === 0) return "Key cannot be empty";
+  if (trimmed.length > KEY_MAX_LENGTH) return `Key exceeds maximum length (${KEY_MAX_LENGTH} chars)`;
+  if (!KEY_PATTERN.test(trimmed)) return "Key must contain only alphanumeric characters, dashes, and underscores";
+  return null;
+}
 var PersistentInstructionsPluginNextGen = class {
   name = "persistent_instructions";
-  _content = null;
+  _entries = /* @__PURE__ */ new Map();
   _initialized = false;
   _destroyed = false;
   storage;
-  maxLength;
+  maxTotalLength;
+  maxEntries;
   agentId;
   estimator = simpleTokenEstimator;
   _tokenCache = null;
@@ -19844,7 +19946,8 @@ var PersistentInstructionsPluginNextGen = class {
       throw new Error("PersistentInstructionsPluginNextGen requires agentId");
     }
     this.agentId = config.agentId;
-    this.maxLength = config.maxLength ?? DEFAULT_MAX_LENGTH;
+    this.maxTotalLength = config.maxTotalLength ?? DEFAULT_MAX_TOTAL_LENGTH;
+    this.maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
     this.storage = config.storage ?? new FilePersistentInstructionsStorage({
       agentId: config.agentId
     });
@@ -19857,14 +19960,16 @@ var PersistentInstructionsPluginNextGen = class {
   }
   async getContent() {
     await this.ensureInitialized();
-    if (!this._content) {
+    if (this._entries.size === 0) {
+      this._tokenCache = 0;
       return null;
     }
-    this._tokenCache = this.estimator.estimateTokens(this._content);
-    return this._content;
+    const rendered = this.renderContent();
+    this._tokenCache = this.estimator.estimateTokens(rendered);
+    return rendered;
   }
   getContents() {
-    return this._content;
+    return new Map(this._entries);
   }
   getTokenSize() {
     return this._tokenCache ?? 0;
@@ -19884,32 +19989,54 @@ var PersistentInstructionsPluginNextGen = class {
   getTools() {
     return [
       this.createInstructionsSetTool(),
-      this.createInstructionsAppendTool(),
-      this.createInstructionsGetTool(),
+      this.createInstructionsRemoveTool(),
+      this.createInstructionsListTool(),
       this.createInstructionsClearTool()
     ];
   }
   destroy() {
     if (this._destroyed) return;
-    this._content = null;
+    this._entries.clear();
     this._destroyed = true;
     this._tokenCache = null;
   }
   getState() {
     return {
-      content: this._content,
-      agentId: this.agentId
+      entries: Array.from(this._entries.values()),
+      agentId: this.agentId,
+      version: 2
     };
   }
   restoreState(state) {
+    if (!state || typeof state !== "object") return;
     const s = state;
-    if (!s) return;
-    this._content = s.content;
-    this._initialized = true;
-    this._tokenCache = null;
+    if ("version" in s && s.version === 2 && Array.isArray(s.entries)) {
+      this._entries.clear();
+      for (const entry of s.entries) {
+        this._entries.set(entry.id, entry);
+      }
+      this._initialized = true;
+      this._tokenCache = null;
+      return;
+    }
+    if ("content" in s) {
+      this._entries.clear();
+      const content = s.content;
+      if (content) {
+        const now = Date.now();
+        this._entries.set("legacy_instructions", {
+          id: "legacy_instructions",
+          content,
+          createdAt: now,
+          updatedAt: now
+        });
+      }
+      this._initialized = true;
+      this._tokenCache = null;
+    }
   }
   // ============================================================================
-  // Content Management
+  // Public API
   // ============================================================================
   /**
    * Initialize by loading from storage (called lazily)
@@ -19917,66 +20044,99 @@ var PersistentInstructionsPluginNextGen = class {
   async initialize() {
     if (this._initialized || this._destroyed) return;
     try {
-      this._content = await this.storage.load();
+      const entries = await this.storage.load();
+      this._entries.clear();
+      if (entries) {
+        for (const entry of entries) {
+          this._entries.set(entry.id, entry);
+        }
+      }
       this._initialized = true;
     } catch (error) {
       console.warn(`Failed to load persistent instructions for agent '${this.agentId}':`, error);
-      this._content = null;
+      this._entries.clear();
       this._initialized = true;
     }
     this._tokenCache = null;
   }
   /**
-   * Set entire instructions content (replaces existing)
+   * Add or update an instruction entry by key
    */
-  async set(content) {
+  async set(key, content) {
     this.assertNotDestroyed();
-    if (content.length > this.maxLength) {
+    await this.ensureInitialized();
+    const keyError = validateKey(key);
+    if (keyError) return false;
+    const trimmedContent = content.trim();
+    if (trimmedContent.length === 0) return false;
+    if (!this._entries.has(key) && this._entries.size >= this.maxEntries) {
       return false;
     }
-    this._content = content.trim() || null;
-    if (this._content) {
-      await this.storage.save(this._content);
-    } else {
-      await this.storage.delete();
+    const currentTotal = this.calculateTotalContentLength();
+    const existingLength = this._entries.get(key)?.content.length ?? 0;
+    const newTotal = currentTotal - existingLength + trimmedContent.length;
+    if (newTotal > this.maxTotalLength) {
+      return false;
     }
+    const now = Date.now();
+    const existing = this._entries.get(key);
+    this._entries.set(key, {
+      id: key,
+      content: trimmedContent,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now
+    });
+    await this.persistToStorage();
     this._tokenCache = null;
     return true;
   }
   /**
-   * Append a section to existing instructions
+   * Remove an instruction entry by key
    */
-  async append(section) {
+  async remove(key) {
     this.assertNotDestroyed();
     await this.ensureInitialized();
-    const trimmedSection = section.trim();
-    if (!trimmedSection) return true;
-    const currentContent = this._content || "";
-    const newContent = currentContent ? `${currentContent}
-
-${trimmedSection}` : trimmedSection;
-    if (newContent.length > this.maxLength) {
-      return false;
+    if (!this._entries.has(key)) return false;
+    this._entries.delete(key);
+    if (this._entries.size === 0) {
+      await this.storage.delete();
+    } else {
+      await this.persistToStorage();
     }
-    this._content = newContent;
-    await this.storage.save(this._content);
     this._tokenCache = null;
     return true;
   }
   /**
-   * Get current content
+   * Get one entry by key, or all entries if no key provided
    */
-  async get() {
+  async get(key) {
     this.assertNotDestroyed();
     await this.ensureInitialized();
-    return this._content;
+    if (key !== void 0) {
+      return this._entries.get(key) ?? null;
+    }
+    if (this._entries.size === 0) return null;
+    return this.getSortedEntries();
   }
   /**
-   * Clear all instructions
+   * List metadata for all entries
+   */
+  async list() {
+    this.assertNotDestroyed();
+    await this.ensureInitialized();
+    return this.getSortedEntries().map((entry) => ({
+      key: entry.id,
+      contentLength: entry.content.length,
+      createdAt: entry.createdAt,
+      updatedAt: entry.updatedAt
+    }));
+  }
+  /**
+   * Clear all instruction entries
    */
   async clear() {
     this.assertNotDestroyed();
-    this._content = null;
+    this._entries.clear();
     await this.storage.delete();
     this._tokenCache = null;
   }
@@ -19999,6 +20159,35 @@ ${trimmedSection}` : trimmedSection;
       throw new Error("PersistentInstructionsPluginNextGen is destroyed");
     }
   }
+  /**
+   * Persist current entries to storage
+   */
+  async persistToStorage() {
+    await this.storage.save(Array.from(this._entries.values()));
+  }
+  /**
+   * Calculate total content length across all entries
+   */
+  calculateTotalContentLength() {
+    let total = 0;
+    for (const entry of this._entries.values()) {
+      total += entry.content.length;
+    }
+    return total;
+  }
+  /**
+   * Get entries sorted by createdAt (oldest first)
+   */
+  getSortedEntries() {
+    return Array.from(this._entries.values()).sort((a, b) => a.createdAt - b.createdAt);
+  }
+  /**
+   * Render all entries as markdown for context injection
+   */
+  renderContent() {
+    return this.getSortedEntries().map((entry) => `### ${entry.id}
+${entry.content}`).join("\n\n");
+  }
   // ============================================================================
   // Tool Factories
   // ============================================================================
@@ -20006,60 +20195,84 @@ ${trimmedSection}` : trimmedSection;
     return {
       definition: instructionsSetDefinition,
       execute: async (args) => {
+        const key = args.key;
         const content = args.content;
+        const keyError = validateKey(key);
+        if (keyError) {
+          return { error: keyError };
+        }
         if (!content || content.trim().length === 0) {
-          return { error: "Content cannot be empty. Use instructions_clear to remove." };
+          return { error: "Content cannot be empty. Use instructions_remove to delete an entry." };
         }
-        const success = await this.set(content);
+        const isUpdate = this._entries.has(key.trim());
+        const success = await this.set(key.trim(), content);
         if (!success) {
-          return { error: `Content exceeds maximum length (${this.maxLength} chars)` };
+          if (!isUpdate && this._entries.size >= this.maxEntries) {
+            return { error: `Maximum number of entries reached (${this.maxEntries})` };
+          }
+          return { error: `Content would exceed maximum total length (${this.maxTotalLength} chars)` };
         }
         return {
           success: true,
-          message: "Custom instructions updated",
-          length: content.length
+          message: isUpdate ? `Instruction '${key.trim()}' updated` : `Instruction '${key.trim()}' added`,
+          key: key.trim(),
+          contentLength: content.trim().length
         };
       },
       permission: { scope: "always", riskLevel: "low" },
-      describeCall: () => "set instructions"
+      describeCall: (args) => `set instruction '${args.key}'`
     };
   }
-  createInstructionsAppendTool() {
+  createInstructionsRemoveTool() {
     return {
-      definition: instructionsAppendDefinition,
+      definition: instructionsRemoveDefinition,
       execute: async (args) => {
-        const section = args.section;
-        if (!section || section.trim().length === 0) {
-          return { error: "Section cannot be empty" };
+        const key = args.key;
+        if (!key || typeof key !== "string" || key.trim().length === 0) {
+          return { error: "Key is required" };
         }
-        const success = await this.append(section);
+        const success = await this.remove(key.trim());
         if (!success) {
-          return { error: `Would exceed maximum length (${this.maxLength} chars)` };
+          return { error: `Instruction '${key.trim()}' not found` };
         }
         return {
           success: true,
-          message: "Section appended to instructions",
-          newLength: this._content?.length ?? 0
+          message: `Instruction '${key.trim()}' removed`,
+          key: key.trim()
         };
       },
       permission: { scope: "always", riskLevel: "low" },
-      describeCall: () => "append to instructions"
+      describeCall: (args) => `remove instruction '${args.key}'`
     };
   }
-  createInstructionsGetTool() {
+  createInstructionsListTool() {
     return {
-      definition: instructionsGetDefinition,
+      definition: instructionsListDefinition,
       execute: async () => {
-        const content = await this.get();
+        const entries = await this.list();
+        const all = await this.get();
+        if (entries.length === 0) {
+          return {
+            count: 0,
+            entries: [],
+            message: "(no custom instructions set)"
+          };
+        }
+        const allEntries = all;
         return {
-          hasContent: content !== null,
-          content: content ?? "(no custom instructions set)",
-          length: content?.length ?? 0,
+          count: entries.length,
+          entries: allEntries.map((e) => ({
+            key: e.id,
+            content: e.content,
+            contentLength: e.content.length,
+            createdAt: e.createdAt,
+            updatedAt: e.updatedAt
+          })),
           agentId: this.agentId
         };
       },
       permission: { scope: "always", riskLevel: "low" },
-      describeCall: () => "get instructions"
+      describeCall: () => "list instructions"
     };
   }
   createInstructionsClearTool() {
@@ -20072,7 +20285,7 @@ ${trimmedSection}` : trimmedSection;
         await this.clear();
         return {
           success: true,
-          message: "Custom instructions cleared"
+          message: "All custom instructions cleared"
         };
       },
       permission: { scope: "once", riskLevel: "medium" },
@@ -20797,7 +21010,9 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
     this._agentId = this._config.agentId;
     this._storage = config.storage;
     this._compactionStrategy = config.compactionStrategy ?? StrategyRegistry.create(this._config.strategy);
-    this._tools = new ToolManager();
+    this._tools = new ToolManager(
+      config.toolExecutionTimeout ? { toolExecutionTimeout: config.toolExecutionTimeout } : void 0
+    );
     if (config.tools) {
       for (const tool of config.tools) {
         this._tools.register(tool);
@@ -22533,7 +22748,7 @@ var OpenAITextProvider = class extends BaseTextProvider {
   streamConverter;
   constructor(config) {
     super(config);
-    this.client = new OpenAI2__default.default({
+    this.client = new OpenAI3__default.default({
       apiKey: this.getApiKey(),
       baseURL: this.getBaseURL(),
       organization: config.organization,
@@ -24263,7 +24478,9 @@ var GoogleTextProvider = class extends BaseTextProvider {
   constructor(config) {
     super(config);
     this.client = new genai.GoogleGenAI({
-      apiKey: this.getApiKey()
+      apiKey: this.getApiKey(),
+      // Pass custom baseURL for proxy support (e.g. when routing through EW proxy)
+      ...config.baseURL ? { httpOptions: { baseUrl: config.baseURL } } : {}
     });
     this.converter = new GoogleConverter();
     this.streamConverter = new GoogleStreamConverter();
@@ -24560,6 +24777,30 @@ var GenericOpenAIProvider = class extends OpenAITextProvider {
 };
 
 // src/core/createProvider.ts
+var VENDOR_DEFAULT_URLS = (() => {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    map.set(Vendor.OpenAI, new OpenAI3__default.default({ apiKey: "_" }).baseURL);
+  } catch {
+  }
+  try {
+    map.set(Vendor.Anthropic, new Anthropic__default.default({ apiKey: "_" }).baseURL);
+  } catch {
+  }
+  map.set(Vendor.Google, "https://generativelanguage.googleapis.com");
+  map.set(Vendor.GoogleVertex, "https://us-central1-aiplatform.googleapis.com");
+  map.set(Vendor.Groq, "https://api.groq.com/openai/v1");
+  map.set(Vendor.Together, "https://api.together.xyz/v1");
+  map.set(Vendor.Perplexity, "https://api.perplexity.ai");
+  map.set(Vendor.Grok, "https://api.x.ai/v1");
+  map.set(Vendor.DeepSeek, "https://api.deepseek.com/v1");
+  map.set(Vendor.Mistral, "https://api.mistral.ai/v1");
+  map.set(Vendor.Ollama, "http://localhost:11434/v1");
+  return map;
+})();
+function getVendorDefaultBaseURL(vendor) {
+  return VENDOR_DEFAULT_URLS.get(vendor);
+}
 function createProvider(connector) {
   const injectedProvider = connector.getOptions().provider;
   if (injectedProvider && typeof injectedProvider.generate === "function") {
@@ -24594,39 +24835,15 @@ function createProvider(connector) {
       });
     // OpenAI-compatible providers (use connector.name for unique identification)
     case Vendor.Groq:
-      return new GenericOpenAIProvider(connector.name, {
-        ...config,
-        baseURL: config.baseURL || "https://api.groq.com/openai/v1"
-      });
     case Vendor.Together:
-      return new GenericOpenAIProvider(connector.name, {
-        ...config,
-        baseURL: config.baseURL || "https://api.together.xyz/v1"
-      });
     case Vendor.Perplexity:
-      return new GenericOpenAIProvider(connector.name, {
-        ...config,
-        baseURL: config.baseURL || "https://api.perplexity.ai"
-      });
     case Vendor.Grok:
-      return new GenericOpenAIProvider(connector.name, {
-        ...config,
-        baseURL: config.baseURL || "https://api.x.ai/v1"
-      });
     case Vendor.DeepSeek:
-      return new GenericOpenAIProvider(connector.name, {
-        ...config,
-        baseURL: config.baseURL || "https://api.deepseek.com/v1"
-      });
     case Vendor.Mistral:
-      return new GenericOpenAIProvider(connector.name, {
-        ...config,
-        baseURL: config.baseURL || "https://api.mistral.ai/v1"
-      });
     case Vendor.Ollama:
       return new GenericOpenAIProvider(connector.name, {
         ...config,
-        baseURL: config.baseURL || "http://localhost:11434/v1"
+        baseURL: config.baseURL || getVendorDefaultBaseURL(vendor)
       });
     case Vendor.Custom:
       if (!config.baseURL) {
@@ -24738,7 +24955,10 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
       agentId: config.name,
       // Include storage and sessionId if session config is provided
       storage: config.session?.storage,
+      // Thread tool execution timeout to ToolManager
+      toolExecutionTimeout: config.toolExecutionTimeout,
       // Subclasses can add systemPrompt via their config
+      // Note: context-level toolExecutionTimeout overrides agent-level if both set
       ...typeof config.context === "object" && config.context !== null ? config.context : {}
     };
     return AgentContextNextGen.create(contextConfig);
@@ -27178,18 +27398,18 @@ var Agent = class _Agent extends BaseAgent {
 (class {
   static DEFAULT_PATHS = [
     "./oneringai.config.json",
-    path3.join(os.homedir(), ".oneringai", "config.json")
+    path2.join(os2.homedir(), ".oneringai", "config.json")
   ];
   /**
    * Load configuration from file
    */
   static async load(path6) {
-    const configPath = path6 ? path3.resolve(path6) : await this.findConfig();
+    const configPath = path6 ? path2.resolve(path6) : await this.findConfig();
     if (!configPath) {
       throw new Error("Configuration file not found. Searched: " + this.DEFAULT_PATHS.join(", "));
     }
     try {
-      const content = await fs15.promises.readFile(configPath, "utf-8");
+      const content = await fs16.promises.readFile(configPath, "utf-8");
       let config = JSON.parse(content);
       config = this.interpolateEnvVars(config);
       this.validate(config);
@@ -27205,13 +27425,13 @@ var Agent = class _Agent extends BaseAgent {
    * Load configuration synchronously
    */
   static loadSync(path6) {
-    const configPath = path6 ? path3.resolve(path6) : this.findConfigSync();
+    const configPath = path6 ? path2.resolve(path6) : this.findConfigSync();
     if (!configPath) {
       throw new Error("Configuration file not found. Searched: " + this.DEFAULT_PATHS.join(", "));
     }
     try {
-      const fs18 = __require("fs");
-      const content = fs18.readFileSync(configPath, "utf-8");
+      const fs17 = __require("fs");
+      const content = fs17.readFileSync(configPath, "utf-8");
       let config = JSON.parse(content);
       config = this.interpolateEnvVars(config);
       this.validate(config);
@@ -27229,8 +27449,8 @@ var Agent = class _Agent extends BaseAgent {
   static async findConfig() {
     for (const path6 of this.DEFAULT_PATHS) {
       try {
-        await fs15.promises.access(path3.resolve(path6));
-        return path3.resolve(path6);
+        await fs16.promises.access(path2.resolve(path6));
+        return path2.resolve(path6);
       } catch {
       }
     }
@@ -27240,11 +27460,11 @@ var Agent = class _Agent extends BaseAgent {
    * Find configuration file synchronously
    */
   static findConfigSync() {
-    const fs18 = __require("fs");
+    const fs17 = __require("fs");
     for (const path6 of this.DEFAULT_PATHS) {
       try {
-        fs18.accessSync(path3.resolve(path6));
-        return path3.resolve(path6);
+        fs17.accessSync(path2.resolve(path6));
+        return path2.resolve(path6);
       } catch {
       }
     }
@@ -32801,8 +33021,8 @@ var MCPRegistry = class {
    */
   static async loadFromConfigFile(path6) {
     try {
-      const configPath = path3.resolve(path6);
-      const content = await fs15.promises.readFile(configPath, "utf-8");
+      const configPath = path2.resolve(path6);
+      const content = await fs16.promises.readFile(configPath, "utf-8");
       const config = JSON.parse(content);
       if (!config.mcp) {
         throw new MCPError("Configuration file does not contain MCP section");
@@ -33190,7 +33410,7 @@ var OpenAITTSProvider = class extends BaseMediaProvider {
   client;
   constructor(config) {
     super({ apiKey: config.auth.apiKey, ...config });
-    this.client = new OpenAI2__default.default({
+    this.client = new OpenAI3__default.default({
       apiKey: config.auth.apiKey,
       baseURL: config.baseURL,
       organization: config.organization,
@@ -33273,7 +33493,7 @@ var OpenAITTSProvider = class extends BaseMediaProvider {
    * Handle OpenAI API errors
    */
   handleError(error) {
-    if (error instanceof OpenAI2__default.default.APIError) {
+    if (error instanceof OpenAI3__default.default.APIError) {
       const status = error.status;
       const message = error.message || "Unknown OpenAI API error";
       if (status === 401) {
@@ -33305,7 +33525,7 @@ var OpenAISTTProvider = class extends BaseMediaProvider {
   client;
   constructor(config) {
     super({ apiKey: config.auth.apiKey, ...config });
-    this.client = new OpenAI2__default.default({
+    this.client = new OpenAI3__default.default({
       apiKey: config.auth.apiKey,
       baseURL: config.baseURL,
       organization: config.organization,
@@ -33407,7 +33627,7 @@ var OpenAISTTProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(audio)) {
       return new File([new Uint8Array(audio)], "audio.wav", { type: "audio/wav" });
     } else if (typeof audio === "string") {
-      return fs15__namespace.createReadStream(audio);
+      return fs16__namespace.createReadStream(audio);
     } else {
       throw new Error("Invalid audio input: must be Buffer or file path");
     }
@@ -33466,7 +33686,7 @@ var OpenAISTTProvider = class extends BaseMediaProvider {
    * Handle OpenAI API errors
    */
   handleError(error) {
-    if (error instanceof OpenAI2__default.default.APIError) {
+    if (error instanceof OpenAI3__default.default.APIError) {
       const status = error.status;
       const message = error.message || "Unknown OpenAI API error";
       if (status === 401) {
@@ -33960,7 +34180,7 @@ var TextToSpeech = class _TextToSpeech {
    */
   async toFile(text, filePath, options) {
     const response = await this.synthesize(text, options);
-    await fs14__namespace.writeFile(filePath, response.audio);
+    await fs15__namespace.writeFile(filePath, response.audio);
   }
   // ======================== Introspection Methods ========================
   /**
@@ -34308,7 +34528,7 @@ var SpeechToText = class _SpeechToText {
    * @param options - Optional transcription parameters
    */
   async transcribeFile(filePath, options) {
-    const audio = await fs14__namespace.readFile(filePath);
+    const audio = await fs15__namespace.readFile(filePath);
     return this.transcribe(audio, options);
   }
   /**
@@ -34472,7 +34692,7 @@ var OpenAIImageProvider = class extends BaseMediaProvider {
   client;
   constructor(config) {
     super({ apiKey: config.auth.apiKey, ...config });
-    this.client = new OpenAI2__default.default({
+    this.client = new OpenAI3__default.default({
       apiKey: config.auth.apiKey,
       baseURL: config.baseURL,
       organization: config.organization,
@@ -34634,7 +34854,7 @@ var OpenAIImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       return new File([new Uint8Array(image)], "image.png", { type: "image/png" });
     }
-    return fs15__namespace.createReadStream(image);
+    return fs16__namespace.createReadStream(image);
   }
   /**
    * Handle OpenAI API errors
@@ -34781,8 +35001,8 @@ var GoogleImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       imageBytes = image.toString("base64");
     } else {
-      const fs18 = await import('fs');
-      const buffer = fs18.readFileSync(image);
+      const fs17 = await import('fs');
+      const buffer = fs17.readFileSync(image);
       imageBytes = buffer.toString("base64");
     }
     return {
@@ -34832,7 +35052,7 @@ var GrokImageProvider = class extends BaseMediaProvider {
   client;
   constructor(config) {
     super({ apiKey: config.auth.apiKey, ...config });
-    this.client = new OpenAI2__default.default({
+    this.client = new OpenAI3__default.default({
       apiKey: config.auth.apiKey,
       baseURL: config.baseURL || GROK_API_BASE_URL,
       timeout: config.timeout,
@@ -34943,7 +35163,7 @@ var GrokImageProvider = class extends BaseMediaProvider {
     if (Buffer.isBuffer(image)) {
       return new File([new Uint8Array(image)], "image.png", { type: "image/png" });
     }
-    return fs15__namespace.createReadStream(image);
+    return fs16__namespace.createReadStream(image);
   }
   /**
    * Handle API errors
@@ -36145,7 +36365,7 @@ var OpenAISoraProvider = class extends BaseMediaProvider {
   client;
   constructor(config) {
     super({ apiKey: config.auth.apiKey, ...config });
-    this.client = new OpenAI2__default.default({
+    this.client = new OpenAI3__default.default({
       apiKey: config.auth.apiKey,
       baseURL: config.baseURL,
       organization: config.organization,
@@ -36393,8 +36613,8 @@ var OpenAISoraProvider = class extends BaseMediaProvider {
       return new File([new Uint8Array(image)], "input.png", { type: "image/png" });
     }
     if (!image.startsWith("http")) {
-      const fs18 = await import('fs');
-      const data = fs18.readFileSync(image);
+      const fs17 = await import('fs');
+      const data = fs17.readFileSync(image);
       return new File([new Uint8Array(data)], "input.png", { type: "image/png" });
     }
     const response = await fetch(image);
@@ -36572,7 +36792,7 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
           if (video.videoBytes) {
             buffer = Buffer.from(video.videoBytes, "base64");
           } else if (video.uri) {
-            const fs18 = await import('fs/promises');
+            const fs17 = await import('fs/promises');
             const os3 = await import('os');
             const path6 = await import('path');
             const tempDir = os3.tmpdir();
@@ -36583,11 +36803,11 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
                 // Pass as GeneratedVideo
                 downloadPath: tempFile
               });
-              buffer = await fs18.readFile(tempFile);
-              await fs18.unlink(tempFile).catch(() => {
+              buffer = await fs17.readFile(tempFile);
+              await fs17.unlink(tempFile).catch(() => {
               });
             } catch (downloadError) {
-              await fs18.unlink(tempFile).catch(() => {
+              await fs17.unlink(tempFile).catch(() => {
               });
               throw new ProviderError(
                 "google",
@@ -36709,8 +36929,8 @@ var GoogleVeoProvider = class extends BaseMediaProvider {
     if (image.startsWith("http://") || image.startsWith("https://")) {
       return { imageUri: image };
     }
-    const fs18 = await import('fs/promises');
-    const data = await fs18.readFile(image);
+    const fs17 = await import('fs/promises');
+    const data = await fs17.readFile(image);
     return {
       imageBytes: data.toString("base64")
     };
@@ -37017,8 +37237,8 @@ var GrokImagineProvider = class extends BaseMediaProvider {
     if (image.startsWith("http") || image.startsWith("data:")) {
       return image;
     }
-    const fs18 = await import('fs');
-    const data = fs18.readFileSync(image);
+    const fs17 = await import('fs');
+    const data = fs17.readFileSync(image);
     const base64 = data.toString("base64");
     const ext = image.split(".").pop()?.toLowerCase() || "png";
     const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext}`;
@@ -40223,10 +40443,10 @@ function getDefaultBaseDirectory2() {
   if (platform2 === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
     if (appData) {
-      return path3.join(appData, "oneringai", "agents");
+      return path2.join(appData, "oneringai", "agents");
     }
   }
-  return path3.join(os.homedir(), ".oneringai", "agents");
+  return path2.join(os2.homedir(), ".oneringai", "agents");
 }
 function sanitizeId(id) {
   return id.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || "default";
@@ -40243,8 +40463,8 @@ var FileContextStorage = class {
     const sanitizedAgentId = sanitizeId(config.agentId);
     const baseDir = config.baseDirectory ?? getDefaultBaseDirectory2();
     this.prettyPrint = config.prettyPrint ?? true;
-    this.sessionsDirectory = path3.join(baseDir, sanitizedAgentId, "sessions");
-    this.indexPath = path3.join(this.sessionsDirectory, "_index.json");
+    this.sessionsDirectory = path2.join(baseDir, sanitizedAgentId, "sessions");
+    this.indexPath = path2.join(this.sessionsDirectory, "_index.json");
   }
   /**
    * Save context state to a session file
@@ -40270,11 +40490,11 @@ var FileContextStorage = class {
     const data = this.prettyPrint ? JSON.stringify(storedSession, null, 2) : JSON.stringify(storedSession);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs15.promises.writeFile(tempPath, data, "utf-8");
-      await fs15.promises.rename(tempPath, filePath);
+      await fs16.promises.writeFile(tempPath, data, "utf-8");
+      await fs16.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs15.promises.unlink(tempPath);
+        await fs16.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -40295,7 +40515,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      await fs15.promises.unlink(filePath);
+      await fs16.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -40310,7 +40530,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      await fs15.promises.access(filePath);
+      await fs16.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -40375,7 +40595,7 @@ var FileContextStorage = class {
     const sanitizedSessionId = sanitizeId(sessionId);
     const filePath = this.getFilePath(sanitizedSessionId);
     const data = this.prettyPrint ? JSON.stringify(stored, null, 2) : JSON.stringify(stored);
-    await fs15.promises.writeFile(filePath, data, "utf-8");
+    await fs16.promises.writeFile(filePath, data, "utf-8");
     await this.updateIndex(stored);
   }
   /**
@@ -40396,13 +40616,13 @@ var FileContextStorage = class {
    */
   async rebuildIndex() {
     await this.ensureDirectory();
-    const files = await fs15.promises.readdir(this.sessionsDirectory);
+    const files = await fs16.promises.readdir(this.sessionsDirectory);
     const sessionFiles = files.filter((f) => f.endsWith(".json") && !f.startsWith("_"));
     const entries = [];
     for (const file of sessionFiles) {
       try {
-        const filePath = path3.join(this.sessionsDirectory, file);
-        const data = await fs15.promises.readFile(filePath, "utf-8");
+        const filePath = path2.join(this.sessionsDirectory, file);
+        const data = await fs16.promises.readFile(filePath, "utf-8");
         const stored = JSON.parse(data);
         entries.push(this.storedToIndexEntry(stored));
       } catch {
@@ -40420,11 +40640,11 @@ var FileContextStorage = class {
   // Private Helpers
   // ==========================================================================
   getFilePath(sanitizedSessionId) {
-    return path3.join(this.sessionsDirectory, `${sanitizedSessionId}.json`);
+    return path2.join(this.sessionsDirectory, `${sanitizedSessionId}.json`);
   }
   async ensureDirectory() {
     try {
-      await fs15.promises.mkdir(this.sessionsDirectory, { recursive: true });
+      await fs16.promises.mkdir(this.sessionsDirectory, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -40434,7 +40654,7 @@ var FileContextStorage = class {
   async loadRaw(sanitizedSessionId) {
     const filePath = this.getFilePath(sanitizedSessionId);
     try {
-      const data = await fs15.promises.readFile(filePath, "utf-8");
+      const data = await fs16.promises.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -40452,7 +40672,7 @@ var FileContextStorage = class {
       return this.index;
     }
     try {
-      const data = await fs15.promises.readFile(this.indexPath, "utf-8");
+      const data = await fs16.promises.readFile(this.indexPath, "utf-8");
       this.index = JSON.parse(data);
       return this.index;
     } catch (error) {
@@ -40473,7 +40693,7 @@ var FileContextStorage = class {
     await this.ensureDirectory();
     this.index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     const data = this.prettyPrint ? JSON.stringify(this.index, null, 2) : JSON.stringify(this.index);
-    await fs15.promises.writeFile(this.indexPath, data, "utf-8");
+    await fs16.promises.writeFile(this.indexPath, data, "utf-8");
   }
   async updateIndex(stored) {
     const index = await this.loadIndex();
@@ -40511,10 +40731,10 @@ function getDefaultBaseDirectory3() {
   if (platform2 === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
     if (appData) {
-      return path3.join(appData, "oneringai", "agents");
+      return path2.join(appData, "oneringai", "agents");
     }
   }
-  return path3.join(os.homedir(), ".oneringai", "agents");
+  return path2.join(os2.homedir(), ".oneringai", "agents");
 }
 function sanitizeAgentId2(agentId) {
   return agentId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase() || "default";
@@ -40527,15 +40747,15 @@ var FileAgentDefinitionStorage = class {
   constructor(config = {}) {
     this.baseDirectory = config.baseDirectory ?? getDefaultBaseDirectory3();
     this.prettyPrint = config.prettyPrint ?? true;
-    this.indexPath = path3.join(this.baseDirectory, "_agents_index.json");
+    this.indexPath = path2.join(this.baseDirectory, "_agents_index.json");
   }
   /**
    * Save an agent definition
    */
   async save(definition) {
     const sanitizedId = sanitizeAgentId2(definition.agentId);
-    const agentDir = path3.join(this.baseDirectory, sanitizedId);
-    const filePath = path3.join(agentDir, "definition.json");
+    const agentDir = path2.join(this.baseDirectory, sanitizedId);
+    const filePath = path2.join(agentDir, "definition.json");
     await this.ensureDirectory(agentDir);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (!definition.createdAt) {
@@ -40547,11 +40767,11 @@ var FileAgentDefinitionStorage = class {
     const data = this.prettyPrint ? JSON.stringify(definition, null, 2) : JSON.stringify(definition);
     const tempPath = `${filePath}.tmp`;
     try {
-      await fs15.promises.writeFile(tempPath, data, "utf-8");
-      await fs15.promises.rename(tempPath, filePath);
+      await fs16.promises.writeFile(tempPath, data, "utf-8");
+      await fs16.promises.rename(tempPath, filePath);
     } catch (error) {
       try {
-        await fs15.promises.unlink(tempPath);
+        await fs16.promises.unlink(tempPath);
       } catch {
       }
       throw error;
@@ -40570,10 +40790,10 @@ var FileAgentDefinitionStorage = class {
    */
   async delete(agentId) {
     const sanitizedId = sanitizeAgentId2(agentId);
-    const agentDir = path3.join(this.baseDirectory, sanitizedId);
-    const filePath = path3.join(agentDir, "definition.json");
+    const agentDir = path2.join(this.baseDirectory, sanitizedId);
+    const filePath = path2.join(agentDir, "definition.json");
     try {
-      await fs15.promises.unlink(filePath);
+      await fs16.promises.unlink(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
         throw error;
@@ -40586,9 +40806,9 @@ var FileAgentDefinitionStorage = class {
    */
   async exists(agentId) {
     const sanitizedId = sanitizeAgentId2(agentId);
-    const filePath = path3.join(this.baseDirectory, sanitizedId, "definition.json");
+    const filePath = path2.join(this.baseDirectory, sanitizedId, "definition.json");
     try {
-      await fs15.promises.access(filePath);
+      await fs16.promises.access(filePath);
       return true;
     } catch {
       return false;
@@ -40650,13 +40870,13 @@ var FileAgentDefinitionStorage = class {
    */
   async rebuildIndex() {
     await this.ensureDirectory(this.baseDirectory);
-    const entries = await fs15.promises.readdir(this.baseDirectory, { withFileTypes: true });
+    const entries = await fs16.promises.readdir(this.baseDirectory, { withFileTypes: true });
     const agentDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("_"));
     const indexEntries = [];
     for (const dir of agentDirs) {
       try {
-        const filePath = path3.join(this.baseDirectory, dir.name, "definition.json");
-        const data = await fs15.promises.readFile(filePath, "utf-8");
+        const filePath = path2.join(this.baseDirectory, dir.name, "definition.json");
+        const data = await fs16.promises.readFile(filePath, "utf-8");
         const definition = JSON.parse(data);
         indexEntries.push(this.definitionToIndexEntry(definition));
       } catch {
@@ -40674,7 +40894,7 @@ var FileAgentDefinitionStorage = class {
   // ==========================================================================
   async ensureDirectory(dir) {
     try {
-      await fs15.promises.mkdir(dir, { recursive: true });
+      await fs16.promises.mkdir(dir, { recursive: true });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
         throw error;
@@ -40682,9 +40902,9 @@ var FileAgentDefinitionStorage = class {
     }
   }
   async loadRaw(sanitizedId) {
-    const filePath = path3.join(this.baseDirectory, sanitizedId, "definition.json");
+    const filePath = path2.join(this.baseDirectory, sanitizedId, "definition.json");
     try {
-      const data = await fs15.promises.readFile(filePath, "utf-8");
+      const data = await fs16.promises.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -40702,7 +40922,7 @@ var FileAgentDefinitionStorage = class {
       return this.index;
     }
     try {
-      const data = await fs15.promises.readFile(this.indexPath, "utf-8");
+      const data = await fs16.promises.readFile(this.indexPath, "utf-8");
       this.index = JSON.parse(data);
       return this.index;
     } catch (error) {
@@ -40722,7 +40942,7 @@ var FileAgentDefinitionStorage = class {
     await this.ensureDirectory(this.baseDirectory);
     this.index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     const data = this.prettyPrint ? JSON.stringify(this.index, null, 2) : JSON.stringify(this.index);
-    await fs15.promises.writeFile(this.indexPath, data, "utf-8");
+    await fs16.promises.writeFile(this.indexPath, data, "utf-8");
   }
   async updateIndex(definition) {
     const index = await this.loadIndex();
@@ -40755,6 +40975,126 @@ var FileAgentDefinitionStorage = class {
 function createFileAgentDefinitionStorage(config) {
   return new FileAgentDefinitionStorage(config);
 }
+var MIME_TYPES = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  opus: "audio/opus",
+  ogg: "audio/ogg",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  pcm: "audio/pcm"
+};
+var MEDIA_TYPE_PREFIXES = ["image", "video", "audio"];
+var FileMediaStorage = class {
+  outputDir;
+  initialized = false;
+  constructor(config) {
+    this.outputDir = config?.outputDir ?? path2__namespace.join(os2__namespace.tmpdir(), "oneringai-media");
+  }
+  async save(data, metadata) {
+    const dir = metadata.userId ? path2__namespace.join(this.outputDir, metadata.userId) : this.outputDir;
+    await fs15__namespace.mkdir(dir, { recursive: true });
+    const filename = metadata.suggestedFilename ?? this.generateFilename(metadata);
+    const filePath = path2__namespace.join(dir, filename);
+    await fs15__namespace.writeFile(filePath, data);
+    const format = metadata.format.toLowerCase();
+    const mimeType = MIME_TYPES[format] ?? "application/octet-stream";
+    return {
+      location: filePath,
+      mimeType,
+      size: data.length
+    };
+  }
+  async read(location) {
+    try {
+      return await fs15__namespace.readFile(location);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async delete(location) {
+    try {
+      await fs15__namespace.unlink(location);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return;
+      }
+      throw err;
+    }
+  }
+  async exists(location) {
+    try {
+      await fs15__namespace.access(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list(options) {
+    await this.ensureDir();
+    let entries = [];
+    const files = await fs15__namespace.readdir(this.outputDir);
+    for (const file of files) {
+      const filePath = path2__namespace.join(this.outputDir, file);
+      try {
+        const stat6 = await fs15__namespace.stat(filePath);
+        if (!stat6.isFile()) continue;
+        const ext = path2__namespace.extname(file).slice(1).toLowerCase();
+        const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+        let type;
+        for (const prefix of MEDIA_TYPE_PREFIXES) {
+          if (file.startsWith(`${prefix}_`)) {
+            type = prefix;
+            break;
+          }
+        }
+        entries.push({
+          location: filePath,
+          mimeType,
+          size: stat6.size,
+          type,
+          createdAt: stat6.birthtime
+        });
+      } catch {
+      }
+    }
+    if (options?.type) {
+      entries = entries.filter((e) => e.type === options.type);
+    }
+    entries.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? entries.length;
+    return entries.slice(offset, offset + limit);
+  }
+  getPath() {
+    return this.outputDir;
+  }
+  generateFilename(metadata) {
+    const timestamp = Date.now();
+    const random2 = crypto2__namespace.randomBytes(4).toString("hex");
+    const indexSuffix = metadata.index != null ? `_${metadata.index}` : "";
+    return `${metadata.type}_${timestamp}_${random2}${indexSuffix}.${metadata.format}`;
+  }
+  async ensureDir() {
+    if (!this.initialized) {
+      await fs15__namespace.mkdir(this.outputDir, { recursive: true });
+      this.initialized = true;
+    }
+  }
+};
+function createFileMediaStorage(config) {
+  return new FileMediaStorage(config);
+}
 
 // src/capabilities/agents/StreamHelpers.ts
 var StreamHelpers = class {
@@ -41677,7 +42017,7 @@ var ConnectorTools = class {
   static createGenericAPITool(connector, options) {
     const toolName = options?.toolName ?? `${connector.name}_api`;
     const userId = options?.userId;
-    const description = options?.description ?? `Make an authenticated API call to ${connector.displayName}.` + (connector.baseURL ? ` Base URL: ${connector.baseURL}` : " Provide full URL in endpoint.");
+    const description = options?.description ?? `Make an authenticated API call to ${connector.displayName}.` + (connector.baseURL ? ` Base URL: ${connector.baseURL}.` : " Provide full URL in endpoint.") + ' IMPORTANT: For POST/PUT/PATCH requests, pass data in the "body" parameter as a JSON object, NOT as query string parameters in the endpoint URL. The body is sent as application/json.';
     return {
       definition: {
         type: "function",
@@ -41694,15 +42034,15 @@ var ConnectorTools = class {
               },
               endpoint: {
                 type: "string",
-                description: "API endpoint (relative to base URL) or full URL"
+                description: 'API endpoint path (relative to base URL) or full URL. Do NOT put request data as query parameters here for POST/PUT/PATCH \u2014 use the "body" parameter instead.'
               },
               body: {
                 type: "object",
-                description: "Request body (for POST/PUT/PATCH)"
+                description: 'JSON request body for POST/PUT/PATCH requests. ALWAYS use this for sending data (e.g., {"channel": "C123", "text": "hello"}) instead of query string parameters.'
               },
               queryParams: {
                 type: "object",
-                description: "URL query parameters"
+                description: 'URL query parameters (for filtering/pagination on GET requests). Do NOT use for POST/PUT/PATCH data \u2014 use "body" instead.'
               },
               headers: {
                 type: "object",
@@ -41767,7 +42107,10 @@ var ConnectorTools = class {
           };
         }
       },
-      describeCall: (args) => `${args.method} ${args.endpoint}`,
+      describeCall: (args) => {
+        const bodyInfo = args.body ? ` body=${JSON.stringify(args.body).slice(0, 100)}` : "";
+        return `${args.method} ${args.endpoint}${bodyInfo}`;
+      },
       permission: options?.permission ?? {
         scope: "session",
         riskLevel: "medium",
@@ -41802,8 +42145,8 @@ var FileStorage = class {
   }
   async ensureDirectory() {
     try {
-      await fs14__namespace.mkdir(this.directory, { recursive: true });
-      await fs14__namespace.chmod(this.directory, 448);
+      await fs15__namespace.mkdir(this.directory, { recursive: true });
+      await fs15__namespace.chmod(this.directory, 448);
     } catch (error) {
     }
   }
@@ -41812,20 +42155,20 @@ var FileStorage = class {
    */
   getFilePath(key) {
     const hash = crypto2__namespace.createHash("sha256").update(key).digest("hex");
-    return path3__namespace.join(this.directory, `${hash}.token`);
+    return path2__namespace.join(this.directory, `${hash}.token`);
   }
   async storeToken(key, token) {
     await this.ensureDirectory();
     const filePath = this.getFilePath(key);
     const plaintext = JSON.stringify(token);
     const encrypted = encrypt(plaintext, this.encryptionKey);
-    await fs14__namespace.writeFile(filePath, encrypted, "utf8");
-    await fs14__namespace.chmod(filePath, 384);
+    await fs15__namespace.writeFile(filePath, encrypted, "utf8");
+    await fs15__namespace.chmod(filePath, 384);
   }
   async getToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      const encrypted = await fs14__namespace.readFile(filePath, "utf8");
+      const encrypted = await fs15__namespace.readFile(filePath, "utf8");
       const decrypted = decrypt(encrypted, this.encryptionKey);
       return JSON.parse(decrypted);
     } catch (error) {
@@ -41834,7 +42177,7 @@ var FileStorage = class {
       }
       console.error("Failed to read/decrypt token file:", error);
       try {
-        await fs14__namespace.unlink(filePath);
+        await fs15__namespace.unlink(filePath);
       } catch {
       }
       return null;
@@ -41843,7 +42186,7 @@ var FileStorage = class {
   async deleteToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs14__namespace.unlink(filePath);
+      await fs15__namespace.unlink(filePath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -41853,7 +42196,7 @@ var FileStorage = class {
   async hasToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs14__namespace.access(filePath);
+      await fs15__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -41864,7 +42207,7 @@ var FileStorage = class {
    */
   async listTokens() {
     try {
-      const files = await fs14__namespace.readdir(this.directory);
+      const files = await fs15__namespace.readdir(this.directory);
       return files.filter((f) => f.endsWith(".token")).map((f) => f.replace(".token", ""));
     } catch {
       return [];
@@ -41875,10 +42218,10 @@ var FileStorage = class {
    */
   async clearAll() {
     try {
-      const files = await fs14__namespace.readdir(this.directory);
+      const files = await fs15__namespace.readdir(this.directory);
       const tokenFiles = files.filter((f) => f.endsWith(".token"));
       await Promise.all(
-        tokenFiles.map((f) => fs14__namespace.unlink(path3__namespace.join(this.directory, f)).catch(() => {
+        tokenFiles.map((f) => fs15__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
         }))
       );
     } catch {
@@ -42146,22 +42489,26 @@ var ConnectorConfigStore = class {
    * Encrypt secrets in ConnectorAuth based on auth type
    */
   encryptAuthSecrets(auth2) {
+    const encryptedExtra = this.encryptExtra(auth2.extra);
     switch (auth2.type) {
       case "api_key":
         return {
           ...auth2,
-          apiKey: this.encryptValue(auth2.apiKey)
+          apiKey: this.encryptValue(auth2.apiKey),
+          ...encryptedExtra ? { extra: encryptedExtra } : {}
         };
       case "oauth":
         return {
           ...auth2,
           clientSecret: auth2.clientSecret ? this.encryptValue(auth2.clientSecret) : void 0,
-          privateKey: auth2.privateKey ? this.encryptValue(auth2.privateKey) : void 0
+          privateKey: auth2.privateKey ? this.encryptValue(auth2.privateKey) : void 0,
+          ...encryptedExtra ? { extra: encryptedExtra } : {}
         };
       case "jwt":
         return {
           ...auth2,
-          privateKey: this.encryptValue(auth2.privateKey)
+          privateKey: this.encryptValue(auth2.privateKey),
+          ...encryptedExtra ? { extra: encryptedExtra } : {}
         };
       default:
         return auth2;
@@ -42171,27 +42518,53 @@ var ConnectorConfigStore = class {
    * Decrypt secrets in ConnectorAuth based on auth type
    */
   decryptAuthSecrets(auth2) {
+    const decryptedExtra = this.decryptExtra(auth2.extra);
     switch (auth2.type) {
       case "api_key":
         return {
           ...auth2,
-          apiKey: this.decryptValue(auth2.apiKey)
+          apiKey: this.decryptValue(auth2.apiKey),
+          ...decryptedExtra ? { extra: decryptedExtra } : {}
         };
       case "oauth":
         return {
           ...auth2,
           clientSecret: auth2.clientSecret ? this.decryptValue(auth2.clientSecret) : void 0,
-          privateKey: auth2.privateKey ? this.decryptValue(auth2.privateKey) : void 0
+          privateKey: auth2.privateKey ? this.decryptValue(auth2.privateKey) : void 0,
+          ...decryptedExtra ? { extra: decryptedExtra } : {}
         };
       case "jwt":
         return {
           ...auth2,
-          privateKey: this.decryptValue(auth2.privateKey)
+          privateKey: this.decryptValue(auth2.privateKey),
+          ...decryptedExtra ? { extra: decryptedExtra } : {}
         };
       default:
         return auth2;
     }
   }
+  /**
+   * Encrypt all values in an extra Record (vendor-specific credentials)
+   */
+  encryptExtra(extra) {
+    if (!extra || Object.keys(extra).length === 0) return void 0;
+    const result = {};
+    for (const [key, value] of Object.entries(extra)) {
+      result[key] = this.encryptValue(value);
+    }
+    return result;
+  }
+  /**
+   * Decrypt all values in an extra Record (vendor-specific credentials)
+   */
+  decryptExtra(extra) {
+    if (!extra || Object.keys(extra).length === 0) return void 0;
+    const result = {};
+    for (const [key, value] of Object.entries(extra)) {
+      result[key] = this.decryptValue(value);
+    }
+    return result;
+  }
   /**
    * Encrypt a single value if not already encrypted
    */
@@ -42269,20 +42642,20 @@ var FileConnectorStorage = class {
       throw new Error("FileConnectorStorage requires a directory path");
     }
     this.directory = config.directory;
-    this.indexPath = path3__namespace.join(this.directory, "_index.json");
+    this.indexPath = path2__namespace.join(this.directory, "_index.json");
   }
   async save(name, stored) {
     await this.ensureDirectory();
     const filePath = this.getFilePath(name);
     const json = JSON.stringify(stored, null, 2);
-    await fs14__namespace.writeFile(filePath, json, "utf8");
-    await fs14__namespace.chmod(filePath, 384);
+    await fs15__namespace.writeFile(filePath, json, "utf8");
+    await fs15__namespace.chmod(filePath, 384);
     await this.updateIndex(name, "add");
   }
   async get(name) {
     const filePath = this.getFilePath(name);
     try {
-      const json = await fs14__namespace.readFile(filePath, "utf8");
+      const json = await fs15__namespace.readFile(filePath, "utf8");
       return JSON.parse(json);
     } catch (error) {
       const err = error;
@@ -42295,7 +42668,7 @@ var FileConnectorStorage = class {
   async delete(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs14__namespace.unlink(filePath);
+      await fs15__namespace.unlink(filePath);
       await this.updateIndex(name, "remove");
       return true;
     } catch (error) {
@@ -42309,7 +42682,7 @@ var FileConnectorStorage = class {
   async has(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs14__namespace.access(filePath);
+      await fs15__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -42335,13 +42708,13 @@ var FileConnectorStorage = class {
    */
   async clear() {
     try {
-      const files = await fs14__namespace.readdir(this.directory);
+      const files = await fs15__namespace.readdir(this.directory);
       const connectorFiles = files.filter(
         (f) => f.endsWith(".connector.json") || f === "_index.json"
       );
       await Promise.all(
         connectorFiles.map(
-          (f) => fs14__namespace.unlink(path3__namespace.join(this.directory, f)).catch(() => {
+          (f) => fs15__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
           })
         )
       );
@@ -42354,7 +42727,7 @@ var FileConnectorStorage = class {
    */
   getFilePath(name) {
     const hash = this.hashName(name);
-    return path3__namespace.join(this.directory, `${hash}.connector.json`);
+    return path2__namespace.join(this.directory, `${hash}.connector.json`);
   }
   /**
    * Hash connector name to prevent enumeration
@@ -42368,8 +42741,8 @@ var FileConnectorStorage = class {
   async ensureDirectory() {
     if (this.initialized) return;
     try {
-      await fs14__namespace.mkdir(this.directory, { recursive: true });
-      await fs14__namespace.chmod(this.directory, 448);
+      await fs15__namespace.mkdir(this.directory, { recursive: true });
+      await fs15__namespace.chmod(this.directory, 448);
       this.initialized = true;
     } catch {
       this.initialized = true;
@@ -42380,7 +42753,7 @@ var FileConnectorStorage = class {
    */
   async loadIndex() {
     try {
-      const json = await fs14__namespace.readFile(this.indexPath, "utf8");
+      const json = await fs15__namespace.readFile(this.indexPath, "utf8");
       return JSON.parse(json);
     } catch {
       return { connectors: {} };
@@ -42398,8 +42771,8 @@ var FileConnectorStorage = class {
       delete index.connectors[hash];
     }
     const json = JSON.stringify(index, null, 2);
-    await fs14__namespace.writeFile(this.indexPath, json, "utf8");
-    await fs14__namespace.chmod(this.indexPath, 384);
+    await fs15__namespace.writeFile(this.indexPath, json, "utf8");
+    await fs15__namespace.chmod(this.indexPath, 384);
   }
 };
 
@@ -42444,11 +42817,19 @@ function buildAuthConfig(authTemplate, credentials) {
     if (!credentials.apiKey) {
       throw new Error("API key is required for api_key auth");
     }
+    const standardApiKeyFields = /* @__PURE__ */ new Set(["apiKey", "headerName", "headerPrefix"]);
+    const extra = {};
+    for (const field of authTemplate.optionalFields ?? []) {
+      if (!standardApiKeyFields.has(field) && credentials[field]) {
+        extra[field] = credentials[field];
+      }
+    }
     return {
       type: "api_key",
       apiKey: credentials.apiKey,
       headerName: defaults.headerName ?? "Authorization",
-      headerPrefix: defaults.headerPrefix ?? "Bearer"
+      headerPrefix: defaults.headerPrefix ?? "Bearer",
+      ...Object.keys(extra).length > 0 ? { extra } : {}
     };
   }
   if (!authTemplate.flow) {
@@ -42718,8 +43099,9 @@ var slackTemplate = {
       id: "bot-token",
       name: "Bot Token",
       type: "api_key",
-      description: "Internal workspace bot - get from OAuth & Permissions page of your Slack app",
+      description: "Internal workspace bot - get from OAuth & Permissions page of your Slack app. For Socket Mode bots, also provide appToken and signingSecret in extra fields.",
       requiredFields: ["apiKey"],
+      optionalFields: ["appToken", "signingSecret"],
       defaults: {
         type: "api_key",
         headerName: "Authorization",
@@ -44557,14 +44939,14 @@ function createMessageWithImages(text, imageUrls, role = "user" /* USER */) {
 var execAsync = util.promisify(child_process.exec);
 function cleanupTempFile(filePath) {
   try {
-    if (fs15__namespace.existsSync(filePath)) {
-      fs15__namespace.unlinkSync(filePath);
+    if (fs16__namespace.existsSync(filePath)) {
+      fs16__namespace.unlinkSync(filePath);
     }
   } catch {
   }
 }
 async function readClipboardImage() {
-  const platform2 = os__namespace.platform();
+  const platform2 = os2__namespace.platform();
   try {
     switch (platform2) {
       case "darwin":
@@ -44587,7 +44969,7 @@ async function readClipboardImage() {
   }
 }
 async function readClipboardImageMac() {
-  const tempFile = path3__namespace.join(os__namespace.tmpdir(), `clipboard-${Date.now()}.png`);
+  const tempFile = path2__namespace.join(os2__namespace.tmpdir(), `clipboard-${Date.now()}.png`);
   try {
     try {
       await execAsync(`pngpaste "${tempFile}"`);
@@ -44609,7 +44991,7 @@ async function readClipboardImageMac() {
         end try
       `;
       const { stdout } = await execAsync(`osascript -e '${script}'`);
-      if (stdout.includes("success") || fs15__namespace.existsSync(tempFile)) {
+      if (stdout.includes("success") || fs16__namespace.existsSync(tempFile)) {
         return await convertFileToDataUri(tempFile);
       }
       return {
@@ -44622,18 +45004,18 @@ async function readClipboardImageMac() {
   }
 }
 async function readClipboardImageLinux() {
-  const tempFile = path3__namespace.join(os__namespace.tmpdir(), `clipboard-${Date.now()}.png`);
+  const tempFile = path2__namespace.join(os2__namespace.tmpdir(), `clipboard-${Date.now()}.png`);
   try {
     try {
       await execAsync(`xclip -selection clipboard -t image/png -o > "${tempFile}"`);
-      if (fs15__namespace.existsSync(tempFile) && fs15__namespace.statSync(tempFile).size > 0) {
+      if (fs16__namespace.existsSync(tempFile) && fs16__namespace.statSync(tempFile).size > 0) {
         return await convertFileToDataUri(tempFile);
       }
     } catch {
     }
     try {
       await execAsync(`wl-paste -t image/png > "${tempFile}"`);
-      if (fs15__namespace.existsSync(tempFile) && fs15__namespace.statSync(tempFile).size > 0) {
+      if (fs16__namespace.existsSync(tempFile) && fs16__namespace.statSync(tempFile).size > 0) {
         return await convertFileToDataUri(tempFile);
       }
     } catch {
@@ -44647,7 +45029,7 @@ async function readClipboardImageLinux() {
   }
 }
 async function readClipboardImageWindows() {
-  const tempFile = path3__namespace.join(os__namespace.tmpdir(), `clipboard-${Date.now()}.png`);
+  const tempFile = path2__namespace.join(os2__namespace.tmpdir(), `clipboard-${Date.now()}.png`);
   try {
     const psScript = `
       Add-Type -AssemblyName System.Windows.Forms;
@@ -44660,7 +45042,7 @@ async function readClipboardImageWindows() {
       }
     `;
     await execAsync(`powershell -Command "${psScript}"`);
-    if (fs15__namespace.existsSync(tempFile) && fs15__namespace.statSync(tempFile).size > 0) {
+    if (fs16__namespace.existsSync(tempFile) && fs16__namespace.statSync(tempFile).size > 0) {
       return await convertFileToDataUri(tempFile);
     }
     return {
@@ -44673,7 +45055,7 @@ async function readClipboardImageWindows() {
 }
 async function convertFileToDataUri(filePath) {
   try {
-    const imageBuffer = fs15__namespace.readFileSync(filePath);
+    const imageBuffer = fs16__namespace.readFileSync(filePath);
     const base64Image = imageBuffer.toString("base64");
     const magic = imageBuffer.slice(0, 4).toString("hex");
     let mimeType = "image/png";
@@ -44700,7 +45082,7 @@ async function convertFileToDataUri(filePath) {
   }
 }
 async function hasClipboardImage() {
-  const platform2 = os__namespace.platform();
+  const platform2 = os2__namespace.platform();
   try {
     switch (platform2) {
       case "darwin":
@@ -44918,17 +45300,24 @@ __export(tools_exports, {
   ConnectorTools: () => ConnectorTools,
   DEFAULT_FILESYSTEM_CONFIG: () => DEFAULT_FILESYSTEM_CONFIG,
   DEFAULT_SHELL_CONFIG: () => DEFAULT_SHELL_CONFIG,
-  FileMediaOutputHandler: () => FileMediaOutputHandler,
+  FileMediaOutputHandler: () => FileMediaStorage,
   ToolRegistry: () => ToolRegistry,
   bash: () => bash,
   createBashTool: () => createBashTool,
+  createCreatePRTool: () => createCreatePRTool,
   createEditFileTool: () => createEditFileTool,
   createExecuteJavaScriptTool: () => createExecuteJavaScriptTool,
+  createGetPRTool: () => createGetPRTool,
+  createGitHubReadFileTool: () => createGitHubReadFileTool,
   createGlobTool: () => createGlobTool,
   createGrepTool: () => createGrepTool,
   createImageGenerationTool: () => createImageGenerationTool,
   createListDirectoryTool: () => createListDirectoryTool,
+  createPRCommentsTool: () => createPRCommentsTool,
+  createPRFilesTool: () => createPRFilesTool,
   createReadFileTool: () => createReadFileTool,
+  createSearchCodeTool: () => createSearchCodeTool,
+  createSearchFilesTool: () => createSearchFilesTool,
   createSpeechToTextTool: () => createSpeechToTextTool,
   createTextToSpeechTool: () => createTextToSpeechTool,
   createVideoTools: () => createVideoTools,
@@ -44940,6 +45329,7 @@ __export(tools_exports, {
   getAllBuiltInTools: () => getAllBuiltInTools,
   getBackgroundOutput: () => getBackgroundOutput,
   getMediaOutputHandler: () => getMediaOutputHandler,
+  getMediaStorage: () => getMediaStorage,
   getToolByName: () => getToolByName,
   getToolCategories: () => getToolCategories,
   getToolRegistry: () => getToolRegistry,
@@ -44952,15 +45342,18 @@ __export(tools_exports, {
   jsonManipulator: () => jsonManipulator,
   killBackgroundProcess: () => killBackgroundProcess,
   listDirectory: () => listDirectory,
-  readFile: () => readFile4,
+  parseRepository: () => parseRepository,
+  readFile: () => readFile5,
+  resolveRepository: () => resolveRepository,
   setMediaOutputHandler: () => setMediaOutputHandler,
+  setMediaStorage: () => setMediaStorage,
   toolRegistry: () => toolRegistry,
   validatePath: () => validatePath,
   webFetch: () => webFetch,
   webFetchJS: () => webFetchJS,
   webScrape: () => webScrape,
   webSearch: () => webSearch,
-  writeFile: () => writeFile4
+  writeFile: () => writeFile5
 });
 var DEFAULT_FILESYSTEM_CONFIG = {
   workingDirectory: process.cwd(),
@@ -45019,15 +45412,15 @@ function validatePath(inputPath, config = {}) {
   const blockedDirs = config.blockedDirectories || DEFAULT_FILESYSTEM_CONFIG.blockedDirectories;
   let expandedPath = inputPath;
   if (inputPath.startsWith("~/")) {
-    expandedPath = path3.resolve(os.homedir(), inputPath.slice(2));
+    expandedPath = path2.resolve(os2.homedir(), inputPath.slice(2));
   } else if (inputPath === "~") {
-    expandedPath = os.homedir();
+    expandedPath = os2.homedir();
   }
   let resolvedPath;
-  if (path3.isAbsolute(expandedPath)) {
-    resolvedPath = path3.normalize(expandedPath);
+  if (path2.isAbsolute(expandedPath)) {
+    resolvedPath = path2.normalize(expandedPath);
   } else {
-    resolvedPath = path3.resolve(workingDir, expandedPath);
+    resolvedPath = path2.resolve(workingDir, expandedPath);
   }
   const pathSegments = resolvedPath.split("/").filter(Boolean);
   for (const blocked of blockedDirs) {
@@ -45040,7 +45433,7 @@ function validatePath(inputPath, config = {}) {
         };
       }
     } else {
-      const blockedPath = path3.isAbsolute(blocked) ? blocked : path3.resolve(workingDir, blocked);
+      const blockedPath = path2.isAbsolute(blocked) ? blocked : path2.resolve(workingDir, blocked);
       if (resolvedPath.startsWith(blockedPath + "/") || resolvedPath === blockedPath) {
         return {
           valid: false,
@@ -45053,7 +45446,7 @@ function validatePath(inputPath, config = {}) {
   if (allowedDirs.length > 0) {
     let isAllowed = false;
     for (const allowed of allowedDirs) {
-      const allowedPath = path3.isAbsolute(allowed) ? allowed : path3.resolve(workingDir, allowed);
+      const allowedPath = path2.isAbsolute(allowed) ? allowed : path2.resolve(workingDir, allowed);
       if (resolvedPath.startsWith(allowedPath + "/") || resolvedPath === allowedPath) {
         isAllowed = true;
         break;
@@ -45071,9 +45464,9 @@ function validatePath(inputPath, config = {}) {
 }
 function expandTilde(inputPath) {
   if (inputPath.startsWith("~/")) {
-    return path3.resolve(os.homedir(), inputPath.slice(2));
+    return path2.resolve(os2.homedir(), inputPath.slice(2));
   } else if (inputPath === "~") {
-    return os.homedir();
+    return os2.homedir();
   }
   return inputPath;
 }
@@ -45148,7 +45541,7 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs16.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${file_path}`,
@@ -45156,7 +45549,7 @@ EXAMPLES:
         };
       }
       try {
-        const stats = await fs14.stat(resolvedPath);
+        const stats = await fs15.stat(resolvedPath);
         if (!stats.isFile()) {
           return {
             success: false,
@@ -45172,7 +45565,7 @@ EXAMPLES:
             size: stats.size
           };
         }
-        const content = await fs14.readFile(resolvedPath, "utf-8");
+        const content = await fs15.readFile(resolvedPath, "utf-8");
         const allLines = content.split("\n");
         const totalLines = allLines.length;
         const startIndex = Math.max(0, offset - 1);
@@ -45213,7 +45606,7 @@ EXAMPLES:
     }
   };
 }
-var readFile4 = createReadFileTool();
+var readFile5 = createReadFileTool();
 function createWriteFileTool(config = {}) {
   const mergedConfig = { ...DEFAULT_FILESYSTEM_CONFIG, ...config };
   return {
@@ -45277,13 +45670,13 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      const fileExists = fs15.existsSync(resolvedPath);
+      const fileExists = fs16.existsSync(resolvedPath);
       try {
-        const parentDir = path3.dirname(resolvedPath);
-        if (!fs15.existsSync(parentDir)) {
-          await fs14.mkdir(parentDir, { recursive: true });
+        const parentDir = path2.dirname(resolvedPath);
+        if (!fs16.existsSync(parentDir)) {
+          await fs15.mkdir(parentDir, { recursive: true });
         }
-        await fs14.writeFile(resolvedPath, content, "utf-8");
+        await fs15.writeFile(resolvedPath, content, "utf-8");
         return {
           success: true,
           path: file_path,
@@ -45300,7 +45693,7 @@ EXAMPLES:
     }
   };
 }
-var writeFile4 = createWriteFileTool();
+var writeFile5 = createWriteFileTool();
 function createEditFileTool(config = {}) {
   const mergedConfig = { ...DEFAULT_FILESYSTEM_CONFIG, ...config };
   return {
@@ -45386,7 +45779,7 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs16.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${file_path}`,
@@ -45394,7 +45787,7 @@ EXAMPLES:
         };
       }
       try {
-        const content = await fs14.readFile(resolvedPath, "utf-8");
+        const content = await fs15.readFile(resolvedPath, "utf-8");
         let occurrences = 0;
         let searchIndex = 0;
         while (true) {
@@ -45433,7 +45826,7 @@ EXAMPLES:
         } else {
           newContent = content.replace(old_string, new_string);
         }
-        await fs14.writeFile(resolvedPath, newContent, "utf-8");
+        await fs15.writeFile(resolvedPath, newContent, "utf-8");
         const diffPreview = generateDiffPreview(old_string, new_string);
         return {
           success: true,
@@ -45489,11 +45882,11 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
     return results;
   }
   try {
-    const entries = await fs14.readdir(dir, { withFileTypes: true });
+    const entries = await fs15.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= config.maxResults) break;
-      const fullPath = path3.join(dir, entry.name);
-      const relativePath = path3.relative(baseDir, fullPath);
+      const fullPath = path2.join(dir, entry.name);
+      const relativePath = path2.relative(baseDir, fullPath);
       if (entry.isDirectory()) {
         const isBlocked = config.blockedDirectories.some(
           (blocked) => entry.name === blocked || relativePath.includes(`/${blocked}/`) || relativePath.startsWith(`${blocked}/`)
@@ -45503,7 +45896,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
       } else if (entry.isFile()) {
         if (matchGlobPattern(pattern, relativePath)) {
           try {
-            const stats = await fs14.stat(fullPath);
+            const stats = await fs15.stat(fullPath);
             results.push({
               path: relativePath,
               mtime: stats.mtimeMs
@@ -45585,7 +45978,7 @@ WHEN TO USE:
         };
       }
       const resolvedDir = validation.resolvedPath;
-      if (!fs15.existsSync(resolvedDir)) {
+      if (!fs16.existsSync(resolvedDir)) {
         return {
           success: false,
           error: `Directory not found: ${searchDir}`
@@ -45640,9 +46033,9 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
     return files;
   }
   try {
-    const entries = await fs14.readdir(dir, { withFileTypes: true });
+    const entries = await fs15.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
         const isBlocked = config.blockedDirectories.some(
           (blocked) => entry.name === blocked
@@ -45654,7 +46047,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
         if (fileType) {
           const extensions = FILE_TYPE_MAP[fileType.toLowerCase()];
           if (extensions) {
-            const ext = path3.extname(entry.name).toLowerCase();
+            const ext = path2.extname(entry.name).toLowerCase();
             if (!extensions.includes(ext)) continue;
           }
         }
@@ -45673,7 +46066,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
 async function searchFile(filePath, regex, contextBefore, contextAfter) {
   const matches = [];
   try {
-    const content = await fs14.readFile(filePath, "utf-8");
+    const content = await fs15.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] ?? "";
@@ -45814,7 +46207,7 @@ WHEN TO USE:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs16.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `Path not found: ${searchPath}`
@@ -45830,7 +46223,7 @@ WHEN TO USE:
         };
       }
       try {
-        const stats = await fs14.stat(resolvedPath);
+        const stats = await fs15.stat(resolvedPath);
         let filesToSearch;
         if (stats.isFile()) {
           filesToSearch = [resolvedPath];
@@ -45856,7 +46249,7 @@ WHEN TO USE:
           );
           if (matches.length > 0) {
             filesMatched++;
-            const relativePath = path3.relative(resolvedPath, file) || file;
+            const relativePath = path2.relative(resolvedPath, file) || file;
             for (const match of matches) {
               match.file = relativePath;
             }
@@ -45918,11 +46311,11 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
     return entries;
   }
   try {
-    const dirEntries = await fs14.readdir(dir, { withFileTypes: true });
+    const dirEntries = await fs15.readdir(dir, { withFileTypes: true });
     for (const entry of dirEntries) {
       if (entries.length >= config.maxResults) break;
-      const fullPath = path3.join(dir, entry.name);
-      const relativePath = path3.relative(baseDir, fullPath);
+      const fullPath = path2.join(dir, entry.name);
+      const relativePath = path2.relative(baseDir, fullPath);
       if (entry.isDirectory() && config.blockedDirectories.includes(entry.name)) {
         continue;
       }
@@ -45936,7 +46329,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
       }
       if (filter === "directories" && !isDir) continue;
       try {
-        const stats = await fs14.stat(fullPath);
+        const stats = await fs15.stat(fullPath);
         const dirEntry = {
           name: entry.name,
           path: relativePath,
@@ -46032,14 +46425,14 @@ EXAMPLES:
         };
       }
       const resolvedPath = validation.resolvedPath;
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs16.existsSync(resolvedPath)) {
         return {
           success: false,
           error: `Directory not found: ${path6}`
         };
       }
       try {
-        const stats = await fs14.stat(resolvedPath);
+        const stats = await fs15.stat(resolvedPath);
         if (!stats.isDirectory()) {
           return {
             success: false,
@@ -46227,7 +46620,8 @@ EXAMPLES:
           shell: mergedConfig.shell,
           cwd: mergedConfig.workingDirectory,
           env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: true
         });
         if (run_in_background && mergedConfig.allowBackground) {
           const bgId = generateBackgroundId();
@@ -46254,14 +46648,27 @@ EXAMPLES:
         let stdout = "";
         let stderr = "";
         let killed = false;
+        const killProcessGroup = (signal) => {
+          try {
+            if (childProcess.pid) {
+              process.kill(-childProcess.pid, signal);
+            }
+          } catch {
+            try {
+              childProcess.kill(signal);
+            } catch {
+            }
+          }
+        };
+        const GRACEFUL_KILL_WAIT_MS = 3e3;
         const timeoutId = setTimeout(() => {
           killed = true;
-          childProcess.kill("SIGTERM");
+          killProcessGroup("SIGTERM");
           setTimeout(() => {
             if (!childProcess.killed) {
-              childProcess.kill("SIGKILL");
+              killProcessGroup("SIGKILL");
             }
-          }, 5e3);
+          }, GRACEFUL_KILL_WAIT_MS);
         }, effectiveTimeout);
         childProcess.stdout.on("data", (data) => {
           stdout += data.toString();
@@ -46275,8 +46682,28 @@ EXAMPLES:
             stderr = stderr.slice(-mergedConfig.maxOutputSize);
           }
         });
-        childProcess.on("close", (code, signal) => {
+        let resolved = false;
+        const safeResolve = (result) => {
+          if (resolved) return;
+          resolved = true;
           clearTimeout(timeoutId);
+          clearTimeout(hardTimeoutId);
+          resolve4(result);
+        };
+        const HARD_TIMEOUT_GRACE_MS = 5e3;
+        const hardTimeoutId = setTimeout(() => {
+          if (!resolved) {
+            killProcessGroup("SIGKILL");
+            safeResolve({
+              success: false,
+              stdout,
+              stderr,
+              duration: Date.now() - startTime,
+              error: `Command timed out after ${effectiveTimeout}ms (hard timeout: process group did not exit)`
+            });
+          }
+        }, effectiveTimeout + GRACEFUL_KILL_WAIT_MS + HARD_TIMEOUT_GRACE_MS);
+        childProcess.on("close", (code, signal) => {
           const duration = Date.now() - startTime;
           let truncated = false;
           if (stdout.length > mergedConfig.maxOutputSize) {
@@ -46288,7 +46715,7 @@ EXAMPLES:
             truncated = true;
           }
           if (killed) {
-            resolve4({
+            safeResolve({
               success: false,
               stdout,
               stderr,
@@ -46299,7 +46726,7 @@ EXAMPLES:
               error: `Command timed out after ${effectiveTimeout}ms`
             });
           } else {
-            resolve4({
+            safeResolve({
               success: code === 0,
               stdout,
               stderr,
@@ -46312,8 +46739,7 @@ EXAMPLES:
           }
         });
         childProcess.on("error", (error) => {
-          clearTimeout(timeoutId);
-          resolve4({
+          safeResolve({
             success: false,
             error: `Failed to execute command: ${error.message}`,
             duration: Date.now() - startTime
@@ -47579,8 +48005,8 @@ async function tryNative(args, startTime, attemptedMethods) {
       method: "native",
       title: result.title,
       content: cleanContent,
-      // Note: raw HTML not available with native method (returns markdown instead)
-      markdown: args.includeMarkdown ? cleanContent : void 0,
+      // Native method already returns markdown-like content — no separate markdown field needed
+      // (would just duplicate content and waste tokens)
       qualityScore: result.qualityScore,
       durationMs: Date.now() - startTime,
       attemptedMethods,
@@ -47616,8 +48042,7 @@ async function tryJS(args, startTime, attemptedMethods) {
       method: "js",
       title: result.title,
       content: cleanContent,
-      // Note: raw HTML not available with JS method (returns markdown instead)
-      markdown: args.includeMarkdown ? cleanContent : void 0,
+      // JS method already returns markdown-like content — no separate markdown field needed
       qualityScore: result.success ? 80 : 0,
       durationMs: Date.now() - startTime,
       attemptedMethods,
@@ -47649,8 +48074,11 @@ async function tryAPI(connectorName, args, startTime, attemptedMethods) {
       includeLinks: args.includeLinks
     };
     const result = await provider.scrape(args.url, options);
-    const cleanContent = stripBase64DataUris(result.result?.content || "");
-    const cleanMarkdown = result.result?.markdown ? stripBase64DataUris(result.result.markdown) : void 0;
+    const rawContent = result.result?.content || "";
+    const rawMarkdown = result.result?.markdown;
+    const cleanContent = stripBase64DataUris(rawContent);
+    const cleanMarkdown = rawMarkdown ? stripBase64DataUris(rawMarkdown) : void 0;
+    const isDuplicate = !!cleanMarkdown && cleanContent === cleanMarkdown;
     return {
       success: result.success,
       url: args.url,
@@ -47660,7 +48088,7 @@ async function tryAPI(connectorName, args, startTime, attemptedMethods) {
       content: cleanContent,
       html: result.result?.html,
       // Keep raw HTML as-is (only used if explicitly requested)
-      markdown: cleanMarkdown,
+      markdown: isDuplicate ? void 0 : cleanMarkdown,
       metadata: result.result?.metadata,
       links: result.result?.links,
       qualityScore: result.success ? 90 : 0,
@@ -47875,68 +48303,25 @@ async function executeInVM(code, input, timeout, logs) {
   const result = await resultPromise;
   return result !== void 0 ? result : sandbox.output;
 }
-var MIME_TYPES = {
-  png: "image/png",
-  jpeg: "image/jpeg",
-  jpg: "image/jpeg",
-  webp: "image/webp",
-  gif: "image/gif",
-  mp4: "video/mp4",
-  webm: "video/webm",
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  opus: "audio/opus",
-  ogg: "audio/ogg",
-  aac: "audio/aac",
-  flac: "audio/flac",
-  pcm: "audio/pcm"
-};
-var FileMediaOutputHandler = class {
-  outputDir;
-  initialized = false;
-  constructor(outputDir) {
-    this.outputDir = outputDir ?? path3__namespace.join(os__namespace.tmpdir(), "oneringai-media");
-  }
-  async save(data, metadata) {
-    if (!this.initialized) {
-      await fs14__namespace.mkdir(this.outputDir, { recursive: true });
-      this.initialized = true;
-    }
-    const filename = metadata.suggestedFilename ?? this.generateFilename(metadata);
-    const filePath = path3__namespace.join(this.outputDir, filename);
-    await fs14__namespace.writeFile(filePath, data);
-    const format = metadata.format.toLowerCase();
-    const mimeType = MIME_TYPES[format] ?? `application/octet-stream`;
-    return {
-      location: filePath,
-      mimeType,
-      size: data.length
-    };
-  }
-  generateFilename(metadata) {
-    const timestamp = Date.now();
-    const random2 = crypto2__namespace.randomBytes(4).toString("hex");
-    const indexSuffix = metadata.index != null ? `_${metadata.index}` : "";
-    return `${metadata.type}_${timestamp}_${random2}${indexSuffix}.${metadata.format}`;
-  }
-};
 
 // src/tools/multimedia/config.ts
-var _outputHandler = null;
-function getMediaOutputHandler() {
-  if (!_outputHandler) {
-    _outputHandler = new FileMediaOutputHandler();
+var _storage = null;
+function getMediaStorage() {
+  if (!_storage) {
+    _storage = new FileMediaStorage();
   }
-  return _outputHandler;
+  return _storage;
 }
-function setMediaOutputHandler(handler) {
-  _outputHandler = handler;
+function setMediaStorage(storage) {
+  _storage = storage;
 }
+var getMediaOutputHandler = getMediaStorage;
+var setMediaOutputHandler = setMediaStorage;
 
 // src/tools/multimedia/imageGeneration.ts
-function createImageGenerationTool(connector, outputHandler) {
+function createImageGenerationTool(connector, storage, userId) {
   const vendor = connector.vendor;
-  const handler = outputHandler ?? getMediaOutputHandler();
+  const handler = storage ?? getMediaStorage();
   const vendorModels = vendor ? getImageModelsByVendor(vendor) : [];
   const modelNames = vendorModels.map((m) => m.name);
   const properties = {
@@ -48009,8 +48394,9 @@ function createImageGenerationTool(connector, outputHandler) {
         }
       }
     },
-    execute: async (args) => {
+    execute: async (args, context) => {
       try {
+        const effectiveUserId = userId ?? context?.userId;
         const imageGen = ImageGeneration.create({ connector });
         const response = await imageGen.generate({
           prompt: args.prompt,
@@ -48041,7 +48427,8 @@ function createImageGenerationTool(connector, outputHandler) {
             format,
             model: modelName,
             vendor: vendor || "unknown",
-            index: response.data.length > 1 ? i : void 0
+            index: response.data.length > 1 ? i : void 0,
+            userId: effectiveUserId
           });
           images.push({
             location: result.location,
@@ -48068,9 +48455,9 @@ function createImageGenerationTool(connector, outputHandler) {
 
 // src/tools/multimedia/videoGeneration.ts
 var videoGenInstances = /* @__PURE__ */ new Map();
-function createVideoTools(connector, outputHandler) {
+function createVideoTools(connector, storage, userId) {
   const vendor = connector.vendor;
-  const handler = outputHandler ?? getMediaOutputHandler();
+  const handler = storage ?? getMediaStorage();
   const vendorModels = vendor ? getVideoModelsByVendor(vendor) : [];
   const modelNames = vendorModels.map((m) => m.name);
   const generateProperties = {
@@ -48134,7 +48521,7 @@ function createVideoTools(connector, outputHandler) {
         }
       }
     },
-    execute: async (args) => {
+    execute: async (args, _context) => {
       try {
         const videoGen = VideoGeneration.create({ connector });
         const response = await videoGen.generate({
@@ -48183,8 +48570,9 @@ function createVideoTools(connector, outputHandler) {
         }
       }
     },
-    execute: async (args) => {
+    execute: async (args, context) => {
       try {
+        const effectiveUserId = userId ?? context?.userId;
         let videoGen = videoGenInstances.get(args.jobId);
         if (!videoGen) {
           videoGen = VideoGeneration.create({ connector });
@@ -48210,7 +48598,8 @@ function createVideoTools(connector, outputHandler) {
               type: "video",
               format,
               model: modelName,
-              vendor: vendor || "unknown"
+              vendor: vendor || "unknown",
+              userId: effectiveUserId
             });
             videoGenInstances.delete(args.jobId);
             return {
@@ -48258,9 +48647,9 @@ function createVideoTools(connector, outputHandler) {
 }
 
 // src/tools/multimedia/textToSpeech.ts
-function createTextToSpeechTool(connector, outputHandler) {
+function createTextToSpeechTool(connector, storage, userId) {
   const vendor = connector.vendor;
-  const handler = outputHandler ?? getMediaOutputHandler();
+  const handler = storage ?? getMediaStorage();
   const vendorModels = vendor ? getTTSModelsByVendor(vendor) : [];
   const modelNames = vendorModels.map((m) => m.name);
   const properties = {
@@ -48321,8 +48710,9 @@ function createTextToSpeechTool(connector, outputHandler) {
         }
       }
     },
-    execute: async (args) => {
+    execute: async (args, context) => {
       try {
+        const effectiveUserId = userId ?? context?.userId;
         const tts = TextToSpeech.create({
           connector,
           model: args.model,
@@ -48336,7 +48726,8 @@ function createTextToSpeechTool(connector, outputHandler) {
           type: "audio",
           format,
           model: args.model || modelNames[0] || "unknown",
-          vendor: vendor || "unknown"
+          vendor: vendor || "unknown",
+          userId: effectiveUserId
         });
         return {
           success: true,
@@ -48359,14 +48750,17 @@ function createTextToSpeechTool(connector, outputHandler) {
     }
   };
 }
-function createSpeechToTextTool(connector) {
+
+// src/tools/multimedia/speechToText.ts
+function createSpeechToTextTool(connector, storage, _userId) {
   const vendor = connector.vendor;
+  const handler = storage ?? getMediaStorage();
   const vendorModels = vendor ? getSTTModelsByVendor(vendor) : [];
   const modelNames = vendorModels.map((m) => m.name);
   const properties = {
-    audioFilePath: {
+    audioSource: {
       type: "string",
-      description: "Path to the audio file to transcribe"
+      description: "Path or location of the audio file to transcribe (file path, storage location, etc.)"
     }
   };
   if (modelNames.length > 0) {
@@ -48394,13 +48788,19 @@ function createSpeechToTextTool(connector) {
         parameters: {
           type: "object",
           properties,
-          required: ["audioFilePath"]
+          required: ["audioSource"]
         }
       }
     },
-    execute: async (args) => {
+    execute: async (args, _context) => {
       try {
-        const audioBuffer = await fs14__namespace.readFile(args.audioFilePath);
+        const audioBuffer = await handler.read(args.audioSource);
+        if (!audioBuffer) {
+          return {
+            success: false,
+            error: `Audio not found at: ${args.audioSource}`
+          };
+        }
         const stt = SpeechToText.create({
           connector,
           model: args.model,
@@ -48422,7 +48822,7 @@ function createSpeechToTextTool(connector) {
         };
       }
     },
-    describeCall: (args) => args.audioFilePath,
+    describeCall: (args) => args.audioSource,
     permission: {
       scope: "session",
       riskLevel: "low",
@@ -48437,21 +48837,22 @@ var VENDOR_CAPABILITIES = {
   [Vendor.Google]: ["image", "video", "tts"],
   [Vendor.Grok]: ["image", "video"]
 };
-function registerMultimediaTools() {
+function registerMultimediaTools(storage) {
   for (const [vendor, capabilities] of Object.entries(VENDOR_CAPABILITIES)) {
-    ConnectorTools.registerService(vendor, (connector, _userId) => {
+    ConnectorTools.registerService(vendor, (connector, userId) => {
+      const handler = getMediaStorage();
       const tools = [];
       if (capabilities.includes("image")) {
-        tools.push(createImageGenerationTool(connector));
+        tools.push(createImageGenerationTool(connector, handler, userId));
       }
       if (capabilities.includes("video")) {
-        tools.push(...createVideoTools(connector));
+        tools.push(...createVideoTools(connector, handler, userId));
       }
       if (capabilities.includes("tts")) {
-        tools.push(createTextToSpeechTool(connector));
+        tools.push(createTextToSpeechTool(connector, handler, userId));
       }
       if (capabilities.includes("stt")) {
-        tools.push(createSpeechToTextTool(connector));
+        tools.push(createSpeechToTextTool(connector, handler));
       }
       return tools;
     });
@@ -48461,6 +48862,851 @@ function registerMultimediaTools() {
 // src/tools/multimedia/index.ts
 registerMultimediaTools();
 
+// src/tools/github/types.ts
+function parseRepository(input) {
+  if (!input || input.trim().length === 0) {
+    throw new Error("Repository cannot be empty");
+  }
+  const trimmed = input.trim();
+  try {
+    const url2 = new URL(trimmed);
+    if (url2.hostname === "github.com" || url2.hostname === "www.github.com") {
+      const segments = url2.pathname.split("/").filter(Boolean);
+      if (segments.length >= 2) {
+        return { owner: segments[0], repo: segments[1].replace(/\.git$/, "") };
+      }
+    }
+  } catch {
+  }
+  const parts = trimmed.split("/");
+  if (parts.length === 2 && parts[0].length > 0 && parts[1].length > 0) {
+    return { owner: parts[0], repo: parts[1] };
+  }
+  throw new Error(
+    `Invalid repository format: "${input}". Expected "owner/repo" or "https://github.com/owner/repo"`
+  );
+}
+function resolveRepository(repository, connector) {
+  const repoStr = repository ?? connector.getOptions().defaultRepository;
+  if (!repoStr) {
+    return {
+      success: false,
+      error: 'No repository specified. Provide a "repository" parameter (e.g., "owner/repo") or configure defaultRepository on the connector.'
+    };
+  }
+  try {
+    return { success: true, repo: parseRepository(repoStr) };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+var GitHubAPIError = class extends Error {
+  constructor(status, statusText, body) {
+    const msg = typeof body === "object" && body !== null && "message" in body ? body.message : statusText;
+    super(`GitHub API error ${status}: ${msg}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "GitHubAPIError";
+  }
+};
+async function githubFetch(connector, endpoint, options) {
+  let url2 = endpoint;
+  if (options?.queryParams && Object.keys(options.queryParams).length > 0) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(options.queryParams)) {
+      params.append(key, String(value));
+    }
+    url2 += (url2.includes("?") ? "&" : "?") + params.toString();
+  }
+  const headers = {
+    "Accept": options?.accept ?? "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (options?.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await connector.fetch(
+    url2,
+    {
+      method: options?.method ?? "GET",
+      headers,
+      body: options?.body ? JSON.stringify(options.body) : void 0
+    },
+    options?.userId
+  );
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = text;
+  }
+  if (!response.ok) {
+    throw new GitHubAPIError(response.status, response.statusText, data);
+  }
+  return data;
+}
+
+// src/tools/github/searchFiles.ts
+function matchGlobPattern2(pattern, filePath) {
+  let regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  regexPattern = "^" + regexPattern + "$";
+  try {
+    const regex = new RegExp(regexPattern);
+    return regex.test(filePath);
+  } catch {
+    return false;
+  }
+}
+function createSearchFilesTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "search_files",
+        description: `Search for files by name/path pattern in a GitHub repository.
+
+USAGE:
+- Supports glob patterns like "**/*.ts", "src/**/*.tsx"
+- Returns matching file paths sorted alphabetically
+- Uses the repository's file tree for fast matching
+
+PATTERN SYNTAX:
+- * matches any characters except /
+- ** matches any characters including /
+- ? matches a single character
+
+EXAMPLES:
+- Find all TypeScript files: { "pattern": "**/*.ts" }
+- Find files in src: { "pattern": "src/**/*.{ts,tsx}" }
+- Find package.json: { "pattern": "**/package.json" }
+- Search specific branch: { "pattern": "**/*.ts", "ref": "develop" }`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            pattern: {
+              type: "string",
+              description: 'Glob pattern to match files (e.g., "**/*.ts", "src/**/*.tsx")'
+            },
+            ref: {
+              type: "string",
+              description: "Branch, tag, or commit SHA. Defaults to the repository's default branch."
+            }
+          },
+          required: ["pattern"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [args.pattern];
+      if (args.repository) parts.push(`in ${args.repository}`);
+      if (args.ref) parts.push(`@${args.ref}`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Search files in a GitHub repository via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        let ref = args.ref;
+        if (!ref) {
+          const repoInfo = await githubFetch(
+            connector,
+            `/repos/${owner}/${repo}`,
+            { userId }
+          );
+          ref = repoInfo.default_branch;
+        }
+        const tree = await githubFetch(
+          connector,
+          `/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`,
+          { userId }
+        );
+        const matching = tree.tree.filter(
+          (entry) => entry.type === "blob" && matchGlobPattern2(args.pattern, entry.path)
+        ).map((entry) => ({
+          path: entry.path,
+          size: entry.size ?? 0,
+          type: entry.type
+        })).sort((a, b) => a.path.localeCompare(b.path));
+        return {
+          success: true,
+          files: matching,
+          count: matching.length,
+          truncated: tree.truncated
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to search files: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/searchCode.ts
+function createSearchCodeTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "search_code",
+        description: `Search for code content across a GitHub repository.
+
+USAGE:
+- Search by keyword, function name, class name, or any text
+- Filter by language, path, or file extension
+- Returns matching files with text fragments showing context
+
+RATE LIMITS:
+- GitHub's code search API is limited to 30 requests per minute
+- Results may be incomplete for very large repositories
+
+EXAMPLES:
+- Find function: { "query": "function handleAuth", "language": "typescript" }
+- Find imports: { "query": "import React", "extension": "tsx" }
+- Search in path: { "query": "TODO", "path": "src/utils" }
+- Limit results: { "query": "console.log", "limit": 10 }`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            query: {
+              type: "string",
+              description: "Search query \u2014 keyword, function name, or any text to find in code"
+            },
+            language: {
+              type: "string",
+              description: 'Filter by programming language (e.g., "typescript", "python", "go")'
+            },
+            path: {
+              type: "string",
+              description: 'Filter by file path prefix (e.g., "src/", "lib/utils")'
+            },
+            extension: {
+              type: "string",
+              description: 'Filter by file extension without dot (e.g., "ts", "py", "go")'
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results (default: 30, max: 100)"
+            }
+          },
+          required: ["query"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [`"${args.query}"`];
+      if (args.language) parts.push(`lang:${args.language}`);
+      if (args.repository) parts.push(`in ${args.repository}`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Search code in a GitHub repository via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        const qualifiers = [`repo:${owner}/${repo}`];
+        if (args.language) qualifiers.push(`language:${args.language}`);
+        if (args.path) qualifiers.push(`path:${args.path}`);
+        if (args.extension) qualifiers.push(`extension:${args.extension}`);
+        const q = `${args.query} ${qualifiers.join(" ")}`;
+        const perPage = Math.min(args.limit ?? 30, 100);
+        const result = await githubFetch(
+          connector,
+          `/search/code`,
+          {
+            userId,
+            // Request text-match fragments
+            accept: "application/vnd.github.text-match+json",
+            queryParams: { q, per_page: perPage }
+          }
+        );
+        const matches = result.items.map((item) => ({
+          file: item.path,
+          fragment: item.text_matches?.[0]?.fragment
+        }));
+        return {
+          success: true,
+          matches,
+          count: result.total_count,
+          truncated: result.incomplete_results || result.total_count > perPage
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to search code: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/readFile.ts
+function createGitHubReadFileTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "read_file",
+        description: `Read file content from a GitHub repository.
+
+USAGE:
+- Reads a file and returns content with line numbers
+- Supports line range selection with offset/limit for large files
+- By default reads up to 2000 lines from the beginning
+
+EXAMPLES:
+- Read entire file: { "path": "src/index.ts" }
+- Read specific branch: { "path": "README.md", "ref": "develop" }
+- Read lines 100-200: { "path": "src/app.ts", "offset": 100, "limit": 100 }
+- Specific repo: { "repository": "owner/repo", "path": "package.json" }
+
+NOTE: Files larger than 1MB are fetched via the Git Blob API. Very large files (>5MB) may be truncated.`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            path: {
+              type: "string",
+              description: 'File path within the repository (e.g., "src/index.ts")'
+            },
+            ref: {
+              type: "string",
+              description: "Branch, tag, or commit SHA. Defaults to the repository's default branch."
+            },
+            offset: {
+              type: "number",
+              description: "Line number to start reading from (1-indexed). Only provide if the file is too large."
+            },
+            limit: {
+              type: "number",
+              description: "Number of lines to read (default: 2000). Only provide if the file is too large."
+            }
+          },
+          required: ["path"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [args.path];
+      if (args.repository) parts.push(`in ${args.repository}`);
+      if (args.ref) parts.push(`@${args.ref}`);
+      if (args.offset && args.limit) parts.push(`[lines ${args.offset}-${args.offset + args.limit}]`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Read a file from a GitHub repository via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        let fileContent;
+        let fileSha;
+        let fileSize;
+        const refParam = args.ref ? `?ref=${encodeURIComponent(args.ref)}` : "";
+        const contentResp = await githubFetch(
+          connector,
+          `/repos/${owner}/${repo}/contents/${args.path}${refParam}`,
+          { userId }
+        );
+        if (contentResp.type !== "file") {
+          return {
+            success: false,
+            error: `Path is not a file: ${args.path} (type: ${contentResp.type}). Use search_files to explore the repository.`,
+            path: args.path
+          };
+        }
+        fileSha = contentResp.sha;
+        fileSize = contentResp.size;
+        if (contentResp.content && contentResp.encoding === "base64") {
+          fileContent = Buffer.from(contentResp.content, "base64").toString("utf-8");
+        } else if (contentResp.git_url) {
+          const blob = await githubFetch(
+            connector,
+            contentResp.git_url,
+            { userId }
+          );
+          fileContent = Buffer.from(blob.content, "base64").toString("utf-8");
+          fileSize = blob.size;
+        } else {
+          return {
+            success: false,
+            error: `Cannot read file content: ${args.path} (no content or git_url in response)`,
+            path: args.path
+          };
+        }
+        const offset = args.offset ?? 1;
+        const limit = args.limit ?? 2e3;
+        const allLines = fileContent.split("\n");
+        const totalLines = allLines.length;
+        const startIndex = Math.max(0, offset - 1);
+        const endIndex = Math.min(totalLines, startIndex + limit);
+        const selectedLines = allLines.slice(startIndex, endIndex);
+        const lineNumberWidth = String(endIndex).length;
+        const formattedLines = selectedLines.map((line, i) => {
+          const lineNum = startIndex + i + 1;
+          const paddedNum = String(lineNum).padStart(lineNumberWidth, " ");
+          const truncatedLine = line.length > 2e3 ? line.substring(0, 2e3) + "..." : line;
+          return `${paddedNum}	${truncatedLine}`;
+        });
+        const truncated = endIndex < totalLines;
+        const result = formattedLines.join("\n");
+        return {
+          success: true,
+          content: result,
+          path: args.path,
+          size: fileSize,
+          lines: totalLines,
+          truncated,
+          sha: fileSha
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+          path: args.path
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/getPR.ts
+function createGetPRTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "get_pr",
+        description: `Get full details of a pull request from a GitHub repository.
+
+Returns: title, description, state, author, labels, reviewers, merge status, branches, file stats, and more.
+
+EXAMPLES:
+- Get PR: { "pull_number": 123 }
+- Specific repo: { "repository": "owner/repo", "pull_number": 456 }`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            pull_number: {
+              type: "number",
+              description: "Pull request number"
+            }
+          },
+          required: ["pull_number"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [`#${args.pull_number}`];
+      if (args.repository) parts.push(`in ${args.repository}`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Get pull request details from GitHub via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        const pr = await githubFetch(
+          connector,
+          `/repos/${owner}/${repo}/pulls/${args.pull_number}`,
+          { userId }
+        );
+        return {
+          success: true,
+          data: {
+            number: pr.number,
+            title: pr.title,
+            body: pr.body,
+            state: pr.state,
+            draft: pr.draft,
+            author: pr.user.login,
+            labels: pr.labels.map((l) => l.name),
+            reviewers: pr.requested_reviewers.map((r) => r.login),
+            mergeable: pr.mergeable,
+            head: pr.head.ref,
+            base: pr.base.ref,
+            url: pr.html_url,
+            created_at: pr.created_at,
+            updated_at: pr.updated_at,
+            additions: pr.additions,
+            deletions: pr.deletions,
+            changed_files: pr.changed_files
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to get PR: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/prFiles.ts
+function createPRFilesTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "pr_files",
+        description: `Get the files changed in a pull request with diffs.
+
+Returns: filename, status (added/modified/removed/renamed), additions, deletions, and patch (diff) content for each file.
+
+EXAMPLES:
+- Get files: { "pull_number": 123 }
+- Specific repo: { "repository": "owner/repo", "pull_number": 456 }
+
+NOTE: Very large diffs may be truncated by GitHub. Patch content may be absent for binary files.`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            pull_number: {
+              type: "number",
+              description: "Pull request number"
+            }
+          },
+          required: ["pull_number"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [`files for #${args.pull_number}`];
+      if (args.repository) parts.push(`in ${args.repository}`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Get PR changed files from GitHub via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        const files = await githubFetch(
+          connector,
+          `/repos/${owner}/${repo}/pulls/${args.pull_number}/files`,
+          {
+            userId,
+            queryParams: { per_page: 100 }
+          }
+        );
+        return {
+          success: true,
+          files: files.map((f) => ({
+            filename: f.filename,
+            status: f.status,
+            additions: f.additions,
+            deletions: f.deletions,
+            changes: f.changes,
+            patch: f.patch
+          })),
+          count: files.length
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to get PR files: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/prComments.ts
+function createPRCommentsTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "pr_comments",
+        description: `Get all comments and reviews on a pull request.
+
+Returns a unified list of:
+- **review_comment**: Line-level comments on specific code (includes file path and line number)
+- **review**: Full reviews (approve/request changes/comment)
+- **comment**: General comments on the PR (issue-level)
+
+All entries are sorted by creation date (oldest first).
+
+EXAMPLES:
+- Get comments: { "pull_number": 123 }
+- Specific repo: { "repository": "owner/repo", "pull_number": 456 }`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            pull_number: {
+              type: "number",
+              description: "Pull request number"
+            }
+          },
+          required: ["pull_number"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [`comments for #${args.pull_number}`];
+      if (args.repository) parts.push(`in ${args.repository}`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "low",
+      approvalMessage: `Get PR comments and reviews from GitHub via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        const basePath = `/repos/${owner}/${repo}`;
+        const queryOpts = { userId, queryParams: { per_page: 100 } };
+        const [reviewComments, reviews, issueComments] = await Promise.all([
+          githubFetch(
+            connector,
+            `${basePath}/pulls/${args.pull_number}/comments`,
+            queryOpts
+          ),
+          githubFetch(
+            connector,
+            `${basePath}/pulls/${args.pull_number}/reviews`,
+            queryOpts
+          ),
+          githubFetch(
+            connector,
+            `${basePath}/issues/${args.pull_number}/comments`,
+            queryOpts
+          )
+        ]);
+        const allComments = [];
+        for (const rc of reviewComments) {
+          allComments.push({
+            id: rc.id,
+            type: "review_comment",
+            author: rc.user.login,
+            body: rc.body,
+            created_at: rc.created_at,
+            path: rc.path,
+            line: rc.line ?? rc.original_line ?? void 0
+          });
+        }
+        for (const r of reviews) {
+          if (!r.body && r.state === "APPROVED") continue;
+          allComments.push({
+            id: r.id,
+            type: "review",
+            author: r.user.login,
+            body: r.body || `[${r.state}]`,
+            created_at: r.submitted_at,
+            state: r.state
+          });
+        }
+        for (const ic of issueComments) {
+          allComments.push({
+            id: ic.id,
+            type: "comment",
+            author: ic.user.login,
+            body: ic.body,
+            created_at: ic.created_at
+          });
+        }
+        allComments.sort(
+          (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+        );
+        return {
+          success: true,
+          comments: allComments,
+          count: allComments.length
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to get PR comments: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/createPR.ts
+function createCreatePRTool(connector, userId) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "create_pr",
+        description: `Create a pull request on a GitHub repository.
+
+USAGE:
+- Specify source branch (head) and target branch (base)
+- Optionally create as draft
+
+EXAMPLES:
+- Create PR: { "title": "Add feature", "head": "feature-branch", "base": "main" }
+- Draft PR: { "title": "WIP: Refactor", "head": "refactor", "base": "develop", "draft": true }
+- With body: { "title": "Fix bug #42", "body": "Fixes the login issue\\n\\n## Changes\\n- Fixed auth flow", "head": "fix/42", "base": "main" }`,
+        parameters: {
+          type: "object",
+          properties: {
+            repository: {
+              type: "string",
+              description: 'Repository in "owner/repo" format or full GitHub URL. Optional if connector has a default repository.'
+            },
+            title: {
+              type: "string",
+              description: "Pull request title"
+            },
+            body: {
+              type: "string",
+              description: "Pull request description/body (Markdown supported)"
+            },
+            head: {
+              type: "string",
+              description: "Source branch name (the branch with your changes)"
+            },
+            base: {
+              type: "string",
+              description: 'Target branch name (the branch you want to merge into, e.g., "main")'
+            },
+            draft: {
+              type: "boolean",
+              description: "Create as a draft pull request (default: false)"
+            }
+          },
+          required: ["title", "head", "base"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [args.title];
+      if (args.repository) parts.push(`in ${args.repository}`);
+      return parts.join(" ");
+    },
+    permission: {
+      scope: "session",
+      riskLevel: "medium",
+      approvalMessage: `Create a pull request on GitHub via ${connector.displayName}`
+    },
+    execute: async (args) => {
+      const resolved = resolveRepository(args.repository, connector);
+      if (!resolved.success) {
+        return { success: false, error: resolved.error };
+      }
+      const { owner, repo } = resolved.repo;
+      try {
+        const pr = await githubFetch(
+          connector,
+          `/repos/${owner}/${repo}/pulls`,
+          {
+            method: "POST",
+            userId,
+            body: {
+              title: args.title,
+              body: args.body,
+              head: args.head,
+              base: args.base,
+              draft: args.draft ?? false
+            }
+          }
+        );
+        return {
+          success: true,
+          data: {
+            number: pr.number,
+            url: pr.html_url,
+            state: pr.state,
+            title: pr.title
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to create PR: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/github/register.ts
+function registerGitHubTools() {
+  ConnectorTools.registerService("github", (connector, userId) => {
+    return [
+      createSearchFilesTool(connector, userId),
+      createSearchCodeTool(connector, userId),
+      createGitHubReadFileTool(connector, userId),
+      createGetPRTool(connector, userId),
+      createPRFilesTool(connector, userId),
+      createPRCommentsTool(connector, userId),
+      createCreatePRTool(connector, userId)
+    ];
+  });
+}
+
+// src/tools/github/index.ts
+registerGitHubTools();
+
 // src/tools/registry.generated.ts
 var toolRegistry = [
   {
@@ -48514,7 +49760,7 @@ var toolRegistry = [
     displayName: "Read File",
     category: "filesystem",
     description: "Read content from a file on the local filesystem.",
-    tool: readFile4,
+    tool: readFile5,
     safeByDefault: true
   },
   {
@@ -48523,7 +49769,7 @@ var toolRegistry = [
     displayName: "Write File",
     category: "filesystem",
     description: "Write content to a file on the local filesystem.",
-    tool: writeFile4,
+    tool: writeFile5,
     safeByDefault: false
   },
   {
@@ -48752,8 +49998,8 @@ var ToolRegistry = class {
 
 // src/tools/index.ts
 var developerTools = [
-  readFile4,
-  writeFile4,
+  readFile5,
+  writeFile5,
   editFile,
   glob,
   grep,
@@ -48977,7 +50223,8 @@ exports.ExternalDependencyHandler = ExternalDependencyHandler;
 exports.FileAgentDefinitionStorage = FileAgentDefinitionStorage;
 exports.FileConnectorStorage = FileConnectorStorage;
 exports.FileContextStorage = FileContextStorage;
-exports.FileMediaOutputHandler = FileMediaOutputHandler;
+exports.FileMediaOutputHandler = FileMediaStorage;
+exports.FileMediaStorage = FileMediaStorage;
 exports.FilePersistentInstructionsStorage = FilePersistentInstructionsStorage;
 exports.FileStorage = FileStorage;
 exports.HookManager = HookManager;
@@ -49083,11 +50330,15 @@ exports.createAgentStorage = createAgentStorage;
 exports.createAuthenticatedFetch = createAuthenticatedFetch;
 exports.createBashTool = createBashTool;
 exports.createConnectorFromTemplate = createConnectorFromTemplate;
+exports.createCreatePRTool = createCreatePRTool;
 exports.createEditFileTool = createEditFileTool;
 exports.createEstimator = createEstimator;
 exports.createExecuteJavaScriptTool = createExecuteJavaScriptTool;
 exports.createFileAgentDefinitionStorage = createFileAgentDefinitionStorage;
 exports.createFileContextStorage = createFileContextStorage;
+exports.createFileMediaStorage = createFileMediaStorage;
+exports.createGetPRTool = createGetPRTool;
+exports.createGitHubReadFileTool = createGitHubReadFileTool;
 exports.createGlobTool = createGlobTool;
 exports.createGrepTool = createGrepTool;
 exports.createImageGenerationTool = createImageGenerationTool;
@@ -49095,9 +50346,13 @@ exports.createImageProvider = createImageProvider;
 exports.createListDirectoryTool = createListDirectoryTool;
 exports.createMessageWithImages = createMessageWithImages;
 exports.createMetricsCollector = createMetricsCollector;
+exports.createPRCommentsTool = createPRCommentsTool;
+exports.createPRFilesTool = createPRFilesTool;
 exports.createPlan = createPlan;
 exports.createProvider = createProvider;
 exports.createReadFileTool = createReadFileTool;
+exports.createSearchCodeTool = createSearchCodeTool;
+exports.createSearchFilesTool = createSearchFilesTool;
 exports.createSpeechToTextTool = createSpeechToTextTool;
 exports.createTask = createTask;
 exports.createTextMessage = createTextMessage;
@@ -49137,6 +50392,7 @@ exports.getImageModelInfo = getImageModelInfo;
 exports.getImageModelsByVendor = getImageModelsByVendor;
 exports.getImageModelsWithFeature = getImageModelsWithFeature;
 exports.getMediaOutputHandler = getMediaOutputHandler;
+exports.getMediaStorage = getMediaStorage;
 exports.getModelInfo = getModelInfo;
 exports.getModelsByVendor = getModelsByVendor;
 exports.getNextExecutableTasks = getNextExecutableTasks;
@@ -49159,6 +50415,7 @@ exports.getToolsByCategory = getToolsByCategory;
 exports.getToolsRequiringConnector = getToolsRequiringConnector;
 exports.getVendorAuthTemplate = getVendorAuthTemplate;
 exports.getVendorColor = getVendorColor;
+exports.getVendorDefaultBaseURL = getVendorDefaultBaseURL;
 exports.getVendorInfo = getVendorInfo;
 exports.getVendorLogo = getVendorLogo;
 exports.getVendorLogoCdnUrl = getVendorLogoCdnUrl;
@@ -49197,15 +50454,18 @@ exports.listVendors = listVendors;
 exports.listVendorsByAuthType = listVendorsByAuthType;
 exports.listVendorsByCategory = listVendorsByCategory;
 exports.listVendorsWithLogos = listVendorsWithLogos;
+exports.parseRepository = parseRepository;
 exports.readClipboardImage = readClipboardImage;
-exports.readFile = readFile4;
+exports.readFile = readFile5;
 exports.registerScrapeProvider = registerScrapeProvider;
 exports.resolveConnector = resolveConnector;
 exports.resolveDependencies = resolveDependencies;
+exports.resolveRepository = resolveRepository;
 exports.retryWithBackoff = retryWithBackoff;
 exports.scopeEquals = scopeEquals;
 exports.scopeMatches = scopeMatches;
 exports.setMediaOutputHandler = setMediaOutputHandler;
+exports.setMediaStorage = setMediaStorage;
 exports.setMetricsCollector = setMetricsCollector;
 exports.simpleTokenEstimator = simpleTokenEstimator;
 exports.toConnectorOptions = toConnectorOptions;
@@ -49213,6 +50473,6 @@ exports.toolRegistry = toolRegistry;
 exports.tools = tools_exports;
 exports.updateTaskStatus = updateTaskStatus;
 exports.validatePath = validatePath;
-exports.writeFile = writeFile4;
+exports.writeFile = writeFile5;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map