@soederpop/luca 0.0.20 → 0.0.22

package/src/introspection/generated.agi.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-21T01:13:42.264Z
+// Generated at: 2026-03-21T15:48:33.144Z
 
 setBuildTimeData('features.googleDocs', {
   "id": "features.googleDocs",
@@ -3270,6 +3270,174 @@ setBuildTimeData('features.repl', {
   ]
 });
 
+setBuildTimeData('features.googleMail', {
+  "id": "features.googleMail",
+  "description": "Google Mail feature for searching, reading, and watching Gmail messages. Depends on the googleAuth feature for authentication. Creates a Gmail v1 API client lazily. Supports Gmail search query syntax, individual message reading, and polling-based new mail detection with event emission.",
+  "shortcut": "features.googleMail",
+  "className": "GoogleMail",
+  "methods": {
+    "search": {
+      "description": "Search for messages using Gmail query syntax and/or structured filters.",
+      "parameters": {
+        "options": {
+          "type": "SearchMailOptions",
+          "description": "Search filters including query, from, to, subject, date ranges",
+          "properties": {
+            "query": {
+              "type": "string",
+              "description": ""
+            },
+            "from": {
+              "type": "string",
+              "description": ""
+            },
+            "to": {
+              "type": "string",
+              "description": ""
+            },
+            "subject": {
+              "type": "string",
+              "description": ""
+            },
+            "after": {
+              "type": "string",
+              "description": ""
+            },
+            "before": {
+              "type": "string",
+              "description": ""
+            },
+            "hasAttachment": {
+              "type": "boolean",
+              "description": ""
+            },
+            "label": {
+              "type": "string",
+              "description": ""
+            },
+            "isUnread": {
+              "type": "boolean",
+              "description": ""
+            },
+            "maxResults": {
+              "type": "number",
+              "description": ""
+            },
+            "pageToken": {
+              "type": "string",
+              "description": ""
+            }
+          }
+        }
+      },
+      "required": [],
+      "returns": "Promise<MailMessageList>"
+    },
+    "getMessage": {
+      "description": "Get a single message by ID.",
+      "parameters": {
+        "messageId": {
+          "type": "string",
+          "description": "The message ID"
+        },
+        "format": {
+          "type": "'full' | 'metadata' | 'minimal' | 'raw'",
+          "description": "Message format (defaults to options.format or 'full')"
+        }
+      },
+      "required": [
+        "messageId"
+      ],
+      "returns": "Promise<MailMessage>"
+    },
+    "getThread": {
+      "description": "Get a full thread with all its messages.",
+      "parameters": {
+        "threadId": {
+          "type": "string",
+          "description": "The thread ID"
+        }
+      },
+      "required": [
+        "threadId"
+      ],
+      "returns": "Promise<MailThread>"
+    },
+    "listLabels": {
+      "description": "List all labels for the authenticated user.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<MailLabel[]>"
+    },
+    "startWatching": {
+      "description": "Start watching for new mail by polling at a regular interval. Emits 'newMail' events with an array of new messages when they arrive. Uses Gmail history API to efficiently detect only new messages since the last check.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<void>"
+    },
+    "stopWatching": {
+      "description": "Stop watching for new mail.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    }
+  },
+  "getters": {
+    "auth": {
+      "description": "Access the google-auth feature lazily.",
+      "returns": "GoogleAuth"
+    },
+    "userId": {
+      "description": "Default user ID from options or 'me'.",
+      "returns": "string"
+    },
+    "defaultFormat": {
+      "description": "Default message format from options or 'full'.",
+      "returns": "'full' | 'metadata' | 'minimal' | 'raw'"
+    },
+    "pollInterval": {
+      "description": "Polling interval from options or 30 seconds.",
+      "returns": "number"
+    }
+  },
+  "events": {
+    "messagesFetched": {
+      "name": "messagesFetched",
+      "description": "Event emitted by GoogleMail",
+      "arguments": {}
+    },
+    "error": {
+      "name": "error",
+      "description": "Event emitted by GoogleMail",
+      "arguments": {}
+    },
+    "watchStarted": {
+      "name": "watchStarted",
+      "description": "Event emitted by GoogleMail",
+      "arguments": {}
+    },
+    "watchStopped": {
+      "name": "watchStopped",
+      "description": "Event emitted by GoogleMail",
+      "arguments": {}
+    },
+    "newMail": {
+      "name": "newMail",
+      "description": "Event emitted by GoogleMail",
+      "arguments": {}
+    }
+  },
+  "state": {},
+  "options": {},
+  "envVars": [],
+  "examples": [
+    {
+      "language": "ts",
+      "code": "const mail = container.feature('googleMail')\n\n// Search by sender\nconst fromBoss = await mail.search({ from: 'boss@company.com' })\n\n// Use Gmail query string\nconst unread = await mail.search({ query: 'is:unread category:primary' })\n\n// Read a specific message\nconst msg = await mail.getMessage('message-id-here')\n\n// Get a full thread\nconst thread = await mail.getThread('thread-id-here')\n\n// List labels\nconst labels = await mail.listLabels()\n\n// Watch for new mail (polls and emits 'newMail' events)\nmail.on('newMail', (messages) => {\n console.log(`Got ${messages.length} new messages!`)\n})\nawait mail.startWatching()\n\n// Stop watching\nmail.stopWatching()"
+    }
+  ]
+});
+
 setBuildTimeData('features.os', {
   "id": "features.os",
   "description": "The OS feature provides access to operating system utilities and information. This feature wraps Node.js's built-in `os` module and provides convenient getters for system information like architecture, platform, directories, network interfaces, and hardware details.",
@@ -9519,135 +9687,331 @@ setBuildTimeData('clients.websocket', {
   ]
 });
 
-setBuildTimeData('clients.openai', {
-  "id": "clients.openai",
-  "description": "OpenAI client — wraps the OpenAI SDK for chat completions, responses API, embeddings, and image generation. Provides convenience methods for common operations while tracking token usage and request counts. Supports both the Chat Completions API and the newer Responses API.",
-  "shortcut": "clients.openai",
-  "className": "OpenAIClient",
+setBuildTimeData('clients.supabase', {
+  "id": "clients.supabase",
+  "description": "Supabase client for the Luca container system. Wraps the official `@supabase/supabase-js` SDK and exposes it through Luca's typed state, events, and introspection system. The SDK is isomorphic so this single implementation works in both Node and browser containers. Use `client.sdk` for full SDK access, or use the convenience wrappers for common operations (auth, database queries, storage, edge functions, realtime).",
+  "shortcut": "clients.supabase",
+  "className": "SupabaseClient",
   "methods": {
-    "connect": {
-      "description": "Test the API connection by listing models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<this>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "await openai.connect()"
-        }
-      ]
-    },
-    "createChatCompletion": {
-      "description": "Create a chat completion using the Chat Completions API.",
+    "from": {
+      "description": "Start a query on a Postgres table or view.",
       "parameters": {
-        "messages": {
-          "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
-          "description": "Array of chat messages"
-        },
-        "options": {
-          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-          "description": "Additional parameters for the completion"
+        "table": {
+          "type": "string",
+          "description": "The table or view name to query"
         }
       },
       "required": [
-        "messages"
+        "table"
       ],
-      "returns": "Promise<OpenAI.Chat.Completions.ChatCompletion>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createChatCompletion([\n { role: 'system', content: 'You are a helpful assistant.' },\n { role: 'user', content: 'Hello!' }\n])\nconsole.log(response.choices[0]?.message?.content)"
-        }
-      ]
+      "returns": "void"
     },
-    "createResponse": {
-      "description": "Create a response using the Responses API.",
+    "rpc": {
+      "description": "Call a Postgres function (RPC).",
       "parameters": {
-        "input": {
-          "type": "OpenAI.Responses.ResponseInput | string",
-          "description": "The input prompt or message array"
+        "fn": {
+          "type": "string",
+          "description": "The function name"
         },
-        "options": {
-          "type": "Partial<OpenAI.Responses.ResponseCreateParamsNonStreaming>",
-          "description": "Additional parameters for the response"
-        }
-      },
-      "required": [
-        "input"
-      ],
-      "returns": "Promise<OpenAI.Responses.Response>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createResponse('Explain quantum computing')"
-        }
-      ]
-    },
-    "streamResponse": {
-      "description": "Stream a response using the Responses API.",
-      "parameters": {
-        "input": {
-          "type": "OpenAI.Responses.ResponseInput | string",
-          "description": "The input prompt or message array"
+        "params": {
+          "type": "Record<string, unknown>",
+          "description": "Arguments to pass to the function"
         },
         "options": {
-          "type": "Partial<OpenAI.Responses.ResponseCreateParamsStreaming>",
-          "description": "Additional parameters for the streaming response"
+          "type": "{ head?: boolean; get?: boolean; count?: \"exact\" | \"planned\" | \"estimated\" }",
+          "description": "Optional settings (head, get, count)"
         }
       },
       "required": [
-        "input"
+        "fn"
       ],
-      "returns": "Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const stream = await openai.streamResponse('Write a poem')\nfor await (const event of stream) {\n if (event.type === 'response.output_text.delta') {\n   process.stdout.write(event.delta)\n }\n}"
-        }
-      ]
+      "returns": "void"
     },
-    "createCompletion": {
-      "description": "Create a legacy text completion.",
+    "signInWithPassword": {
+      "description": "Sign in with email and password.",
       "parameters": {
-        "prompt": {
+        "email": {
           "type": "string",
-          "description": "The text prompt to complete"
+          "description": "Parameter email"
         },
-        "options": {
-          "type": "Partial<OpenAI.Completions.CompletionCreateParams>",
-          "description": "Additional parameters for the completion"
+        "password": {
+          "type": "string",
+          "description": "Parameter password"
         }
       },
       "required": [
-        "prompt"
+        "email",
+        "password"
       ],
-      "returns": "Promise<OpenAI.Completions.Completion>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const response = await openai.createCompletion('Once upon a time')"
-        }
-      ]
+      "returns": "void"
     },
-    "createEmbedding": {
-      "description": "Create text embeddings for semantic search or similarity comparisons.",
+    "signUp": {
+      "description": "Create a new user account with email and password.",
       "parameters": {
-        "input": {
-          "type": "string | string[]",
-          "description": "A string or array of strings to embed"
+        "email": {
+          "type": "string",
+          "description": "Parameter email"
         },
-        "options": {
-          "type": "Partial<OpenAI.Embeddings.EmbeddingCreateParams>",
-          "description": "Additional parameters (model, etc.)"
+        "password": {
+          "type": "string",
+          "description": "Parameter password"
         }
       },
       "required": [
-        "input"
+        "email",
+        "password"
       ],
-      "returns": "Promise<OpenAI.Embeddings.CreateEmbeddingResponse>",
-      "examples": [
-        {
-          "language": "ts",
+      "returns": "void"
+    },
+    "signOut": {
+      "description": "Sign the current user out.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "getSession": {
+      "description": "Get the current session, if any.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "getUser": {
+      "description": "Get the current user, if any.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "invoke": {
+      "description": "Invoke a Supabase Edge Function by name.",
+      "parameters": {
+        "name": {
+          "type": "string",
+          "description": "Parameter name"
+        },
+        "body": {
+          "type": "any",
+          "description": "Parameter body"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "returns": "void"
+    },
+    "subscribe": {
+      "description": "Subscribe to realtime changes on a Postgres table.",
+      "parameters": {
+        "channelName": {
+          "type": "string",
+          "description": "A name for this subscription channel"
+        },
+        "table": {
+          "type": "string",
+          "description": "The table to listen to"
+        },
+        "callback": {
+          "type": "(payload: any) => void",
+          "description": "Called with the payload on each change"
+        },
+        "event": {
+          "type": "\"INSERT\" | \"UPDATE\" | \"DELETE\" | \"*\"",
+          "description": "The event type to listen for (default: all changes)"
+        }
+      },
+      "required": [
+        "channelName",
+        "table",
+        "callback"
+      ],
+      "returns": "RealtimeChannel"
+    },
+    "unsubscribe": {
+      "description": "Unsubscribe and remove a realtime channel by name.",
+      "parameters": {
+        "channelName": {
+          "type": "string",
+          "description": "The channel name to remove"
+        }
+      },
+      "required": [
+        "channelName"
+      ],
+      "returns": "void"
+    },
+    "unsubscribeAll": {
+      "description": "Unsubscribe and remove all realtime channels.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "connect": {
+      "description": "Connect is a no-op since the Supabase SDK initializes on construction. The client is ready to use immediately after creation.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "disconnect": {
+      "description": "Disconnect by signing out and removing all realtime channels.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    }
+  },
+  "getters": {
+    "sdk": {
+      "description": "Returns the raw Supabase SDK client for full access to all SDK methods.",
+      "returns": "SupabaseSDKClient<any, any>"
+    },
+    "storage": {
+      "description": "Returns the Supabase Storage client for managing buckets and files.",
+      "returns": "any"
+    },
+    "functions": {
+      "description": "Returns the Supabase Functions client.",
+      "returns": "any"
+    }
+  },
+  "events": {},
+  "state": {},
+  "options": {},
+  "envVars": [],
+  "examples": [
+    {
+      "language": "ts",
+      "code": "const supabase = container.client('supabase', {\n supabaseUrl: 'https://xyz.supabase.co',\n supabaseKey: 'your-anon-key',\n})\n\n// Query data\nconst { data } = await supabase.from('users').select('*')\n\n// Auth\nawait supabase.signInWithPassword('user@example.com', 'password')\n\n// Realtime\nsupabase.subscribe('changes', 'users', (payload) => {\n console.log('Change:', payload)\n})"
+    }
+  ]
+});
+
+setBuildTimeData('clients.openai', {
+  "id": "clients.openai",
+  "description": "OpenAI client — wraps the OpenAI SDK for chat completions, responses API, embeddings, and image generation. Provides convenience methods for common operations while tracking token usage and request counts. Supports both the Chat Completions API and the newer Responses API.",
+  "shortcut": "clients.openai",
+  "className": "OpenAIClient",
+  "methods": {
+    "connect": {
+      "description": "Test the API connection by listing models.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<this>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "await openai.connect()"
+        }
+      ]
+    },
+    "createChatCompletion": {
+      "description": "Create a chat completion using the Chat Completions API.",
+      "parameters": {
+        "messages": {
+          "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
+          "description": "Array of chat messages"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+          "description": "Additional parameters for the completion"
+        }
+      },
+      "required": [
+        "messages"
+      ],
+      "returns": "Promise<OpenAI.Chat.Completions.ChatCompletion>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createChatCompletion([\n { role: 'system', content: 'You are a helpful assistant.' },\n { role: 'user', content: 'Hello!' }\n])\nconsole.log(response.choices[0]?.message?.content)"
+        }
+      ]
+    },
+    "createResponse": {
+      "description": "Create a response using the Responses API.",
+      "parameters": {
+        "input": {
+          "type": "OpenAI.Responses.ResponseInput | string",
+          "description": "The input prompt or message array"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Responses.ResponseCreateParamsNonStreaming>",
+          "description": "Additional parameters for the response"
+        }
+      },
+      "required": [
+        "input"
+      ],
+      "returns": "Promise<OpenAI.Responses.Response>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createResponse('Explain quantum computing')"
+        }
+      ]
+    },
+    "streamResponse": {
+      "description": "Stream a response using the Responses API.",
+      "parameters": {
+        "input": {
+          "type": "OpenAI.Responses.ResponseInput | string",
+          "description": "The input prompt or message array"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Responses.ResponseCreateParamsStreaming>",
+          "description": "Additional parameters for the streaming response"
+        }
+      },
+      "required": [
+        "input"
+      ],
+      "returns": "Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const stream = await openai.streamResponse('Write a poem')\nfor await (const event of stream) {\n if (event.type === 'response.output_text.delta') {\n   process.stdout.write(event.delta)\n }\n}"
+        }
+      ]
+    },
+    "createCompletion": {
+      "description": "Create a legacy text completion.",
+      "parameters": {
+        "prompt": {
+          "type": "string",
+          "description": "The text prompt to complete"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Completions.CompletionCreateParams>",
+          "description": "Additional parameters for the completion"
+        }
+      },
+      "required": [
+        "prompt"
+      ],
+      "returns": "Promise<OpenAI.Completions.Completion>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const response = await openai.createCompletion('Once upon a time')"
+        }
+      ]
+    },
+    "createEmbedding": {
+      "description": "Create text embeddings for semantic search or similarity comparisons.",
+      "parameters": {
+        "input": {
+          "type": "string | string[]",
+          "description": "A string or array of strings to embed"
+        },
+        "options": {
+          "type": "Partial<OpenAI.Embeddings.EmbeddingCreateParams>",
+          "description": "Additional parameters (model, etc.)"
+        }
+      },
+      "required": [
+        "input"
+      ],
+      "returns": "Promise<OpenAI.Embeddings.CreateEmbeddingResponse>",
+      "examples": [
+        {
+          "language": "ts",
           "code": "const response = await openai.createEmbedding('Hello world')\nconsole.log(response.data[0].embedding.length)"
         }
       ]
@@ -9787,404 +10151,6 @@ setBuildTimeData('clients.openai', {
   ]
 });
 
-setBuildTimeData('clients.elevenlabs', {
-  "id": "clients.elevenlabs",
-  "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
-  "shortcut": "clients.elevenlabs",
-  "className": "ElevenLabsClient",
-  "methods": {
-    "beforeRequest": {
-      "description": "Inject the xi-api-key header before each request.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "connect": {
-      "description": "Validate the API key by listing available models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<this>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "await el.connect()"
-        }
-      ]
-    },
-    "listVoices": {
-      "description": "List available voices with optional search and filtering.",
-      "parameters": {
-        "options": {
-          "type": "{\n    search?: string\n    category?: string\n    voice_type?: string\n    page_size?: number\n    next_page_token?: string\n  }",
-          "description": "Query parameters for filtering voices"
-        }
-      },
-      "required": [],
-      "returns": "Promise<any>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const voices = await el.listVoices()\nconst premade = await el.listVoices({ category: 'premade' })"
-        }
-      ]
-    },
-    "getVoice": {
-      "description": "Get details for a single voice.",
-      "parameters": {
-        "voiceId": {
-          "type": "string",
-          "description": "The voice ID to look up"
-        }
-      },
-      "required": [
-        "voiceId"
-      ],
-      "returns": "Promise<any>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const voice = await el.getVoice('21m00Tcm4TlvDq8ikWAM')\nconsole.log(voice.name, voice.settings)"
-        }
-      ]
-    },
-    "listModels": {
-      "description": "List available TTS models.",
-      "parameters": {},
-      "required": [],
-      "returns": "Promise<any[]>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const models = await el.listModels()\nconsole.log(models.map(m => m.model_id))"
-        }
-      ]
-    },
-    "synthesize": {
-      "description": "Synthesize speech from text, returning audio as a Buffer.",
-      "parameters": {
-        "text": {
-          "type": "string",
-          "description": "The text to convert to speech"
-        },
-        "options": {
-          "type": "SynthesizeOptions",
-          "description": "Voice, model, format, and voice settings overrides",
-          "properties": {
-            "voiceId": {
-              "type": "string",
-              "description": ""
-            },
-            "modelId": {
-              "type": "string",
-              "description": ""
-            },
-            "outputFormat": {
-              "type": "string",
-              "description": ""
-            },
-            "voiceSettings": {
-              "type": "ElevenLabsVoiceSettings",
-              "description": ""
-            },
-            "disableCache": {
-              "type": "boolean",
-              "description": ""
-            }
-          }
-        }
-      },
-      "required": [
-        "text"
-      ],
-      "returns": "Promise<Buffer>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data\n\nconst custom = await el.synthesize('Hello', {\n voiceId: '21m00Tcm4TlvDq8ikWAM',\n voiceSettings: { stability: 0.5, similarityBoost: 0.8 }\n})"
-        }
-      ]
-    },
-    "say": {
-      "description": "Synthesize speech and write the audio to a file.",
-      "parameters": {
-        "text": {
-          "type": "string",
-          "description": "The text to convert to speech"
-        },
-        "outputPath": {
-          "type": "string",
-          "description": "File path to write the audio to"
-        },
-        "options": {
-          "type": "SynthesizeOptions",
-          "description": "Voice, model, format, and voice settings overrides",
-          "properties": {
-            "voiceId": {
-              "type": "string",
-              "description": ""
-            },
-            "modelId": {
-              "type": "string",
-              "description": ""
-            },
-            "outputFormat": {
-              "type": "string",
-              "description": ""
-            },
-            "voiceSettings": {
-              "type": "ElevenLabsVoiceSettings",
-              "description": ""
-            },
-            "disableCache": {
-              "type": "boolean",
-              "description": ""
-            }
-          }
-        }
-      },
-      "required": [
-        "text",
-        "outputPath"
-      ],
-      "returns": "Promise<string>",
-      "examples": [
-        {
-          "language": "ts",
-          "code": "const path = await el.say('Hello world', './hello.mp3')\nconsole.log(`Audio saved to ${path}`)"
-        }
-      ]
-    }
-  },
-  "getters": {
-    "apiKey": {
-      "description": "The resolved API key from options or environment.",
-      "returns": "string"
-    }
-  },
-  "events": {
-    "failure": {
-      "name": "failure",
-      "description": "Event emitted by ElevenLabsClient",
-      "arguments": {}
-    },
-    "voices": {
-      "name": "voices",
-      "description": "Event emitted by ElevenLabsClient",
-      "arguments": {}
-    },
-    "speech": {
-      "name": "speech",
-      "description": "Event emitted by ElevenLabsClient",
-      "arguments": {}
-    }
-  },
-  "state": {},
-  "options": {},
-  "envVars": [],
-  "examples": [
-    {
-      "language": "ts",
-      "code": "const el = container.client('elevenlabs')\nawait el.connect()\nconst voices = await el.listVoices()\nconst audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data"
-    }
-  ]
-});
-
-setBuildTimeData('clients.supabase', {
-  "id": "clients.supabase",
-  "description": "Supabase client for the Luca container system. Wraps the official `@supabase/supabase-js` SDK and exposes it through Luca's typed state, events, and introspection system. The SDK is isomorphic so this single implementation works in both Node and browser containers. Use `client.sdk` for full SDK access, or use the convenience wrappers for common operations (auth, database queries, storage, edge functions, realtime).",
-  "shortcut": "clients.supabase",
-  "className": "SupabaseClient",
-  "methods": {
-    "from": {
-      "description": "Start a query on a Postgres table or view.",
-      "parameters": {
-        "table": {
-          "type": "string",
-          "description": "The table or view name to query"
-        }
-      },
-      "required": [
-        "table"
-      ],
-      "returns": "void"
-    },
-    "rpc": {
-      "description": "Call a Postgres function (RPC).",
-      "parameters": {
-        "fn": {
-          "type": "string",
-          "description": "The function name"
-        },
-        "params": {
-          "type": "Record<string, unknown>",
-          "description": "Arguments to pass to the function"
-        },
-        "options": {
-          "type": "{ head?: boolean; get?: boolean; count?: \"exact\" | \"planned\" | \"estimated\" }",
-          "description": "Optional settings (head, get, count)"
-        }
-      },
-      "required": [
-        "fn"
-      ],
-      "returns": "void"
-    },
-    "signInWithPassword": {
-      "description": "Sign in with email and password.",
-      "parameters": {
-        "email": {
-          "type": "string",
-          "description": "Parameter email"
-        },
-        "password": {
-          "type": "string",
-          "description": "Parameter password"
-        }
-      },
-      "required": [
-        "email",
-        "password"
-      ],
-      "returns": "void"
-    },
-    "signUp": {
-      "description": "Create a new user account with email and password.",
-      "parameters": {
-        "email": {
-          "type": "string",
-          "description": "Parameter email"
-        },
-        "password": {
-          "type": "string",
-          "description": "Parameter password"
-        }
-      },
-      "required": [
-        "email",
-        "password"
-      ],
-      "returns": "void"
-    },
-    "signOut": {
-      "description": "Sign the current user out.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "getSession": {
-      "description": "Get the current session, if any.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "getUser": {
-      "description": "Get the current user, if any.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "invoke": {
-      "description": "Invoke a Supabase Edge Function by name.",
-      "parameters": {
-        "name": {
-          "type": "string",
-          "description": "Parameter name"
-        },
-        "body": {
-          "type": "any",
-          "description": "Parameter body"
-        }
-      },
-      "required": [
-        "name"
-      ],
-      "returns": "void"
-    },
-    "subscribe": {
-      "description": "Subscribe to realtime changes on a Postgres table.",
-      "parameters": {
-        "channelName": {
-          "type": "string",
-          "description": "A name for this subscription channel"
-        },
-        "table": {
-          "type": "string",
-          "description": "The table to listen to"
-        },
-        "callback": {
-          "type": "(payload: any) => void",
-          "description": "Called with the payload on each change"
-        },
-        "event": {
-          "type": "\"INSERT\" | \"UPDATE\" | \"DELETE\" | \"*\"",
-          "description": "The event type to listen for (default: all changes)"
-        }
-      },
-      "required": [
-        "channelName",
-        "table",
-        "callback"
-      ],
-      "returns": "RealtimeChannel"
-    },
-    "unsubscribe": {
-      "description": "Unsubscribe and remove a realtime channel by name.",
-      "parameters": {
-        "channelName": {
-          "type": "string",
-          "description": "The channel name to remove"
-        }
-      },
-      "required": [
-        "channelName"
-      ],
-      "returns": "void"
-    },
-    "unsubscribeAll": {
-      "description": "Unsubscribe and remove all realtime channels.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "connect": {
-      "description": "Connect is a no-op since the Supabase SDK initializes on construction. The client is ready to use immediately after creation.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    },
-    "disconnect": {
-      "description": "Disconnect by signing out and removing all realtime channels.",
-      "parameters": {},
-      "required": [],
-      "returns": "void"
-    }
-  },
-  "getters": {
-    "sdk": {
-      "description": "Returns the raw Supabase SDK client for full access to all SDK methods.",
-      "returns": "SupabaseSDKClient<any, any>"
-    },
-    "storage": {
-      "description": "Returns the Supabase Storage client for managing buckets and files.",
-      "returns": "any"
-    },
-    "functions": {
-      "description": "Returns the Supabase Functions client.",
-      "returns": "any"
-    }
-  },
-  "events": {},
-  "state": {},
-  "options": {},
-  "envVars": [],
-  "examples": [
-    {
-      "language": "ts",
-      "code": "const supabase = container.client('supabase', {\n supabaseUrl: 'https://xyz.supabase.co',\n supabaseKey: 'your-anon-key',\n})\n\n// Query data\nconst { data } = await supabase.from('users').select('*')\n\n// Auth\nawait supabase.signInWithPassword('user@example.com', 'password')\n\n// Realtime\nsupabase.subscribe('changes', 'users', (payload) => {\n console.log('Change:', payload)\n})"
-    }
-  ]
-});
-
 setBuildTimeData('clients.comfyui', {
   "id": "clients.comfyui",
   "description": "ComfyUI client — execute Stable Diffusion workflows via the ComfyUI API. Connects to a ComfyUI instance to queue prompts, track execution via WebSocket or polling, and download generated images. Supports both UI-format and API-format workflows with automatic conversion.",
@@ -10326,103 +10292,305 @@ setBuildTimeData('clients.comfyui', {
       "required": [],
       "returns": "void"
     },
-    "toApiFormat": {
-      "description": "Convert a UI-format workflow to the API format that /prompt expects. Requires a running ComfyUI instance to fetch `object_info` so we can map positional `widgets_values` to their named input fields. If the workflow is already in API format, it's returned as-is.",
+    "toApiFormat": {
+      "description": "Convert a UI-format workflow to the API format that /prompt expects. Requires a running ComfyUI instance to fetch `object_info` so we can map positional `widgets_values` to their named input fields. If the workflow is already in API format, it's returned as-is.",
+      "parameters": {
+        "workflow": {
+          "type": "Record<string, any>",
+          "description": "Parameter workflow"
+        }
+      },
+      "required": [
+        "workflow"
+      ],
+      "returns": "Promise<Record<string, any>>"
+    },
+    "runWorkflow": {
+      "description": "Run a ComfyUI workflow with optional runtime input overrides. Inputs can be provided in two forms: **Direct node mapping** (when no `inputMap` in options): ``` { '3': { seed: 42 }, '6': { text: 'a cat' } } ``` **Named inputs** (when `inputMap` is provided in options): ``` inputs: { positive_prompt: 'a cat', seed: 42 } options.inputMap: { positive_prompt: { nodeId: '6', field: 'text' }, seed: { nodeId: '3', field: 'seed' } } ```",
+      "parameters": {
+        "workflow": {
+          "type": "Record<string, any>",
+          "description": "Parameter workflow"
+        },
+        "inputs": {
+          "type": "Record<string, any>",
+          "description": "Parameter inputs"
+        },
+        "options": {
+          "type": "WorkflowRunOptions",
+          "description": "Parameter options",
+          "properties": {
+            "poll": {
+              "type": "boolean",
+              "description": "Use polling instead of WebSocket for tracking execution"
+            },
+            "pollInterval": {
+              "type": "number",
+              "description": "Polling interval in ms (default 1000)"
+            },
+            "inputMap": {
+              "type": "InputMapping",
+              "description": "Named input mapping: semantic name -> { nodeId, field }"
+            },
+            "outputDir": {
+              "type": "string",
+              "description": "If provided, output images are downloaded to this directory"
+            }
+          }
+        }
+      },
+      "required": [
+        "workflow"
+      ],
+      "returns": "Promise<WorkflowResult>"
+    }
+  },
+  "getters": {
+    "clientId": {
+      "description": "The unique client ID used for WebSocket session tracking.",
+      "returns": "string"
+    },
+    "wsURL": {
+      "description": "The WebSocket URL derived from baseURL or overridden via options.",
+      "returns": "string"
+    }
+  },
+  "events": {
+    "execution_start": {
+      "name": "execution_start",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    },
+    "execution_complete": {
+      "name": "execution_complete",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    },
+    "executing": {
+      "name": "executing",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    },
+    "progress": {
+      "name": "progress",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    },
+    "executed": {
+      "name": "executed",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    },
+    "execution_cached": {
+      "name": "execution_cached",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    },
+    "execution_error": {
+      "name": "execution_error",
+      "description": "Event emitted by ComfyUIClient",
+      "arguments": {}
+    }
+  },
+  "state": {},
+  "options": {},
+  "envVars": [],
+  "examples": [
+    {
+      "language": "ts",
+      "code": "const comfy = container.client('comfyui', { baseURL: 'http://localhost:8188' })\nconst result = await comfy.runWorkflow(workflow, {\n '6': { text: 'a beautiful sunset' }\n})\nconsole.log(result.images)"
+    }
+  ]
+});
+
+setBuildTimeData('clients.elevenlabs', {
+  "id": "clients.elevenlabs",
+  "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
+  "shortcut": "clients.elevenlabs",
+  "className": "ElevenLabsClient",
+  "methods": {
+    "beforeRequest": {
+      "description": "Inject the xi-api-key header before each request.",
+      "parameters": {},
+      "required": [],
+      "returns": "void"
+    },
+    "connect": {
+      "description": "Validate the API key by listing available models.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<this>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "await el.connect()"
+        }
+      ]
+    },
+    "listVoices": {
+      "description": "List available voices with optional search and filtering.",
+      "parameters": {
+        "options": {
+          "type": "{\n    search?: string\n    category?: string\n    voice_type?: string\n    page_size?: number\n    next_page_token?: string\n  }",
+          "description": "Query parameters for filtering voices"
+        }
+      },
+      "required": [],
+      "returns": "Promise<any>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const voices = await el.listVoices()\nconst premade = await el.listVoices({ category: 'premade' })"
+        }
+      ]
+    },
+    "getVoice": {
+      "description": "Get details for a single voice.",
+      "parameters": {
+        "voiceId": {
+          "type": "string",
+          "description": "The voice ID to look up"
+        }
+      },
+      "required": [
+        "voiceId"
+      ],
+      "returns": "Promise<any>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const voice = await el.getVoice('21m00Tcm4TlvDq8ikWAM')\nconsole.log(voice.name, voice.settings)"
+        }
+      ]
+    },
+    "listModels": {
+      "description": "List available TTS models.",
+      "parameters": {},
+      "required": [],
+      "returns": "Promise<any[]>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const models = await el.listModels()\nconsole.log(models.map(m => m.model_id))"
+        }
+      ]
+    },
+    "synthesize": {
+      "description": "Synthesize speech from text, returning audio as a Buffer.",
       "parameters": {
-        "workflow": {
-          "type": "Record<string, any>",
-          "description": "Parameter workflow"
+        "text": {
+          "type": "string",
+          "description": "The text to convert to speech"
+        },
+        "options": {
+          "type": "SynthesizeOptions",
+          "description": "Voice, model, format, and voice settings overrides",
+          "properties": {
+            "voiceId": {
+              "type": "string",
+              "description": ""
+            },
+            "modelId": {
+              "type": "string",
+              "description": ""
+            },
+            "outputFormat": {
+              "type": "string",
+              "description": ""
+            },
+            "voiceSettings": {
+              "type": "ElevenLabsVoiceSettings",
+              "description": ""
+            },
+            "disableCache": {
+              "type": "boolean",
+              "description": ""
+            }
+          }
         }
       },
       "required": [
-        "workflow"
+        "text"
       ],
-      "returns": "Promise<Record<string, any>>"
+      "returns": "Promise<Buffer>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data\n\nconst custom = await el.synthesize('Hello', {\n voiceId: '21m00Tcm4TlvDq8ikWAM',\n voiceSettings: { stability: 0.5, similarityBoost: 0.8 }\n})"
+        }
+      ]
     },
