@sekuire/sdk 0.1.4 → 0.1.6

package/dist/index.js

@@ -15,6 +15,7 @@ var path$4 = require('node:path');
 var https = require('https');
 var http = require('http');
 var url = require('url');
+var zod = require('zod');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -1664,14 +1665,14 @@ class SekuireClient {
 /**
  * Load sekuire.yml configuration file
  */
-async function loadConfig(configPath = "./sekuire.yml") {
+async function loadConfig(configPath = './sekuire.yml') {
     try {
-        const content = await fs$2.readFile(configPath, "utf-8");
+        const content = await fs$2.readFile(configPath, 'utf-8');
         const config = yaml.load(content);
         return resolveEnvVars(config);
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        if (error.code === 'ENOENT') {
             throw new Error(`Config file not found: ${configPath}`);
         }
         throw error;
@@ -1680,15 +1681,13 @@ async function loadConfig(configPath = "./sekuire.yml") {
 /**
  * Load system prompt from file
  */
-async function loadSystemPrompt(promptPath, basePath = ".") {
+async function loadSystemPrompt(promptPath, basePath = '.') {
     try {
-        const fullPath = path$3.isAbsolute(promptPath)
-            ? promptPath
-            : path$3.join(basePath, promptPath);
-        return await fs$2.readFile(fullPath, "utf-8");
+        const fullPath = path$3.isAbsolute(promptPath) ? promptPath : path$3.join(basePath, promptPath);
+        return await fs$2.readFile(fullPath, 'utf-8');
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        if (error.code === 'ENOENT') {
             throw new Error(`System prompt file not found: ${promptPath}`);
         }
         throw error;
@@ -1697,16 +1696,14 @@ async function loadSystemPrompt(promptPath, basePath = ".") {
 /**
  * Load tools configuration from JSON file
  */
-async function loadTools(toolsPath, basePath = ".") {
+async function loadTools(toolsPath, basePath = '.') {
     try {
-        const fullPath = path$3.isAbsolute(toolsPath)
-            ? toolsPath
-            : path$3.join(basePath, toolsPath);
-        const content = await fs$2.readFile(fullPath, "utf-8");
+        const fullPath = path$3.isAbsolute(toolsPath) ? toolsPath : path$3.join(basePath, toolsPath);
+        const content = await fs$2.readFile(fullPath, 'utf-8');
         return JSON.parse(content);
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        if (error.code === 'ENOENT') {
             throw new Error(`Tools file not found: ${toolsPath}`);
         }
         throw error;
@@ -1717,7 +1714,7 @@ async function loadTools(toolsPath, basePath = ".") {
  * Supports ${VAR} and ${VAR:-default} syntax
  */
 function resolveEnvVars(obj) {
-    if (typeof obj === "string") {
+    if (typeof obj === 'string') {
         // Match ${VAR} or ${VAR:-default}
         return obj.replace(/\$\{([^}:]+)(?::-([^}]*))?\}/g, (match, varName, defaultValue) => {
             const value = process.env[varName];
@@ -1727,7 +1724,7 @@ function resolveEnvVars(obj) {
     if (Array.isArray(obj)) {
         return obj.map((item) => resolveEnvVars(item));
     }
-    if (obj !== null && typeof obj === "object") {
+    if (obj !== null && typeof obj === 'object') {
         const resolved = {};
         for (const [key, value] of Object.entries(obj)) {
             resolved[key] = resolveEnvVars(value);
@@ -1747,7 +1744,7 @@ function getAgentConfig(config, agentName) {
             // Return first agent if no name specified
             const firstKey = Object.keys(config.agents)[0];
             if (!firstKey) {
-                throw new Error("No agents defined in sekuire.yml");
+                throw new Error('No agents defined in sekuire.yml');
             }
             return config.agents[firstKey];
         }
@@ -1774,12 +1771,12 @@ function getAgentConfig(config, agentName) {
     if (config.llm) {
         return {
             name: config.project.name,
-            system_prompt: "./system_prompt.md",
-            tools: "./tools.json",
+            system_prompt: './system_prompt.md',
+            tools: './tools.json',
             llm: config.llm,
         };
     }
-    throw new Error("No agent configuration found in sekuire.yml");
+    throw new Error('No agent configuration found in sekuire.yml');
 }
 
 function __classPrivateFieldSet$1(receiver, state, value, kind, f) {
@@ -6702,8 +6699,8 @@ class AnthropicProvider {
     async chat(messages, options) {
         try {
             // Anthropic requires system message separately
-            const systemMessage = messages.find((m) => m.role === "system");
-            const conversationMessages = messages.filter((m) => m.role !== "system");
+            const systemMessage = messages.find((m) => m.role === 'system');
+            const conversationMessages = messages.filter((m) => m.role !== 'system');
             const response = await this.client.messages.create({
                 model: this.model,
                 max_tokens: options?.max_tokens || 4096,
@@ -6713,14 +6710,14 @@ class AnthropicProvider {
                 system: systemMessage?.content || undefined,
                 messages: conversationMessages.map((m) => ({
                     role: m.role,
-                    content: m.content || "",
+                    content: m.content || '',
                 })),
             });
             // Extract text content from response
             const content = response.content
-                .filter((block) => block.type === "text")
+                .filter((block) => block.type === 'text')
                 .map((block) => block.text)
-                .join("");
+                .join('');
             return {
                 content,
                 model: response.model,
@@ -6739,8 +6736,8 @@ class AnthropicProvider {
     async *chatStream(messages, options) {
         try {
             // Anthropic requires system message separately
-            const systemMessage = messages.find((m) => m.role === "system");
-            const conversationMessages = messages.filter((m) => m.role !== "system");
+            const systemMessage = messages.find((m) => m.role === 'system');
+            const conversationMessages = messages.filter((m) => m.role !== 'system');
             const stream = await this.client.messages.create({
                 model: this.model,
                 max_tokens: options?.max_tokens || 4096,
@@ -6750,22 +6747,22 @@ class AnthropicProvider {
                 system: systemMessage?.content || undefined,
                 messages: conversationMessages.map((m) => ({
                     role: m.role,
-                    content: m.content || "",
+                    content: m.content || '',
                 })),
                 stream: true,
             });
             for await (const event of stream) {
-                if (event.type === "content_block_delta") {
-                    if (event.delta.type === "text_delta") {
+                if (event.type === 'content_block_delta') {
+                    if (event.delta.type === 'text_delta') {
                         yield {
                             content: event.delta.text,
                         };
                     }
                 }
-                else if (event.type === "message_stop") {
+                else if (event.type === 'message_stop') {
                     yield {
-                        content: "",
-                        finish_reason: "stop",
+                        content: '',
+                        finish_reason: 'stop',
                     };
                 }
             }
@@ -6783,29 +6780,29 @@ class AnthropicProvider {
         return this.maxTokens;
     }
     getProviderName() {
-        return "anthropic";
+        return 'anthropic';
     }
     getModelName() {
         return this.model;
     }
     getMaxTokensForModel(model) {
         // Context window sizes for Claude models
-        if (model.includes("claude-3-5-sonnet")) {
+        if (model.includes('claude-3-5-sonnet')) {
             return 200000; // Claude 3.5 Sonnet
         }
-        if (model.includes("claude-3-opus")) {
+        if (model.includes('claude-3-opus')) {
             return 200000; // Claude 3 Opus
         }
-        if (model.includes("claude-3-sonnet")) {
+        if (model.includes('claude-3-sonnet')) {
             return 200000; // Claude 3 Sonnet
         }
-        if (model.includes("claude-3-haiku")) {
+        if (model.includes('claude-3-haiku')) {
             return 200000; // Claude 3 Haiku
         }
-        if (model.includes("claude-2.1")) {
+        if (model.includes('claude-2.1')) {
             return 200000; // Claude 2.1
         }
-        if (model.includes("claude-2")) {
+        if (model.includes('claude-2')) {
             return 100000; // Claude 2.0
         }
         // Default fallback
@@ -8344,13 +8341,17 @@ class GoogleProvider {
     async chat(messages, options) {
         try {
             // Convert tools to Gemini format
-            const tools = options?.tools ? [{
-                    functionDeclarations: options.tools.map(t => ({
-                        name: t.function.name,
-                        description: t.function.description,
-                        parameters: t.function.parameters
-                    }))
-                }] : undefined;
+            const tools = options?.tools
+                ? [
+                    {
+                        functionDeclarations: options.tools.map((t) => ({
+                            name: t.function.name,
+                            description: t.function.description,
+                            parameters: t.function.parameters,
+                        })),
+                    },
+                ]
+                : undefined;
             const model = this.client.getGenerativeModel({
                 model: this.model,
                 generationConfig: {
@@ -8380,38 +8381,40 @@ class GoogleProvider {
                 ...(tools && { tools }),
             });
             // Google Gemini uses a different message format
-            const systemMessage = messages.find((m) => m.role === "system");
-            const conversationMessages = messages.filter((m) => m.role !== "system");
+            const systemMessage = messages.find((m) => m.role === 'system');
+            const conversationMessages = messages.filter((m) => m.role !== 'system');
             // Build chat history with proper tool call support
             const history = conversationMessages.slice(0, -1).map((m) => {
-                if (m.role === "assistant" || m.role === "model") {
+                if (m.role === 'assistant' || m.role === 'model') {
                     return {
-                        role: "model",
-                        parts: [{ text: m.content || "" }],
+                        role: 'model',
+                        parts: [{ text: m.content || '' }],
                     };
                 }
-                else if (m.role === "tool") {
+                else if (m.role === 'tool') {
                     // Tool result message - Gemini expects this in a specific format
                     return {
-                        role: "function",
-                        parts: [{
+                        role: 'function',
+                        parts: [
+                            {
                                 functionResponse: {
                                     name: m.name,
                                     response: {
-                                        content: m.content
-                                    }
-                                }
-                            }]
+                                        content: m.content,
+                                    },
+                                },
+                            },
+                        ],
                     };
                 }
                 else {
                     return {
-                        role: "user",
-                        parts: [{ text: m.content || "" }],
+                        role: 'user',
+                        parts: [{ text: m.content || '' }],
                     };
                 }
             });
-            const lastMessage = conversationMessages[conversationMessages.length - 1]?.content || "";
+            const lastMessage = conversationMessages[conversationMessages.length - 1]?.content || '';
             // Start chat with history
             const chat = model.startChat({
                 history,
@@ -8433,13 +8436,11 @@ class GoogleProvider {
                 type: 'function',
                 function: {
                     name: fc.name,
-                    arguments: JSON.stringify(fc.args)
-                }
+                    arguments: JSON.stringify(fc.args),
+                },
             }));
             // Only get text if no function calls (Gemini returns empty text when calling functions)
-            const content = functionCalls && functionCalls.length > 0
-                ? ""
-                : response.text();
+            const content = functionCalls && functionCalls.length > 0 ? '' : response.text();
             return {
                 content,
                 model: this.model,
@@ -8467,13 +8468,13 @@ class GoogleProvider {
                     stopSequences: options?.stop,
                 },
             });
-            const systemMessage = messages.find((m) => m.role === "system");
-            const conversationMessages = messages.filter((m) => m.role !== "system");
+            const systemMessage = messages.find((m) => m.role === 'system');
+            const conversationMessages = messages.filter((m) => m.role !== 'system');
             const history = conversationMessages.slice(0, -1).map((m) => ({
-                role: m.role === "assistant" ? "model" : "user",
-                parts: [{ text: m.content || "" }],
+                role: m.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: m.content || '' }],
             }));
-            const lastMessage = conversationMessages[conversationMessages.length - 1]?.content || "";
+            const lastMessage = conversationMessages[conversationMessages.length - 1]?.content || '';
             const chat = model.startChat({ history });
             const prompt = systemMessage
                 ? `${systemMessage.content}\n\nUser: ${lastMessage}`
@@ -8489,8 +8490,8 @@ class GoogleProvider {
             }
             // Final chunk with finish reason
             yield {
-                content: "",
-                finish_reason: "stop",
+                content: '',
+                finish_reason: 'stop',
             };
         }
         catch (error) {
@@ -8506,23 +8507,23 @@ class GoogleProvider {
         return this.maxTokens;
     }
     getProviderName() {
-        return "google";
+        return 'google';
     }
     getModelName() {
         return this.model;
     }
     getMaxTokensForModel(model) {
         // Context window sizes for Gemini models
-        if (model.includes("gemini-1.5-pro")) {
+        if (model.includes('gemini-1.5-pro')) {
             return 2000000; // 2M tokens!
         }
-        if (model.includes("gemini-1.5-flash")) {
+        if (model.includes('gemini-1.5-flash')) {
             return 1000000; // 1M tokens
         }
-        if (model.includes("gemini-pro")) {
+        if (model.includes('gemini-pro')) {
             return 32768;
         }
-        if (model.includes("gemini-pro-vision")) {
+        if (model.includes('gemini-pro-vision')) {
             return 16384;
         }
         // Default fallback
@@ -8536,7 +8537,7 @@ class GoogleProvider {
  */
 class OllamaProvider {
     constructor(config) {
-        this.baseUrl = config.baseUrl || "http://localhost:11434";
+        this.baseUrl = config.baseUrl || 'http://localhost:11434';
         this.model = config.model;
         this.maxTokens = config.maxTokens || 4096;
     }
@@ -8546,7 +8547,7 @@ class OllamaProvider {
                 model: this.model,
                 messages: messages.map((m) => ({
                     role: m.role,
-                    content: m.content || "",
+                    content: m.content || '',
                 })),
                 stream: false,
                 options: {
@@ -8557,9 +8558,9 @@ class OllamaProvider {
                 },
             };
             const response = await fetch(`${this.baseUrl}/api/chat`, {
-                method: "POST",
+                method: 'POST',
                 headers: {
-                    "Content-Type": "application/json",
+                    'Content-Type': 'application/json',
                 },
                 body: JSON.stringify(requestBody),
             });
@@ -8570,7 +8571,7 @@ class OllamaProvider {
             return {
                 content: data.message.content,
                 model: data.model,
-                finish_reason: data.done ? "stop" : undefined,
+                finish_reason: data.done ? 'stop' : undefined,
                 usage: {
                     prompt_tokens: data.prompt_eval_count || 0,
                     completion_tokens: data.eval_count || 0,
@@ -8588,7 +8589,7 @@ class OllamaProvider {
                 model: this.model,
                 messages: messages.map((m) => ({
                     role: m.role,
-                    content: m.content || "",
+                    content: m.content || '',
                 })),
                 stream: true,
                 options: {
@@ -8599,9 +8600,9 @@ class OllamaProvider {
                 },
             };
             const response = await fetch(`${this.baseUrl}/api/chat`, {
-                method: "POST",
+                method: 'POST',
                 headers: {
-                    "Content-Type": "application/json",
+                    'Content-Type': 'application/json',
                 },
                 body: JSON.stringify(requestBody),
             });
@@ -8609,7 +8610,7 @@ class OllamaProvider {
                 throw new Error(`Ollama API error: ${response.statusText}`);
             }
             if (!response.body) {
-                throw new Error("Response body is null");
+                throw new Error('Response body is null');
             }
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
@@ -8618,7 +8619,7 @@ class OllamaProvider {
                 if (done)
                     break;
                 const chunk = decoder.decode(value);
-                const lines = chunk.split("\n").filter((line) => line.trim());
+                const lines = chunk.split('\n').filter((line) => line.trim());
                 for (const line of lines) {
                     try {
                         const data = JSON.parse(line);
@@ -8629,8 +8630,8 @@ class OllamaProvider {
                         }
                         if (data.done) {
                             yield {
-                                content: "",
-                                finish_reason: "stop",
+                                content: '',
+                                finish_reason: 'stop',
                             };
                         }
                     }
@@ -8650,7 +8651,7 @@ class OllamaProvider {
         return this.maxTokens;
     }
     getProviderName() {
-        return "ollama";
+        return 'ollama';
     }
     getModelName() {
         return this.model;
@@ -8888,7 +8889,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '6.13.0'; // x-release-please-version
+const VERSION = '6.15.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -15857,7 +15858,7 @@ class OpenAIProvider {
                 tools: options?.tools,
             });
             return {
-                content: response.choices[0]?.message?.content || "",
+                content: response.choices[0]?.message?.content || '',
                 model: response.model,
                 finish_reason: response.choices[0]?.finish_reason || undefined,
                 tool_calls: response.choices[0]?.message?.tool_calls,
@@ -15888,7 +15889,7 @@ class OpenAIProvider {
                 stream: true,
             });
             for await (const chunk of stream) {
-                const content = chunk.choices[0]?.delta?.content || "";
+                const content = chunk.choices[0]?.delta?.content || '';
                 const finishReason = chunk.choices[0]?.finish_reason || undefined;
                 if (content || finishReason) {
                     yield {
@@ -15911,26 +15912,26 @@ class OpenAIProvider {
         return this.maxTokens;
     }
     getProviderName() {
-        return "openai";
+        return 'openai';
     }
     getModelName() {
         return this.model;
     }
     getMaxTokensForModel(model) {
         // Context window sizes for common models
-        if (model.includes("gpt-4-turbo") || model.includes("gpt-4-1106")) {
+        if (model.includes('gpt-4-turbo') || model.includes('gpt-4-1106')) {
             return 128000;
         }
-        if (model.includes("gpt-4-32k")) {
+        if (model.includes('gpt-4-32k')) {
             return 32768;
         }
-        if (model.includes("gpt-4")) {
+        if (model.includes('gpt-4')) {
             return 8192;
         }
-        if (model.includes("gpt-3.5-turbo-16k")) {
+        if (model.includes('gpt-3.5-turbo-16k')) {
             return 16385;
         }
-        if (model.includes("gpt-3.5-turbo")) {
+        if (model.includes('gpt-3.5-turbo')) {
             return 4096;
         }
         // Default fallback
@@ -15944,14 +15945,14 @@ class OpenAIProvider {
 function createLLMProvider(provider, config) {
     const normalizedProvider = provider.toLowerCase();
     switch (normalizedProvider) {
-        case "openai":
+        case 'openai':
             return new OpenAIProvider(config);
-        case "anthropic":
+        case 'anthropic':
             return new AnthropicProvider(config);
-        case "google":
-        case "gemini":
+        case 'google':
+        case 'gemini':
             return new GoogleProvider(config);
-        case "ollama":
+        case 'ollama':
             return new OllamaProvider(config);
         default:
             throw new Error(`Unknown LLM provider: ${provider}. Supported providers: openai, anthropic, google, ollama`);
@@ -15967,7 +15968,7 @@ const llm = {
     openai: (config) => {
         return new OpenAIProvider({
             ...config,
-            model: config.model || "gpt-4",
+            model: config.model || 'gpt-4',
         });
     },
     /**
@@ -15976,7 +15977,7 @@ const llm = {
     anthropic: (config) => {
         return new AnthropicProvider({
             ...config,
-            model: config.model || "claude-3-5-sonnet-20241022",
+            model: config.model || 'claude-3-5-sonnet-20241022',
         });
     },
     /**
@@ -15985,7 +15986,7 @@ const llm = {
     google: (config) => {
         return new GoogleProvider({
             ...config,
-            model: config.model || "gemini-1.5-pro",
+            model: config.model || 'gemini-1.5-pro',
         });
     },
     /**
@@ -15994,11 +15995,241 @@ const llm = {
     ollama: (config) => {
         return new OllamaProvider({
             ...config,
-            model: config.model || "llama2",
+            model: config.model || 'llama2',
         });
     },
 };
 
+class BaseMemoryStorage {
+}
+
+class InMemoryStorage extends BaseMemoryStorage {
+    constructor() {
+        super(...arguments);
+        this.storage = new Map();
+    }
+    async add(sessionId, message) {
+        if (!this.storage.has(sessionId)) {
+            this.storage.set(sessionId, []);
+        }
+        this.storage.get(sessionId).push(message);
+    }
+    async get(sessionId, limit) {
+        const messages = this.storage.get(sessionId) || [];
+        if (limit) {
+            return messages.slice(-limit);
+        }
+        return messages;
+    }
+    async clear(sessionId) {
+        this.storage.set(sessionId, []);
+    }
+    async delete(sessionId) {
+        this.storage.delete(sessionId);
+    }
+    async exists(sessionId) {
+        return this.storage.has(sessionId);
+    }
+}
+
+class PostgresStorage extends BaseMemoryStorage {
+    constructor(config) {
+        super();
+        this.initialized = false;
+        this.tableName = config.tableName || 'sekuire_memory';
+        this.initPool(config);
+    }
+    async initPool(config) {
+        try {
+            const { Pool } = await import('pg');
+            if (config.connectionString) {
+                this.pool = new Pool({ connectionString: config.connectionString });
+            }
+            else {
+                this.pool = new Pool({
+                    host: config.host || 'localhost',
+                    port: config.port || 5432,
+                    database: config.database,
+                    user: config.user,
+                    password: config.password,
+                });
+            }
+            await this.createTableIfNotExists();
+            this.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize Postgres: ${error}`);
+        }
+    }
+    async createTableIfNotExists() {
+        const query = `
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id SERIAL PRIMARY KEY,
+        session_id VARCHAR(255) NOT NULL,
+        role VARCHAR(50) NOT NULL,
+        content TEXT NOT NULL,
+        timestamp BIGINT NOT NULL,
+        metadata JSONB,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_session_id ON ${this.tableName}(session_id);
+    `;
+        await this.pool.query(query);
+    }
+    async add(sessionId, message) {
+        if (!this.initialized)
+            throw new Error('Postgres not initialized');
+        const query = `
+      INSERT INTO ${this.tableName} (session_id, role, content, timestamp, metadata)
+      VALUES ($1, $2, $3, $4, $5)
+    `;
+        await this.pool.query(query, [
+            sessionId,
+            message.role,
+            message.content,
+            message.timestamp,
+            message.metadata ? JSON.stringify(message.metadata) : null,
+        ]);
+    }
+    async get(sessionId, limit) {
+        if (!this.initialized)
+            throw new Error('Postgres not initialized');
+        let query = `
+      SELECT role, content, timestamp, metadata
+      FROM ${this.tableName}
+      WHERE session_id = $1
+      ORDER BY timestamp ASC
+    `;
+        if (limit) {
+            query += ` LIMIT ${limit}`;
+        }
+        const result = await this.pool.query(query, [sessionId]);
+        return result.rows.map((row) => ({
+            role: row.role,
+            content: row.content,
+            timestamp: row.timestamp,
+            metadata: row.metadata,
+        }));
+    }
+    async clear(sessionId) {
+        if (!this.initialized)
+            throw new Error('Postgres not initialized');
+        const query = `DELETE FROM ${this.tableName} WHERE session_id = $1`;
+        await this.pool.query(query, [sessionId]);
+    }
+    async delete(sessionId) {
+        await this.clear(sessionId);
+    }
+    async exists(sessionId) {
+        if (!this.initialized)
+            throw new Error('Postgres not initialized');
+        const query = `SELECT COUNT(*) FROM ${this.tableName} WHERE session_id = $1`;
+        const result = await this.pool.query(query, [sessionId]);
+        return parseInt(result.rows[0].count) > 0;
+    }
+    async disconnect() {
+        if (this.initialized) {
+            await this.pool.end();
+            this.initialized = false;
+        }
+    }
+}
+
+class RedisStorage extends BaseMemoryStorage {
+    constructor(config) {
+        super();
+        this.client = null;
+        this.connected = false;
+        this.keyPrefix = config.keyPrefix || 'sekuire:memory:';
+        this.initClient(config);
+    }
+    async initClient(config) {
+        try {
+            const { createClient } = await import('redis');
+            if (config.url) {
+                this.client = createClient({ url: config.url });
+            }
+            else {
+                this.client = createClient({
+                    socket: {
+                        host: config.host || 'localhost',
+                        port: config.port || 6379,
+                    },
+                    password: config.password,
+                    database: config.db || 0,
+                });
+            }
+            this.client.on('error', (err) => {
+                console.error('Redis client error:', err);
+            });
+            await this.client.connect();
+            this.connected = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize Redis: ${error}`);
+        }
+    }
+    getKey(sessionId) {
+        return `${this.keyPrefix}${sessionId}`;
+    }
+    async add(sessionId, message) {
+        if (!this.connected)
+            throw new Error('Redis not connected');
+        const key = this.getKey(sessionId);
+        await this.client.rPush(key, JSON.stringify(message));
+    }
+    async get(sessionId, limit) {
+        if (!this.connected)
+            throw new Error('Redis not connected');
+        const key = this.getKey(sessionId);
+        const start = limit ? -limit : 0;
+        const messages = await this.client.lRange(key, start, -1);
+        return messages.map((msg) => JSON.parse(msg));
+    }
+    async clear(sessionId) {
+        if (!this.connected)
+            throw new Error('Redis not connected');
+        const key = this.getKey(sessionId);
+        await this.client.del(key);
+    }
+    async delete(sessionId) {
+        await this.clear(sessionId);
+    }
+    async exists(sessionId) {
+        if (!this.connected)
+            throw new Error('Redis not connected');
+        const key = this.getKey(sessionId);
+        return (await this.client.exists(key)) === 1;
+    }
+    async disconnect() {
+        if (this.connected) {
+            await this.client.quit();
+            this.connected = false;
+        }
+    }
+}
+
+function createMemoryStorage(config) {
+    // Normalize type (support "buffer" as alias for "in-memory")
+    const normalizedType = config.type === 'buffer' ? 'in-memory' : config.type;
+    switch (normalizedType) {
+        case 'in-memory':
+            return new InMemoryStorage();
+        case 'redis':
+            if (!config.redis) {
+                throw new Error('Redis config required for redis memory type');
+            }
+            return new RedisStorage(config.redis);
+        case 'postgres':
+            if (!config.postgres) {
+                throw new Error('Postgres config required for postgres memory type');
+            }
+            return new PostgresStorage(config.postgres);
+        default:
+            throw new Error(`Unknown memory type: ${config.type}`);
+    }
+}
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -16636,10 +16867,10 @@ class Tool {
             if (param.name in input) {
                 const value = input[param.name];
                 const actualType = typeof value;
-                if (param.type === "object" && actualType !== "object") {
+                if (param.type === 'object' && actualType !== 'object') {
                     throw new Error(`Parameter ${param.name} must be an object`);
                 }
-                if (param.type !== "object" && actualType !== param.type) {
+                if (param.type !== 'object' && actualType !== param.type) {
                     throw new Error(`Parameter ${param.name} must be of type ${param.type}`);
                 }
             }
@@ -16651,7 +16882,7 @@ class Tool {
             name: this.metadata.name,
             description: this.metadata.description,
             parameters: {
-                type: "object",
+                type: 'object',
                 properties: Object.fromEntries(this.metadata.parameters.map((p) => [
                     p.name,
                     {
@@ -16660,9 +16891,7 @@ class Tool {
                         ...(p.default && { default: p.default }),
                     },
                 ])),
-                required: this.metadata.parameters
-                    .filter((p) => p.required)
-                    .map((p) => p.name),
+                required: this.metadata.parameters.filter((p) => p.required).map((p) => p.name),
             },
         };
     }
@@ -16675,7 +16904,7 @@ class ToolRegistry {
     register(tool) {
         this.tools.set(tool.metadata.name, tool);
         // Track by category
-        const category = tool.metadata.category || "general";
+        const category = tool.metadata.category || 'general';
         if (!this.categories.has(category)) {
             this.categories.set(category, new Set());
         }
@@ -16755,7 +16984,7 @@ class AgentDiscoveryTool extends Tool {
         };
     }
     async execute(input) {
-        const { capability, tag, category, verified_only = false, scope = 'workspace' } = input;
+        const { capability, tag, category, verified_only = false, scope = 'workspace', } = input;
         try {
             const workspaceId = process.env.SEKUIRE_WORKSPACE_ID;
             const orgId = process.env.SEKUIRE_ORG_ID;
@@ -16843,7 +17072,7 @@ class AgentDelegationTool extends Tool {
         };
     }
     async execute(input) {
-        const { target_agent_id, capability, task, timeout_seconds = 30 } = input;
+        const { target_agent_id, capability, task, timeout_seconds = 30, } = input;
         try {
             // Determine target agent
             let targetId = target_agent_id;
@@ -16853,7 +17082,7 @@ class AgentDelegationTool extends Tool {
                 const discoveryResult = await discoveryTool.execute({
                     capability: String(capability),
                     verified_only: true,
-                    scope: 'workspace'
+                    scope: 'workspace',
                 });
                 // Parse first agent from discovery result (simplified)
                 const match = String(discoveryResult).match(/\(sekuire_agent_[a-zA-Z0-9]+\)/);
@@ -16972,38 +17201,38 @@ class AgentStatusTool extends Tool {
  * Performs handshake and sends requests to verified agents
  */
 class InvokeAgentTool {
-    constructor(privateKey, publicKey, registryUrl = "https://api.sekuire.com") {
+    constructor(privateKey, publicKey, registryUrl = 'https://api.sekuire.com') {
         this.privateKey = privateKey;
         this.publicKey = publicKey;
         this.registryUrl = registryUrl;
-        this.name = "invoke_agent";
-        this.description = "Invoke another Sekuire agent by performing a secure handshake and sending a request. Use this to delegate tasks to specialized agents.";
+        this.name = 'invoke_agent';
+        this.description = 'Invoke another Sekuire agent by performing a secure handshake and sending a request. Use this to delegate tasks to specialized agents.';
         this.parameters = {
-            type: "object",
+            type: 'object',
             properties: {
                 agent_url: {
-                    type: "string",
-                    description: "The base URL of the agent to invoke (e.g., https://agent.example.com)",
+                    type: 'string',
+                    description: 'The base URL of the agent to invoke (e.g., https://agent.example.com)',
                 },
                 agent_id: {
-                    type: "string",
-                    description: "Optional: The expected agent ID for verification",
+                    type: 'string',
+                    description: 'Optional: The expected agent ID for verification',
                 },
                 request: {
-                    type: "string",
-                    description: "The request/query to send to the agent",
+                    type: 'string',
+                    description: 'The request/query to send to the agent',
                 },
                 parameters: {
-                    type: "object",
-                    description: "Optional: Additional parameters to pass to the agent",
+                    type: 'object',
+                    description: 'Optional: Additional parameters to pass to the agent',
                 },
             },
-            required: ["agent_url", "request"],
+            required: ['agent_url', 'request'],
         };
         this.metadata = {
-            category: "agent_communication",
+            category: 'agent_communication',
             requiresAuth: true,
-            riskLevel: "medium",
+            riskLevel: 'medium',
         };
         this.client = null;
     }
@@ -17025,16 +17254,16 @@ class InvokeAgentTool {
             if (!handshakeResult.verified) {
                 return JSON.stringify({
                     success: false,
-                    error: "Failed to verify agent identity during handshake",
+                    error: 'Failed to verify agent identity during handshake',
                     agent_id: handshakeResult.agentId,
                 });
             }
             // Send request to the agent
             const response = await fetch(`${agent_url}/agent/invoke`, {
-                method: "POST",
+                method: 'POST',
                 headers: {
-                    "Content-Type": "application/json",
-                    "X-Sekuire-Agent-Id": handshakeResult.agentId,
+                    'Content-Type': 'application/json',
+                    'X-Sekuire-Agent-Id': handshakeResult.agentId,
                 },
                 body: JSON.stringify({
                     request,
@@ -17060,7 +17289,7 @@ class InvokeAgentTool {
         catch (error) {
             return JSON.stringify({
                 success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
+                error: error instanceof Error ? error.message : 'Unknown error',
             });
         }
     }
@@ -17069,30 +17298,30 @@ class InvokeAgentTool {
  * Tool for searching the Sekuire registry for agents
  */
 class SearchAgentsTool {
-    constructor(privateKey, publicKey, registryUrl = "https://api.sekuire.com") {
+    constructor(privateKey, publicKey, registryUrl = 'https://api.sekuire.com') {
         this.privateKey = privateKey;
         this.publicKey = publicKey;
         this.registryUrl = registryUrl;
-        this.name = "search_agents";
-        this.description = "Search the Sekuire registry for agents by name, capability, or description. Returns a list of verified agents.";
+        this.name = 'search_agents';
+        this.description = 'Search the Sekuire registry for agents by name, capability, or description. Returns a list of verified agents.';
         this.parameters = {
-            type: "object",
+            type: 'object',
             properties: {
                 query: {
-                    type: "string",
-                    description: "Search query (agent name, capability, or description)",
+                    type: 'string',
+                    description: 'Search query (agent name, capability, or description)',
                 },
                 limit: {
-                    type: "number",
-                    description: "Maximum number of results to return (default: 10)",
+                    type: 'number',
+                    description: 'Maximum number of results to return (default: 10)',
                 },
             },
-            required: ["query"],
+            required: ['query'],
         };
         this.metadata = {
-            category: "agent_communication",
+            category: 'agent_communication',
             requiresAuth: false,
-            riskLevel: "low",
+            riskLevel: 'low',
         };
         this.client = null;
     }
@@ -17130,7 +17359,7 @@ class SearchAgentsTool {
         catch (error) {
             return JSON.stringify({
                 success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
+                error: error instanceof Error ? error.message : 'Unknown error',
                 agents: [],
             });
         }
@@ -17140,26 +17369,26 @@ class SearchAgentsTool {
  * Tool for getting detailed information about a specific agent
  */
 class GetAgentInfoTool {
-    constructor(privateKey, publicKey, registryUrl = "https://api.sekuire.com") {
+    constructor(privateKey, publicKey, registryUrl = 'https://api.sekuire.com') {
         this.privateKey = privateKey;
         this.publicKey = publicKey;
         this.registryUrl = registryUrl;
-        this.name = "get_agent_info";
-        this.description = "Get detailed information about a specific Sekuire agent including its verification status, capabilities, and public key.";
+        this.name = 'get_agent_info';
+        this.description = 'Get detailed information about a specific Sekuire agent including its verification status, capabilities, and public key.';
         this.parameters = {
-            type: "object",
+            type: 'object',
             properties: {
                 agent_id: {
-                    type: "string",
-                    description: "The unique identifier of the agent",
+                    type: 'string',
+                    description: 'The unique identifier of the agent',
                 },
             },
-            required: ["agent_id"],
+            required: ['agent_id'],
         };
         this.metadata = {
-            category: "agent_communication",
+            category: 'agent_communication',
             requiresAuth: false,
-            riskLevel: "low",
+            riskLevel: 'low',
         };
         this.client = null;
     }
@@ -17198,7 +17427,7 @@ class GetAgentInfoTool {
         catch (error) {
             return JSON.stringify({
                 success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
+                error: error instanceof Error ? error.message : 'Unknown error',
             });
         }
     }
@@ -17208,18 +17437,18 @@ class CalculatorTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "calculator",
-            description: "Perform mathematical calculations",
+            name: 'calculator',
+            description: 'Perform mathematical calculations',
             parameters: [
                 {
-                    name: "expression",
-                    type: "string",
+                    name: 'expression',
+                    type: 'string',
                     description: 'Mathematical expression to evaluate (e.g., "2 + 2 * 3")',
                     required: true,
                 },
             ],
-            category: "utility",
-            compliance_level: "public",
+            category: 'utility',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17227,15 +17456,15 @@ class CalculatorTool extends Tool {
         const expression = input.expression;
         // Basic validation to prevent code injection
         if (!/^[\d\s+\-*/.()]+$/.test(expression)) {
-            throw new Error("Invalid expression. Only numbers and basic operators (+, -, *, /, .) are allowed");
+            throw new Error('Invalid expression. Only numbers and basic operators (+, -, *, /, .) are allowed');
         }
         try {
             // Safe evaluation using Function constructor with restricted scope
-            const result = new Function("return " + expression)();
+            const result = new Function('return ' + expression)();
             return `${expression} = ${result}`;
         }
         catch (error) {
-            throw new Error(`Calculation failed: ${error instanceof Error ? error.message : "Invalid expression"}`);
+            throw new Error(`Calculation failed: ${error instanceof Error ? error.message : 'Invalid expression'}`);
         }
     }
 }
@@ -17244,23 +17473,23 @@ class AuditLogTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "audit_log",
-            description: "Log action for compliance audit trail",
+            name: 'audit_log',
+            description: 'Log action for compliance audit trail',
             parameters: [],
-            category: "compliance",
-            compliance_level: "public",
+            category: 'compliance',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
         const logEntry = {
             timestamp: new Date().toISOString(),
             action: input.action,
-            actor: input.actor || "system",
+            actor: input.actor || 'system',
             resource: input.resource,
             metadata: input.metadata,
         };
         // In production, send to logging service
-        console.log("[AUDIT]", JSON.stringify(logEntry));
+        console.log('[AUDIT]', JSON.stringify(logEntry));
         return { logged: true };
     }
 }
@@ -17268,11 +17497,11 @@ class PiiDetectTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "pii_detect",
-            description: "Detect personally identifiable information in text",
+            name: 'pii_detect',
+            description: 'Detect personally identifiable information in text',
             parameters: [],
-            category: "compliance",
-            compliance_level: "public",
+            category: 'compliance',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17303,24 +17532,24 @@ class EncryptDataTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "encrypt_data",
-            description: "Encrypt sensitive data",
+            name: 'encrypt_data',
+            description: 'Encrypt sensitive data',
             parameters: [],
-            category: "compliance",
-            compliance_level: "public",
+            category: 'compliance',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
         const key = input.key
-            ? Buffer.from(crypto$2.createHash("sha256").update(input.key).digest("hex").slice(0, 32))
+            ? Buffer.from(crypto$2.createHash('sha256').update(input.key).digest('hex').slice(0, 32))
             : crypto$2.randomBytes(32);
         const iv = crypto$2.randomBytes(16);
-        const cipher = crypto$2.createCipheriv("aes-256-cbc", key, iv);
-        let encrypted = cipher.update(input.data, "utf8", "hex");
-        encrypted += cipher.final("hex");
+        const cipher = crypto$2.createCipheriv('aes-256-cbc', key, iv);
+        let encrypted = cipher.update(input.data, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
         return {
             encrypted,
-            iv: iv.toString("hex"),
+            iv: iv.toString('hex'),
         };
     }
 }
@@ -17328,19 +17557,19 @@ class DecryptDataTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "decrypt_data",
-            description: "Decrypt encrypted data (HIGH RISK)",
+            name: 'decrypt_data',
+            description: 'Decrypt encrypted data (HIGH RISK)',
             parameters: [],
-            category: "compliance",
-            compliance_level: "public",
+            category: 'compliance',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
-        const key = Buffer.from(crypto$2.createHash("sha256").update(input.key).digest("hex").slice(0, 32));
-        const iv = Buffer.from(input.iv, "hex");
-        const decipher = crypto$2.createDecipheriv("aes-256-cbc", key, iv);
-        let decrypted = decipher.update(input.encrypted, "hex", "utf8");
-        decrypted += decipher.final("utf8");
+        const key = Buffer.from(crypto$2.createHash('sha256').update(input.key).digest('hex').slice(0, 32));
+        const iv = Buffer.from(input.iv, 'hex');
+        const decipher = crypto$2.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = decipher.update(input.encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
         return decrypted;
     }
 }
@@ -17353,7 +17582,7 @@ class JsonStringifyTool extends Tool {
             description: 'Convert object to JSON string',
             parameters: [],
             category: 'data',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17368,7 +17597,7 @@ class CsvParseTool extends Tool {
             description: 'Parse CSV string to array of objects',
             parameters: [],
             category: 'data',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17378,11 +17607,11 @@ class CsvParseTool extends Tool {
         if (lines.length === 0)
             return [];
         const headers = hasHeaders
-            ? lines[0].split(delimiter).map(h => h.trim())
+            ? lines[0].split(delimiter).map((h) => h.trim())
             : Array.from({ length: lines[0].split(delimiter).length }, (_, i) => `column${i}`);
         const startIndex = hasHeaders ? 1 : 0;
-        return lines.slice(startIndex).map(line => {
-            const values = line.split(delimiter).map(v => v.trim());
+        return lines.slice(startIndex).map((line) => {
+            const values = line.split(delimiter).map((v) => v.trim());
             const obj = {};
             headers.forEach((header, i) => {
                 obj[header] = values[i] || '';
@@ -17399,7 +17628,7 @@ class CsvWriteTool extends Tool {
             description: 'Convert array of objects to CSV string',
             parameters: [],
             category: 'data',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17414,7 +17643,7 @@ class CsvWriteTool extends Tool {
             rows.push(headers.join(delimiter));
         }
         for (const item of input.data) {
-            const values = headers.map(header => {
+            const values = headers.map((header) => {
                 const value = item[header]?.toString() || '';
                 // Escape values containing delimiter or quotes
                 return value.includes(delimiter) || value.includes('"')
@@ -17434,7 +17663,7 @@ class YamlParseTool extends Tool {
             description: 'Parse YAML string to object',
             parameters: [],
             category: 'data',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17480,7 +17709,7 @@ class XmlParseTool extends Tool {
             description: 'Parse XML string to object',
             parameters: [],
             category: 'data',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17500,18 +17729,18 @@ class JsonParseTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "json_parse",
-            description: "Parse and format JSON string",
+            name: 'json_parse',
+            description: 'Parse and format JSON string',
             parameters: [
                 {
-                    name: "json",
-                    type: "string",
-                    description: "JSON string to parse",
+                    name: 'json',
+                    type: 'string',
+                    description: 'JSON string to parse',
                     required: true,
                 },
             ],
-            category: "data",
-            compliance_level: "internal",
+            category: 'data',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
@@ -17522,7 +17751,7 @@ class JsonParseTool extends Tool {
             return JSON.stringify(parsed, null, 2);
         }
         catch (error) {
-            throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17530,52 +17759,52 @@ class Base64EncodeTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "base64_encode",
-            description: "Encode text to base64",
+            name: 'base64_encode',
+            description: 'Encode text to base64',
             parameters: [
                 {
-                    name: "text",
-                    type: "string",
-                    description: "Text to encode",
+                    name: 'text',
+                    type: 'string',
+                    description: 'Text to encode',
                     required: true,
                 },
             ],
-            category: "data",
-            compliance_level: "internal",
+            category: 'data',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const text = input.text;
-        return Buffer.from(text).toString("base64");
+        return Buffer.from(text).toString('base64');
     }
 }
 class Base64DecodeTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "base64_decode",
-            description: "Decode base64 string to text",
+            name: 'base64_decode',
+            description: 'Decode base64 string to text',
             parameters: [
                 {
-                    name: "base64",
-                    type: "string",
-                    description: "Base64 string to decode",
+                    name: 'base64',
+                    type: 'string',
+                    description: 'Base64 string to decode',
                     required: true,
                 },
             ],
-            category: "data",
-            compliance_level: "internal",
+            category: 'data',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const base64Str = input.base64;
         try {
-            return Buffer.from(base64Str, "base64").toString("utf-8");
+            return Buffer.from(base64Str, 'base64').toString('utf-8');
         }
         catch (error) {
-            throw new Error(`Invalid base64: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Invalid base64: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17583,37 +17812,37 @@ class HashTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "hash",
-            description: "Generate cryptographic hash (md5, sha256, sha512, etc.)",
+            name: 'hash',
+            description: 'Generate cryptographic hash (md5, sha256, sha512, etc.)',
             parameters: [
                 {
-                    name: "text",
-                    type: "string",
-                    description: "Text to hash",
+                    name: 'text',
+                    type: 'string',
+                    description: 'Text to hash',
                     required: true,
                 },
                 {
-                    name: "algorithm",
-                    type: "string",
-                    description: "Hash algorithm (default: sha256)",
+                    name: 'algorithm',
+                    type: 'string',
+                    description: 'Hash algorithm (default: sha256)',
                     required: false,
                 },
             ],
-            category: "data",
-            compliance_level: "internal",
+            category: 'data',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const text = input.text;
-        const algorithm = input.algorithm || "sha256";
+        const algorithm = input.algorithm || 'sha256';
         try {
             const hash = crypto__namespace.createHash(algorithm);
             hash.update(text);
-            return hash.digest("hex");
+            return hash.digest('hex');
         }
         catch (error) {
-            throw new Error(`Hash generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Hash generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17622,36 +17851,36 @@ class DirectoryListTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_list",
-            description: "List contents of a directory",
+            name: 'dir_list',
+            description: 'List contents of a directory',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the directory",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the directory',
                     required: true,
                 },
             ],
-            category: "directories",
-            compliance_level: "internal",
+            category: 'directories',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const dirPath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(dirPath, "read");
+            this.policyEnforcer.enforceFilesystem(dirPath, 'read');
         }
         try {
             const files = await fs__namespace$1.readdir(dirPath, { withFileTypes: true });
             const formatted = files.map((file) => {
-                const type = file.isDirectory() ? "[DIR]" : "[FILE]";
+                const type = file.isDirectory() ? '[DIR]' : '[FILE]';
                 return `${type} ${file.name}`;
             });
-            return formatted.join("\n");
+            return formatted.join('\n');
         }
         catch (error) {
-            throw new Error(`Failed to list directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to list directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17659,40 +17888,40 @@ class DirectoryMkdirTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_mkdir",
-            description: "Create a new directory",
+            name: 'dir_mkdir',
+            description: 'Create a new directory',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the directory to create",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the directory to create',
                     required: true,
                 },
                 {
-                    name: "recursive",
-                    type: "boolean",
+                    name: 'recursive',
+                    type: 'boolean',
                     description: "Create parent directories if they don't exist",
                     required: false,
                 },
             ],
-            category: "directories",
-            compliance_level: "restricted",
+            category: 'directories',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
     async execute(input) {
         this.validate(input);
         const dirPath = input.path;
-        const recursive = input.recursive === true || input.recursive === "true";
+        const recursive = input.recursive === true || input.recursive === 'true';
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(dirPath, "write");
+            this.policyEnforcer.enforceFilesystem(dirPath, 'write');
         }
         try {
             await fs__namespace$1.mkdir(dirPath, { recursive });
             return `Successfully created directory ${dirPath}`;
         }
         catch (error) {
-            throw new Error(`Failed to create directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to create directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17700,18 +17929,18 @@ class DirectoryRmdirTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_rmdir",
-            description: "Remove an empty directory",
+            name: 'dir_rmdir',
+            description: 'Remove an empty directory',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the directory to remove",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the directory to remove',
                     required: true,
                 },
             ],
-            category: "directories",
-            compliance_level: "restricted",
+            category: 'directories',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -17719,14 +17948,14 @@ class DirectoryRmdirTool extends Tool {
         this.validate(input);
         const dirPath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(dirPath, "delete");
+            this.policyEnforcer.enforceFilesystem(dirPath, 'delete');
         }
         try {
             await fs__namespace$1.rmdir(dirPath);
             return `Successfully removed directory ${dirPath}`;
         }
         catch (error) {
-            throw new Error(`Failed to remove directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to remove directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17734,18 +17963,18 @@ class DirectoryRmRecursiveTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_rm_recursive",
-            description: "Remove a directory and all its contents (DANGEROUS - use with caution)",
+            name: 'dir_rm_recursive',
+            description: 'Remove a directory and all its contents (DANGEROUS - use with caution)',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the directory to remove recursively",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the directory to remove recursively',
                     required: true,
                 },
             ],
-            category: "directories",
-            compliance_level: "restricted",
+            category: 'directories',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -17753,14 +17982,14 @@ class DirectoryRmRecursiveTool extends Tool {
         this.validate(input);
         const dirPath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(dirPath, "delete");
+            this.policyEnforcer.enforceFilesystem(dirPath, 'delete');
         }
         try {
             await fs__namespace$1.rm(dirPath, { recursive: true, force: true });
             return `Successfully removed directory and contents: ${dirPath}`;
         }
         catch (error) {
-            throw new Error(`Failed to remove directory recursively: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to remove directory recursively: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17768,32 +17997,32 @@ class DirectoryExistsTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_exists",
-            description: "Check if a directory exists",
+            name: 'dir_exists',
+            description: 'Check if a directory exists',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to check",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to check',
                     required: true,
                 },
             ],
-            category: "directories",
-            compliance_level: "internal",
+            category: 'directories',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const dirPath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(dirPath, "read");
+            this.policyEnforcer.enforceFilesystem(dirPath, 'read');
         }
         try {
             const stats = await fs__namespace$1.stat(dirPath);
-            return stats.isDirectory() ? "true" : "false";
+            return stats.isDirectory() ? 'true' : 'false';
         }
         catch {
-            return "false";
+            return 'false';
         }
     }
 }
@@ -17801,11 +18030,11 @@ class DirectoryMoveTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_move",
-            description: "Move or rename directory",
+            name: 'dir_move',
+            description: 'Move or rename directory',
             parameters: [],
-            category: "directories",
-            compliance_level: "public",
+            category: 'directories',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17817,11 +18046,11 @@ class DirectoryCopyTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_copy",
-            description: "Copy directory recursively",
+            name: 'dir_copy',
+            description: 'Copy directory recursively',
             parameters: [],
-            category: "directories",
-            compliance_level: "public",
+            category: 'directories',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17833,11 +18062,11 @@ class DirectoryTreeTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "dir_tree",
-            description: "Get directory tree structure",
+            name: 'dir_tree',
+            description: 'Get directory tree structure',
             parameters: [],
-            category: "directories",
-            compliance_level: "public",
+            category: 'directories',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -17856,7 +18085,7 @@ class DirectoryTreeTool extends Tool {
                     }
                 }
                 else {
-                    tree.children.push({ name: entry.name, type: "file" });
+                    tree.children.push({ name: entry.name, type: 'file' });
                 }
             }
             return tree;
@@ -17869,18 +18098,18 @@ class FileReadTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_read",
-            description: "Read contents of a file",
+            name: 'file_read',
+            description: 'Read contents of a file',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the file to read",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the file to read',
                     required: true,
                 },
             ],
-            category: "filesystem",
-            compliance_level: "restricted",
+            category: 'filesystem',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -17888,14 +18117,14 @@ class FileReadTool extends Tool {
         this.validate(input);
         const filePath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(filePath, "read");
+            this.policyEnforcer.enforceFilesystem(filePath, 'read');
         }
         try {
-            const content = await fs__namespace$1.readFile(filePath, "utf-8");
+            const content = await fs__namespace$1.readFile(filePath, 'utf-8');
             return content;
         }
         catch (error) {
-            throw new Error(`Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to read file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17903,24 +18132,24 @@ class FileWriteTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_write",
-            description: "Write content to a file",
+            name: 'file_write',
+            description: 'Write content to a file',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the file to write",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the file to write',
                     required: true,
                 },
                 {
-                    name: "content",
-                    type: "string",
-                    description: "Content to write to the file",
+                    name: 'content',
+                    type: 'string',
+                    description: 'Content to write to the file',
                     required: true,
                 },
             ],
-            category: "filesystem",
-            compliance_level: "restricted",
+            category: 'filesystem',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -17929,14 +18158,14 @@ class FileWriteTool extends Tool {
         const filePath = input.path;
         const content = input.content;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(filePath, "write");
+            this.policyEnforcer.enforceFilesystem(filePath, 'write');
         }
         try {
-            await fs__namespace$1.writeFile(filePath, content, "utf-8");
+            await fs__namespace$1.writeFile(filePath, content, 'utf-8');
             return `Successfully wrote to ${filePath}`;
         }
         catch (error) {
-            throw new Error(`Failed to write file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to write file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17944,32 +18173,32 @@ class FileListTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_list",
-            description: "List files in a directory",
+            name: 'file_list',
+            description: 'List files in a directory',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the directory",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the directory',
                     required: true,
                 },
             ],
-            category: "filesystem",
-            compliance_level: "internal",
+            category: 'filesystem',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const dirPath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(dirPath, "read");
+            this.policyEnforcer.enforceFilesystem(dirPath, 'read');
         }
         try {
             const files = await fs__namespace$1.readdir(dirPath);
-            return files.join("\n");
+            return files.join('\n');
         }
         catch (error) {
-            throw new Error(`Failed to list directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to list directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -17977,24 +18206,24 @@ class FileAppendTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_append",
-            description: "Append content to the end of a file",
+            name: 'file_append',
+            description: 'Append content to the end of a file',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the file",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the file',
                     required: true,
                 },
                 {
-                    name: "content",
-                    type: "string",
-                    description: "Content to append",
+                    name: 'content',
+                    type: 'string',
+                    description: 'Content to append',
                     required: true,
                 },
             ],
-            category: "files",
-            compliance_level: "restricted",
+            category: 'files',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -18003,14 +18232,14 @@ class FileAppendTool extends Tool {
         const filePath = input.path;
         const content = input.content;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(filePath, "write");
+            this.policyEnforcer.enforceFilesystem(filePath, 'write');
         }
         try {
-            await fs__namespace$1.appendFile(filePath, content, "utf-8");
+            await fs__namespace$1.appendFile(filePath, content, 'utf-8');
             return `Successfully appended to ${filePath}`;
         }
         catch (error) {
-            throw new Error(`Failed to append to file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to append to file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -18018,18 +18247,18 @@ class FileDeleteTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_delete",
-            description: "Delete a file",
+            name: 'file_delete',
+            description: 'Delete a file',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the file to delete",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the file to delete',
                     required: true,
                 },
             ],
-            category: "files",
-            compliance_level: "restricted",
+            category: 'files',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -18037,14 +18266,14 @@ class FileDeleteTool extends Tool {
         this.validate(input);
         const filePath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(filePath, "delete");
+            this.policyEnforcer.enforceFilesystem(filePath, 'delete');
         }
         try {
             await fs__namespace$1.unlink(filePath);
             return `Successfully deleted ${filePath}`;
         }
         catch (error) {
-            throw new Error(`Failed to delete file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to delete file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -18052,24 +18281,24 @@ class FileMoveTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_move",
-            description: "Move or rename a file",
+            name: 'file_move',
+            description: 'Move or rename a file',
             parameters: [
                 {
-                    name: "from",
-                    type: "string",
-                    description: "Source file path",
+                    name: 'from',
+                    type: 'string',
+                    description: 'Source file path',
                     required: true,
                 },
                 {
-                    name: "to",
-                    type: "string",
-                    description: "Destination file path",
+                    name: 'to',
+                    type: 'string',
+                    description: 'Destination file path',
                     required: true,
                 },
             ],
-            category: "files",
-            compliance_level: "restricted",
+            category: 'files',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -18078,15 +18307,15 @@ class FileMoveTool extends Tool {
         const fromPath = input.from;
         const toPath = input.to;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(fromPath, "read");
-            this.policyEnforcer.enforceFilesystem(toPath, "write");
+            this.policyEnforcer.enforceFilesystem(fromPath, 'read');
+            this.policyEnforcer.enforceFilesystem(toPath, 'write');
         }
         try {
             await fs__namespace$1.rename(fromPath, toPath);
             return `Successfully moved ${fromPath} to ${toPath}`;
         }
         catch (error) {
-            throw new Error(`Failed to move file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to move file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -18094,24 +18323,24 @@ class FileCopyTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_copy",
-            description: "Copy a file to another location",
+            name: 'file_copy',
+            description: 'Copy a file to another location',
             parameters: [
                 {
-                    name: "from",
-                    type: "string",
-                    description: "Source file path",
+                    name: 'from',
+                    type: 'string',
+                    description: 'Source file path',
                     required: true,
                 },
                 {
-                    name: "to",
-                    type: "string",
-                    description: "Destination file path",
+                    name: 'to',
+                    type: 'string',
+                    description: 'Destination file path',
                     required: true,
                 },
             ],
-            category: "files",
-            compliance_level: "restricted",
+            category: 'files',
+            compliance_level: 'restricted',
             requires_approval: true,
         };
     }
@@ -18120,15 +18349,15 @@ class FileCopyTool extends Tool {
         const fromPath = input.from;
         const toPath = input.to;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(fromPath, "read");
-            this.policyEnforcer.enforceFilesystem(toPath, "write");
+            this.policyEnforcer.enforceFilesystem(fromPath, 'read');
+            this.policyEnforcer.enforceFilesystem(toPath, 'write');
         }
         try {
             await fs__namespace$1.copyFile(fromPath, toPath);
             return `Successfully copied ${fromPath} to ${toPath}`;
         }
         catch (error) {
-            throw new Error(`Failed to copy file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to copy file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -18136,25 +18365,25 @@ class FileStatTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_stat",
-            description: "Get file metadata (size, dates, type)",
+            name: 'file_stat',
+            description: 'Get file metadata (size, dates, type)',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to the file",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to the file',
                     required: true,
                 },
             ],
-            category: "files",
-            compliance_level: "internal",
+            category: 'files',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const filePath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(filePath, "read");
+            this.policyEnforcer.enforceFilesystem(filePath, 'read');
         }
         try {
             const stats = await fs__namespace$1.stat(filePath);
@@ -18169,7 +18398,7 @@ class FileStatTool extends Tool {
             }, null, 2);
         }
         catch (error) {
-            throw new Error(`Failed to get file stats: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to get file stats: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -18177,32 +18406,32 @@ class FileExistsTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "file_exists",
-            description: "Check if a file exists",
+            name: 'file_exists',
+            description: 'Check if a file exists',
             parameters: [
                 {
-                    name: "path",
-                    type: "string",
-                    description: "Path to check",
+                    name: 'path',
+                    type: 'string',
+                    description: 'Path to check',
                     required: true,
                 },
             ],
-            category: "files",
-            compliance_level: "internal",
+            category: 'files',
+            compliance_level: 'internal',
         };
     }
     async execute(input) {
         this.validate(input);
         const filePath = input.path;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceFilesystem(filePath, "read");
+            this.policyEnforcer.enforceFilesystem(filePath, 'read');
         }
         try {
             await fs__namespace$1.access(filePath);
-            return "true";
+            return 'true';
         }
         catch {
-            return "false";
+            return 'false';
         }
     }
 }
@@ -18214,71 +18443,172 @@ class FileChmodTool extends Tool {
             description: 'Change file permissions',
             parameters: [],
             category: 'files',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
-        const mode = typeof input.mode === 'string'
-            ? parseInt(input.mode, 8)
-            : input.mode;
+        const mode = typeof input.mode === 'string' ? parseInt(input.mode, 8) : input.mode;
         await fs__namespace$1.chmod(input.path, mode);
         return { changed: true };
     }
 }
 
+class GoogleDocsCreateTool extends Tool {
+    constructor() {
+        super(...arguments);
+        this.metadata = {
+            name: 'google_docs_create',
+            description: 'Create a Google Doc (optionally in a folder) and write initial content. Requires GOOGLE_ACCESS_TOKEN or GOOGLE_DRIVE_MOCK=true.',
+            parameters: [
+                {
+                    name: 'title',
+                    type: 'string',
+                    description: 'Document title',
+                    required: true,
+                },
+                {
+                    name: 'content',
+                    type: 'string',
+                    description: 'Initial document body text',
+                    required: false,
+                },
+                {
+                    name: 'folder_id',
+                    type: 'string',
+                    description: 'Optional Google Drive folder ID (uses GOOGLE_DRIVE_FOLDER_ID if omitted)',
+                    required: false,
+                },
+            ],
+            category: 'google-workspace',
+            compliance_level: 'restricted',
+            requires_approval: false,
+        };
+    }
+    async execute(input) {
+        this.validate(input);
+        const title = String(input.title);
+        const content = typeof input.content === 'string' ? input.content : '';
+        const folderId = typeof input.folder_id === 'string' ? input.folder_id : '';
+        const mockMode = (process.env.GOOGLE_DRIVE_MOCK || '').toLowerCase() === 'true';
+        if (mockMode) {
+            const fakeId = `mock_${Date.now().toString(36)}`;
+            return {
+                documentId: fakeId,
+                url: `https://docs.google.com/document/d/${fakeId}/edit`,
+            };
+        }
+        const accessToken = (process.env.GOOGLE_ACCESS_TOKEN || '').trim();
+        if (!accessToken) {
+            throw new Error('Missing GOOGLE_ACCESS_TOKEN (or set GOOGLE_DRIVE_MOCK=true).');
+        }
+        const effectiveFolderId = (folderId || process.env.GOOGLE_DRIVE_FOLDER_ID || '').trim();
+        const driveCreateBody = {
+            name: title,
+            mimeType: 'application/vnd.google-apps.document',
+        };
+        if (effectiveFolderId) {
+            driveCreateBody.parents = [effectiveFolderId];
+        }
+        const driveRes = await fetch('https://www.googleapis.com/drive/v3/files?supportsAllDrives=true', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(driveCreateBody),
+        });
+        if (!driveRes.ok) {
+            const text = await driveRes.text().catch(() => '');
+            throw new Error(`Drive create failed: ${driveRes.status} ${driveRes.statusText} ${text}`);
+        }
+        const driveJson = (await driveRes.json());
+        const documentId = driveJson.id;
+        if (!documentId) {
+            throw new Error('Drive create returned no file id');
+        }
+        if (content.trim().length > 0) {
+            const docsRes = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}:batchUpdate`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    requests: [
+                        {
+                            insertText: {
+                                location: { index: 1 },
+                                text: content,
+                            },
+                        },
+                    ],
+                }),
+            });
+            if (!docsRes.ok) {
+                const text = await docsRes.text().catch(() => '');
+                throw new Error(`Docs update failed: ${docsRes.status} ${docsRes.statusText} ${text}`);
+            }
+        }
+        return {
+            documentId,
+            url: `https://docs.google.com/document/d/${documentId}/edit`,
+        };
+    }
+}
+
 class HttpRequestTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "http_request",
-            description: "Make HTTP requests to external APIs",
+            name: 'http_request',
+            description: 'Make HTTP requests to external APIs',
             parameters: [
                 {
-                    name: "url",
-                    type: "string",
-                    description: "The URL to make the request to",
+                    name: 'url',
+                    type: 'string',
+                    description: 'The URL to make the request to',
                     required: true,
                 },
                 {
-                    name: "method",
-                    type: "string",
-                    description: "HTTP method (GET, POST, PUT, DELETE)",
+                    name: 'method',
+                    type: 'string',
+                    description: 'HTTP method (GET, POST, PUT, DELETE)',
                     required: false,
-                    default: "GET",
+                    default: 'GET',
                 },
                 {
-                    name: "headers",
-                    type: "object",
-                    description: "HTTP headers as key-value pairs",
+                    name: 'headers',
+                    type: 'object',
+                    description: 'HTTP headers as key-value pairs',
                     required: false,
                 },
                 {
-                    name: "body",
-                    type: "object",
-                    description: "Request body for POST/PUT requests",
+                    name: 'body',
+                    type: 'object',
+                    description: 'Request body for POST/PUT requests',
                     required: false,
                 },
             ],
-            category: "network",
-            compliance_level: "internal",
+            category: 'network',
+            compliance_level: 'internal',
             requires_approval: true,
         };
     }
     async execute(input) {
         this.validate(input);
         const url = input.url;
-        const method = input.method?.toUpperCase() || "GET";
+        const method = input.method?.toUpperCase() || 'GET';
         const headers = input.headers || {};
         const body = input.body;
         if (this.policyEnforcer) {
             try {
                 const parsedUrl = new URL(url);
                 // Remove trailing colon from protocol (e.g., 'https:' -> 'https')
-                const protocol = parsedUrl.protocol.replace(":", "");
+                const protocol = parsedUrl.protocol.replace(':', '');
                 this.policyEnforcer.enforceNetwork(parsedUrl.hostname, protocol);
             }
             catch (e) {
-                if (e instanceof Error && e.message.includes("Invalid URL")) {
+                if (e instanceof Error && e.message.includes('Invalid URL')) {
                     throw new Error(`Invalid URL: ${url}`);
                 }
                 throw e;
@@ -18302,7 +18632,7 @@ class HttpRequestTool extends Tool {
             if (axios.isAxiosError(error)) {
                 throw new Error(`HTTP request failed: ${error.response?.status} - ${error.message}`);
             }
-            throw new Error(`HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`HTTP request failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -18315,7 +18645,7 @@ class HttpPostTool extends Tool {
             description: 'Send HTTP POST request',
             parameters: [],
             category: 'network',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18332,7 +18662,9 @@ class HttpPostTool extends Tool {
             statusText: response.statusText,
             headers: (() => {
                 const h = {};
-                response.headers.forEach((v, k) => { h[k] = v; });
+                response.headers.forEach((v, k) => {
+                    h[k] = v;
+                });
                 return h;
             })(),
             body: await response.text(),
@@ -18347,7 +18679,7 @@ class HttpPutTool extends Tool {
             description: 'Send HTTP PUT request',
             parameters: [],
             category: 'network',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18364,7 +18696,9 @@ class HttpPutTool extends Tool {
             statusText: response.statusText,
             headers: (() => {
                 const h = {};
-                response.headers.forEach((v, k) => { h[k] = v; });
+                response.headers.forEach((v, k) => {
+                    h[k] = v;
+                });
                 return h;
             })(),
             body: await response.text(),
@@ -18379,7 +18713,7 @@ class HttpDeleteTool extends Tool {
             description: 'Send HTTP DELETE request',
             parameters: [],
             category: 'network',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18392,7 +18726,9 @@ class HttpDeleteTool extends Tool {
             statusText: response.statusText,
             headers: (() => {
                 const h = {};
-                response.headers.forEach((v, k) => { h[k] = v; });
+                response.headers.forEach((v, k) => {
+                    h[k] = v;
+                });
                 return h;
             })(),
             body: await response.text(),
@@ -18407,7 +18743,7 @@ class DownloadFileTool extends Tool {
             description: 'Download file from URL',
             parameters: [],
             category: 'network',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18415,7 +18751,8 @@ class DownloadFileTool extends Tool {
         const protocol = parsedUrl.protocol === 'https:' ? https__namespace : http__namespace;
         return new Promise((resolve, reject) => {
             const file = fs__namespace.createWriteStream(input.destination);
-            protocol.get(input.url, (response) => {
+            protocol
+                .get(input.url, (response) => {
                 if (response.statusCode !== 200) {
                     reject(new Error(`Failed to download: ${response.statusCode}`));
                     return;
@@ -18429,7 +18766,8 @@ class DownloadFileTool extends Tool {
                         size: stats.size,
                     });
                 });
-            }).on('error', (err) => {
+            })
+                .on('error', (err) => {
                 fs__namespace.unlinkSync(input.destination);
                 reject(err);
             });
@@ -18444,7 +18782,7 @@ class DnsLookupTool extends Tool {
             description: 'Perform DNS lookup',
             parameters: [],
             category: 'network',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18461,7 +18799,7 @@ class PingTool extends Tool {
             description: 'Ping a host',
             parameters: [],
             category: 'network',
-            compliance_level: 'public'
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18492,10 +18830,10 @@ class ToolPatternParser {
      */
     static getCategoryPrefix(category) {
         const prefixMap = {
-            files: "file",
-            directories: "dir",
-            utilities: "util",
-            agent_communication: "agent",
+            files: 'file',
+            directories: 'dir',
+            utilities: 'util',
+            agent_communication: 'agent',
         };
         return prefixMap[category] || category;
     }
@@ -18507,23 +18845,23 @@ class ToolPatternParser {
      */
     static parse(pattern, registry) {
         // Simple tool name (no colon)
-        if (!pattern.includes(":")) {
+        if (!pattern.includes(':')) {
             return [pattern];
         }
-        const [category, operations] = pattern.split(":", 2);
+        const [category, operations] = pattern.split(':', 2);
         // Validate category exists
         if (!registry.hasCategory(category)) {
             throw new Error(`Unknown tool category: ${category}`);
         }
         // Wildcard: all tools in category
-        if (operations === "*") {
+        if (operations === '*') {
             return registry.getToolsByCategory(category);
         }
         // Granular selection: [read,write,delete]
-        if (operations.startsWith("[") && operations.endsWith("]")) {
+        if (operations.startsWith('[') && operations.endsWith(']')) {
             const ops = operations
                 .slice(1, -1)
-                .split(",")
+                .split(',')
                 .map((s) => s.trim())
                 .filter((s) => s.length > 0);
             // Convert category to singular form for tool naming
@@ -18562,11 +18900,11 @@ class GetCwdTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "get_cwd",
-            description: "Get current working directory",
+            name: 'get_cwd',
+            description: 'Get current working directory',
             parameters: [],
-            category: "system",
-            compliance_level: "public",
+            category: 'system',
+            compliance_level: 'public',
         };
     }
     async execute() {
@@ -18577,11 +18915,11 @@ class GetPlatformTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "get_platform",
-            description: "Get system platform information",
+            name: 'get_platform',
+            description: 'Get system platform information',
             parameters: [],
-            category: "system",
-            compliance_level: "public",
+            category: 'system',
+            compliance_level: 'public',
         };
     }
     async execute() {
@@ -18603,26 +18941,26 @@ class EnvGetTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "env_get",
-            description: "Get environment variable (read-only)",
+            name: 'env_get',
+            description: 'Get environment variable (read-only)',
             parameters: [],
-            category: "system",
-            compliance_level: "public",
+            category: 'system',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
-        return process.env[input.key] || "";
+        return process.env[input.key] || '';
     }
 }
 class EnvSetTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "env_set",
-            description: "Set environment variable (DANGEROUS)",
+            name: 'env_set',
+            description: 'Set environment variable (DANGEROUS)',
             parameters: [],
-            category: "system",
-            compliance_level: "public",
+            category: 'system',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18635,28 +18973,28 @@ class DateFormatTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "date_format",
-            description: "Format dates in various formats",
+            name: 'date_format',
+            description: 'Format dates in various formats',
             parameters: [],
-            category: "utils",
-            compliance_level: "public",
+            category: 'utils',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
         const date = input.date ? new Date(input.date) : new Date();
-        const format = input.format || "iso";
+        const format = input.format || 'iso';
         switch (format.toLowerCase()) {
-            case "iso":
+            case 'iso':
                 return date.toISOString();
-            case "date":
+            case 'date':
                 return date.toDateString();
-            case "time":
+            case 'time':
                 return date.toTimeString();
-            case "locale":
+            case 'locale':
                 return date.toLocaleString();
-            case "utc":
+            case 'utc':
                 return date.toUTCString();
-            case "unix":
+            case 'unix':
                 return Math.floor(date.getTime() / 1000).toString();
             default:
                 return date.toISOString();
@@ -18667,28 +19005,28 @@ class GenerateUuidTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "generate_uuid",
-            description: "Generate UUID v4",
+            name: 'generate_uuid',
+            description: 'Generate UUID v4',
             parameters: [],
-            category: "utils",
-            compliance_level: "public",
+            category: 'utils',
+            compliance_level: 'public',
         };
     }
     async execute() {
         return crypto$2.randomBytes(16)
-            .toString("hex")
-            .replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+            .toString('hex')
+            .replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, '$1-$2-$3-$4-$5');
     }
 }
 class RandomNumberTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "random_number",
-            description: "Generate random number",
+            name: 'random_number',
+            description: 'Generate random number',
             parameters: [],
-            category: "utils",
-            compliance_level: "public",
+            category: 'utils',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18701,11 +19039,11 @@ class SleepTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "sleep",
-            description: "Delay execution for specified milliseconds",
+            name: 'sleep',
+            description: 'Delay execution for specified milliseconds',
             parameters: [],
-            category: "utils",
-            compliance_level: "public",
+            category: 'utils',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18718,15 +19056,15 @@ class RegexMatchTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "regex_match",
-            description: "Match text against regular expression",
+            name: 'regex_match',
+            description: 'Match text against regular expression',
             parameters: [],
-            category: "utils",
-            compliance_level: "public",
+            category: 'utils',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
-        const regex = new RegExp(input.pattern, input.flags || "g");
+        const regex = new RegExp(input.pattern, input.flags || 'g');
         const matches = [];
         const groups = [];
         let match;
@@ -18743,11 +19081,11 @@ class UrlParseTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "url_parse",
-            description: "Parse URL into components",
+            name: 'url_parse',
+            description: 'Parse URL into components',
             parameters: [],
-            category: "utils",
-            compliance_level: "public",
+            category: 'utils',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -18788,51 +19126,48 @@ class VerificationStatusTool extends Tool {
     constructor(registryUrl) {
         super();
         this.metadata = {
-            name: "get_verification_status",
-            description: "Check the verification and compliance status of this agent in the Sekuire registry. This tool is required for trust protocol compliance and must not be removed.",
+            name: 'get_verification_status',
+            description: 'Check the verification and compliance status of this agent in the Sekuire registry. This tool is required for trust protocol compliance and must not be removed.',
             parameters: [
                 {
-                    name: "sekuire_id",
-                    type: "string",
-                    description: "The Sekuire ID of the agent to check (defaults to current agent)",
+                    name: 'sekuire_id',
+                    type: 'string',
+                    description: 'The Sekuire ID of the agent to check (defaults to current agent)',
                     required: false,
                 },
                 {
-                    name: "include_details",
-                    type: "boolean",
-                    description: "Include detailed verification information",
+                    name: 'include_details',
+                    type: 'boolean',
+                    description: 'Include detailed verification information',
                     required: false,
                 },
             ],
-            category: "compliance",
-            compliance_level: "system", // System-level tool that cannot be disabled
+            category: 'compliance',
+            compliance_level: 'system', // System-level tool that cannot be disabled
         };
         // Default to production registry, or use custom URL
-        this.registryUrl =
-            registryUrl ||
-                process.env.SEKUIRE_REGISTRY_URL ||
-                "http://localhost:5556";
+        this.registryUrl = registryUrl || process.env.SEKUIRE_REGISTRY_URL || 'http://localhost:5556';
     }
     async execute(input) {
         this.validate(input);
         const sekuireId = input.sekuire_id || this.getAgentId();
         const includeDetails = input.include_details || false;
         if (!sekuireId) {
-            throw new Error("No Sekuire ID provided and unable to determine current agent ID");
+            throw new Error('No Sekuire ID provided and unable to determine current agent ID');
         }
         try {
             // Query the Sekuire registry API
             const response = await fetch(`${this.registryUrl}/api/v1/agents/${sekuireId}`, {
-                method: "GET",
+                method: 'GET',
                 headers: {
-                    "Content-Type": "application/json",
-                    "User-Agent": "Sekuire-SDK/1.0",
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'Sekuire-SDK/1.0',
                 },
             });
             if (!response.ok) {
                 if (response.status === 404) {
                     return JSON.stringify({
-                        status: "error",
+                        status: 'error',
                         message: `Agent ${sekuireId} not found in registry. This agent may not be registered or verified.`,
                         is_verified: false,
                         is_compliant: false,
@@ -18844,7 +19179,7 @@ class VerificationStatusTool extends Tool {
             // Build verification status response
             const result = {
                 sekuire_id: agentData.sekuire_id,
-                verification_status: agentData.verification_status || "Unverified",
+                verification_status: agentData.verification_status || 'Unverified',
                 reputation_score: agentData.reputation_score || 0,
                 security_score: agentData.security_score,
                 code_review_status: agentData.code_review_status,
@@ -18867,8 +19202,8 @@ class VerificationStatusTool extends Tool {
         }
         catch (error) {
             return JSON.stringify({
-                status: "error",
-                message: `Failed to verify agent status: ${error instanceof Error ? error.message : "Unknown error"}`,
+                status: 'error',
+                message: `Failed to verify agent status: ${error instanceof Error ? error.message : 'Unknown error'}`,
                 is_verified: false,
                 is_compliant: false,
                 recommendation: "Unable to verify agent. Please ensure the agent is properly registered with 'sekuire publish'.",
@@ -18885,11 +19220,11 @@ class VerificationStatusTool extends Tool {
             return envId;
         // Try to read from .sekuire directory
         try {
-            const fs = require("node:fs");
-            const path = require("node:path");
-            const sekuirePath = path.join(process.cwd(), ".sekuire", "agent.json");
+            const fs = require('node:fs');
+            const path = require('node:path');
+            const sekuirePath = path.join(process.cwd(), '.sekuire', 'agent.json');
             if (fs.existsSync(sekuirePath)) {
-                const config = JSON.parse(fs.readFileSync(sekuirePath, "utf-8"));
+                const config = JSON.parse(fs.readFileSync(sekuirePath, 'utf-8'));
                 return config.sekuire_id;
             }
         }
@@ -18904,7 +19239,7 @@ class VerificationStatusTool extends Tool {
     extractComplianceFrameworks(manifest) {
         const frameworks = [];
         try {
-            const manifestObj = typeof manifest === "string" ? JSON.parse(manifest) : manifest;
+            const manifestObj = typeof manifest === 'string' ? JSON.parse(manifest) : manifest;
             if (manifestObj?.agent?.compliance?.framework) {
                 frameworks.push(manifestObj.agent.compliance.framework);
             }
@@ -18918,8 +19253,7 @@ class VerificationStatusTool extends Tool {
      * Determine if agent is compliant based on verification status and checks
      */
     isCompliant(agentData) {
-        const hasVerification = agentData.verification_status === "Verified" ||
-            agentData.verification_status === "Pending";
+        const hasVerification = agentData.verification_status === 'Verified' || agentData.verification_status === 'Pending';
         const hasGoodReputation = (Number(agentData.reputation_score) || 0) >= 0;
         const hasSecurityScore = (Number(agentData.security_score) || 0) >= 60;
         return hasVerification && hasGoodReputation && hasSecurityScore;
@@ -18930,9 +19264,9 @@ class VerificationStatusTool extends Tool {
     calculateComplianceScore(agentData) {
         let score = 0;
         // Verification status (40 points)
-        if (agentData.verification_status === "Verified")
+        if (agentData.verification_status === 'Verified')
             score += 40;
-        else if (agentData.verification_status === "Pending")
+        else if (agentData.verification_status === 'Pending')
             score += 20;
         // Reputation (30 points)
         const repScore = Math.min(30, Math.floor((Number(agentData.reputation_score) || 0) / 10));
@@ -18941,7 +19275,7 @@ class VerificationStatusTool extends Tool {
         const secScore = Math.min(20, Math.floor(((Number(agentData.security_score) || 0) / 100) * 20));
         score += secScore;
         // Code review (10 points)
-        if (agentData.code_review_status === "approved")
+        if (agentData.code_review_status === 'approved')
             score += 10;
         return score;
     }
@@ -18949,11 +19283,11 @@ class VerificationStatusTool extends Tool {
      * Format the response for the agent
      */
     formatResponse(result) {
-        const statusEmoji = result.verification_status === "Verified"
-            ? "✅"
-            : result.verification_status === "Pending"
-                ? "⏳"
-                : "⚠️";
+        const statusEmoji = result.verification_status === 'Verified'
+            ? '✅'
+            : result.verification_status === 'Pending'
+                ? '⏳'
+                : '⚠️';
         let response = `${statusEmoji} Agent Verification Status\n\n`;
         response += `Sekuire ID: ${result.sekuire_id}\n`;
         response += `Status: ${result.verification_status}\n`;
@@ -18962,14 +19296,14 @@ class VerificationStatusTool extends Tool {
             response += `Security Score: ${result.security_score}/100\n`;
         }
         if (result.compliance_frameworks.length > 0) {
-            response += `Compliance: ${result.compliance_frameworks.join(", ")}\n`;
+            response += `Compliance: ${result.compliance_frameworks.join(', ')}\n`;
         }
-        response += `\nCompliant: ${result.is_compliant ? "Yes ✓" : "No ✗"}\n`;
+        response += `\nCompliant: ${result.is_compliant ? 'Yes ✓' : 'No ✗'}\n`;
         if (result.verification_details) {
             response += `\nDetailed Verification:\n`;
-            response += `  • Valid Signature: ${result.verification_details.has_valid_signature ? "✓" : "✗"}\n`;
-            response += `  • Repository Verified: ${result.verification_details.repository_verified ? "✓" : "✗"}\n`;
-            response += `  • Security Checks: ${result.verification_details.passes_security_checks ? "✓" : "✗"}\n`;
+            response += `  • Valid Signature: ${result.verification_details.has_valid_signature ? '✓' : '✗'}\n`;
+            response += `  • Repository Verified: ${result.verification_details.repository_verified ? '✓' : '✗'}\n`;
+            response += `  • Security Checks: ${result.verification_details.passes_security_checks ? '✓' : '✗'}\n`;
             response += `  • Compliance Score: ${result.verification_details.compliance_score}/100\n`;
         }
         if (!result.is_compliant) {
@@ -18984,25 +19318,25 @@ class WebSearchTool extends Tool {
     constructor() {
         super(...arguments);
         this.metadata = {
-            name: "web_search",
-            description: "Search the web for information using various search engines",
+            name: 'web_search',
+            description: 'Search the web for information using various search engines',
             parameters: [
                 {
-                    name: "query",
-                    type: "string",
-                    description: "The search query",
+                    name: 'query',
+                    type: 'string',
+                    description: 'The search query',
                     required: true,
                 },
                 {
-                    name: "num_results",
-                    type: "number",
-                    description: "Number of results to return",
+                    name: 'num_results',
+                    type: 'number',
+                    description: 'Number of results to return',
                     required: false,
                     default: 5,
                 },
             ],
-            category: "web",
-            compliance_level: "public",
+            category: 'web',
+            compliance_level: 'public',
         };
     }
     async execute(input) {
@@ -19010,14 +19344,14 @@ class WebSearchTool extends Tool {
         const query = input.query;
         const numResults = input.num_results || 5;
         if (this.policyEnforcer) {
-            this.policyEnforcer.enforceNetwork("api.duckduckgo.com", "https");
+            this.policyEnforcer.enforceNetwork('api.duckduckgo.com', 'https');
         }
         // Use DuckDuckGo Instant Answer API (no auth required)
         try {
-            const response = await axios.get("https://api.duckduckgo.com/", {
+            const response = await axios.get('https://api.duckduckgo.com/', {
                 params: {
                     q: query,
-                    format: "json",
+                    format: 'json',
                     no_html: 1,
                 },
             });
@@ -19036,10 +19370,10 @@ class WebSearchTool extends Tool {
             if (results.length === 0) {
                 return `No results found for query: ${query}`;
             }
-            return `Search results for "${query}":\n\n${results.join("\n\n")}`;
+            return `Search results for "${query}":\n\n${results.join('\n\n')}`;
         }
         catch (error) {
-            throw new Error(`Web search failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Web search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 }
@@ -19075,6 +19409,8 @@ function createDefaultToolRegistry(options) {
     registry.register(new DownloadFileTool());
     registry.register(new DnsLookupTool());
     registry.register(new PingTool());
+    // Google Workspace category
+    registry.register(new GoogleDocsCreateTool());
     // Data category
     registry.register(new JsonParseTool());
     registry.register(new JsonStringifyTool());
@@ -19145,6 +19481,8 @@ const builtInTools = {
     DownloadFileTool,
     DnsLookupTool,
     PingTool,
+    // Google Workspace
+    GoogleDocsCreateTool,
     // Data
     JsonParseTool,
     JsonStringifyTool,
@@ -19184,236 +19522,6 @@ const builtInTools = {
     DecryptDataTool,
 };
 
-class BaseMemoryStorage {
-}
-
-class InMemoryStorage extends BaseMemoryStorage {
-    constructor() {
-        super(...arguments);
-        this.storage = new Map();
-    }
-    async add(sessionId, message) {
-        if (!this.storage.has(sessionId)) {
-            this.storage.set(sessionId, []);
-        }
-        this.storage.get(sessionId).push(message);
-    }
-    async get(sessionId, limit) {
-        const messages = this.storage.get(sessionId) || [];
-        if (limit) {
-            return messages.slice(-limit);
-        }
-        return messages;
-    }
-    async clear(sessionId) {
-        this.storage.set(sessionId, []);
-    }
-    async delete(sessionId) {
-        this.storage.delete(sessionId);
-    }
-    async exists(sessionId) {
-        return this.storage.has(sessionId);
-    }
-}
-
-class PostgresStorage extends BaseMemoryStorage {
-    constructor(config) {
-        super();
-        this.initialized = false;
-        this.tableName = config.tableName || "sekuire_memory";
-        this.initPool(config);
-    }
-    async initPool(config) {
-        try {
-            const { Pool } = await import('pg');
-            if (config.connectionString) {
-                this.pool = new Pool({ connectionString: config.connectionString });
-            }
-            else {
-                this.pool = new Pool({
-                    host: config.host || "localhost",
-                    port: config.port || 5432,
-                    database: config.database,
-                    user: config.user,
-                    password: config.password,
-                });
-            }
-            await this.createTableIfNotExists();
-            this.initialized = true;
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize Postgres: ${error}`);
-        }
-    }
-    async createTableIfNotExists() {
-        const query = `
-      CREATE TABLE IF NOT EXISTS ${this.tableName} (
-        id SERIAL PRIMARY KEY,
-        session_id VARCHAR(255) NOT NULL,
-        role VARCHAR(50) NOT NULL,
-        content TEXT NOT NULL,
-        timestamp BIGINT NOT NULL,
-        metadata JSONB,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
-      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_session_id ON ${this.tableName}(session_id);
-    `;
-        await this.pool.query(query);
-    }
-    async add(sessionId, message) {
-        if (!this.initialized)
-            throw new Error("Postgres not initialized");
-        const query = `
-      INSERT INTO ${this.tableName} (session_id, role, content, timestamp, metadata)
-      VALUES ($1, $2, $3, $4, $5)
-    `;
-        await this.pool.query(query, [
-            sessionId,
-            message.role,
-            message.content,
-            message.timestamp,
-            message.metadata ? JSON.stringify(message.metadata) : null,
-        ]);
-    }
-    async get(sessionId, limit) {
-        if (!this.initialized)
-            throw new Error("Postgres not initialized");
-        let query = `
-      SELECT role, content, timestamp, metadata
-      FROM ${this.tableName}
-      WHERE session_id = $1
-      ORDER BY timestamp ASC
-    `;
-        if (limit) {
-            query += ` LIMIT ${limit}`;
-        }
-        const result = await this.pool.query(query, [sessionId]);
-        return result.rows.map((row) => ({
-            role: row.role,
-            content: row.content,
-            timestamp: row.timestamp,
-            metadata: row.metadata,
-        }));
-    }
-    async clear(sessionId) {
-        if (!this.initialized)
-            throw new Error("Postgres not initialized");
-        const query = `DELETE FROM ${this.tableName} WHERE session_id = $1`;
-        await this.pool.query(query, [sessionId]);
-    }
-    async delete(sessionId) {
-        await this.clear(sessionId);
-    }
-    async exists(sessionId) {
-        if (!this.initialized)
-            throw new Error("Postgres not initialized");
-        const query = `SELECT COUNT(*) FROM ${this.tableName} WHERE session_id = $1`;
-        const result = await this.pool.query(query, [sessionId]);
-        return parseInt(result.rows[0].count) > 0;
-    }
-    async disconnect() {
-        if (this.initialized) {
-            await this.pool.end();
-            this.initialized = false;
-        }
-    }
-}
-
-class RedisStorage extends BaseMemoryStorage {
-    constructor(config) {
-        super();
-        this.client = null;
-        this.connected = false;
-        this.keyPrefix = config.keyPrefix || "sekuire:memory:";
-        this.initClient(config);
-    }
-    async initClient(config) {
-        try {
-            const { createClient } = await import('redis');
-            if (config.url) {
-                this.client = createClient({ url: config.url });
-            }
-            else {
-                this.client = createClient({
-                    socket: {
-                        host: config.host || "localhost",
-                        port: config.port || 6379,
-                    },
-                    password: config.password,
-                    database: config.db || 0,
-                });
-            }
-            this.client.on("error", (err) => {
-                console.error("Redis client error:", err);
-            });
-            await this.client.connect();
-            this.connected = true;
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize Redis: ${error}`);
-        }
-    }
-    getKey(sessionId) {
-        return `${this.keyPrefix}${sessionId}`;
-    }
-    async add(sessionId, message) {
-        if (!this.connected)
-            throw new Error("Redis not connected");
-        const key = this.getKey(sessionId);
-        await this.client.rPush(key, JSON.stringify(message));
-    }
-    async get(sessionId, limit) {
-        if (!this.connected)
-            throw new Error("Redis not connected");
-        const key = this.getKey(sessionId);
-        const start = limit ? -limit : 0;
-        const messages = await this.client.lRange(key, start, -1);
-        return messages.map((msg) => JSON.parse(msg));
-    }
-    async clear(sessionId) {
-        if (!this.connected)
-            throw new Error("Redis not connected");
-        const key = this.getKey(sessionId);
-        await this.client.del(key);
-    }
-    async delete(sessionId) {
-        await this.clear(sessionId);
-    }
-    async exists(sessionId) {
-        if (!this.connected)
-            throw new Error("Redis not connected");
-        const key = this.getKey(sessionId);
-        return (await this.client.exists(key)) === 1;
-    }
-    async disconnect() {
-        if (this.connected) {
-            await this.client.quit();
-            this.connected = false;
-        }
-    }
-}
-
-function createMemoryStorage(config) {
-    // Normalize type (support "buffer" as alias for "in-memory")
-    const normalizedType = config.type === "buffer" ? "in-memory" : config.type;
-    switch (normalizedType) {
-        case "in-memory":
-            return new InMemoryStorage();
-        case "redis":
-            if (!config.redis) {
-                throw new Error("Redis config required for redis memory type");
-            }
-            return new RedisStorage(config.redis);
-        case "postgres":
-            if (!config.postgres) {
-                throw new Error("Postgres config required for postgres memory type");
-            }
-            return new PostgresStorage(config.postgres);
-        default:
-            throw new Error(`Unknown memory type: ${config.type}`);
-    }
-}
-
 // Load environment variables
 dotenv.config();
 // Global cache for policy files to prevent repetitive disk I/O
@@ -20009,6 +20117,14 @@ class SekuireServer {
     getAgentId() {
         return this.agentId;
     }
+    /**
+     * Handle incoming webhooks from other agents
+     */
+    async handleWebhook(payload, signature) {
+        // In a real implementation, we would verify the signature
+        // For now, we just pass the payload through to be handled by the implementation
+        return { received: true };
+    }
 }
 /**
  * Express.js middleware for Sekuire protocol
@@ -20032,6 +20148,11 @@ function createSekuireExpressMiddleware(server) {
                     await server.handleAuth(req.body, clientNonce);
                     return res.json({ success: true });
                 }
+                else if (req.path === "/sekuire/webhook" && req.method === "POST") {
+                    const signature = req.headers["x-sekuire-signature"];
+                    const result = await server.handleWebhook(req.body, signature);
+                    return res.json(result);
+                }
                 next();
             }
             catch (error) {
@@ -20084,6 +20205,86 @@ function createSekuireFastifyPlugin(server) {
                 return { error: error.message };
             }
         });
+        fastify.post("/sekuire/webhook", async (request, reply) => {
+            try {
+                const signature = request.headers["x-sekuire-signature"];
+                const result = await server.handleWebhook(request.body, signature);
+                return result;
+            }
+            catch (error) {
+                reply.code(500);
+                return { error: error.message };
+            }
+        });
+    };
+}
+
+/**
+ * Create a tool for discovering other agents in the Sekuire network
+ */
+function createDiscoveryTool(client) {
+    return {
+        name: 'discover_agents',
+        description: "Search for other AI agents in the Sekuire network by capability or name. Use this to find agents that can help with specific tasks (e.g., 'jira', 'google drive').",
+        schema: zod.z.object({
+            query: zod.z.string().describe("The search query (e.g., 'jira', 'drive', 'github')"),
+        }),
+        execute: async ({ query }) => {
+            try {
+                const agents = await client.searchAgents(query);
+                if (agents.length === 0) {
+                    return `No agents found matching '${query}'.`;
+                }
+                return agents.map((a) => ({
+                    name: a.name,
+                    id: a.sekuire_id,
+                    description: a.description,
+                    status: a.verification_status,
+                }));
+            }
+            catch (error) {
+                return `Error searching for agents: ${error.message}`;
+            }
+        },
+    };
+}
+/**
+ * Create a tool for delegating tasks to other agents
+ */
+function createDelegationTool(client) {
+    return {
+        name: 'delegate_task',
+        description: "Delegate a task to another agent. Requires the target agent's Sekuire ID (found via discover_agents).",
+        schema: zod.z.object({
+            agent_id: zod.z.string().describe('The Sekuire ID of the target agent'),
+            task: zod.z.string().describe('The task description or message to send to the agent'),
+            context: zod.z.record(zod.z.any()).optional().describe('Optional context data to pass'),
+        }),
+        execute: async ({ agent_id, task, context }) => {
+            try {
+                // 1. Get Agent Info
+                const agentInfo = await client.getAgentInfo(agent_id);
+                // 2. Perform Handshake & Auth (Simulated for this phase as we don't have dynamic URLs yet)
+                // In a real scenario:
+                // const handshake = await client.connect(agentInfo.url);
+                // 3. Send Task
+                // const result = await client.sendTask(handshake.session, { task, context });
+                // For the demo/prototype phase without dynamic routing:
+                // We simulate the success message. The actual inter-process communication
+                // would happen here via HTTP/WebSocket.
+                return {
+                    status: 'success',
+                    message: `Task successfully delegated to ${agentInfo.name || agent_id}`,
+                    details: {
+                        recipient: agent_id,
+                        task_summary: task.substring(0, 50) + '...',
+                    },
+                };
+            }
+            catch (error) {
+                return `Error delegating task to agent ${agent_id}: ${error.message}`;
+            }
+        },
     };
 }
 
@@ -20146,6 +20347,8 @@ exports.builtInTools = builtInTools;
 exports.calculateSekuireId = calculateSekuireId;
 exports.createAgent = createAgent;
 exports.createDefaultToolRegistry = createDefaultToolRegistry;
+exports.createDelegationTool = createDelegationTool;
+exports.createDiscoveryTool = createDiscoveryTool;
 exports.createLLMProvider = createLLMProvider;
 exports.createMemoryStorage = createMemoryStorage;
 exports.createSekuireClient = createSekuireClient;