-    "runWorkflow": {
-      "description": "Run a ComfyUI workflow with optional runtime input overrides. Inputs can be provided in two forms: **Direct node mapping** (when no `inputMap` in options): ``` { '3': { seed: 42 }, '6': { text: 'a cat' } } ``` **Named inputs** (when `inputMap` is provided in options): ``` inputs: { positive_prompt: 'a cat', seed: 42 } options.inputMap: { positive_prompt: { nodeId: '6', field: 'text' }, seed: { nodeId: '3', field: 'seed' } } ```",
+    "say": {
+      "description": "Synthesize speech and write the audio to a file.",
       "parameters": {
-        "workflow": {
-          "type": "Record<string, any>",
-          "description": "Parameter workflow"
+        "text": {
+          "type": "string",
+          "description": "The text to convert to speech"
         },
-        "inputs": {
-          "type": "Record<string, any>",
-          "description": "Parameter inputs"
+        "outputPath": {
+          "type": "string",
+          "description": "File path to write the audio to"
         },
         "options": {
-          "type": "WorkflowRunOptions",
-          "description": "Parameter options",
+          "type": "SynthesizeOptions",
+          "description": "Voice, model, format, and voice settings overrides",
           "properties": {
-            "poll": {
-              "type": "boolean",
-              "description": "Use polling instead of WebSocket for tracking execution"
-            },
-            "pollInterval": {
-              "type": "number",
-              "description": "Polling interval in ms (default 1000)"
+            "voiceId": {
+              "type": "string",
+              "description": ""
             },
-            "inputMap": {
-              "type": "InputMapping",
-              "description": "Named input mapping: semantic name -> { nodeId, field }"
+            "modelId": {
+              "type": "string",
+              "description": ""
             },
-            "outputDir": {
+            "outputFormat": {
               "type": "string",
-              "description": "If provided, output images are downloaded to this directory"
+              "description": ""
+            },
+            "voiceSettings": {
+              "type": "ElevenLabsVoiceSettings",
+              "description": ""
+            },
+            "disableCache": {
+              "type": "boolean",
+              "description": ""
             }
           }
         }
       },
       "required": [
-        "workflow"
+        "text",
+        "outputPath"
       ],
-      "returns": "Promise<WorkflowResult>"
+      "returns": "Promise<string>",
+      "examples": [
+        {
+          "language": "ts",
+          "code": "const path = await el.say('Hello world', './hello.mp3')\nconsole.log(`Audio saved to ${path}`)"
+        }
+      ]
     }
   },
   "getters": {
-    "clientId": {
-      "description": "The unique client ID used for WebSocket session tracking.",
-      "returns": "string"
-    },
-    "wsURL": {
-      "description": "The WebSocket URL derived from baseURL or overridden via options.",
+    "apiKey": {
+      "description": "The resolved API key from options or environment.",
       "returns": "string"
     }
   },
   "events": {
-    "execution_start": {
-      "name": "execution_start",
-      "description": "Event emitted by ComfyUIClient",
-      "arguments": {}
-    },
-    "execution_complete": {
-      "name": "execution_complete",
-      "description": "Event emitted by ComfyUIClient",
-      "arguments": {}
-    },
-    "executing": {
-      "name": "executing",
-      "description": "Event emitted by ComfyUIClient",
-      "arguments": {}
-    },
-    "progress": {
-      "name": "progress",
-      "description": "Event emitted by ComfyUIClient",
-      "arguments": {}
-    },
-    "executed": {
-      "name": "executed",
-      "description": "Event emitted by ComfyUIClient",
+    "failure": {
+      "name": "failure",
+      "description": "Event emitted by ElevenLabsClient",
       "arguments": {}
     },
-    "execution_cached": {
-      "name": "execution_cached",
-      "description": "Event emitted by ComfyUIClient",
+    "voices": {
+      "name": "voices",
+      "description": "Event emitted by ElevenLabsClient",
       "arguments": {}
     },
-    "execution_error": {
-      "name": "execution_error",
-      "description": "Event emitted by ComfyUIClient",
+    "speech": {
+      "name": "speech",
+      "description": "Event emitted by ElevenLabsClient",
       "arguments": {}
     }
   },
@@ -10432,7 +10600,7 @@ setBuildTimeData('clients.comfyui', {
   "examples": [
     {
       "language": "ts",
-      "code": "const comfy = container.client('comfyui', { baseURL: 'http://localhost:8188' })\nconst result = await comfy.runWorkflow(workflow, {\n '6': { text: 'a beautiful sunset' }\n})\nconsole.log(result.images)"
+      "code": "const el = container.client('elevenlabs')\nawait el.connect()\nconst voices = await el.listVoices()\nconst audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data"
     }
   ]
 });
@@ -16749,33 +16917,200 @@ export const introspectionData = [
           }
         },
         "required": [],
-        "returns": "void",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const repl = container.feature('repl', { enable: true })\nawait repl.start({\n context: { db: myDatabase },\n historyPath: '.repl-history'\n})"
-          }
-        ]
+        "returns": "void",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const repl = container.feature('repl', { enable: true })\nawait repl.start({\n context: { db: myDatabase },\n historyPath: '.repl-history'\n})"
+          }
+        ]
+      }
+    },
+    "getters": {
+      "isStarted": {
+        "description": "Whether the REPL session is currently running.",
+        "returns": "any"
+      },
+      "vmContext": {
+        "description": "The VM context object used for evaluating expressions in the REPL.",
+        "returns": "any"
+      }
+    },
+    "events": {},
+    "state": {},
+    "options": {},
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const repl = container.feature('repl', { enable: true })\nawait repl.start({ context: { myVar: 42 } })"
+      }
+    ]
+  },
+  {
+    "id": "features.googleMail",
+    "description": "Google Mail feature for searching, reading, and watching Gmail messages. Depends on the googleAuth feature for authentication. Creates a Gmail v1 API client lazily. Supports Gmail search query syntax, individual message reading, and polling-based new mail detection with event emission.",
+    "shortcut": "features.googleMail",
+    "className": "GoogleMail",
+    "methods": {
+      "search": {
+        "description": "Search for messages using Gmail query syntax and/or structured filters.",
+        "parameters": {
+          "options": {
+            "type": "SearchMailOptions",
+            "description": "Search filters including query, from, to, subject, date ranges",
+            "properties": {
+              "query": {
+                "type": "string",
+                "description": ""
+              },
+              "from": {
+                "type": "string",
+                "description": ""
+              },
+              "to": {
+                "type": "string",
+                "description": ""
+              },
+              "subject": {
+                "type": "string",
+                "description": ""
+              },
+              "after": {
+                "type": "string",
+                "description": ""
+              },
+              "before": {
+                "type": "string",
+                "description": ""
+              },
+              "hasAttachment": {
+                "type": "boolean",
+                "description": ""
+              },
+              "label": {
+                "type": "string",
+                "description": ""
+              },
+              "isUnread": {
+                "type": "boolean",
+                "description": ""
+              },
+              "maxResults": {
+                "type": "number",
+                "description": ""
+              },
+              "pageToken": {
+                "type": "string",
+                "description": ""
+              }
+            }
+          }
+        },
+        "required": [],
+        "returns": "Promise<MailMessageList>"
+      },
+      "getMessage": {
+        "description": "Get a single message by ID.",
+        "parameters": {
+          "messageId": {
+            "type": "string",
+            "description": "The message ID"
+          },
+          "format": {
+            "type": "'full' | 'metadata' | 'minimal' | 'raw'",
+            "description": "Message format (defaults to options.format or 'full')"
+          }
+        },
+        "required": [
+          "messageId"
+        ],
+        "returns": "Promise<MailMessage>"
+      },
+      "getThread": {
+        "description": "Get a full thread with all its messages.",
+        "parameters": {
+          "threadId": {
+            "type": "string",
+            "description": "The thread ID"
+          }
+        },
+        "required": [
+          "threadId"
+        ],
+        "returns": "Promise<MailThread>"
+      },
+      "listLabels": {
+        "description": "List all labels for the authenticated user.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<MailLabel[]>"
+      },
+      "startWatching": {
+        "description": "Start watching for new mail by polling at a regular interval. Emits 'newMail' events with an array of new messages when they arrive. Uses Gmail history API to efficiently detect only new messages since the last check.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<void>"
+      },
+      "stopWatching": {
+        "description": "Stop watching for new mail.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
       }
     },
     "getters": {
-      "isStarted": {
-        "description": "Whether the REPL session is currently running.",
-        "returns": "any"
+      "auth": {
+        "description": "Access the google-auth feature lazily.",
+        "returns": "GoogleAuth"
       },
-      "vmContext": {
-        "description": "The VM context object used for evaluating expressions in the REPL.",
-        "returns": "any"
+      "userId": {
+        "description": "Default user ID from options or 'me'.",
+        "returns": "string"
+      },
+      "defaultFormat": {
+        "description": "Default message format from options or 'full'.",
+        "returns": "'full' | 'metadata' | 'minimal' | 'raw'"
+      },
+      "pollInterval": {
+        "description": "Polling interval from options or 30 seconds.",
+        "returns": "number"
+      }
+    },
+    "events": {
+      "messagesFetched": {
+        "name": "messagesFetched",
+        "description": "Event emitted by GoogleMail",
+        "arguments": {}
+      },
+      "error": {
+        "name": "error",
+        "description": "Event emitted by GoogleMail",
+        "arguments": {}
+      },
+      "watchStarted": {
+        "name": "watchStarted",
+        "description": "Event emitted by GoogleMail",
+        "arguments": {}
+      },
+      "watchStopped": {
+        "name": "watchStopped",
+        "description": "Event emitted by GoogleMail",
+        "arguments": {}
+      },
+      "newMail": {
+        "name": "newMail",
+        "description": "Event emitted by GoogleMail",
+        "arguments": {}
       }
     },
-    "events": {},
     "state": {},
     "options": {},
     "envVars": [],
     "examples": [
       {
         "language": "ts",
-        "code": "const repl = container.feature('repl', { enable: true })\nawait repl.start({ context: { myVar: 42 } })"
+        "code": "const mail = container.feature('googleMail')\n\n// Search by sender\nconst fromBoss = await mail.search({ from: 'boss@company.com' })\n\n// Use Gmail query string\nconst unread = await mail.search({ query: 'is:unread category:primary' })\n\n// Read a specific message\nconst msg = await mail.getMessage('message-id-here')\n\n// Get a full thread\nconst thread = await mail.getThread('thread-id-here')\n\n// List labels\nconst labels = await mail.listLabels()\n\n// Watch for new mail (polls and emits 'newMail' events)\nmail.on('newMail', (messages) => {\n console.log(`Got ${messages.length} new messages!`)\n})\nawait mail.startWatching()\n\n// Stop watching\nmail.stopWatching()"
       }
     ]
   },
@@ -22727,264 +23062,31 @@ export const introspectionData = [
             "description": "Optional variables for the mutation"
           },
           "operationName": {
-            "type": "string",
-            "description": "Optional operation name when the mutation contains multiple operations"
-          }
-        },
-        "required": [
-          "mutation"
-        ],
-        "returns": "Promise<R>"
-      }
-    },
-    "getters": {
-      "endpoint": {
-        "description": "The GraphQL endpoint path. Defaults to '/graphql'.",
-        "returns": "any"
-      }
-    },
-    "events": {
-      "graphqlError": {
-        "name": "graphqlError",
-        "description": "Event emitted by GraphClient",
-        "arguments": {}
-      },
-      "failure": {
-        "name": "failure",
-        "description": "Event emitted by GraphClient",
-        "arguments": {}
-      }
-    },
-    "state": {},
-    "options": {},
-    "envVars": [],
-    "examples": [
-      {
-        "language": "ts",
-        "code": "const gql = container.client('graph', { baseURL: 'https://api.example.com' })\nconst data = await gql.query(`{ users { id name } }`)\nawait gql.mutate(`mutation($name: String!) { createUser(name: $name) { id } }`, { name: 'Alice' })"
-      }
-    ]
-  },
-  {
-    "id": "clients.rest",
-    "description": "HTTP REST client built on top of axios. Provides convenience methods for GET, POST, PUT, PATCH, and DELETE requests with automatic JSON handling, configurable base URL, and error event emission.",
-    "shortcut": "clients.rest",
-    "className": "RestClient",
-    "methods": {
-      "beforeRequest": {
-        "description": "",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
-      "patch": {
-        "description": "Send a PATCH request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
-        "parameters": {
-          "url": {
-            "type": "string",
-            "description": "Request path relative to baseURL"
-          },
-          "data": {
-            "type": "any",
-            "description": "Request body"
-          },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
-          }
-        },
-        "required": [
-          "url"
-        ],
-        "returns": "void"
-      },
-      "put": {
-        "description": "Send a PUT request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
-        "parameters": {
-          "url": {
-            "type": "string",
-            "description": "Request path relative to baseURL"
-          },
-          "data": {
-            "type": "any",
-            "description": "Request body"
-          },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
-          }
-        },
-        "required": [
-          "url"
-        ],
-        "returns": "void"
-      },
-      "post": {
-        "description": "Send a POST request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
-        "parameters": {
-          "url": {
-            "type": "string",
-            "description": "Request path relative to baseURL"
-          },
-          "data": {
-            "type": "any",
-            "description": "Request body"
-          },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
-          }
-        },
-        "required": [
-          "url"
-        ],
-        "returns": "void"
-      },
-      "delete": {
-        "description": "Send a DELETE request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
-        "parameters": {
-          "url": {
-            "type": "string",
-            "description": "Request path relative to baseURL"
-          },
-          "params": {
-            "type": "any",
-            "description": "Query parameters"
-          },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
-          }
-        },
-        "required": [
-          "url"
-        ],
-        "returns": "void"
-      },
-      "get": {
-        "description": "Send a GET request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
-        "parameters": {
-          "url": {
-            "type": "string",
-            "description": "Request path relative to baseURL"
-          },
-          "params": {
-            "type": "any",
-            "description": "Query parameters"
-          },
-          "options": {
-            "type": "AxiosRequestConfig",
-            "description": "Additional axios request config"
-          }
-        },
-        "required": [
-          "url"
-        ],
-        "returns": "void"
-      },
-      "handleError": {
-        "description": "Handle an axios error by emitting 'failure' and returning the error as JSON.",
-        "parameters": {
-          "error": {
-            "type": "AxiosError",
-            "description": "Parameter error"
-          }
-        },
-        "required": [
-          "error"
-        ],
-        "returns": "void"
-      }
-    },
-    "getters": {
-      "useJSON": {
-        "description": "Whether JSON content-type headers should be set automatically.",
-        "returns": "any"
-      },
-      "baseURL": {
-        "description": "",
-        "returns": "any"
-      }
-    },
-    "events": {
-      "failure": {
-        "name": "failure",
-        "description": "Event emitted by RestClient",
-        "arguments": {}
-      }
-    },
-    "state": {},
-    "options": {},
-    "envVars": [],
-    "examples": [
-      {
-        "language": "ts",
-        "code": "const api = container.client('rest', { baseURL: 'https://api.example.com', json: true })\nconst users = await api.get('/users')\nawait api.post('/users', { name: 'Alice' })"
-      }
-    ]
-  },
-  {
-    "id": "clients.websocket",
-    "description": "WebSocket client that bridges raw WebSocket events to Luca's Helper event bus, providing a clean interface for sending/receiving messages, tracking connection state, and optional auto-reconnection with exponential backoff. Events emitted: - `open` — connection established - `message` — message received (JSON-parsed when possible) - `close` — connection closed (with code and reason) - `error` — connection error - `reconnecting` — attempting reconnection (with attempt number)",
-    "shortcut": "clients.websocket",
-    "className": "WebSocketClient",
-    "methods": {
-      "connect": {
-        "description": "Establish a WebSocket connection to the configured baseURL. Wires all raw WebSocket events (open, message, close, error) to the Helper event bus and updates connection state accordingly. Resolves once the connection is open; rejects on error.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<this>"
-      },
-      "send": {
-        "description": "Send data over the WebSocket connection. Automatically JSON-serializes the payload. If not currently connected, attempts to connect first.",
-        "parameters": {
-          "data": {
-            "type": "any",
-            "description": "The data to send (will be JSON.stringify'd)"
+            "type": "string",
+            "description": "Optional operation name when the mutation contains multiple operations"
           }
         },
         "required": [
-          "data"
+          "mutation"
         ],
-        "returns": "Promise<void>"
-      },
-      "disconnect": {
-        "description": "Gracefully close the WebSocket connection. Suppresses auto-reconnect and updates connection state to disconnected.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<this>"
+        "returns": "Promise<R>"
       }
     },
     "getters": {
-      "hasError": {
-        "description": "Whether the client is in an error state.",
+      "endpoint": {
+        "description": "The GraphQL endpoint path. Defaults to '/graphql'.",
         "returns": "any"
       }
     },
     "events": {
-      "open": {
-        "name": "open",
-        "description": "Event emitted by WebSocketClient",
-        "arguments": {}
-      },
-      "error": {
-        "name": "error",
-        "description": "Event emitted by WebSocketClient",
-        "arguments": {}
-      },
-      "message": {
-        "name": "message",
-        "description": "Event emitted by WebSocketClient",
-        "arguments": {}
-      },
-      "close": {
-        "name": "close",
-        "description": "Event emitted by WebSocketClient",
+      "graphqlError": {
+        "name": "graphqlError",
+        "description": "Event emitted by GraphClient",
         "arguments": {}
       },
-      "reconnecting": {
-        "name": "reconnecting",
-        "description": "Event emitted by WebSocketClient",
+      "failure": {
+        "name": "failure",
+        "description": "Event emitted by GraphClient",
         "arguments": {}
       }
     },
@@ -22994,264 +23096,155 @@ export const introspectionData = [
     "examples": [
       {
         "language": "ts",
-        "code": "const ws = container.client('websocket', {\n baseURL: 'ws://localhost:8080',\n reconnect: true,\n maxReconnectAttempts: 5\n})\nws.on('message', (data) => console.log('Received:', data))\nawait ws.connect()\nawait ws.send({ type: 'hello' })"
+        "code": "const gql = container.client('graph', { baseURL: 'https://api.example.com' })\nconst data = await gql.query(`{ users { id name } }`)\nawait gql.mutate(`mutation($name: String!) { createUser(name: $name) { id } }`, { name: 'Alice' })"
       }
     ]
   },
   {
-    "id": "clients.openai",
-    "description": "OpenAI client — wraps the OpenAI SDK for chat completions, responses API, embeddings, and image generation. Provides convenience methods for common operations while tracking token usage and request counts. Supports both the Chat Completions API and the newer Responses API.",
-    "shortcut": "clients.openai",
-    "className": "OpenAIClient",
+    "id": "clients.rest",
+    "description": "HTTP REST client built on top of axios. Provides convenience methods for GET, POST, PUT, PATCH, and DELETE requests with automatic JSON handling, configurable base URL, and error event emission.",
+    "shortcut": "clients.rest",
+    "className": "RestClient",
     "methods": {
-      "connect": {
-        "description": "Test the API connection by listing models.",
+      "beforeRequest": {
+        "description": "",
         "parameters": {},
         "required": [],
-        "returns": "Promise<this>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "await openai.connect()"
-          }
-        ]
-      },
-      "createChatCompletion": {
-        "description": "Create a chat completion using the Chat Completions API.",
-        "parameters": {
-          "messages": {
-            "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
-            "description": "Array of chat messages"
-          },
-          "options": {
-            "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-            "description": "Additional parameters for the completion"
-          }
-        },
-        "required": [
-          "messages"
-        ],
-        "returns": "Promise<OpenAI.Chat.Completions.ChatCompletion>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const response = await openai.createChatCompletion([\n { role: 'system', content: 'You are a helpful assistant.' },\n { role: 'user', content: 'Hello!' }\n])\nconsole.log(response.choices[0]?.message?.content)"
-          }
-        ]
+        "returns": "void"
       },
-      "createResponse": {
-        "description": "Create a response using the Responses API.",
+      "patch": {
+        "description": "Send a PATCH request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
         "parameters": {
-          "input": {
-            "type": "OpenAI.Responses.ResponseInput | string",
-            "description": "The input prompt or message array"
+          "url": {
+            "type": "string",
+            "description": "Request path relative to baseURL"
           },
-          "options": {
-            "type": "Partial<OpenAI.Responses.ResponseCreateParamsNonStreaming>",
-            "description": "Additional parameters for the response"
-          }
-        },
-        "required": [
-          "input"
-        ],
-        "returns": "Promise<OpenAI.Responses.Response>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const response = await openai.createResponse('Explain quantum computing')"
-          }
-        ]
-      },
-      "streamResponse": {
-        "description": "Stream a response using the Responses API.",
-        "parameters": {
-          "input": {
-            "type": "OpenAI.Responses.ResponseInput | string",
-            "description": "The input prompt or message array"
+          "data": {
+            "type": "any",
+            "description": "Request body"
           },
           "options": {
-            "type": "Partial<OpenAI.Responses.ResponseCreateParamsStreaming>",
-            "description": "Additional parameters for the streaming response"
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
           }
         },
         "required": [
-          "input"
+          "url"
         ],
-        "returns": "Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const stream = await openai.streamResponse('Write a poem')\nfor await (const event of stream) {\n if (event.type === 'response.output_text.delta') {\n   process.stdout.write(event.delta)\n }\n}"
-          }
-        ]
+        "returns": "void"
       },
-      "createCompletion": {
-        "description": "Create a legacy text completion.",
+      "put": {
+        "description": "Send a PUT request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
         "parameters": {
-          "prompt": {
+          "url": {
             "type": "string",
-            "description": "The text prompt to complete"
+            "description": "Request path relative to baseURL"
           },
-          "options": {
-            "type": "Partial<OpenAI.Completions.CompletionCreateParams>",
-            "description": "Additional parameters for the completion"
-          }
-        },
-        "required": [
-          "prompt"
-        ],
-        "returns": "Promise<OpenAI.Completions.Completion>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const response = await openai.createCompletion('Once upon a time')"
-          }
-        ]
-      },
-      "createEmbedding": {
-        "description": "Create text embeddings for semantic search or similarity comparisons.",
-        "parameters": {
-          "input": {
-            "type": "string | string[]",
-            "description": "A string or array of strings to embed"
+          "data": {
+            "type": "any",
+            "description": "Request body"
           },
           "options": {
-            "type": "Partial<OpenAI.Embeddings.EmbeddingCreateParams>",
-            "description": "Additional parameters (model, etc.)"
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
           }
         },
         "required": [
-          "input"
+          "url"
         ],
-        "returns": "Promise<OpenAI.Embeddings.CreateEmbeddingResponse>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const response = await openai.createEmbedding('Hello world')\nconsole.log(response.data[0].embedding.length)"
-          }
-        ]
+        "returns": "void"
       },
-      "createImage": {
-        "description": "Generate an image from a text prompt using DALL-E.",
+      "post": {
+        "description": "Send a POST request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
         "parameters": {
-          "prompt": {
+          "url": {
             "type": "string",
-            "description": "Description of the image to generate"
+            "description": "Request path relative to baseURL"
+          },
+          "data": {
+            "type": "any",
+            "description": "Request body"
           },
           "options": {
-            "type": "Partial<OpenAI.Images.ImageGenerateParams>",
-            "description": "Additional parameters (size, n, etc.)"
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
           }
         },
         "required": [
-          "prompt"
+          "url"
         ],
-        "returns": "Promise<OpenAI.Images.ImagesResponse>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const response = await openai.createImage('A sunset over mountains')\nconsole.log(response.data[0].url)"
-          }
-        ]
-      },
-      "listModels": {
-        "description": "List all available models.",
-        "parameters": {},
-        "required": [],
-        "returns": "Promise<OpenAI.Models.ModelsPage>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const models = await openai.listModels()"
-          }
-        ]
+        "returns": "void"
       },
-      "ask": {
-        "description": "Ask a single question and get a text response. Convenience wrapper around `createChatCompletion` for simple Q&A.",
+      "delete": {
+        "description": "Send a DELETE request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
         "parameters": {
-          "question": {
+          "url": {
             "type": "string",
-            "description": "The question to ask"
+            "description": "Request path relative to baseURL"
+          },
+          "params": {
+            "type": "any",
+            "description": "Query parameters"
           },
           "options": {
-            "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-            "description": "Additional completion parameters"
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
           }
         },
         "required": [
-          "question"
+          "url"
         ],
-        "returns": "Promise<string>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const answer = await openai.ask('What is 2 + 2?')\nconsole.log(answer) // '4'"
-          }
-        ]
+        "returns": "void"
       },
-      "chat": {
-        "description": "Send a multi-turn conversation and get a text response. Convenience wrapper around `createChatCompletion` that returns just the text.",
-        "parameters": {
-          "messages": {
-            "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
-            "description": "Array of chat messages"
+      "get": {
+        "description": "Send a GET request. Returns the parsed response body directly (not an axios Response wrapper). On HTTP errors, returns the error as JSON instead of throwing.",
+        "parameters": {
+          "url": {
+            "type": "string",
+            "description": "Request path relative to baseURL"
+          },
+          "params": {
+            "type": "any",
+            "description": "Query parameters"
           },
           "options": {
-            "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
-            "description": "Additional completion parameters"
+            "type": "AxiosRequestConfig",
+            "description": "Additional axios request config"
           }
         },
         "required": [
-          "messages"
+          "url"
         ],
-        "returns": "Promise<string>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const reply = await openai.chat([\n { role: 'system', content: 'You are a pirate.' },\n { role: 'user', content: 'Hello!' }\n])"
+        "returns": "void"
+      },
+      "handleError": {
+        "description": "Handle an axios error by emitting 'failure' and returning the error as JSON.",
+        "parameters": {
+          "error": {
+            "type": "AxiosError",
+            "description": "Parameter error"
           }
-        ]
+        },
+        "required": [
+          "error"
+        ],
+        "returns": "void"
       }
     },
     "getters": {
-      "defaultModel": {
-        "description": "The default model used for completions, from options or 'gpt-4o'.",
-        "returns": "string"
+      "useJSON": {
+        "description": "Whether JSON content-type headers should be set automatically.",
+        "returns": "any"
       },
-      "raw": {
-        "description": "The underlying OpenAI SDK instance for advanced use cases.",
-        "returns": "OpenAI"
+      "baseURL": {
+        "description": "",
+        "returns": "any"
       }
     },
     "events": {
-      "connected": {
-        "name": "connected",
-        "description": "Event emitted by OpenAIClient",
-        "arguments": {}
-      },
       "failure": {
         "name": "failure",
-        "description": "Event emitted by OpenAIClient",
-        "arguments": {}
-      },
-      "completion": {
-        "name": "completion",
-        "description": "Event emitted by OpenAIClient",
-        "arguments": {}
-      },
-      "embedding": {
-        "name": "embedding",
-        "description": "Event emitted by OpenAIClient",
-        "arguments": {}
-      },
-      "image": {
-        "name": "image",
-        "description": "Event emitted by OpenAIClient",
-        "arguments": {}
-      },
-      "models": {
-        "name": "models",
-        "description": "Event emitted by OpenAIClient",
+        "description": "Event emitted by RestClient",
         "arguments": {}
       }
     },
@@ -23261,198 +23254,72 @@ export const introspectionData = [
     "examples": [
       {
         "language": "ts",
-        "code": "const openai = container.client('openai', { defaultModel: 'gpt-4o' })\nconst answer = await openai.ask('What is the meaning of life?')\nconsole.log(answer)"
+        "code": "const api = container.client('rest', { baseURL: 'https://api.example.com', json: true })\nconst users = await api.get('/users')\nawait api.post('/users', { name: 'Alice' })"
       }
     ]
   },
   {
-    "id": "clients.elevenlabs",
-    "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
-    "shortcut": "clients.elevenlabs",
-    "className": "ElevenLabsClient",
+    "id": "clients.websocket",
+    "description": "WebSocket client that bridges raw WebSocket events to Luca's Helper event bus, providing a clean interface for sending/receiving messages, tracking connection state, and optional auto-reconnection with exponential backoff. Events emitted: - `open` — connection established - `message` — message received (JSON-parsed when possible) - `close` — connection closed (with code and reason) - `error` — connection error - `reconnecting` — attempting reconnection (with attempt number)",
+    "shortcut": "clients.websocket",
+    "className": "WebSocketClient",
     "methods": {
-      "beforeRequest": {
-        "description": "Inject the xi-api-key header before each request.",
-        "parameters": {},
-        "required": [],
-        "returns": "void"
-      },
       "connect": {
-        "description": "Validate the API key by listing available models.",
+        "description": "Establish a WebSocket connection to the configured baseURL. Wires all raw WebSocket events (open, message, close, error) to the Helper event bus and updates connection state accordingly. Resolves once the connection is open; rejects on error.",
         "parameters": {},
         "required": [],
-        "returns": "Promise<this>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "await el.connect()"
-          }
-        ]
-      },
-      "listVoices": {
-        "description": "List available voices with optional search and filtering.",
-        "parameters": {
-          "options": {
-            "type": "{\n    search?: string\n    category?: string\n    voice_type?: string\n    page_size?: number\n    next_page_token?: string\n  }",
-            "description": "Query parameters for filtering voices"
-          }
-        },
-        "required": [],
-        "returns": "Promise<any>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const voices = await el.listVoices()\nconst premade = await el.listVoices({ category: 'premade' })"
-          }
-        ]
+        "returns": "Promise<this>"
       },
-      "getVoice": {
-        "description": "Get details for a single voice.",
+      "send": {
+        "description": "Send data over the WebSocket connection. Automatically JSON-serializes the payload. If not currently connected, attempts to connect first.",
         "parameters": {
-          "voiceId": {
-            "type": "string",
-            "description": "The voice ID to look up"
+          "data": {
+            "type": "any",
+            "description": "The data to send (will be JSON.stringify'd)"
           }
         },
         "required": [
-          "voiceId"
+          "data"
         ],
-        "returns": "Promise<any>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const voice = await el.getVoice('21m00Tcm4TlvDq8ikWAM')\nconsole.log(voice.name, voice.settings)"
-          }
-        ]
+        "returns": "Promise<void>"
       },
-      "listModels": {
-        "description": "List available TTS models.",
+      "disconnect": {
+        "description": "Gracefully close the WebSocket connection. Suppresses auto-reconnect and updates connection state to disconnected.",
         "parameters": {},
         "required": [],
-        "returns": "Promise<any[]>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const models = await el.listModels()\nconsole.log(models.map(m => m.model_id))"
-          }
-        ]
-      },
-      "synthesize": {
-        "description": "Synthesize speech from text, returning audio as a Buffer.",
-        "parameters": {
-          "text": {
-            "type": "string",
-            "description": "The text to convert to speech"
-          },
-          "options": {
-            "type": "SynthesizeOptions",
-            "description": "Voice, model, format, and voice settings overrides",
-            "properties": {
-              "voiceId": {
-                "type": "string",
-                "description": ""
-              },
-              "modelId": {
-                "type": "string",
-                "description": ""
-              },
-              "outputFormat": {
-                "type": "string",
-                "description": ""
-              },
-              "voiceSettings": {
-                "type": "ElevenLabsVoiceSettings",
-                "description": ""
-              },
-              "disableCache": {
-                "type": "boolean",
-                "description": ""
-              }
-            }
-          }
-        },
-        "required": [
-          "text"
-        ],
-        "returns": "Promise<Buffer>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data\n\nconst custom = await el.synthesize('Hello', {\n voiceId: '21m00Tcm4TlvDq8ikWAM',\n voiceSettings: { stability: 0.5, similarityBoost: 0.8 }\n})"
-          }
-        ]
-      },
-      "say": {
-        "description": "Synthesize speech and write the audio to a file.",
-        "parameters": {
-          "text": {
-            "type": "string",
-            "description": "The text to convert to speech"
-          },
-          "outputPath": {
-            "type": "string",
-            "description": "File path to write the audio to"
-          },
-          "options": {
-            "type": "SynthesizeOptions",
-            "description": "Voice, model, format, and voice settings overrides",
-            "properties": {
-              "voiceId": {
-                "type": "string",
-                "description": ""
-              },
-              "modelId": {
-                "type": "string",
-                "description": ""
-              },
-              "outputFormat": {
-                "type": "string",
-                "description": ""
-              },
-              "voiceSettings": {
-                "type": "ElevenLabsVoiceSettings",
-                "description": ""
-              },
-              "disableCache": {
-                "type": "boolean",
-                "description": ""
-              }
-            }
-          }
-        },
-        "required": [
-          "text",
-          "outputPath"
-        ],
-        "returns": "Promise<string>",
-        "examples": [
-          {
-            "language": "ts",
-            "code": "const path = await el.say('Hello world', './hello.mp3')\nconsole.log(`Audio saved to ${path}`)"
-          }
-        ]
+        "returns": "Promise<this>"
       }
     },
     "getters": {
-      "apiKey": {
-        "description": "The resolved API key from options or environment.",
-        "returns": "string"
+      "hasError": {
+        "description": "Whether the client is in an error state.",
+        "returns": "any"
       }
     },
     "events": {
-      "failure": {
-        "name": "failure",
-        "description": "Event emitted by ElevenLabsClient",
+      "open": {
+        "name": "open",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      },
+      "error": {
+        "name": "error",
+        "description": "Event emitted by WebSocketClient",
         "arguments": {}
       },
-      "voices": {
-        "name": "voices",
-        "description": "Event emitted by ElevenLabsClient",
+      "message": {
+        "name": "message",
+        "description": "Event emitted by WebSocketClient",
         "arguments": {}
       },
-      "speech": {
-        "name": "speech",
-        "description": "Event emitted by ElevenLabsClient",
+      "close": {
+        "name": "close",
+        "description": "Event emitted by WebSocketClient",
+        "arguments": {}
+      },
+      "reconnecting": {
+        "name": "reconnecting",
+        "description": "Event emitted by WebSocketClient",
         "arguments": {}
       }
     },
@@ -23462,7 +23329,7 @@ export const introspectionData = [
     "examples": [
       {
         "language": "ts",
-        "code": "const el = container.client('elevenlabs')\nawait el.connect()\nconst voices = await el.listVoices()\nconst audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data"
+        "code": "const ws = container.client('websocket', {\n baseURL: 'ws://localhost:8080',\n reconnect: true,\n maxReconnectAttempts: 5\n})\nws.on('message', (data) => console.log('Received:', data))\nawait ws.connect()\nawait ws.send({ type: 'hello' })"
       }
     ]
   },
@@ -23637,27 +23504,294 @@ export const introspectionData = [
       }
     },
     "getters": {
-      "sdk": {
-        "description": "Returns the raw Supabase SDK client for full access to all SDK methods.",
-        "returns": "SupabaseSDKClient<any, any>"
+      "sdk": {
+        "description": "Returns the raw Supabase SDK client for full access to all SDK methods.",
+        "returns": "SupabaseSDKClient<any, any>"
+      },
+      "storage": {
+        "description": "Returns the Supabase Storage client for managing buckets and files.",
+        "returns": "any"
+      },
+      "functions": {
+        "description": "Returns the Supabase Functions client.",
+        "returns": "any"
+      }
+    },
+    "events": {},
+    "state": {},
+    "options": {},
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const supabase = container.client('supabase', {\n supabaseUrl: 'https://xyz.supabase.co',\n supabaseKey: 'your-anon-key',\n})\n\n// Query data\nconst { data } = await supabase.from('users').select('*')\n\n// Auth\nawait supabase.signInWithPassword('user@example.com', 'password')\n\n// Realtime\nsupabase.subscribe('changes', 'users', (payload) => {\n console.log('Change:', payload)\n})"
+      }
+    ]
+  },
+  {
+    "id": "clients.openai",
+    "description": "OpenAI client — wraps the OpenAI SDK for chat completions, responses API, embeddings, and image generation. Provides convenience methods for common operations while tracking token usage and request counts. Supports both the Chat Completions API and the newer Responses API.",
+    "shortcut": "clients.openai",
+    "className": "OpenAIClient",
+    "methods": {
+      "connect": {
+        "description": "Test the API connection by listing models.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<this>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "await openai.connect()"
+          }
+        ]
+      },
+      "createChatCompletion": {
+        "description": "Create a chat completion using the Chat Completions API.",
+        "parameters": {
+          "messages": {
+            "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
+            "description": "Array of chat messages"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+            "description": "Additional parameters for the completion"
+          }
+        },
+        "required": [
+          "messages"
+        ],
+        "returns": "Promise<OpenAI.Chat.Completions.ChatCompletion>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const response = await openai.createChatCompletion([\n { role: 'system', content: 'You are a helpful assistant.' },\n { role: 'user', content: 'Hello!' }\n])\nconsole.log(response.choices[0]?.message?.content)"
+          }
+        ]
+      },
+      "createResponse": {
+        "description": "Create a response using the Responses API.",
+        "parameters": {
+          "input": {
+            "type": "OpenAI.Responses.ResponseInput | string",
+            "description": "The input prompt or message array"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Responses.ResponseCreateParamsNonStreaming>",
+            "description": "Additional parameters for the response"
+          }
+        },
+        "required": [
+          "input"
+        ],
+        "returns": "Promise<OpenAI.Responses.Response>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const response = await openai.createResponse('Explain quantum computing')"
+          }
+        ]
+      },
+      "streamResponse": {
+        "description": "Stream a response using the Responses API.",
+        "parameters": {
+          "input": {
+            "type": "OpenAI.Responses.ResponseInput | string",
+            "description": "The input prompt or message array"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Responses.ResponseCreateParamsStreaming>",
+            "description": "Additional parameters for the streaming response"
+          }
+        },
+        "required": [
+          "input"
+        ],
+        "returns": "Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const stream = await openai.streamResponse('Write a poem')\nfor await (const event of stream) {\n if (event.type === 'response.output_text.delta') {\n   process.stdout.write(event.delta)\n }\n}"
+          }
+        ]
+      },
+      "createCompletion": {
+        "description": "Create a legacy text completion.",
+        "parameters": {
+          "prompt": {
+            "type": "string",
+            "description": "The text prompt to complete"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Completions.CompletionCreateParams>",
+            "description": "Additional parameters for the completion"
+          }
+        },
+        "required": [
+          "prompt"
+        ],
+        "returns": "Promise<OpenAI.Completions.Completion>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const response = await openai.createCompletion('Once upon a time')"
+          }
+        ]
+      },
+      "createEmbedding": {
+        "description": "Create text embeddings for semantic search or similarity comparisons.",
+        "parameters": {
+          "input": {
+            "type": "string | string[]",
+            "description": "A string or array of strings to embed"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Embeddings.EmbeddingCreateParams>",
+            "description": "Additional parameters (model, etc.)"
+          }
+        },
+        "required": [
+          "input"
+        ],
+        "returns": "Promise<OpenAI.Embeddings.CreateEmbeddingResponse>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const response = await openai.createEmbedding('Hello world')\nconsole.log(response.data[0].embedding.length)"
+          }
+        ]
+      },
+      "createImage": {
+        "description": "Generate an image from a text prompt using DALL-E.",
+        "parameters": {
+          "prompt": {
+            "type": "string",
+            "description": "Description of the image to generate"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Images.ImageGenerateParams>",
+            "description": "Additional parameters (size, n, etc.)"
+          }
+        },
+        "required": [
+          "prompt"
+        ],
+        "returns": "Promise<OpenAI.Images.ImagesResponse>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const response = await openai.createImage('A sunset over mountains')\nconsole.log(response.data[0].url)"
+          }
+        ]
+      },
+      "listModels": {
+        "description": "List all available models.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<OpenAI.Models.ModelsPage>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const models = await openai.listModels()"
+          }
+        ]
+      },
+      "ask": {
+        "description": "Ask a single question and get a text response. Convenience wrapper around `createChatCompletion` for simple Q&A.",
+        "parameters": {
+          "question": {
+            "type": "string",
+            "description": "The question to ask"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+            "description": "Additional completion parameters"
+          }
+        },
+        "required": [
+          "question"
+        ],
+        "returns": "Promise<string>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const answer = await openai.ask('What is 2 + 2?')\nconsole.log(answer) // '4'"
+          }
+        ]
+      },
+      "chat": {
+        "description": "Send a multi-turn conversation and get a text response. Convenience wrapper around `createChatCompletion` that returns just the text.",
+        "parameters": {
+          "messages": {
+            "type": "OpenAI.Chat.Completions.ChatCompletionMessageParam[]",
+            "description": "Array of chat messages"
+          },
+          "options": {
+            "type": "Partial<OpenAI.Chat.Completions.ChatCompletionCreateParams>",
+            "description": "Additional completion parameters"
+          }
+        },
+        "required": [
+          "messages"
+        ],
+        "returns": "Promise<string>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const reply = await openai.chat([\n { role: 'system', content: 'You are a pirate.' },\n { role: 'user', content: 'Hello!' }\n])"
+          }
+        ]
+      }
+    },
+    "getters": {
+      "defaultModel": {
+        "description": "The default model used for completions, from options or 'gpt-4o'.",
+        "returns": "string"
       },
-      "storage": {
-        "description": "Returns the Supabase Storage client for managing buckets and files.",
-        "returns": "any"
+      "raw": {
+        "description": "The underlying OpenAI SDK instance for advanced use cases.",
+        "returns": "OpenAI"
+      }
+    },
+    "events": {
+      "connected": {
+        "name": "connected",
+        "description": "Event emitted by OpenAIClient",
+        "arguments": {}
       },
-      "functions": {
-        "description": "Returns the Supabase Functions client.",
-        "returns": "any"
+      "failure": {
+        "name": "failure",
+        "description": "Event emitted by OpenAIClient",
+        "arguments": {}
+      },
+      "completion": {
+        "name": "completion",
+        "description": "Event emitted by OpenAIClient",
+        "arguments": {}
+      },
+      "embedding": {
+        "name": "embedding",
+        "description": "Event emitted by OpenAIClient",
+        "arguments": {}
+      },
+      "image": {
+        "name": "image",
+        "description": "Event emitted by OpenAIClient",
+        "arguments": {}
+      },
+      "models": {
+        "name": "models",
+        "description": "Event emitted by OpenAIClient",
+        "arguments": {}
       }
     },
-    "events": {},
     "state": {},
     "options": {},
     "envVars": [],
     "examples": [
       {
         "language": "ts",
-        "code": "const supabase = container.client('supabase', {\n supabaseUrl: 'https://xyz.supabase.co',\n supabaseKey: 'your-anon-key',\n})\n\n// Query data\nconst { data } = await supabase.from('users').select('*')\n\n// Auth\nawait supabase.signInWithPassword('user@example.com', 'password')\n\n// Realtime\nsupabase.subscribe('changes', 'users', (payload) => {\n console.log('Change:', payload)\n})"
+        "code": "const openai = container.client('openai', { defaultModel: 'gpt-4o' })\nconst answer = await openai.ask('What is the meaning of life?')\nconsole.log(answer)"
       }
     ]
   },
@@ -23912,6 +24046,207 @@ export const introspectionData = [
       }
     ]
   },
+  {
+    "id": "clients.elevenlabs",
+    "description": "ElevenLabs client — text-to-speech synthesis via the ElevenLabs REST API. Provides methods for listing voices, listing models, and generating speech audio. Audio is returned as a Buffer; use `say()` for a convenience method that writes to disk.",
+    "shortcut": "clients.elevenlabs",
+    "className": "ElevenLabsClient",
+    "methods": {
+      "beforeRequest": {
+        "description": "Inject the xi-api-key header before each request.",
+        "parameters": {},
+        "required": [],
+        "returns": "void"
+      },
+      "connect": {
+        "description": "Validate the API key by listing available models.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<this>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "await el.connect()"
+          }
+        ]
+      },
+      "listVoices": {
+        "description": "List available voices with optional search and filtering.",
+        "parameters": {
+          "options": {
+            "type": "{\n    search?: string\n    category?: string\n    voice_type?: string\n    page_size?: number\n    next_page_token?: string\n  }",
+            "description": "Query parameters for filtering voices"
+          }
+        },
+        "required": [],
+        "returns": "Promise<any>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const voices = await el.listVoices()\nconst premade = await el.listVoices({ category: 'premade' })"
+          }
+        ]
+      },
+      "getVoice": {
+        "description": "Get details for a single voice.",
+        "parameters": {
+          "voiceId": {
+            "type": "string",
+            "description": "The voice ID to look up"
+          }
+        },
+        "required": [
+          "voiceId"
+        ],
+        "returns": "Promise<any>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const voice = await el.getVoice('21m00Tcm4TlvDq8ikWAM')\nconsole.log(voice.name, voice.settings)"
+          }
+        ]
+      },
+      "listModels": {
+        "description": "List available TTS models.",
+        "parameters": {},
+        "required": [],
+        "returns": "Promise<any[]>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const models = await el.listModels()\nconsole.log(models.map(m => m.model_id))"
+          }
+        ]
+      },
+      "synthesize": {
+        "description": "Synthesize speech from text, returning audio as a Buffer.",
+        "parameters": {
+          "text": {
+            "type": "string",
+            "description": "The text to convert to speech"
+          },
+          "options": {
+            "type": "SynthesizeOptions",
+            "description": "Voice, model, format, and voice settings overrides",
+            "properties": {
+              "voiceId": {
+                "type": "string",
+                "description": ""
+              },
+              "modelId": {
+                "type": "string",
+                "description": ""
+              },
+              "outputFormat": {
+                "type": "string",
+                "description": ""
+              },
+              "voiceSettings": {
+                "type": "ElevenLabsVoiceSettings",
+                "description": ""
+              },
+              "disableCache": {
+                "type": "boolean",
+                "description": ""
+              }
+            }
+          }
+        },
+        "required": [
+          "text"
+        ],
+        "returns": "Promise<Buffer>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data\n\nconst custom = await el.synthesize('Hello', {\n voiceId: '21m00Tcm4TlvDq8ikWAM',\n voiceSettings: { stability: 0.5, similarityBoost: 0.8 }\n})"
+          }
+        ]
+      },
+      "say": {
+        "description": "Synthesize speech and write the audio to a file.",
+        "parameters": {
+          "text": {
+            "type": "string",
+            "description": "The text to convert to speech"
+          },
+          "outputPath": {
+            "type": "string",
+            "description": "File path to write the audio to"
+          },
+          "options": {
+            "type": "SynthesizeOptions",
+            "description": "Voice, model, format, and voice settings overrides",
+            "properties": {
+              "voiceId": {
+                "type": "string",
+                "description": ""
+              },
+              "modelId": {
+                "type": "string",
+                "description": ""
+              },
+              "outputFormat": {
+                "type": "string",
+                "description": ""
+              },
+              "voiceSettings": {
+                "type": "ElevenLabsVoiceSettings",
+                "description": ""
+              },
+              "disableCache": {
+                "type": "boolean",
+                "description": ""
+              }
+            }
+          }
+        },
+        "required": [
+          "text",
+          "outputPath"
+        ],
+        "returns": "Promise<string>",
+        "examples": [
+          {
+            "language": "ts",
+            "code": "const path = await el.say('Hello world', './hello.mp3')\nconsole.log(`Audio saved to ${path}`)"
+          }
+        ]
+      }
+    },
+    "getters": {
+      "apiKey": {
+        "description": "The resolved API key from options or environment.",
+        "returns": "string"
+      }
+    },
+    "events": {
+      "failure": {
+        "name": "failure",
+        "description": "Event emitted by ElevenLabsClient",
+        "arguments": {}
+      },
+      "voices": {
+        "name": "voices",
+        "description": "Event emitted by ElevenLabsClient",
+        "arguments": {}
+      },
+      "speech": {
+        "name": "speech",
+        "description": "Event emitted by ElevenLabsClient",
+        "arguments": {}
+      }
+    },
+    "state": {},
+    "options": {},
+    "envVars": [],
+    "examples": [
+      {
+        "language": "ts",
+        "code": "const el = container.client('elevenlabs')\nawait el.connect()\nconst voices = await el.listVoices()\nconst audio = await el.synthesize('Hello world')\n// audio is a Buffer of mp3 data"
+      }
+    ]
+  },
   {
     "id": "servers.mcp",
     "description": "MCP (Model Context Protocol) server for exposing tools, resources, and prompts to AI clients like Claude Code. Uses the low-level MCP SDK Server class directly with Zod 4 native JSON Schema conversion. Register tools, resources, and prompts programmatically, then start the server over stdio (for CLI integration) or HTTP (for remote access).",