Add files using upload-large-folder tool

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Base44 CLI"
+  short_description: "Initialize, configure, deploy, and manage Base44 projects"
+  default_prompt: "Use Base44 CLI guidance to initialize, configure, authenticate, and deploy this Base44 app."

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/agents-push.md

@@ -0,0 +1,156 @@
+# base44 agents push
+
+Push local AI agent configurations to Base44. Agents are conversational AI assistants that can interact with users, access your app's entities, and call backend functions.
+
+## Syntax
+
+```bash
+npx base44 agents push
+```
+
+## Authentication
+
+**Required**: Yes. If not authenticated, you'll be prompted to login first.
+
+## What It Does
+
+1. Reads all agent files from the `base44/agents/` directory
+2. Validates agent configurations
+3. Displays the count of agents to be pushed
+4. Uploads agents to the Base44 backend
+5. Reports the results: created, updated, and deleted agents
+
+## Prerequisites
+
+- Must be run from a Base44 project directory
+- Project must have agent definitions in the `base44/agents/` folder
+
+## Output
+
+```bash
+$ npx base44 agents push
+
+Found 2 agents to push
+Pushing agents to Base44...
+
+Created: support_agent
+Updated: order_bot
+Deleted: old_agent
+
+✓ Agents pushed to Base44
+```
+
+## Agent Synchronization
+
+The push operation synchronizes your local agents with Base44:
+
+- **Created**: New agents that didn't exist in Base44
+- **Updated**: Existing agents with modified configuration
+- **Deleted**: Agents that were removed from your local configuration
+
+**Warning**: This is a full sync operation. Agents removed locally will be deleted from Base44.
+
+## Error Handling
+
+If no agents are found in your project:
+```bash
+$ npx base44 agents push
+No local agents found - this will delete all remote agents
+```
+
+If an agent has an invalid name:
+```bash
+$ npx base44 agents push
+Error: Agent name must be lowercase alphanumeric with underscores
+```
+
+## Agent Configuration Schema
+
+Each agent file should be a `.jsonc` file in `base44/agents/` with this structure:
+
+```jsonc
+{
+  "name": "agent_name",              // Required: lowercase alphanumeric with underscores, 1-100 chars
+  "description": "Brief description of what this agent does",  // Required: min 1 char
+  "instructions": "Detailed instructions for the agent's behavior",  // Required: min 1 char
+  "tool_configs": [                  // Optional: defaults to []
+    // Entity tool - gives agent access to entity operations
+    { "entity_name": "Task", "allowed_operations": ["read", "create", "update", "delete"] },
+    // Backend function tool - gives agent access to a function
+    { "function_name": "send_email", "description": "Send an email notification" }
+  ],
+  "whatsapp_greeting": "Hello! How can I help you today?"  // Optional
+}
+```
+
+**Naming rules:**
+- **Agent names** must match pattern: `/^[a-z0-9_]+$/` (lowercase alphanumeric with underscores only, 1-100 characters)
+  - Valid: `support_agent`, `order_bot`, `task_helper`
+  - Invalid: `Support-Agent`, `OrderBot`, `task helper`
+- **Agent file names** must use underscores (matching the agent name)
+  - Valid: `support_agent.jsonc`, `order_bot.jsonc`
+  - Invalid: `support-agent.jsonc` (hyphens not allowed)
+- **Entity names in `tool_configs`** must use PascalCase (matching the entity's `name` field)
+  - Valid: `"entity_name": "Task"`, `"entity_name": "TeamMember"`
+  - Invalid: `"entity_name": "task"`, `"entity_name": "team_member"`
+
+**Required fields:**
+- `name`: Required, must follow naming rules above
+- `description`: Required, minimum 1 character
+- `instructions`: Required, minimum 1 character
+- `tool_configs`: Optional, defaults to empty array
+- `whatsapp_greeting`: Optional
+
+### Common Mistake: Wrong tool_configs Format
+
+**WRONG** - Do NOT use `tools` with `type` and `entity`:
+```jsonc
+{
+  "name": "my_agent",
+  "tools": [                                    // ❌ WRONG
+    { "type": "entity_query", "entity": "Task" }
+  ]
+}
+```
+
+**CORRECT** - Use `tool_configs` with `entity_name` and `allowed_operations`:
+```jsonc
+{
+  "name": "my_agent",
+  "tool_configs": [                             // ✅ CORRECT
+    { "entity_name": "Task", "allowed_operations": ["read"] }
+  ]
+}
+```
+
+### Best Practices for Agent Instructions
+
+When giving agents access to entities, be explicit in the instructions about using the tools:
+
+```jsonc
+{
+  "name": "support_agent",
+  "instructions": "You are a helpful support agent.\n\nIMPORTANT: You have access to customer data through entity tools. When users ask about their orders or account:\n1. ALWAYS use the Order entity tool to query their order history\n2. Use the Customer entity tool to look up account details\n3. Analyze the data and provide personalized responses\n\nAlways query the relevant entities first before answering questions about user data.",
+  "tool_configs": [
+    { "entity_name": "Order", "allowed_operations": ["read"] },
+    { "entity_name": "Customer", "allowed_operations": ["read"] }
+  ]
+}
+```
+
+Without explicit instructions to use the entity tools, the agent may not proactively query user data when asked.
+
+## Use Cases
+
+- After defining new agents in your project
+- When modifying existing agent configurations
+- To sync agent changes before testing
+- As part of your development workflow when agent behavior changes
+
+## Notes
+
+- This command syncs the agent configuration, not conversation data
+- Changes are applied to your Base44 project immediately
+- Make sure to test agent changes in a development environment first
+- Agent definitions are located in the `base44/agents/` directory
+- Use `base44 agents pull` to download agents from Base44

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/auth-login.md

@@ -0,0 +1,54 @@
+# base44 login
+
+Authenticate with Base44 using device code flow.
+
+## Syntax
+
+```bash
+npx base44 login
+```
+
+## Authentication
+
+**Required**: No (this is the login command itself)
+
+## How It Works
+
+The login command uses OAuth 2.0 device code flow for authentication:
+
+1. Generates a device code for authentication
+2. Displays a verification code and verification URI
+3. Directs you to visit the URI and enter the code
+4. Polls for authentication completion (up to device code expiration)
+5. Retrieves access and refresh tokens upon successful authentication
+6. Fetches and displays your user information
+7. Saves authentication data locally with expiration timestamp
+
+## Interactive Flow
+
+```bash
+$ npx base44 login
+
+Please visit: https://auth.base44.com/device
+Enter code: ABCD-EFGH
+
+Waiting for authentication...
+✓ Successfully authenticated!
+
+Logged in as: user@example.com
+```
+
+## Session Management
+
+- Authentication tokens are stored locally on your device
+- Tokens include expiration timestamps
+- The session persists across CLI sessions
+- Other commands will automatically use your stored credentials
+- Use `npx base44 logout` to clear your session
+- Use `npx base44 whoami` to check your current authentication status
+
+## Notes
+
+- You only need to login once per device
+- If your session expires, you'll be prompted to login again when running authenticated commands
+- The CLI automatically prompts for login when you run commands that require authentication

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/connectors-create.md

@@ -0,0 +1,126 @@
+# Creating Connectors
+
+Connectors are OAuth integrations that let your Base44 app connect to external services like Google Calendar, Slack, Notion, and more. Once connected, you can use access tokens in backend functions to call external APIs directly.
+
+## Key Concepts
+
+- **Direct API Access**: Connectors provide raw OAuth access tokens - you call the external APIs directly from backend functions
+- **App Builder's Account**: Connects your account (the app builder), not your end users' accounts
+- **Backend Functions Only**: Tokens are only accessible server-side for security
+
+## File Location
+
+Create connector files in the `base44/connectors/` directory (or the directory specified by `connectorsDir` in your config.jsonc).
+
+**File naming:** `{type}.jsonc` or `{type}.json`
+
+Examples:
+- `base44/connectors/googlecalendar.jsonc`
+- `base44/connectors/slack.jsonc`
+- `base44/connectors/notion.json`
+
+## Schema
+
+Each connector file must specify a `type` and optionally a list of `scopes`:
+
+```jsonc
+{
+  "type": "googlecalendar",
+  "scopes": [
+    "https://www.googleapis.com/auth/calendar.readonly",
+    "https://www.googleapis.com/auth/calendar.events"
+  ]
+}
+```
+
+### Fields
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `type` | string | Yes | The integration type (run `npx base44 connectors list-available` to see options) |
+| `scopes` | string[] | No | OAuth scopes to request (defaults to `[]`) |
+
+## Discovering Available Connector Types
+
+Run the following command to get the up-to-date list of supported connector types. Note: `stripe` is also a valid type but is not returned by this command — treat it as supported (see Stripe example below).
+
+```bash
+npx base44 connectors list-available
+```
+
+This returns a JSON object with all available integrations, their display names, descriptions, and any required connection config fields. Example output (trimmed):
+
+```json
+{
+    "integrations": [
+        {
+            "integration_type": "googlecalendar",
+            "display_name": "Google Calendar",
+            "description": "Access and manage Google Calendar events",
+            "connection_config_fields": []
+        },
+        {
+            "integration_type": "slack",
+            "display_name": "Slack User",
+            "description": "Send messages and interact with Slack as yourself (user integration)",
+            "connection_config_fields": []
+        },
+        {
+            "integration_type": "share_point",
+            "display_name": "SharePoint",
+            "description": "Manage documents, lists, sites, and collaboration content in SharePoint",
+            "connection_config_fields": [
+                {
+                    "name": "subdomain",
+                    "display_name": "SharePoint Site",
+                    "description": "The name of your SharePoint site (e.g., sites/mysite)",
+                    "placeholder": "sites/mysite",
+                    "required": true,
+                    "validation_pattern": "^[a-zA-Z0-9/_-]+$",
+                    "validation_error": "Please enter a valid SharePoint site path"
+                }
+            ]
+        }
+    ]
+}
+```
+
+Use the `integration_type` value from this output as the `type` field in your connector file. Some connectors require additional `connection_config_fields` — check the output for details.
+
+### Stripe (Sandbox)
+
+```jsonc
+// base44/connectors/stripe.jsonc
+{
+  "type": "stripe",
+  "scopes": []
+}
+```
+
+Note: Stripe does not require an OAuth browser flow. When you push this connector, Base44 automatically provisions a Stripe sandbox account on the server side. You may receive a claim URL in the push output to link the sandbox to your Stripe account.
+
+## Rules and Constraints
+
+1. **One connector per type**: You cannot have multiple connectors of the same type (e.g., two `googlecalendar` connectors)
+
+2. **Type must be valid**: The `type` field must be a valid integration type (run `npx base44 connectors list-available` to see available types)
+
+3. **Scopes are provider-specific**: Each service has its own scope format - refer to the provider's documentation
+
+## Next Steps
+
+After creating connector files, push them to Base44:
+
+```bash
+npx base44 connectors push
+```
+
+This will prompt you to authorize each new OAuth connector in your browser. Stripe is the exception — it is provisioned automatically without a browser flow. See [connectors-push.md](connectors-push.md) for details.
+
+To pull existing connectors from Base44 to local files:
+
+```bash
+npx base44 connectors pull
+```
+
+See [connectors-pull.md](connectors-pull.md) for details.

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/connectors-list-available.md

@@ -0,0 +1,56 @@
+# base44 connectors list-available
+
+List all integration types available in the Base44 connector catalog.
+
+## Syntax
+
+```bash
+npx base44 connectors list-available
+```
+
+## Authentication
+
+**Required**: Yes. If not authenticated, you'll be prompted to login first.
+
+## What It Does
+
+Fetches the catalog of available integration types from Base44 and displays each one with its display name, description, and any required configuration fields.
+
+## Output
+
+```bash
+$ npx base44 connectors list-available
+
+✓ Available integrations fetched successfully
+
+Google Calendar
+  integrationType: googlecalendar
+  description: Access Google Calendar events and schedules
+  connectionConfigFields: []
+
+Slack
+  integrationType: slack
+  description: Send messages and interact with Slack workspaces
+  connectionConfigFields: []
+
+Stripe
+  integrationType: stripe
+  description: Process payments and manage Stripe accounts
+  connectionConfigFields: []
+
+Found 14 available integrations.
+```
+
+Each integration is displayed in YAML format showing the integration type, description, and any connection configuration fields required for setup.
+
+## Use Cases
+
+- Discover all supported connector types before creating connector files
+- Check if a specific integration is available in your Base44 plan
+- See what configuration fields (if any) a connector requires
+
+## Related Commands
+
+- [connectors-create.md](connectors-create.md) - How to create connector configuration files
+- [connectors-push.md](connectors-push.md) - Push local connectors to Base44
+- [connectors-pull.md](connectors-pull.md) - Pull connectors from Base44 to local files

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/connectors-push.md

@@ -0,0 +1,137 @@
+# base44 connectors push
+
+Push local connector configurations to Base44, synchronizing scopes and handling OAuth authorization.
+
+## Usage
+
+```bash
+npx base44 connectors push
+```
+
+## What It Does
+
+1. **Reads local connectors** from your `base44/connectors/` directory
+2. **Syncs with Base44** - updates scopes for existing connectors
+3. **Adds new connectors** - new OAuth connector types trigger authorization; Stripe is provisioned automatically
+4. **Removes unlisted connectors** - connectors not in your local files are removed from Base44
+
+## OAuth Authorization Flow
+
+When you add a new connector, it needs to be authorized:
+
+1. The CLI detects which connectors need authorization
+2. You're prompted: "Open browser to authorize now?"
+3. If you accept, the browser opens to the OAuth provider (Google, Slack, etc.)
+4. You log into your account and approve the requested permissions
+5. The browser closes and the CLI confirms authorization
+
+**Important**: You choose which account to connect by logging into it during the OAuth flow. For example, if you have multiple Google accounts, you select which one to use in the Google login screen.
+
+## Example Output
+
+### Pushing connectors (no new authorization needed)
+
+```
+Found 2 connectors to push: googlecalendar, slack
+✓ Connectors pushed
+
+Summary:
+  Synced: googlecalendar, slack
+```
+
+### Pushing new connectors (authorization required)
+
+```
+Found 3 connectors to push: googlecalendar, slack, notion
+✓ Connectors pushed
+
+2 connector(s) require authorization in your browser:
+  slack: https://auth.base44.io/oauth/...
+  notion: https://auth.base44.io/oauth/...
+
+? Open browser to authorize now? › Yes
+
+Opening browser for slack...
+✓ slack authorization complete
+
+Opening browser for notion...
+✓ notion authorization complete
+
+Summary:
+  Synced: googlecalendar
+  Added: slack, notion
+```
+
+### Pushing Stripe (no OAuth required)
+
+Stripe is provisioned automatically — no browser flow is needed:
+
+```
+Found 2 connectors to push: googlecalendar, stripe
+✓ Connectors pushed
+
+Summary:
+  ✓ Stripe sandbox provisioned
+    Claim your Stripe sandbox: https://dashboard.stripe.com/...
+    Connectors dashboard: https://app.base44.com/...
+  Synced: googlecalendar
+```
+
+### Removing connectors
+
+If you delete a connector file locally and push, it will be removed:
+
+```
+Found 1 connectors to push: googlecalendar
+✓ Connectors pushed
+
+Summary:
+  Synced: googlecalendar
+  Removed: slack
+```
+
+## CI/CD Environments
+
+In non-interactive environments (no TTY, such as CI/CD pipelines), the OAuth flow is skipped automatically:
+
+```
+Skipped OAuth in non-interactive mode. Run 'base44 connectors push' locally or open the links above to authorize.
+```
+
+You must run `npx base44 connectors push` locally to complete authorization for new connectors.
+
+## Skipping Authorization
+
+If you choose not to authorize immediately, the connectors remain in a pending state:
+
+```
+? Open browser to authorize now? › No
+
+Authorization skipped. Pending: slack, notion. Run 'base44 connectors push' again to complete.
+```
+
+Run the command again when you're ready to authorize.
+
+## Summary Status Meanings
+
+| Status | Meaning |
+|--------|---------|
+| Provisioned | Stripe sandbox was created automatically (no OAuth needed) |
+| Synced | Connector already existed, scopes updated if needed |
+| Added | New connector successfully authorized via OAuth |
+| Removed | Connector was deleted from Base44 (not in local files) |
+| Failed | Authorization timed out, failed, or was skipped |
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| Authorization timed out | Re-run `npx base44 connectors push` and complete OAuth faster |
+| Authorization failed | Check that you approved all requested permissions |
+| Wrong account connected | Remove the connector file, push to delete it, then add it back and authorize with the correct account |
+| Browser didn't open | Copy the URL shown in the terminal and open it manually |
+
+## Related Commands
+
+- [connectors-create.md](connectors-create.md) - How to create connector configuration files
+- [connectors-pull.md](connectors-pull.md) - Pull connectors from Base44 to local files

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/exec.md

@@ -0,0 +1,47 @@
+# base44 exec
+
+Run a script with the Base44 SDK pre-authenticated as the current user. Reads the script from stdin.
+
+## Syntax
+
+```bash
+cat ./script.ts | npx base44 exec
+echo "<code>" | npx base44 exec
+```
+
+## How It Works
+
+The `exec` command reads a script from stdin and runs it server-side with the Base44 SDK pre-authenticated as the currently logged-in user. This allows you to run one-off scripts against your app's data without writing a full function.
+
+## Available Globals
+
+> **`base44`** — a preinitialized SDK client, available as a global variable in every exec script. You do not need to import or configure it — it is ready to use immediately.
+
+Use it to interact with your app's resources:
+
+- `base44.entities.<EntityName>` — CRUD operations on entities (`.list()`, `.get(id)`, `.create(data)`, `.update(id, data)`, `.delete(id)`)
+- `base44.functions.invoke(name, data?)` — call a backend function
+- `base44.agents.<AgentName>` — invoke AI agents
+- For more available resources and methods, see the [Base44 SDK reference](../../base44-sdk/SKILL.md)
+
+## Examples
+
+```bash
+# Run a script file
+cat ./script.ts | npx base44 exec
+
+# Inline script
+echo "const users = await base44.entities.User.list(); console.log(users)" | npx base44 exec
+```
+
+## Requirements
+
+- Must be authenticated (`npx base44 login`)
+- Must be run from a linked Base44 project directory
+- Script must be piped via stdin (non-interactive mode)
+
+## Notes
+
+- The script runs with the Base44 SDK pre-authenticated — you can use `base44.entities`, `base44.functions`, etc. directly
+- Exit code from the script is forwarded as the CLI process exit code
+- This command requires stdin to be piped (it does not accept input in interactive TTY mode)

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/functions-pull.md

@@ -0,0 +1,80 @@
+# base44 functions pull
+
+Pull deployed functions from Base44 to local files.
+
+## Syntax
+
+```bash
+npx base44 functions pull [name]
+```
+
+## Arguments
+
+| Argument | Description | Required |
+|----------|-------------|----------|
+| `[name]` | Function name to pull (pulls all if omitted) | No |
+
+## Authentication
+
+**Required**: Yes. If not authenticated, you'll be prompted to login first.
+
+## What It Does
+
+1. Fetches deployed functions from Base44
+2. Filters to the specified function if `[name]` is provided
+3. Writes function files to the local `functions/` directory (configured in `base44/config.jsonc`)
+4. Reports each file as `written` (new/updated) or `unchanged`
+
+## Examples
+
+```bash
+# Pull all deployed functions
+npx base44 functions pull
+
+# Pull a specific function
+npx base44 functions pull process-order
+```
+
+## Output
+
+```bash
+$ npx base44 functions pull
+✓ Functions fetched successfully
+✓ Function files written successfully
+✓ process-order              written
+◆ send-notification          unchanged
+
+✓ Pulled 2 functions to base44/functions
+```
+
+Single function:
+```bash
+$ npx base44 functions pull process-order
+✓ Functions fetched successfully
+✓ Function files written successfully
+✓ process-order              written
+
+✓ Pulled 1 function to base44/functions
+```
+
+## Error Handling
+
+If the specified function is not found on remote:
+```bash
+$ npx base44 functions pull nonexistent
+✓ Function "nonexistent" not found on remote
+```
+
+If no functions exist on remote:
+```bash
+$ npx base44 functions pull
+✓ No functions found on remote
+```
+
+## Notes
+
+- Files are written to the `functionsDir` configured in `base44/config.jsonc` (defaults to `functions/`)
+- Files already matching remote content are skipped (reported as `unchanged`)
+- This overwrites existing local function files with remote versions — commit local changes first
+- Use `npx base44 functions deploy` to push local changes back to Base44
+- Use `npx base44 functions list` to see what functions are deployed on remote

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-cli/references/secrets-list.md

@@ -0,0 +1,25 @@
+# base44 secrets list
+
+List the names of all secrets configured for the current project.
+
+## Syntax
+
+```bash
+npx base44 secrets list
+```
+
+## Options
+
+No options. The command takes no arguments or flags.
+
+## Examples
+
+```bash
+npx base44 secrets list
+```
+
+## Notes
+
+- Only secret **names** are listed (values are never displayed)
+- Returns "No secrets configured." if there are none
+- Requires authentication

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Base44 SDK"
+  short_description: "Build features with the Base44 JavaScript and TypeScript SDK"
+  default_prompt: "Use Base44 SDK guidance to implement this feature against entities, functions, auth, and integrations."

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/QUICK_REFERENCE.md

@@ -0,0 +1,178 @@
+# Base44 SDK Quick Reference
+
+Compact method signatures for all SDK modules. **Verify against this before writing code.**
+
+---
+
+## Auth (`base44.auth.*`)
+
+```
+loginViaEmailPassword(email, password, turnstileToken?) → Promise<{access_token, user}>
+loginWithProvider('google' | 'microsoft' | 'facebook', fromUrl?) → void
+me() → Promise<User | null>
+updateMe(data) → Promise<User>
+isAuthenticated() → Promise<boolean>
+logout(redirectUrl?) → void
+redirectToLogin(nextUrl) → void              # ⚠️ Avoid - prefer custom login UI
+register({email, password, turnstile_token?, referral_code?}) → Promise<any>
+verifyOtp({email, otpCode}) → Promise<any>
+resendOtp(email) → Promise<any>
+inviteUser(userEmail, role) → Promise<any>
+resetPasswordRequest(email) → Promise<any>
+resetPassword({resetToken, newPassword}) → Promise<any>
+changePassword({userId, currentPassword, newPassword}) → Promise<any>
+setToken(token, saveToStorage?) → void
+```
+
+---
+
+## Entities (`base44.entities.EntityName.*`)
+
+```
+create(data) → Promise<T>
+bulkCreate(dataArray) → Promise<T[]>
+list(sort?, limit?, skip?, fields?) → Promise<Pick<T, K>[]>
+filter(query, sort?, limit?, skip?, fields?) → Promise<Pick<T, K>[]>
+get(id) → Promise<T>
+update(id, data) → Promise<T>
+updateMany(query, mongoUpdateOp) → Promise<UpdateManyResult>   // e.g. { $set: { field: val } }
+bulkUpdate(dataArray) → Promise<T[]>                           // each item must have id
+delete(id) → Promise<DeleteResult>
+deleteMany(query) → Promise<DeleteManyResult>
+importEntities(file) → Promise<ImportResult<T>>                // frontend only
+subscribe(callback) → () => void                               // returns unsubscribe fn
+```
+
+**Sort:** Use `SortField<T>`: `-fieldName` for descending (e.g., `-created_date`). Max 5,000 per request for list/filter.
+
+---
+
+## Functions (`base44.functions.*`)
+
+```
+invoke(functionName, data?) → Promise<any>
+fetch(path, init?) → Promise<Response>   // low-level, for streaming/custom methods
+```
+
+**Backend:** Use `base44.asServiceRole.functions.invoke()` for admin access.
+
+---
+
+## Integrations (`base44.integrations.Core.*`)
+
+```
+InvokeLLM({prompt, add_context_from_internet?, response_json_schema?, file_urls?}) → Promise<string | object>
+GenerateImage({prompt}) → Promise<{url}>
+SendEmail({to, subject, body, from_name?}) → Promise<any>
+UploadFile({file}) → Promise<{file_url}>
+UploadPrivateFile({file}) → Promise<{file_uri}>
+CreateFileSignedUrl({file_uri, expires_in?}) → Promise<{signed_url}>
+ExtractDataFromUploadedFile({file_url, json_schema}) → Promise<object>
+```
+
+### Custom Integrations (`base44.integrations.custom.*`)
+
+```
+call(slug, operationId, {payload?, pathParams?, queryParams?}?) → Promise<{success, status_code, data}>
+```
+
+**operationId format:** `"method:/path"` (e.g., `"get:/contacts"`, `"post:/users/{id}"`)
+
+---
+
+## Analytics (`base44.analytics.*`)
+
+```
+track({eventName, properties?}) → void
+```
+
+---
+
+## App Logs (`base44.appLogs.*`)
+
+```
+logUserInApp(pageName) → Promise<void>
+fetchLogs(params?) → Promise<any>
+getStats(params?) → Promise<any>
+```
+
+---
+
+## Users (`base44.users.*`)
+
+```
+inviteUser(userEmail, role) → Promise<any>    // role: 'user' | 'admin'
+```
+
+---
+
+## Service Role Connectors (`base44.asServiceRole.connectors.*`)
+
+**Backend only, service role required.** App-scoped (shared account).
+
+```
+getConnection(integrationType) → Promise<{accessToken, connectionConfig}>   // recommended
+getAccessToken(integrationType) → Promise<string>                           // deprecated
+```
+
+**Types:** Run `npx base44 connectors list-available` to see all available integration types.
+
+---
+
+## SSO (`base44.asServiceRole.sso.*`)
+
+**Backend only, service role required.**
+
+```
+getAccessToken(userId) → Promise<{access_token}>
+```
+
+---
+
+## Service Role Access
+
+**Backend functions only.** Prefix any module with `asServiceRole` for admin access:
+
+```javascript
+base44.asServiceRole.entities.Task.list()
+base44.asServiceRole.functions.invoke('name', data)
+base44.asServiceRole.connectors.getConnection('slack')
+base44.asServiceRole.sso.getAccessToken(userId)
+```
+
+---
+
+## Backend Function Template
+
+```javascript
+import { createClientFromRequest } from "@base44/sdk";
+
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+  const data = await req.json();
+  
+  // User context
+  const user = await base44.auth.me();
+  
+  // Service role for admin operations
+  const allRecords = await base44.asServiceRole.entities.Task.list();
+  
+  return Response.json({ success: true });
+});
+```
+
+---
+
+## Client Initialization (External Apps)
+
+```javascript
+import { createClient } from "@base44/sdk";
+
+const base44 = createClient({ appId: "your-app-id" });  // MUST use 'appId'
+```
+
+---
+
+## TypeScript type registries
+
+For typed entities, function names, and agent names (autocomplete and type checking), the Base44 CLI generates types and wires them into your project. Use the **base44-cli** skill for how to generate types.

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/analytics.md

@@ -0,0 +1,113 @@
+# Analytics Module
+
+Track custom events and user activity via `base44.analytics`.
+
+## Contents
+- [Methods](#methods)
+- [Examples](#examples)
+- [Automatic Tracking](#automatic-tracking)
+- [Best Practices](#best-practices)
+
+## Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `track(params)` | `void` | Track a custom event |
+
+## Examples
+
+### Track Custom Event
+
+```javascript
+// Track a simple event
+base44.analytics.track({
+  eventName: "button_clicked"
+});
+
+// Track event with properties
+base44.analytics.track({
+  eventName: "purchase_completed",
+  properties: {
+    product_id: "prod-123",
+    amount: 99.99,
+    currency: "USD"
+  }
+});
+```
+
+### Track User Actions
+
+```javascript
+// Track page view
+base44.analytics.track({
+  eventName: "page_view",
+  properties: {
+    page: "/dashboard",
+    referrer: document.referrer
+  }
+});
+
+// Track feature usage
+base44.analytics.track({
+  eventName: "feature_used",
+  properties: {
+    feature: "export_data",
+    format: "csv"
+  }
+});
+```
+
+## Automatic Tracking
+
+The analytics module automatically tracks:
+- **Initialization events**: When the app loads
+- **Heartbeat events**: Periodic activity signals
+- **Session duration**: Time spent in the app
+
+These internal events help measure user engagement without manual instrumentation.
+
+## Best Practices
+
+1. **Use descriptive event names**: `order_completed` instead of `click`
+2. **Include relevant properties**: Add context that helps analyze the event
+3. **Be consistent**: Use the same event names and property keys across your app
+4. **Don't track sensitive data**: Avoid PII in event properties
+
+```javascript
+// Good: Descriptive with relevant properties
+base44.analytics.track({
+  eventName: "subscription_started",
+  properties: {
+    plan: "pro",
+    billing_cycle: "annual"
+  }
+});
+
+// Avoid: Vague event name, no context
+base44.analytics.track({
+  eventName: "click"
+});
+```
+
+## Type Definitions
+
+```typescript
+/** Properties that can be attached to a tracked event. */
+type TrackEventProperties = {
+  [key: string]: string | number | boolean | null | undefined;
+};
+
+/** Parameters for the track() method. */
+interface TrackEventParams {
+  /** The name of the event to track. */
+  eventName: string;
+  /** Optional properties to attach to the event. */
+  properties?: TrackEventProperties;
+}
+
+/** The analytics module interface. */
+interface AnalyticsModule {
+  /** Track a custom event with optional properties. */
+  track(params: TrackEventParams): void;
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/app-logs.md

@@ -0,0 +1,120 @@
+# App Logs Module
+
+Log user activity in your app via `base44.appLogs`.
+
+## Contents
+- [Methods](#methods)
+- [Examples](#examples)
+- [Use Cases](#use-cases)
+
+## Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `logUserInApp(pageName)` | `Promise<void>` | Log user activity on a page |
+| `fetchLogs(params?)` | `Promise<any>` | Fetch app logs with optional filter parameters |
+| `getStats(params?)` | `Promise<any>` | Get app usage statistics |
+
+## Examples
+
+### Log User Activity
+
+```javascript
+// Log when user visits a page
+await base44.appLogs.logUserInApp("dashboard");
+
+// Log specific page visits
+await base44.appLogs.logUserInApp("settings");
+await base44.appLogs.logUserInApp("profile");
+
+// Log feature usage
+await base44.appLogs.logUserInApp("export-button-click");
+```
+
+The page name doesn't have to be an actual page - it can be any string you want to track.
+
+## Use Cases
+
+### Track Page Views in React
+
+```javascript
+// Log page views on route change
+useEffect(() => {
+  base44.appLogs.logUserInApp(window.location.pathname);
+}, [location.pathname]);
+```
+
+### Track Feature Usage
+
+```javascript
+// Log when user uses specific features
+function handleExport() {
+  base44.appLogs.logUserInApp("export-data");
+  // ... export logic
+}
+
+function handleSettingsChange() {
+  base44.appLogs.logUserInApp("settings-updated");
+  // ... save settings
+}
+```
+
+### Fetch Logs
+
+```javascript
+// Fetch all logs
+const logs = await base44.appLogs.fetchLogs();
+
+// Fetch logs with filters
+const recentLogs = await base44.appLogs.fetchLogs({
+  limit: 50,
+  page: "/dashboard"
+});
+```
+
+### Get Stats
+
+```javascript
+// Get usage statistics for the app
+const stats = await base44.appLogs.getStats();
+
+// Get stats with date range params
+const weekStats = await base44.appLogs.getStats({
+  from: "2024-01-01",
+  to: "2024-01-07"
+});
+```
+
+## Notes
+
+- Logs appear in the Analytics page of your app dashboard
+- App logs track page-level and feature-level activity
+- Use `analytics.track()` for custom events with properties, `appLogs.logUserInApp()` for simple page/feature tracking
+
+## Type Definitions
+
+```typescript
+/** App Logs module for tracking and analyzing app usage. */
+interface AppLogsModule {
+  /**
+   * Log user activity in the app.
+   * @param pageName - Name of the page or section being visited.
+   * @returns Promise that resolves when the log is recorded.
+   */
+  logUserInApp(pageName: string): Promise<void>;
+
+  /**
+   * Fetch app logs with optional filter parameters.
+   * @param params - Optional filter parameters (e.g., limit, page name, date range).
+   * @returns Promise resolving to the logs data.
+   */
+  fetchLogs(params?: Record<string, any>): Promise<any>;
+
+  /**
+   * Get app usage statistics.
+   * @param params - Optional filter parameters (e.g., date range).
+   * @returns Promise resolving to the statistics data.
+   */
+  getStats(params?: Record<string, any>): Promise<any>;
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/auth.md

@@ -0,0 +1,770 @@
+# Auth Module
+
+User authentication, registration, and session management via `base44.auth`.
+
+## Contents
+- [TypeScript Types](#typescript-types)
+- [Methods](#methods)
+- [Examples](#examples)
+- [Error Handling](#error-handling)
+- [Auth Providers](#auth-providers)
+- [Environment Availability](#environment-availability)
+- [App Visibility](#app-visibility)
+- [Limitations](#limitations)
+
+---
+
+## TypeScript Types
+
+### User Interface
+```typescript
+interface User {
+  id: string;
+  created_date: string;
+  updated_date: string;
+  email: string;
+  full_name: string | null;
+  disabled: boolean | null;
+  is_verified: boolean;
+  app_id: string;
+  is_service: boolean;
+  role: string;
+  [key: string]: any; // Custom schema fields
+}
+```
+
+### LoginResponse Interface
+```typescript
+interface LoginResponse {
+  access_token: string;  // JWT token
+  user: User;           // Complete user object
+}
+```
+
+### Parameter Interfaces
+
+#### RegisterParams
+```typescript
+interface RegisterParams {
+  email: string;                    // Required
+  password: string;                 // Required
+  turnstile_token?: string | null;  // Optional: Cloudflare Turnstile for bot protection
+  referral_code?: string | null;    // Optional: Referral code
+}
+```
+
+#### VerifyOtpParams
+```typescript
+interface VerifyOtpParams {
+  email: string;     // User's email
+  otpCode: string;   // OTP code from email
+}
+```
+
+#### ResetPasswordParams
+```typescript
+interface ResetPasswordParams {
+  resetToken: string;   // Token from password reset email
+  newPassword: string;  // New password to set
+}
+```
+
+#### ChangePasswordParams
+```typescript
+interface ChangePasswordParams {
+  userId: string;          // User ID
+  currentPassword: string; // Current password for verification
+  newPassword: string;     // New password to set
+}
+```
+
+### Provider Type
+```typescript
+type Provider = 'google' | 'microsoft' | 'facebook';
+```
+
+---
+
+## Methods
+
+### Module Interface
+```typescript
+interface AuthModule {
+  // User Info
+  me(): Promise<User>;
+  updateMe(data: Partial<Omit<User, 'id' | 'created_date' | 'updated_date' | 'app_id' | 'is_service'>>): Promise<User>;
+  isAuthenticated(): Promise<boolean>;
+
+  // Login/Logout
+  loginViaEmailPassword(email: string, password: string, turnstileToken?: string): Promise<LoginResponse>;
+  loginWithProvider(provider: Provider, fromUrl?: string): void;
+  logout(redirectUrl?: string): void;
+  redirectToLogin(nextUrl: string): void;
+
+  // Token Management
+  setToken(token: string, saveToStorage?: boolean): void;
+
+  // Registration
+  register(params: RegisterParams): Promise<any>;
+  verifyOtp(params: VerifyOtpParams): Promise<any>;
+  resendOtp(email: string): Promise<any>;
+
+  // User Management
+  inviteUser(userEmail: string, role: string): Promise<any>;
+
+  // Password Management
+  resetPasswordRequest(email: string): Promise<any>;
+  resetPassword(params: ResetPasswordParams): Promise<any>;
+  changePassword(params: ChangePasswordParams): Promise<any>;
+}
+```
+
+### Method Reference Table
+
+| Method | Parameters | Return Type | Description |
+|--------|-----------|-------------|-------------|
+| `register()` | `params: RegisterParams` | `Promise<any>` | Create new user account |
+| `loginViaEmailPassword()` | `email: string, password: string, turnstileToken?: string` | `Promise<LoginResponse>` | Authenticate with email/password |
+| `loginWithProvider()` | `provider: Provider, fromUrl?: string` | `void` | Initiate OAuth login flow. Providers: `'google'` (default), `'microsoft'`, `'facebook'` (enable in app settings) |
+| `me()` | None | `Promise<User>` | Get current authenticated user |
+| `updateMe()` | `data: Partial<User>` | `Promise<User>` | Update current user's profile |
+| `logout()` | `redirectUrl?: string` | `void` | Redirect to server-side logout (clears HTTP-only cookies and session), then to redirectUrl or current URL |
+| `redirectToLogin()` | `nextUrl: string` | `void` | ⚠️ **Avoid** - Prefer custom login UI with `loginViaEmailPassword()` or `loginWithProvider()` |
+| `isAuthenticated()` | None | `Promise<boolean>` | Check if user is logged in |
+| `setToken()` | `token: string, saveToStorage?: boolean` | `void` | Manually set auth token |
+| `inviteUser()` | `userEmail: string, role: string` | `Promise<any>` | Send invitation email |
+| `verifyOtp()` | `params: VerifyOtpParams` | `Promise<any>` | Verify OTP code |
+| `resendOtp()` | `email: string` | `Promise<any>` | Resend OTP code |
+| `resetPasswordRequest()` | `email: string` | `Promise<any>` | Request password reset |
+| `resetPassword()` | `params: ResetPasswordParams` | `Promise<any>` | Reset password with token |
+| `changePassword()` | `params: ChangePasswordParams` | `Promise<any>` | Change user password |
+
+---
+
+## Examples
+
+### Register New User (Complete Flow)
+
+Registration requires email verification before login. Complete flow:
+
+1. **Register** - Create the user account
+2. **Verification email sent** - User receives an OTP code
+3. **Verify OTP** - User enters code to verify email
+4. **Login** - User can now log in
+
+```javascript
+try {
+  // Step 1: Register the user
+  await base44.auth.register({
+    email: "user@example.com",
+    password: "securePassword123",
+    referral_code: "OPTIONAL_CODE",    // optional
+    turnstile_token: "CAPTCHA_TOKEN"   // optional, for bot protection
+  });
+  console.log('Registration successful. Check email for OTP code.');
+
+  // Step 2: User receives email with OTP code (e.g., "123456")
+
+  // Step 3: Verify the OTP code
+  await base44.auth.verifyOtp({
+    email: "user@example.com",
+    otpCode: "123456"  // code from verification email
+  });
+  console.log('Email verified successfully.');
+
+  // Step 4: Now the user can log in
+  const loginResponse = await base44.auth.loginViaEmailPassword(
+    "user@example.com",
+    "securePassword123"
+  );
+  console.log('Login successful:', loginResponse.user);
+
+} catch (error) {
+  console.error('Registration flow failed:', error.message);
+  // Handle specific errors (see Error Handling section)
+}
+```
+
+> **Important**: Users cannot log in until they complete OTP verification. Attempting to call `loginViaEmailPassword` before verification will fail.
+
+### Login with Email/Password
+
+```javascript
+try {
+  const response = await base44.auth.loginViaEmailPassword(
+    "user@example.com",
+    "password123",
+    turnstileToken  // optional: for bot protection
+  );
+
+  console.log('Login successful');
+  console.log('User:', response.user);
+  console.log('Token:', response.access_token);
+
+  // JWT is automatically stored for subsequent requests
+
+} catch (error) {
+  console.error('Login failed:', error.message);
+  if (error.status === 401) {
+    console.error('Invalid credentials');
+  } else if (error.status === 403) {
+    console.error('Email not verified. Please check your email for OTP.');
+  }
+}
+```
+
+### Login with OAuth Provider
+
+Supported providers: `'google'` (enabled by default), `'microsoft'`, and `'facebook'`. Enable Microsoft or Facebook in your app's authentication settings before using them.
+
+```javascript
+// Redirect to Google OAuth
+base44.auth.loginWithProvider('google');
+
+// Redirect to Google OAuth and return to current page after
+base44.auth.loginWithProvider('google', window.location.href);
+
+// Microsoft or Facebook (enable in app settings first)
+base44.auth.loginWithProvider('microsoft');
+base44.auth.loginWithProvider('facebook', '/dashboard');
+```
+
+### Get Current User
+
+```javascript
+try {
+  const user = await base44.auth.me();
+
+  if (user) {
+    console.log('User ID:', user.id);
+    console.log('Email:', user.email);
+    console.log('Name:', user.full_name);
+    console.log('Role:', user.role);
+    console.log('Verified:', user.is_verified);
+  } else {
+    console.log('User not authenticated');
+  }
+
+} catch (error) {
+  console.error('Failed to fetch user:', error.message);
+  if (error.status === 401) {
+    // Token expired or invalid - navigate to your custom login page
+    navigate('/login');
+  }
+}
+```
+
+### Update User Profile
+
+```javascript
+try {
+  const updatedUser = await base44.auth.updateMe({
+    full_name: "John Doe",
+    // Custom schema fields can be updated here
+    phone: "+1234567890",
+    preferences: { theme: "dark" }
+  });
+
+  console.log('Profile updated:', updatedUser);
+
+} catch (error) {
+  console.error('Profile update failed:', error.message);
+  if (error.status === 400) {
+    console.error('Invalid data provided');
+  } else if (error.status === 401) {
+    console.error('Authentication required');
+    navigate('/login');
+  }
+}
+```
+
+### Check Authentication Status
+
+```javascript
+try {
+  const isLoggedIn = await base44.auth.isAuthenticated();
+
+  if (isLoggedIn) {
+    // Show authenticated UI
+    console.log('User is authenticated');
+  } else {
+    // Show login button
+    console.log('User is not authenticated');
+  }
+
+} catch (error) {
+  console.error('Failed to check authentication:', error.message);
+  // On error, treat as not authenticated
+}
+```
+
+### Logout
+
+Logout redirects the user to the server-side logout endpoint (`/api/apps/auth/logout`) to clear HTTP-only cookies and the session, then redirects to the given URL (or the current page if omitted). Requires a browser environment.
+
+```javascript
+// Logout: clears session via server, then redirects to current page
+base44.auth.logout();
+
+// Logout and redirect to goodbye page after
+base44.auth.logout("/goodbye");
+
+// Logout and redirect to homepage
+base44.auth.logout("/");
+```
+
+### Protected Route Pattern
+
+```javascript
+// Using a navigation function (e.g., React Router's useNavigate, Next.js router)
+async function requireAuth(navigate) {
+  try {
+    const user = await base44.auth.me();
+
+    if (!user) {
+      // Navigate to your custom login page
+      navigate('/login', { state: { returnTo: window.location.pathname } });
+      return null;
+    }
+
+    return user;
+
+  } catch (error) {
+    console.error('Authentication check failed:', error.message);
+    navigate('/login', { state: { returnTo: window.location.pathname } });
+    return null;
+  }
+}
+
+// Usage in your app
+async function loadProtectedPage(navigate) {
+  const user = await requireAuth(navigate);
+  if (!user) {
+    // Will navigate to login
+    return;
+  }
+
+  // Continue with authenticated logic
+  console.log('Welcome,', user.full_name);
+}
+```
+
+### Set Authentication Token
+
+```javascript
+// SECURITY WARNING: Never hardcode tokens or expose them in client code
+// Tokens should only be received from secure authentication flows
+
+// Set token and save to localStorage (default)
+base44.auth.setToken(receivedToken);
+
+// Set token without saving to localStorage (temporary session)
+base44.auth.setToken(receivedToken, false);
+
+// Verify token was set
+try {
+  const isAuthenticated = await base44.auth.isAuthenticated();
+  if (!isAuthenticated) {
+    console.error('Token validation failed');
+  }
+} catch (error) {
+  console.error('Failed to set token:', error.message);
+}
+```
+
+### Invite User to Application
+
+```javascript
+try {
+  // Note: Typically requires admin privileges
+  const response = await base44.auth.inviteUser(
+    "newuser@example.com",
+    "user"  // or "admin"
+  );
+
+  console.log('Invitation sent successfully');
+
+} catch (error) {
+  console.error('Failed to invite user:', error.message);
+  if (error.status === 403) {
+    console.error('Insufficient permissions to invite users');
+  } else if (error.status === 400) {
+    console.error('Invalid email or role');
+  }
+}
+```
+
+### OTP Verification
+
+```javascript
+try {
+  // Verify OTP code sent to user's email
+  await base44.auth.verifyOtp({
+    email: "user@example.com",
+    otpCode: "123456"
+  });
+
+  console.log('OTP verified successfully');
+
+} catch (error) {
+  console.error('OTP verification failed:', error.message);
+  if (error.status === 400) {
+    console.error('Invalid or expired OTP code');
+  } else if (error.status === 429) {
+    console.error('Too many attempts. Please try again later.');
+  }
+}
+
+// Resend OTP if needed
+try {
+  await base44.auth.resendOtp("user@example.com");
+  console.log('OTP resent successfully');
+
+} catch (error) {
+  console.error('Failed to resend OTP:', error.message);
+  if (error.status === 429) {
+    console.error('Too many requests. Please wait before trying again.');
+  }
+}
+```
+
+### Password Reset Flow
+
+```javascript
+// Step 1: Request password reset
+try {
+  await base44.auth.resetPasswordRequest("user@example.com");
+  console.log('Password reset email sent. Check your inbox.');
+
+} catch (error) {
+  console.error('Password reset request failed:', error.message);
+  if (error.status === 429) {
+    console.error('Too many requests. Please try again later.');
+  }
+  // Note: For security, don't reveal if email exists
+}
+
+// Step 2: Reset password with token from email
+try {
+  await base44.auth.resetPassword({
+    resetToken: "token-from-email",
+    newPassword: "newSecurePassword123"
+  });
+
+  console.log('Password reset successfully. You can now log in.');
+
+} catch (error) {
+  console.error('Password reset failed:', error.message);
+  if (error.status === 400) {
+    console.error('Invalid or expired reset token');
+  } else if (error.status === 422) {
+    console.error('Password does not meet requirements');
+  }
+}
+```
+
+### Change Password
+
+```javascript
+try {
+  const currentUser = await base44.auth.me();
+
+  if (!currentUser) {
+    throw new Error('User must be authenticated to change password');
+  }
+
+  await base44.auth.changePassword({
+    userId: currentUser.id,
+    currentPassword: "oldPassword123",
+    newPassword: "newSecurePassword456"
+  });
+
+  console.log('Password changed successfully');
+
+} catch (error) {
+  console.error('Password change failed:', error.message);
+  if (error.status === 401) {
+    console.error('Current password is incorrect');
+  } else if (error.status === 422) {
+    console.error('New password does not meet requirements');
+  } else if (error.status === 403) {
+    console.error('Not authorized to change this password');
+  }
+}
+```
+
+---
+
+## Error Handling
+
+### Common Error Scenarios
+
+The auth module can throw various errors. Here are common scenarios and how to handle them:
+
+#### Authentication Errors (401/403)
+```javascript
+try {
+  const user = await base44.auth.me();
+} catch (error) {
+  if (error.status === 401) {
+    // Token expired or invalid - navigate to your custom login page
+    navigate('/login');
+  } else if (error.status === 403) {
+    // Email not verified or insufficient permissions
+    console.error('Access denied:', error.message);
+  }
+}
+```
+
+#### Validation Errors (400/422)
+```javascript
+try {
+  await base44.auth.register({
+    email: "invalid-email",
+    password: "weak"
+  });
+} catch (error) {
+  if (error.status === 400) {
+    console.error('Invalid input:', error.message);
+    // Handle validation errors
+  } else if (error.status === 422) {
+    console.error('Data validation failed:', error.details);
+  }
+}
+```
+
+#### Rate Limiting (429)
+```javascript
+try {
+  await base44.auth.resendOtp("user@example.com");
+} catch (error) {
+  if (error.status === 429) {
+    console.error('Too many requests. Please wait before trying again.');
+    // Show countdown or disable button temporarily
+  }
+}
+```
+
+#### Generic Error Handler
+```javascript
+function handleAuthError(error) {
+  switch (error.status) {
+    case 400:
+      return 'Invalid input. Please check your data.';
+    case 401:
+      return 'Authentication required. Redirecting to login...';
+    case 403:
+      return 'Access denied. You may need to verify your email.';
+    case 404:
+      return 'Resource not found.';
+    case 422:
+      return 'Validation failed. Please check your input.';
+    case 429:
+      return 'Too many requests. Please try again later.';
+    case 500:
+      return 'Server error. Please try again.';
+    default:
+      return 'An unexpected error occurred.';
+  }
+}
+
+// Usage
+try {
+  await base44.auth.loginViaEmailPassword(email, password);
+} catch (error) {
+  console.error(handleAuthError(error));
+}
+```
+
+---
+
+## Auth Providers
+
+Configure authentication providers in your app dashboard:
+
+### Available Providers
+
+**Built-in (All Plans):**
+- **Email/Password** - Default, always enabled
+- **Google** - OAuth authentication
+- **Microsoft** - OAuth authentication
+- **Facebook** - OAuth authentication
+
+**SSO Providers (Elite Plan):**
+- **Okta**
+- **Azure AD**
+- **GitHub**
+
+### Using OAuth Providers
+
+- **Google** – enabled by default.
+- **Microsoft** – enable in your app's authentication settings before use.
+- **Facebook** – enable in your app's authentication settings before use.
+
+```javascript
+// Initiate OAuth login flow
+base44.auth.loginWithProvider('google');
+
+// Return to specific page after authentication
+base44.auth.loginWithProvider('microsoft', '/dashboard');
+
+// Supported values: 'google', 'microsoft', 'facebook'
+```
+
+---
+
+## Environment Availability
+
+| Environment | Availability | Notes |
+|------------|--------------|-------|
+| **Frontend** | ✅ Yes | All methods available |
+| **Backend Functions** | ✅ Yes | Use `createClientFromRequest(req)` for authenticated client |
+| **Service Role** | ❌ No | Auth methods not available in service role context |
+
+### Frontend Usage
+```javascript
+// Standard browser usage
+const user = await base44.auth.me();
+```
+
+### Backend Functions Usage
+```javascript
+import { createClientFromRequest } from "@base44/sdk";
+
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+
+  // Get user from request context
+  const user = await base44.auth.me();
+
+  // User operations here...
+  return Response.json({ user });
+});
+```
+
+---
+
+## App Visibility
+
+Control who can access your app in the app settings:
+
+### Public Apps
+- No login required for basic access
+- Users can view public content without authentication
+- Authenticated users get additional features/data
+
+### Private Apps
+- Login required to access any content
+- Unauthenticated users are automatically redirected to login
+- All content is protected by default
+
+---
+
+## Limitations
+
+### Authentication UI Options
+- **Recommended:** Build custom login/signup UI using `loginViaEmailPassword()` and `loginWithProvider()` for full control over user experience and branding
+- **Alternative:** `redirectToLogin()` uses Base44's hosted authentication pages with limited customization
+
+### Hosted Login (via redirectToLogin)
+- `redirectToLogin()` shows both login and signup options on the same page
+- No separate `redirectToSignup()` method
+- Users can switch between login/signup on the hosted page
+- ⚠️ **Note:** Prefer building custom login UI for better user experience
+
+### Password Requirements
+- Minimum length and complexity requirements enforced
+- Requirements not exposed via API
+- Validation errors returned when requirements not met
+
+### Rate Limiting
+- OTP requests are rate-limited to prevent abuse
+- Password reset requests are rate-limited
+- Login attempts may be rate-limited with Turnstile protection
+
+### Token Management
+- JWTs are automatically stored in localStorage by default
+- Token expiration and refresh not exposed in API
+- Call `me()` or `isAuthenticated()` to verify token validity
+
+---
+
+## Best Practices
+
+### 1. Always Handle Errors
+```javascript
+try {
+  await base44.auth.loginViaEmailPassword(email, password);
+} catch (error) {
+  // Always handle authentication errors
+  console.error('Login failed:', error.message);
+}
+```
+
+### 2. Verify Authentication Before Protected Actions
+```javascript
+const user = await requireAuth();
+if (!user) return; // Will redirect to login
+// Proceed with authenticated action
+```
+
+### 3. Use Type Safety with TypeScript
+```typescript
+import type { User, LoginResponse } from '@base44/sdk';
+
+const user: User = await base44.auth.me();
+const response: LoginResponse = await base44.auth.loginViaEmailPassword(email, password);
+```
+
+### 4. Don't Hardcode Credentials
+```javascript
+// ❌ BAD
+base44.auth.setToken("hardcoded-token-here");
+
+// ✅ GOOD
+const token = await secureAuthFlow();
+base44.auth.setToken(token);
+```
+
+### 5. Provide User Feedback
+```javascript
+try {
+  await base44.auth.register(params);
+  showSuccessMessage('Registration successful! Check your email for verification code.');
+} catch (error) {
+  showErrorMessage('Registration failed: ' + error.message);
+}
+```
+
+### 6. Handle Token Expiration Gracefully
+```javascript
+try {
+  const user = await base44.auth.me();
+} catch (error) {
+  if (error.status === 401) {
+    // Clear local state and navigate to login
+    localStorage.clear();
+    navigate('/login');
+  }
+}
+```
+
+### 7. Build Custom Login UI (Recommended)
+```javascript
+// ✅ RECOMMENDED - Custom login form with direct methods
+const handleLogin = async (email, password) => {
+  try {
+    const { user } = await base44.auth.loginViaEmailPassword(email, password);
+    navigate('/dashboard');
+  } catch (error) {
+    setError(error.message);
+  }
+};
+
+const handleGoogleLogin = () => {
+  base44.auth.loginWithProvider('google', '/dashboard');
+};
+
+// ❌ AVOID - Redirecting to hosted login page
+// base44.auth.redirectToLogin(window.location.href);
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/base44-agents.md

@@ -0,0 +1,386 @@
+# Agents Module
+
+AI agent conversations and messages via `base44.agents`.
+
+> **Note:** This module requires a logged-in user. All agent methods work in the context of the authenticated user.
+
+## Contents
+- [Concepts](#concepts)
+- [Methods](#methods)
+- [Examples](#examples) (Create, Get Conversations, List, Subscribe, Send Message, WhatsApp)
+- [Message Structure](#message-structure)
+- [Conversation Structure](#conversation-structure)
+- [Common Patterns](#common-patterns)
+
+## Concepts
+
+- **Conversation**: A dialogue between user and an AI agent. Has unique ID, agent name, user reference, and metadata.
+- **Message**: Single message in a conversation. Has role (`user`, `assistant`, `system`), content, timestamps, and optional metadata.
+
+## Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `createConversation(params)` | `Promise<Conversation>` | Create a new conversation with an agent |
+| `getConversations()` | `Promise<Conversation[]>` | Get all user's conversations |
+| `getConversation(id)` | `Promise<Conversation>` | Get conversation with messages (includes full tool call results) |
+| `listConversations(filterParams)` | `Promise<Conversation[]>` | Filter/sort/paginate conversations |
+| `subscribeToConversation(id, onUpdate?)` | `() => void` | Realtime updates via WebSocket; tool call data truncated (returns unsubscribe function) |
+| `addMessage(conversation, message)` | `Promise<Message>` | Send a message |
+| `getWhatsAppConnectURL(agentName)` | `string` | Get WhatsApp connection URL for agent |
+
+## Examples
+
+### Create Conversation
+
+```javascript
+const conversation = await base44.agents.createConversation({
+  agent_name: "support-agent",
+  metadata: {
+    order_id: "ORD-123",
+    category: "billing"
+  }
+});
+
+console.log(conversation.id);
+```
+
+### Get All Conversations
+
+```javascript
+const conversations = await base44.agents.getConversations();
+
+conversations.forEach(conv => {
+  console.log(conv.id, conv.agent_name, conv.created_date);
+});
+```
+
+### Get Single Conversation (with messages)
+
+Returns the complete stored conversation including full tool call results (unlike the realtime subscription, which truncates tool call data).
+
+```javascript
+const conversation = await base44.agents.getConversation("conv-id-123");
+
+console.log(conversation.messages);
+```
+
+### List with Filters
+
+```javascript
+// Using filterParams object with q, sort, limit, skip, fields
+const recent = await base44.agents.listConversations({
+  q: { agent_name: "support-agent" },
+  sort: "-created_date",
+  limit: 10,
+  skip: 0
+});
+
+// Filter by metadata
+const highPriority = await base44.agents.listConversations({
+  q: {
+    agent_name: "support-agent",
+    "metadata.priority": "high"
+  },
+  sort: "-updated_date",
+  limit: 20
+});
+```
+
+### Subscribe to Updates (Realtime)
+
+When receiving messages through this subscription, tool call data is truncated for efficiency (`arguments_string` limited to 500 characters, `results` to 50). Use `getConversation()` after the message completes to retrieve full tool call data.
+
+```javascript
+const unsubscribe = base44.agents.subscribeToConversation(
+  "conv-id-123",
+  (updatedConversation) => {
+    // Called when new messages arrive
+    console.log("New messages:", updatedConversation.messages);
+  }
+);
+
+// Later: unsubscribe
+unsubscribe();
+```
+
+### Send a Message
+
+```javascript
+const conversation = await base44.agents.getConversation("conv-id-123");
+
+await base44.agents.addMessage(conversation, {
+  role: "user",
+  content: "What's the weather like today?"
+});
+```
+
+### Get WhatsApp Connection URL
+
+```javascript
+const whatsappUrl = base44.agents.getWhatsAppConnectURL("support-agent");
+// Returns URL for users to connect with agent via WhatsApp
+console.log(whatsappUrl);
+```
+
+## Message Structure
+
+```javascript
+{
+  role: "user" | "assistant" | "system",
+  content: "Message text or structured object",
+  created_date: "2024-01-15T10:30:00Z",
+  updated_date: "2024-01-15T10:30:00Z",
+  
+  // Optional fields
+  reasoning: {
+    content: "Agent's reasoning process",
+    timing: 1500
+  },
+  tool_calls: [{
+    name: "search",
+    arguments: { query: "weather" },
+    result: { ... },
+    status: "success"
+  }],
+  file_urls: ["https://..."],
+  usage: {
+    prompt_tokens: 150,
+    completion_tokens: 50
+  },
+  metadata: { ... },
+  custom_context: { ... }
+}
+```
+
+## Conversation Structure
+
+```javascript
+{
+  id: "conv-id-123",
+  app_id: "app-id",
+  agent_name: "support-agent",
+  created_by_id: "user-id",
+  created_date: "2024-01-15T10:00:00Z",
+  updated_date: "2024-01-15T10:30:00Z",
+  messages: [ ... ],
+  metadata: { ... }
+}
+```
+
+## Common Patterns
+
+### Chat Interface
+
+```javascript
+// Load conversation
+const conv = await base44.agents.getConversation(conversationId);
+setMessages(conv.messages);
+
+// Subscribe to updates
+const unsubscribe = base44.agents.subscribeToConversation(conversationId, (updated) => {
+  setMessages(updated.messages);
+});
+
+// Send message
+async function sendMessage(text) {
+  await base44.agents.addMessage(conv, { role: "user", content: text });
+}
+
+// Cleanup on unmount
+return () => unsubscribe();
+```
+
+## Type Definitions
+
+### AgentNameRegistry and AgentName
+
+**How to get typed agent names:** The Base44 CLI can generate an augmentation of `AgentNameRegistry` from your project. For how to run it, use the **base44-cli** skill.
+
+```typescript
+/**
+ * Registry of agent names.
+ * Augment this interface to enable autocomplete for agent names.
+ * Typically populated by the Base44 CLI type generator.
+ */
+interface AgentNameRegistry {}
+
+/**
+ * Agent name type - uses registry keys if augmented, otherwise string.
+ */
+type AgentName = keyof AgentNameRegistry extends never ? string : keyof AgentNameRegistry;
+```
+
+### AgentConversation
+
+```typescript
+/** An agent conversation containing messages exchanged with an AI agent. */
+interface AgentConversation {
+  /** Unique identifier for the conversation. */
+  id: string;
+  /** Application ID. */
+  app_id: string;
+  /** Name of the agent in this conversation. */
+  agent_name: string;
+  /** ID of the user who created the conversation. */
+  created_by_id: string;
+  /** When the conversation was created. */
+  created_date: string;
+  /** When the conversation was last updated. */
+  updated_date: string;
+  /** Array of messages in the conversation. */
+  messages: AgentMessage[];
+  /** Optional metadata associated with the conversation. */
+  metadata?: Record<string, any>;
+}
+```
+
+### AgentMessage
+
+```typescript
+/** A message in an agent conversation. */
+interface AgentMessage {
+  /** Unique identifier for the message. */
+  id: string;
+  /** Role of the message sender. */
+  role: "user" | "assistant" | "system";
+  /** When the message was created. */
+  created_date: string;
+  /** When the message was last updated. */
+  updated_date: string;
+  /** Message content. */
+  content?: string | Record<string, any>;
+  /** Optional reasoning information for the message. */
+  reasoning?: AgentMessageReasoning | null;
+  /** URLs to files attached to the message. */
+  file_urls?: string[];
+  /** Tool calls made by the agent. */
+  tool_calls?: AgentMessageToolCall[];
+  /** Token usage statistics. */
+  usage?: AgentMessageUsage;
+  /** Whether the message is hidden from the user. */
+  hidden?: boolean;
+  /** Custom context provided with the message. */
+  custom_context?: AgentMessageCustomContext[];
+  /** Model used to generate the message. */
+  model?: string;
+  /** Checkpoint ID for the message. */
+  checkpoint_id?: string;
+  /** Metadata about when and by whom the message was created. */
+  metadata?: AgentMessageMetadata;
+}
+```
+
+### Supporting Types
+
+```typescript
+/** Reasoning information for an agent message. */
+interface AgentMessageReasoning {
+  /** When reasoning started. */
+  start_date: string;
+  /** When reasoning ended. */
+  end_date?: string;
+  /** Reasoning content. */
+  content: string;
+}
+
+/** A tool call made by the agent. */
+interface AgentMessageToolCall {
+  /** Tool call ID. */
+  id: string;
+  /** Name of the tool called. */
+  name: string;
+  /** Arguments passed to the tool as JSON string. */
+  arguments_string: string;
+  /** Status of the tool call. */
+  status: "running" | "success" | "error" | "stopped";
+  /** Results from the tool call. */
+  results?: string;
+}
+
+/** Token usage statistics for an agent message. */
+interface AgentMessageUsage {
+  /** Number of tokens in the prompt. */
+  prompt_tokens?: number;
+  /** Number of tokens in the completion. */
+  completion_tokens?: number;
+}
+
+/** Custom context provided with an agent message. */
+interface AgentMessageCustomContext {
+  /** Context message. */
+  message: string;
+  /** Associated data for the context. */
+  data: Record<string, any>;
+  /** Type of context. */
+  type: string;
+}
+
+/** Metadata about when and by whom a message was created. */
+interface AgentMessageMetadata {
+  /** When the message was created. */
+  created_date: string;
+  /** Email of the user who created the message. */
+  created_by_email: string;
+  /** Full name of the user who created the message. */
+  created_by_full_name: string;
+}
+```
+
+### CreateConversationParams
+
+```typescript
+/** Parameters for creating a new conversation. */
+interface CreateConversationParams {
+  /** The name of the agent to create a conversation with. */
+  agent_name: AgentName;
+  /** Optional metadata to attach to the conversation. */
+  metadata?: Record<string, any>;
+}
+```
+
+### ModelFilterParams
+
+```typescript
+/** Parameters for filtering, sorting, and paginating conversations. */
+interface ModelFilterParams {
+  /** Query object with field-value pairs for filtering. */
+  q?: Record<string, any>;
+  /** Sort parameter (e.g., "-created_date" for descending). */
+  sort?: string | null;
+  /** Maximum number of results to return. */
+  limit?: number | null;
+  /** Number of results to skip for pagination. */
+  skip?: number | null;
+  /** Array of field names to include in the response. */
+  fields?: string[] | null;
+}
+```
+
+### AgentsModule
+
+```typescript
+/** Agents module for managing AI agent conversations. */
+interface AgentsModule {
+  /** Gets all conversations from all agents in the app. */
+  getConversations(): Promise<AgentConversation[]>;
+
+  /** Gets a specific conversation by ID. Returns complete stored conversation including full tool call results. */
+  getConversation(conversationId: string): Promise<AgentConversation | undefined>;
+
+  /** Lists conversations with filtering, sorting, and pagination. */
+  listConversations(filterParams: ModelFilterParams): Promise<AgentConversation[]>;
+
+  /** Creates a new conversation with an agent. */
+  createConversation(conversation: CreateConversationParams): Promise<AgentConversation>;
+
+  /** Adds a message to a conversation. */
+  addMessage(conversation: AgentConversation, message: Partial<AgentMessage>): Promise<AgentMessage>;
+
+  /** Subscribes to realtime updates for a conversation. Returns unsubscribe function. */
+  subscribeToConversation(conversationId: string, onUpdate?: (conversation: AgentConversation) => void): () => void;
+
+  /** Gets WhatsApp connection URL for an agent. */
+  getWhatsAppConnectURL(agentName: AgentName): string;
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/client.md

@@ -0,0 +1,265 @@
+# Client Setup
+
+How to create and configure the Base44 client.
+
+## Contents
+- [In Base44-Generated Apps](#in-base44-generated-apps)
+- [In External Apps](#in-external-apps)
+- [In Backend Functions](#in-backend-functions)
+- [Authentication Modes](#authentication-modes) (Anonymous, User, Service Role)
+- [Available Modules](#available-modules)
+- [Client Methods](#client-methods)
+- [Client Configuration Options](#client-configuration-options)
+
+## In Base44-Generated Apps
+
+Inside a Base44 app, the client is automatically created and configured. Import it from `@/api/base44Client` and use it as `base44`:
+
+```javascript
+const tasks = await base44.entities.Task.list();
+```
+
+## In External Apps
+
+When using Base44 as a backend from an external app, install the SDK and create a client by calling `createClient()` directly:
+
+```bash
+npm install @base44/sdk
+```
+
+```javascript
+import { createClient } from "@base44/sdk";
+
+// IMPORTANT: The parameter name is 'appId' (NOT 'clientId', NOT 'id')
+// IMPORTANT: onError must be nested inside 'options' object
+const base44 = createClient({
+  appId: "your-app-id",          // Required: Use 'appId' parameter
+  token: "optional-user-token",  // Optional: for pre-authenticated requests
+  options: {                      // Optional: configuration options
+    onError: (error) => {         // Optional: error handler (must be in options)
+      console.error("Base44 error:", error);
+    }
+  }
+});
+```
+
+**Common Mistakes:**
+- ❌ `createClient({ clientId: "..." })` - WRONG parameter name
+- ❌ `createClient({ id: "..." })` - WRONG parameter name
+- ❌ `createClient({ appId: "...", onError: ... })` - WRONG: onError must be in options
+- ✅ `createClient({ appId: "..." })` - CORRECT parameter name
+- ✅ `createClient({ appId: "...", options: { onError: ... } })` - CORRECT: onError in options
+
+## In Backend Functions
+
+`createClientFromRequest()` is designed for Base44-hosted backend functions. It extracts auth from request headers that Base44 injects and returns a client that includes service role access (`base44.asServiceRole`). For frontends and external backends, use `createClient()` instead.
+
+```javascript
+import { createClientFromRequest } from "@base44/sdk";
+
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+  
+  // Client inherits authentication from the request
+  const user = await base44.auth.me();
+  
+  return Response.json({ user });
+});
+```
+
+## Authentication Modes
+
+| Mode | How to Get | Permissions |
+|------|-----------|-------------|
+| **Anonymous** | `createClient({ appId })` without token | Public data only |
+| **User** | After `loginViaEmailPassword()` or via `createClientFromRequest` | User's own data |
+| **Service Role** | `base44.asServiceRole.*` in backend | Full admin access |
+
+## Anonymous Mode
+
+No authentication. Can only access public resources.
+
+```javascript
+const base44 = createClient({ appId: "your-app-id" });
+
+// Only works if Task entity allows anonymous read
+const publicTasks = await base44.entities.Task.list();
+```
+
+## User Mode
+
+After user logs in, the client automatically includes their token.
+
+```javascript
+const base44 = createClient({ appId: "your-app-id" });
+
+// Login sets the token
+await base44.auth.loginViaEmailPassword("user@example.com", "password");
+
+// Subsequent requests are authenticated
+const user = await base44.auth.me();
+const myTasks = await base44.entities.Task.list();  // filtered by permissions
+```
+
+## Service Role Mode
+
+Admin-level access. **Backend only.**
+
+```javascript
+// Inside a backend function
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+  
+  // User mode - respects permissions
+  const myTasks = await base44.entities.Task.list();
+  
+  // Service role - bypasses permissions
+  const allTasks = await base44.asServiceRole.entities.Task.list();
+  const allUsers = await base44.asServiceRole.entities.User.list();
+  const oauthToken = await base44.asServiceRole.connectors.getAccessToken("slack");
+  
+  return Response.json({ myTasks, allTasks });
+});
+```
+
+## Available Modules
+
+The client exposes these modules:
+
+```javascript
+base44.agents        // AI conversations
+base44.analytics     // Event tracking
+base44.appLogs       // App usage logging
+base44.auth          // Authentication
+base44.connectors    // Per-user OAuth flows (UserConnectorsModule)
+base44.entities      // CRUD operations
+base44.functions     // Backend function invocation
+base44.integrations  // Third-party services
+base44.users         // User invitations
+
+// Service role only (backend)
+base44.asServiceRole.agents
+base44.asServiceRole.appLogs
+base44.asServiceRole.connectors  // App-scoped OAuth tokens (ConnectorsModule)
+base44.asServiceRole.entities
+base44.asServiceRole.functions
+base44.asServiceRole.integrations
+base44.asServiceRole.sso         // SSO token generation
+```
+
+## Client Methods
+
+The client provides these methods:
+
+```javascript
+// Set authentication token for all subsequent requests
+base44.setToken(newToken);
+
+// Cleanup WebSocket connections (call when done with client)
+base44.cleanup();
+```
+
+### setToken
+
+Updates the authentication token for all subsequent API requests and WebSocket connections.
+
+```javascript
+// After receiving a token (e.g., from external auth)
+base44.setToken("new-jwt-token");
+```
+
+### cleanup
+
+Disconnects WebSocket connections. Call when you're done with the client or when the component unmounts.
+
+```javascript
+// Cleanup on component unmount (React example)
+useEffect(() => {
+  return () => base44.cleanup();
+}, []);
+```
+
+## Client Configuration Options
+
+```javascript
+createClient({
+  appId: "your-app-id",      // Required: MUST use 'appId' (not 'clientId' or 'id')
+  token: "jwt-token",        // Optional: pre-set auth token
+  options: {                 // Optional: configuration options
+    onError: (error) => {}   // Optional: global error handler (must be in options)
+  }
+});
+```
+
+**⚠️ Critical:**
+- The parameter name is `appId`, not `clientId` or `id`. Using the wrong parameter name will cause errors.
+- The `onError` handler must be nested inside the `options` object, not at the top level.
+
+## Type Definitions
+
+### CreateClientConfig
+
+```typescript
+/** Configuration for creating a Base44 client. */
+interface CreateClientConfig {
+  /** The Base44 app ID (required). */
+  appId: string;
+  /** User authentication token. Used to authenticate as a specific user. */
+  token?: string;
+  /** @internal Service role token; only set automatically in Base44-hosted backend functions. */
+  serviceToken?: string;
+  /** Additional client options. */
+  options?: CreateClientOptions;
+}
+
+/** Options for creating a Base44 client. */
+interface CreateClientOptions {
+  /** Optional error handler called whenever an API error occurs. */
+  onError?: (error: Error) => void;
+}
+```
+
+### Base44Client
+
+```typescript
+/** The Base44 client instance. */
+interface Base44Client {
+  /** Agents module for managing AI agent conversations. */
+  agents: AgentsModule;
+  /** Analytics module for tracking custom events. */
+  analytics: AnalyticsModule;
+  /** App logs module for tracking app usage. */
+  appLogs: AppLogsModule;
+  /** Auth module for user authentication and management. */
+  auth: AuthModule;
+  /** Entities module for CRUD operations on your data models. */
+  entities: EntitiesModule;
+  /** Functions module for invoking custom backend functions. */
+  functions: FunctionsModule;
+  /** Integrations module for calling pre-built integration methods. */
+  integrations: IntegrationsModule;
+
+  /** Cleanup function to disconnect WebSocket connections. */
+  cleanup(): void;
+
+  /** Sets a new authentication token for all subsequent requests. */
+  setToken(newToken: string): void;
+
+  /** Per-user OAuth flows. Each end user has their own connection. */
+  connectors: UserConnectorsModule;
+
+  /** Provides access to modules with elevated service role permissions (backend only). */
+  readonly asServiceRole: {
+    agents: AgentsModule;
+    appLogs: AppLogsModule;
+    /** App-scoped OAuth tokens. All users share the same connected account. */
+    connectors: ConnectorsModule;
+    entities: EntitiesModule;
+    functions: FunctionsModule;
+    integrations: IntegrationsModule;
+    /** SSO token generation for users. */
+    sso: SsoModule;
+    cleanup(): void;
+  };
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/connectors.md

@@ -0,0 +1,157 @@
+# Connectors Module
+
+OAuth token management for external services.
+
+- **`base44.asServiceRole.connectors`** — App-scoped OAuth tokens (backend/service role only). All users share the same connected account.
+
+## Contents
+- [Service Role Connectors (`base44.asServiceRole.connectors`)](#service-role-connectors-base44asserviceroleconnectors)
+- [Available Services](#available-services)
+- [Type Definitions](#type-definitions)
+
+---
+
+## Service Role Connectors (`base44.asServiceRole.connectors`)
+
+App-scoped OAuth tokens. The app builder connects the account once; all users share it. **Backend/service role only.**
+
+### Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `getConnection(integrationType)` | `Promise<ConnectorConnectionResponse>` | Get access token and optional connection config |
+| `getAccessToken(integrationType)` | `Promise<string>` | ⚠️ **Deprecated** — use `getConnection()` instead |
+
+### Examples
+
+```javascript
+// Backend function only
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+
+  // Recommended: use getConnection() for token + optional config
+  const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getConnection("slack");
+
+  const response = await fetch("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ channel: "#general", text: "Hello from Base44!" })
+  });
+
+  return Response.json(await response.json());
+});
+```
+
+```javascript
+// Using connectionConfig (for services that need extra params, e.g. a subdomain)
+const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getConnection("myservice");
+const subdomain = connectionConfig?.subdomain;
+const response = await fetch(`https://${subdomain}.example.com/api/v1/data`, {
+  headers: { "Authorization": `Bearer ${accessToken}` }
+});
+```
+
+```javascript
+// Google Calendar example
+const { accessToken } = await base44.asServiceRole.connectors.getConnection("googlecalendar");
+
+const events = await fetch(
+  "https://www.googleapis.com/calendar/v3/calendars/primary/events?" +
+  new URLSearchParams({ maxResults: "10", orderBy: "startTime", singleEvents: "true", timeMin: new Date().toISOString() }),
+  { headers: { "Authorization": `Bearer ${accessToken}` } }
+).then(r => r.json());
+```
+
+---
+
+## Available Services
+
+| Service | Type identifier |
+|---------|----------------|
+| Airtable | `airtable` |
+| Box | `box` |
+| ClickUp | `clickup` |
+| Discord | `discord` |
+| Dropbox | `dropbox` |
+| GitHub | `github` |
+| Gmail | `gmail` |
+| Google Analytics | `google_analytics` |
+| Google BigQuery | `googlebigquery` |
+| Google Calendar | `googlecalendar` |
+| Google Classroom | `google_classroom` |
+| Google Docs | `googledocs` |
+| Google Drive | `googledrive` |
+| Google Search Console | `google_search_console` |
+| Google Sheets | `googlesheets` |
+| Google Slides | `googleslides` |
+| HubSpot | `hubspot` |
+| Linear | `linear` |
+| LinkedIn | `linkedin` |
+| Microsoft Teams | `microsoft_teams` |
+| Microsoft OneDrive | `one_drive` |
+| Notion | `notion` |
+| Outlook | `outlook` |
+| Salesforce | `salesforce` |
+| SharePoint | `share_point` |
+| Slack User | `slack` |
+| Slack Bot | `slackbot` |
+| Splitwise | `splitwise` |
+| TikTok | `tiktok` |
+| Typeform | `typeform` |
+| Wix | `wix` |
+| Wrike | `wrike` |
+
+Run `npx base44 connectors list-available` from the CLI to see all available types.
+
+---
+
+## Setup Requirements
+
+1. **Builder plan** or higher
+2. **Backend functions** enabled (for service role connectors)
+3. **Connector configured** in Base44 dashboard (OAuth flow completed)
+
+## Important Notes
+
+- **Service role connectors**: One account per connector per app — all users share the same connected account
+- **You handle the API calls**: Base44 provides the token; you make the actual API requests
+- **Token refresh**: Base44 handles token refresh automatically
+
+---
+
+## Type Definitions
+
+```typescript
+/**
+ * The type of external integration/connector (for service role connectors).
+ * Examples: 'googlecalendar', 'slack', 'github', 'notion', etc.
+ */
+type ConnectorIntegrationType = string;
+
+/** Connection details returned by getConnection(). */
+interface ConnectorConnectionResponse {
+  /** The OAuth access token for the external service. */
+  accessToken: string;
+  /** Key-value configuration for the connection, or null if not needed. */
+  connectionConfig: Record<string, string> | null;
+}
+
+/** Service role connectors module (app-scoped OAuth). Backend only. */
+interface ConnectorsModule {
+  /**
+   * Retrieves the OAuth access token and optional connection config.
+   * @param integrationType - e.g., 'googlecalendar', 'slack', 'github'.
+   */
+  getConnection(integrationType: ConnectorIntegrationType): Promise<ConnectorConnectionResponse>;
+
+  /**
+   * @deprecated Use getConnection() instead.
+   * Retrieves only the OAuth access token string.
+   */
+  getAccessToken(integrationType: ConnectorIntegrationType): Promise<string>;
+}
+
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/entities.md

@@ -0,0 +1,399 @@
+# Entities Module
+
+CRUD operations on data models. Access via `base44.entities.EntityName.method()`.
+
+## Contents
+- [Methods](#methods)
+- [Examples](#examples) (Create, Bulk Create, List, Filter, Get, Update, Delete, Subscribe)
+- [User Entity](#user-entity)
+- [Service Role Access](#service-role-access)
+- [Permissions](#permissions)
+
+## Methods
+
+**Note:** The maximum limit for `list()` and `filter()` is 5,000 items per request.
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `create(data)` | `Promise<T>` | Create one record |
+| `bulkCreate(dataArray)` | `Promise<T[]>` | Create multiple records |
+| `list(sort?, limit?, skip?, fields?)` | `Promise<Pick<T, K>[]>` | Get all records (paginated) |
+| `filter(query, sort?, limit?, skip?, fields?)` | `Promise<Pick<T, K>[]>` | Get records matching conditions |
+| `get(id)` | `Promise<T>` | Get single record by ID |
+| `update(id, data)` | `Promise<T>` | Update record (partial update) |
+| `updateMany(query, data)` | `Promise<UpdateManyResult>` | Update all matching records using MongoDB update operators |
+| `bulkUpdate(dataArray)` | `Promise<T[]>` | Update multiple records by ID, each with its own data |
+| `delete(id)` | `Promise<DeleteResult>` | Delete record by ID |
+| `deleteMany(query)` | `Promise<DeleteManyResult>` | Delete all matching records |
+| `importEntities(file)` | `Promise<ImportResult<T>>` | Import from CSV (frontend only) |
+| `subscribe(callback)` | `() => void` | Subscribe to realtime updates (returns unsubscribe function) |
+
+## Examples
+
+### Create
+
+```javascript
+const task = await base44.entities.Task.create({
+  title: "Complete documentation",
+  status: "pending",
+  dueDate: "2024-12-31"
+});
+```
+
+### Bulk Create
+
+```javascript
+const tasks = await base44.entities.Task.bulkCreate([
+  { title: "Task 1", status: "pending" },
+  { title: "Task 2", status: "pending" }
+]);
+```
+
+### List with Pagination
+
+```javascript
+// Get first 10 records, sorted by created_date descending (max 5,000 per request)
+const tasks = await base44.entities.Task.list(
+  "-created_date",  // sort (SortField: prefix with - for descending)
+  10,               // limit
+  0                 // skip
+);
+
+// Get next page
+const page2 = await base44.entities.Task.list("-created_date", 10, 10);
+```
+
+### Filter
+
+```javascript
+// Simple filter
+const pending = await base44.entities.Task.filter({ status: "pending" });
+
+// Multiple conditions
+const myPending = await base44.entities.Task.filter({
+  status: "pending",
+  assignedTo: userId
+});
+
+// With sort, limit, skip (max 5,000 per request)
+const recent = await base44.entities.Task.filter(
+  { status: "pending" },
+  "-created_date",  // sort (SortField: prefix with - for descending)
+  5,
+  0
+);
+
+// Select specific fields
+const titles = await base44.entities.Task.filter(
+  { status: "pending" },
+  null,
+  null,
+  null,
+  ["id", "title"]
+);
+```
+
+### Get by ID
+
+```javascript
+const task = await base44.entities.Task.get("task-id-123");
+```
+
+### Update
+
+```javascript
+// Partial update - only specified fields change
+await base44.entities.Task.update("task-id-123", {
+  status: "completed",
+  completedAt: new Date().toISOString()
+});
+```
+
+### Delete
+
+```javascript
+// Single record
+const result = await base44.entities.Task.delete("task-id-123");
+console.log("Deleted:", result.success);
+
+// Multiple records matching query
+const manyResult = await base44.entities.Task.deleteMany({ status: "archived" });
+console.log("Deleted:", manyResult.deleted);
+```
+
+### Update Many (MongoDB-style)
+
+```javascript
+// Update all pending tasks to status "in-progress"
+const result = await base44.entities.Task.updateMany(
+  { status: "pending" },                     // query: which records to update
+  { $set: { status: "in-progress" } }        // MongoDB update operator
+);
+console.log("Updated:", result.updated);
+
+// Increment a counter field
+await base44.entities.Task.updateMany(
+  { category: "bugs" },
+  { $inc: { priority: 1 } }
+);
+```
+
+### Bulk Update (by ID)
+
+```javascript
+// Update multiple records, each with different data
+const updated = await base44.entities.Task.bulkUpdate([
+  { id: "task-1", status: "done", completedAt: new Date().toISOString() },
+  { id: "task-2", status: "in-progress", assignedTo: userId },
+  { id: "task-3", priority: 5 }
+]);
+```
+
+### Import from File
+
+```javascript
+// Frontend only: import from CSV/file
+const result = await base44.entities.Task.importEntities(file);
+if (result.status === "success" && result.output) {
+  console.log(`Imported ${result.output.length} records`);
+} else {
+  console.error(result.details);
+}
+```
+
+### Subscribe to Realtime Updates
+
+```javascript
+// Subscribe to all changes on Task entity
+const unsubscribe = base44.entities.Task.subscribe((event) => {
+  console.log(`Task ${event.id} was ${event.type}:`, event.data);
+  // event.type is "create", "update", or "delete"
+});
+
+// Later: unsubscribe to stop receiving updates
+unsubscribe();
+```
+
+**Event structure:**
+```javascript
+{
+  type: "create" | "update" | "delete",
+  data: { ... },       // the entity data
+  id: "entity-id",     // the affected entity's ID
+  timestamp: "2024-01-15T10:30:00Z"
+}
+```
+
+## User Entity
+
+Every app has a built-in `User` entity with special rules:
+
+- Regular users can only read/update **their own** record
+- Cannot create users via `entities.create()` - use `auth.register()` instead
+- Service role has full access to all user records
+
+```javascript
+// Get current user's record
+const me = await base44.entities.User.get(currentUserId);
+
+// Service role: get any user
+const anyUser = await base44.asServiceRole.entities.User.get(userId);
+```
+
+## Service Role Access
+
+For admin-level operations (bypass user permissions):
+
+```javascript
+// Backend only
+const allTasks = await base44.asServiceRole.entities.Task.list();
+const allUsers = await base44.asServiceRole.entities.User.list();
+```
+
+## Permissions (RLS & FLS)
+
+Data access is controlled by **Row Level Security (RLS)** and **Field Level Security (FLS)** rules defined in entity schemas.
+
+1. **Authentication level**: anonymous, authenticated, or service role
+2. **RLS rules**: Control which records (rows) users can create/read/update/delete
+3. **FLS rules**: Control which fields users can read/write within accessible records
+
+Operations succeed or fail based on these rules - no partial results.
+
+RLS and FLS are configured in entity schema files (`base44/entities/*.jsonc`). See [entities-create.md](../../base44-cli/references/entities-create.md#row-level-security-rls) for configuration details.
+
+**Note:** `asServiceRole` sets the user's role to `"admin"` but does NOT bypass RLS. Your RLS rules must include admin access (e.g., `{ "user_condition": { "role": "admin" } }`) for service role operations to succeed.
+
+## Type Definitions
+
+### RealtimeEvent
+
+```typescript
+/** Event types for realtime entity updates. */
+type RealtimeEventType = "create" | "update" | "delete";
+
+/** Payload received when a realtime event occurs. */
+interface RealtimeEvent<T = any> {
+  /** The type of change that occurred. */
+  type: RealtimeEventType;
+  /** The entity data. */
+  data: T;
+  /** The unique identifier of the affected entity. */
+  id: string;
+  /** ISO 8601 timestamp of when the event occurred. */
+  timestamp: string;
+}
+
+/** Callback function invoked when a realtime event occurs. */
+type RealtimeCallback<T = any> = (event: RealtimeEvent<T>) => void;
+```
+
+### Result Types
+
+```typescript
+/** Result returned when updating multiple entities. */
+interface UpdateManyResult {
+  /** Whether the update was successful. */
+  success: boolean;
+  /** Number of entities that were updated. */
+  updated: number;
+}
+
+/** Result returned when deleting a single entity. */
+interface DeleteResult {
+  /** Whether the deletion was successful. */
+  success: boolean;
+}
+
+/** Result returned when deleting multiple entities. */
+interface DeleteManyResult {
+  /** Whether the deletion was successful. */
+  success: boolean;
+  /** Number of entities that were deleted. */
+  deleted: number;
+}
+
+/** Result returned when importing entities from a file. */
+interface ImportResult<T = any> {
+  /** Status of the import operation. */
+  status: "success" | "error";
+  /** Details message, e.g., "Successfully imported 3 entities with RLS enforcement". */
+  details: string | null;
+  /** Array of created entity objects when successful, or null on error. */
+  output: T[] | null;
+}
+```
+
+### SortField and Server Fields
+
+```typescript
+/**
+ * Sort field type for entity queries.
+ * Supports ascending (no prefix or '+') and descending ('-') sorting.
+ * Example: 'created_date', '+created_date', '-created_date'
+ */
+type SortField<T> = (keyof T & string) | `+${keyof T & string}` | `-${keyof T & string}`;
+
+/** Fields added by the server to every entity record. */
+interface ServerEntityFields {
+  id: string;
+  created_date: string;
+  updated_date: string;
+  created_by?: string | null;
+  created_by_id?: string | null;
+  is_sample?: boolean;
+}
+```
+
+### Type Registry (for typed entities)
+
+**How to get typed entities:** The Base44 CLI can generate entity interfaces and an augmentation of `EntityTypeRegistry` from your project. For how to run it, use the **base44-cli** skill.
+
+```typescript
+/**
+ * Registry mapping entity names to their TypeScript types.
+ * Augment this interface with your entity schema (user-defined fields only).
+ * Typically populated by the Base44 CLI type generator.
+ */
+interface EntityTypeRegistry {}
+
+/**
+ * Full record type for each entity: schema fields + server-injected fields.
+ */
+type EntityRecord = {
+  [K in keyof EntityTypeRegistry]: EntityTypeRegistry[K] & ServerEntityFields;
+};
+```
+
+### EntityHandler
+
+```typescript
+/** Entity handler providing CRUD operations for a specific entity type. */
+interface EntityHandler<T = any> {
+  /** Lists records with optional pagination and sorting. Max 5,000 per request. */
+  list<K extends keyof T = keyof T>(
+    sort?: SortField<T>,
+    limit?: number,
+    skip?: number,
+    fields?: K[]
+  ): Promise<Pick<T, K>[]>;
+
+  /** Filters records based on a query. Max 5,000 per request. */
+  filter<K extends keyof T = keyof T>(
+    query: Partial<T>,
+    sort?: SortField<T>,
+    limit?: number,
+    skip?: number,
+    fields?: K[]
+  ): Promise<Pick<T, K>[]>;
+
+  /** Gets a single record by ID. */
+  get(id: string): Promise<T>;
+
+  /** Creates a new record. */
+  create(data: Partial<T>): Promise<T>;
+
+  /** Updates an existing record. */
+  update(id: string, data: Partial<T>): Promise<T>;
+
+  /** Deletes a single record by ID. */
+  delete(id: string): Promise<DeleteResult>;
+
+  /** Deletes multiple records matching a query. */
+  deleteMany(query: Partial<T>): Promise<DeleteManyResult>;
+
+  /** Creates multiple records in a single request. */
+  bulkCreate(data: Partial<T>[]): Promise<T[]>;
+
+  /**
+   * Updates multiple records matching a query using MongoDB update operators.
+   * @param query - Filter to select which records to update.
+   * @param data - MongoDB update operator object (e.g., `{ $set: { field: value } }`).
+   */
+  updateMany(query: Partial<T>, data: Record<string, Record<string, any>>): Promise<UpdateManyResult>;
+
+  /** Updates multiple records by ID, each with its own update data. */
+  bulkUpdate(data: (Partial<T> & { id: string })[]): Promise<T[]>;
+
+  /** Imports records from a file (frontend only). */
+  importEntities(file: File): Promise<ImportResult<T>>;
+
+  /** Subscribes to realtime updates. Returns unsubscribe function. */
+  subscribe(callback: RealtimeCallback<T>): () => void;
+}
+```
+
+### EntitiesModule
+
+```typescript
+/** Entities module: typed registry keys get typed handlers; dynamic access remains untyped. */
+type EntitiesModule = TypedEntitiesModule & DynamicEntitiesModule;
+
+type TypedEntitiesModule = {
+  [K in keyof EntityTypeRegistry]: EntityHandler<EntityRecord[K]>;
+};
+
+type DynamicEntitiesModule = {
+  [entityName: string]: EntityHandler<any>;
+};
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/functions.md

@@ -0,0 +1,291 @@
+# Functions Module
+
+Invoke custom backend functions via `base44.functions`.
+
+## Contents
+- [Method](#method)
+- [Invoking Functions](#invoking-functions) (Frontend, File Upload, Service Role, REST API)
+- [Writing Backend Functions](#writing-backend-functions) (Basic, Service Role, Secrets, Errors)
+- [Setup Requirements](#setup-requirements)
+- [Authentication Modes](#authentication-modes)
+
+## Methods
+
+### `invoke`
+
+```javascript
+base44.functions.invoke(functionName, data?): Promise<any>
+```
+
+- `functionName`: Name of the backend function
+- `data`: Optional object of parameters (sent as JSON, or multipart if contains File objects)
+- Returns: Whatever the function returns
+
+### `fetch`
+
+```javascript
+base44.functions.fetch(path, init?): Promise<Response>
+```
+
+Low-level method that performs a direct HTTP request to a backend function path and returns the native `Response` object. Use when you need streaming responses, custom HTTP methods, or raw response access.
+
+- `path`: Function path (e.g., `/streaming_demo` or `/my-function/endpoint`)
+- `init`: Optional native fetch options (`RequestInit`)
+- Returns: Native `Response` object
+
+## Invoking Functions
+
+### From Frontend
+
+```javascript
+const result = await base44.functions.invoke("processOrder", {
+  orderId: "order-123",
+  action: "ship"
+});
+
+console.log(result);
+```
+
+### Streaming Response (using fetch)
+
+```javascript
+// Use fetch() for streaming responses (SSE, chunked text, etc.)
+const response = await base44.functions.fetch("/stream-data", {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ prompt: "Tell me a story" })
+});
+
+// Read as a stream
+const reader = response.body.getReader();
+const decoder = new TextDecoder();
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  console.log(decoder.decode(value));
+}
+```
+
+### Custom HTTP Methods (using fetch)
+
+```javascript
+// PUT, PATCH, DELETE, or other methods
+const response = await base44.functions.fetch("/my-resource/123", {
+  method: "DELETE"
+});
+console.log(response.status); // 204
+```
+
+### With File Upload
+
+```javascript
+const fileInput = document.querySelector('input[type="file"]');
+const file = fileInput.files[0];
+
+// Automatically uses multipart/form-data when File objects present
+const result = await base44.functions.invoke("uploadDocument", {
+  file: file,
+  category: "invoices"
+});
+```
+
+### With Service Role (Backend)
+
+```javascript
+// Inside another backend function
+const result = await base44.asServiceRole.functions.invoke("adminTask", {
+  userId: "user-123"
+});
+```
+
+### Via REST API (curl)
+
+Functions can be called via HTTP POST to your app domain:
+
+```bash
+curl -X POST "https://<app-domain>/functions/<function-name>" \
+  -H "Content-Type: application/json" \
+  -d '{"key": "value"}'
+```
+
+## Writing Backend Functions
+
+Backend functions run on Deno. Must export using `Deno.serve()`.
+
+### Required Directory Structure
+
+Each function must be in its own subdirectory under `base44/functions/` with a configuration file:
+
+```
+base44/
+  functions/
+    process-order/          # kebab-case directory name
+      function.jsonc        # required configuration
+      index.ts              # entry point
+```
+
+**function.jsonc:**
+```jsonc
+{
+  "name": "process-order",
+  "entry": "index.ts"
+}
+```
+
+For complete setup and deployment instructions, see [functions-create.md](../../base44-cli/references/functions-create.md) in base44-cli.
+
+### Basic Structure
+
+```javascript
+// base44/functions/process-order/index.ts
+import { createClientFromRequest } from "npm:@base44/sdk";
+
+Deno.serve(async (req) => {
+  // Get authenticated client from request
+  const base44 = createClientFromRequest(req);
+  
+  // Parse input
+  const { orderId, action } = await req.json();
+  
+  // Your logic here
+  const order = await base44.entities.Orders.get(orderId);
+  
+  // Return response
+  return Response.json({
+    success: true,
+    order: order
+  });
+});
+```
+
+### With Service Role Access
+
+```javascript
+import { createClientFromRequest } from "npm:@base44/sdk";
+
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+  
+  // Check user is authenticated
+  const user = await base44.auth.me();
+  if (!user) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  
+  // Use service role for admin operations
+  const allOrders = await base44.asServiceRole.entities.Orders.list();
+  
+  return Response.json({ orders: allOrders });
+});
+```
+
+### Using Secrets
+
+```javascript
+Deno.serve(async (req) => {
+  // Access environment variables (configured in app settings)
+  const apiKey = Deno.env.get("STRIPE_API_KEY");
+  
+  const response = await fetch("https://api.stripe.com/v1/charges", {
+    headers: {
+      "Authorization": `Bearer ${apiKey}`
+    }
+  });
+  
+  return Response.json(await response.json());
+});
+```
+
+### Error Handling
+
+```javascript
+import { createClientFromRequest } from "npm:@base44/sdk";
+
+Deno.serve(async (req) => {
+  try {
+    const base44 = createClientFromRequest(req);
+    const { orderId } = await req.json();
+    
+    const order = await base44.entities.Orders.get(orderId);
+    if (!order) {
+      return Response.json(
+        { error: "Order not found" },
+        { status: 404 }
+      );
+    }
+    
+    return Response.json({ order });
+    
+  } catch (error) {
+    return Response.json(
+      { error: error.message },
+      { status: 500 }
+    );
+  }
+});
+```
+
+## Setup Requirements
+
+1. Enable Backend Functions in app settings (requires appropriate plan)
+2. Create function files in `/functions` folder
+3. Configure secrets via app dashboard for API keys
+
+## Authentication Modes
+
+| Mode | Context | Permissions |
+|------|---------|-------------|
+| User | `base44.functions.invoke()` | Runs under calling user's permissions |
+| Service Role | `base44.asServiceRole.functions.invoke()` | Admin-level access |
+
+Inside the function, use `createClientFromRequest(req)` to get a client that inherits the caller's auth context.
+
+## Type Definitions
+
+**How to get typed function names:** The Base44 CLI can generate an augmentation of `FunctionNameRegistry` from your project. For how to run it, use the **base44-cli** skill.
+
+```typescript
+/**
+ * Registry of function names.
+ * Augment this interface to enable autocomplete for function names.
+ * Typically populated by the Base44 CLI type generator.
+ */
+interface FunctionNameRegistry {}
+
+/**
+ * Function name type - uses registry keys if augmented, otherwise string.
+ */
+type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;
+
+/**
+ * Options for functions.fetch(). Uses native fetch options directly.
+ */
+type FunctionsFetchInit = RequestInit;
+
+/** Functions module for invoking custom backend functions. */
+interface FunctionsModule {
+  /**
+   * Invokes a custom backend function by name.
+   *
+   * If any parameter is a File object, the request will automatically be
+   * sent as multipart/form-data. Otherwise, it will be sent as JSON.
+   *
+   * @param functionName - The name of the function to invoke.
+   * @param data - Optional object containing named parameters for the function.
+   * @returns Promise resolving to the function's response.
+   */
+  invoke(functionName: FunctionName, data?: Record<string, any>): Promise<any>;
+
+  /**
+   * Performs a direct HTTP request to a backend function path and returns the native Response.
+   *
+   * Use for streaming responses (SSE, chunked text), custom HTTP methods,
+   * or when you need raw access to the response.
+   *
+   * @param path - Function path, e.g. `/streaming_demo` or `/my-function/endpoint`
+   * @param init - Optional native fetch options.
+   * @returns Promise resolving to a native fetch Response.
+   */
+  fetch(path: string, init?: FunctionsFetchInit): Promise<Response>;
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/integrations.md

@@ -0,0 +1,375 @@
+# Integrations Module
+
+Access third-party services via `base44.integrations`.
+
+## Types of Integrations
+
+1. **Core/Built-in**: AI, email, file uploads (available by default)
+2. **Catalog integrations**: Pre-built connectors from Base44 catalog
+3. **Custom integrations**: Your own OpenAPI-based integrations
+
+## Accessing Integrations
+
+```javascript
+// Core integrations
+base44.integrations.Core.FunctionName(params)
+
+// Custom integrations
+base44.integrations.custom.call(slug, operationId, params)
+```
+
+## Core Integrations
+
+### InvokeLLM (AI Text Generation)
+
+Generate text or structured JSON data using AI models.
+
+```javascript
+// Basic prompt - returns string
+const response = await base44.integrations.Core.InvokeLLM({
+  prompt: "Summarize this text: ..."
+});
+
+// With internet context (uses Google Search, Maps, News)
+const response = await base44.integrations.Core.InvokeLLM({
+  prompt: "What's the current weather in NYC?",
+  add_context_from_internet: true
+});
+
+// Structured JSON response - returns object
+const response = await base44.integrations.Core.InvokeLLM({
+  prompt: "Analyze the sentiment of: 'Great product but slow shipping'",
+  response_json_schema: {
+    type: "object",
+    properties: {
+      sentiment: { type: "string", enum: ["positive", "negative", "mixed"] },
+      score: { type: "number", description: "Score from 1-10" },
+      key_points: { type: "array", items: { type: "string" } }
+    }
+  }
+});
+// Returns: { sentiment: "mixed", score: 7, key_points: ["great product", "slow shipping"] }
+
+// With file attachments (uploaded via UploadFile)
+const response = await base44.integrations.Core.InvokeLLM({
+  prompt: "Describe what's in this image",
+  file_urls: ["https://...uploaded_image.png"]
+});
+```
+
+**Parameters:**
+- `prompt` (string, required): The prompt text to send to the model
+- `add_context_from_internet` (boolean, optional): If true, uses Google Search/Maps/News for real-time context
+- `response_json_schema` (object, optional): JSON schema for structured output
+- `file_urls` (string[], optional): URLs of uploaded files for context
+
+### GenerateImage
+
+Create AI-generated images from text prompts.
+
+```javascript
+const { url } = await base44.integrations.Core.GenerateImage({
+  prompt: "A serene mountain landscape with a lake"
+});
+console.log(url); // https://...generated_image.png
+```
+
+### SendEmail
+
+Send emails to registered users. Every app gets this integration (no plan upgrade required).
+
+```javascript
+await base44.integrations.Core.SendEmail({
+  to: "user@example.com",
+  subject: "Welcome!",
+  body: "<h1>Hello</h1><p>Welcome to our app.</p>",
+  from_name: "My App"  // optional, defaults to app name
+});
+```
+
+**Parameters:**
+- `to` (string, required): Recipient email address
+- `subject` (string, required): Email subject line
+- `body` (string, required): Plain text or HTML email body
+- `from_name` (string, optional): Sender name displayed to recipient
+
+**Limitations:**
+- 1 credit per email (2 credits with custom domain)
+
+### UploadFile (Public)
+
+Upload files to public storage.
+
+```javascript
+const fileInput = document.querySelector('input[type="file"]');
+const { file_url } = await base44.integrations.Core.UploadFile({
+  file: fileInput.files[0]
+});
+console.log(file_url); // https://...uploaded_file.pdf
+```
+
+### UploadPrivateFile
+
+Upload files to private storage that requires a signed URL to access.
+
+```javascript
+const { file_uri } = await base44.integrations.Core.UploadPrivateFile({
+  file: fileInput.files[0]
+});
+console.log(file_uri); // "private/user123/document.pdf"
+
+// Create a signed URL to access the file
+const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
+  file_uri,
+  expires_in: 3600  // URL expires in 1 hour (default: 300 seconds)
+});
+console.log(signed_url); // Temporary URL to access the private file
+```
+
+### CreateFileSignedUrl
+
+Generate temporary access links for private files.
+
+```javascript
+const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
+  file_uri: "private/user123/document.pdf",
+  expires_in: 7200  // 2 hours
+});
+```
+
+**Parameters:**
+- `file_uri` (string, required): URI from UploadPrivateFile
+- `expires_in` (number, optional): Expiration time in seconds (default: 300)
+
+### ExtractDataFromUploadedFile
+
+Extract structured data from uploaded files using AI.
+
+```javascript
+// First upload the file
+const { file_url } = await base44.integrations.Core.UploadFile({ file });
+
+// Then extract structured data
+const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
+  file_url,
+  json_schema: {
+    type: "object",
+    properties: {
+      invoice_number: { type: "string" },
+      total_amount: { type: "number" },
+      date: { type: "string" },
+      vendor_name: { type: "string" }
+    }
+  }
+});
+console.log(result); // { invoice_number: "INV-12345", total_amount: 1250.00, ... }
+```
+
+## Custom Integrations
+
+Custom integrations allow workspace administrators to connect any external API by importing an OpenAPI specification. Use `base44.integrations.custom.call()` to invoke them.
+
+### Syntax
+
+```javascript
+const response = await base44.integrations.custom.call(
+  slug,        // Integration identifier (set by admin)
+  operationId, // Endpoint in "method:path" format (e.g. "get:/contacts", "post:/repos/{owner}/{repo}/issues")
+  params       // Optional: payload, pathParams, queryParams
+);
+```
+
+### Examples
+
+```javascript
+// GET request with query params
+const response = await base44.integrations.custom.call(
+  "my-crm",
+  "get:/contacts",
+  { queryParams: { limit: 10, status: "active" } }
+);
+
+// POST request with body
+const response = await base44.integrations.custom.call(
+  "my-crm",
+  "post:/contacts",
+  { payload: { name: "John Doe", email: "john@example.com" } }
+);
+
+// Request with path parameters
+const response = await base44.integrations.custom.call(
+  "github",
+  "post:/repos/{owner}/{repo}/issues",
+  {
+    pathParams: { owner: "myorg", repo: "myrepo" },
+    payload: { title: "Bug report", body: "Something is broken" }
+  }
+);
+```
+
+### Response Structure
+
+```javascript
+{
+  success: true,      // Whether external API returned 2xx
+  status_code: 200,   // HTTP status code
+  data: { ... }       // Response from external API
+}
+```
+
+## Requirements
+
+- **Core integrations**: Available on all plans
+- **Catalog/Custom integrations**: Require Builder plan or higher
+
+## Type Definitions
+
+### Core Integration Parameters
+
+```typescript
+/** Parameters for the InvokeLLM function. */
+interface InvokeLLMParams {
+  /** The prompt text to send to the model. */
+  prompt: string;
+  /** If true, uses Google Search/Maps/News for real-time context. */
+  add_context_from_internet?: boolean;
+  /** JSON schema for structured output. If provided, returns object instead of string. */
+  response_json_schema?: object;
+  /** File URLs (from UploadFile) to provide as context. */
+  file_urls?: string[];
+}
+
+/** Parameters for the GenerateImage function. */
+interface GenerateImageParams {
+  /** Description of the image to generate. */
+  prompt: string;
+}
+
+/** Result from GenerateImage. */
+interface GenerateImageResult {
+  /** URL of the generated image. */
+  url: string;
+}
+
+/** Parameters for the UploadFile function. */
+interface UploadFileParams {
+  /** The file object to upload. */
+  file: File;
+}
+
+/** Result from UploadFile. */
+interface UploadFileResult {
+  /** URL of the uploaded file. */
+  file_url: string;
+}
+
+/** Parameters for the SendEmail function. */
+interface SendEmailParams {
+  /** Recipient email address. */
+  to: string;
+  /** Email subject line. */
+  subject: string;
+  /** Plain text or HTML email body. */
+  body: string;
+  /** Sender name (defaults to app name). */
+  from_name?: string;
+}
+
+/** Parameters for ExtractDataFromUploadedFile. */
+interface ExtractDataFromUploadedFileParams {
+  /** URL of the uploaded file. */
+  file_url: string;
+  /** JSON schema defining fields to extract. */
+  json_schema: object;
+}
+
+/** Parameters for UploadPrivateFile. */
+interface UploadPrivateFileParams {
+  /** The file object to upload. */
+  file: File;
+}
+
+/** Result from UploadPrivateFile. */
+interface UploadPrivateFileResult {
+  /** URI of the private file (used for signed URLs). */
+  file_uri: string;
+}
+
+/** Parameters for CreateFileSignedUrl. */
+interface CreateFileSignedUrlParams {
+  /** URI from UploadPrivateFile. */
+  file_uri: string;
+  /** Expiration time in seconds (default: 300). */
+  expires_in?: number;
+}
+
+/** Result from CreateFileSignedUrl. */
+interface CreateFileSignedUrlResult {
+  /** Temporary signed URL to access the file. */
+  signed_url: string;
+}
+```
+
+### CoreIntegrations
+
+```typescript
+/** Core package containing built-in Base44 integration functions. */
+interface CoreIntegrations {
+  InvokeLLM(params: InvokeLLMParams): Promise<string | object>;
+  GenerateImage(params: GenerateImageParams): Promise<GenerateImageResult>;
+  UploadFile(params: UploadFileParams): Promise<UploadFileResult>;
+  SendEmail(params: SendEmailParams): Promise<any>;
+  ExtractDataFromUploadedFile(params: ExtractDataFromUploadedFileParams): Promise<object>;
+  UploadPrivateFile(params: UploadPrivateFileParams): Promise<UploadPrivateFileResult>;
+  CreateFileSignedUrl(params: CreateFileSignedUrlParams): Promise<CreateFileSignedUrlResult>;
+}
+```
+
+### Custom Integrations
+
+```typescript
+/** Parameters for calling a custom integration method. */
+interface CustomIntegrationCallParams {
+  /** Request body payload. */
+  payload?: Record<string, any>;
+  /** Path parameters to substitute in the URL. For example, { owner: "user", repo: "repo" }. */
+  pathParams?: Record<string, string>;
+  /** Query string parameters. */
+  queryParams?: Record<string, any>;
+}
+
+/** Response from a custom integration call. */
+interface CustomIntegrationCallResponse {
+  /** Whether the external API returned a 2xx status code. */
+  success: boolean;
+  /** The HTTP status code from the external API. */
+  status_code: number;
+  /** The response data from the external API. */
+  data: any;
+}
+
+/** Module for calling custom pre-configured API integrations. */
+interface CustomIntegrationsModule {
+  /**
+   * Call a custom integration method.
+   * @param slug - The integration's unique identifier (set by workspace admin).
+   * @param operationId - The endpoint in "method:path" format (e.g. "get:/contacts", "post:/users/{id}").
+   * @param params - Optional payload, pathParams, queryParams.
+   */
+  call(slug: string, operationId: string, params?: CustomIntegrationCallParams): Promise<CustomIntegrationCallResponse>;
+}
+```
+
+### IntegrationsModule
+
+```typescript
+/** Integrations module for calling integration methods. */
+type IntegrationsModule = {
+  /** Core package with built-in integrations. */
+  Core: CoreIntegrations;
+  /** Custom integrations module. */
+  custom: CustomIntegrationsModule;
+  /** Additional integration packages (dynamic). */
+  [packageName: string]: any;
+};
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/sso.md

@@ -0,0 +1,75 @@
+# SSO Module
+
+Single Sign-On (SSO) support for authenticating Base44 users with external systems. Available via `base44.asServiceRole.sso`.
+
+> **Backend only**: This module requires service role access and can only be used in Base44-hosted backend functions.
+
+## Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `getAccessToken(userId)` | `Promise<SsoAccessTokenResponse>` | Get an SSO access token for a specific user |
+
+## Examples
+
+### Get SSO Access Token
+
+```javascript
+import { createClientFromRequest } from "npm:@base44/sdk";
+
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+
+  // Get the current user
+  const user = await base44.auth.me();
+  if (!user) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  // Get SSO access token for this user
+  const { access_token } = await base44.asServiceRole.sso.getAccessToken(user.id);
+
+  // Use the token to authenticate with an external system
+  return Response.json({ ssoToken: access_token });
+});
+```
+
+### Get Token for a Specific User (Service Role)
+
+```javascript
+Deno.serve(async (req) => {
+  const base44 = createClientFromRequest(req);
+  const { userId } = await req.json();
+
+  // Get SSO token for any user (service role has access to all users)
+  const { access_token } = await base44.asServiceRole.sso.getAccessToken(userId);
+
+  return Response.json({ token: access_token });
+});
+```
+
+## Use Cases
+
+- Authenticating Base44 users with external SaaS tools (e.g., Okta, Azure AD)
+- Building SSO bridges between Base44 and third-party systems
+- Generating tokens for backend-to-backend authenticated calls
+
+## Type Definitions
+
+```typescript
+/** Response from the SSO access token endpoint. */
+interface SsoAccessTokenResponse {
+  /** The SSO access token for the specified user. */
+  access_token: string;
+}
+
+/** SSO module for managing SSO authentication (service role only). */
+interface SsoModule {
+  /**
+   * Gets an SSO access token for a specific user.
+   * @param userid - The Base44 user ID to get the SSO token for.
+   * @returns Promise resolving to the SSO access token response.
+   */
+  getAccessToken(userid: string): Promise<SsoAccessTokenResponse>;
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-sdk/references/users.md

@@ -0,0 +1,82 @@
+# Users Module
+
+Invite users to the app via `base44.users`.
+
+## Contents
+- [Methods](#methods)
+- [Examples](#examples) (Invite User)
+- [Roles](#roles)
+- [Notes](#notes)
+
+## Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `inviteUser(user_email, role)` | `Promise<any>` | Invite a user to the app |
+
+## Examples
+
+### Invite User
+
+```javascript
+// Invite a user with "user" role
+await base44.users.inviteUser("newuser@example.com", "user");
+
+// Invite an admin
+await base44.users.inviteUser("admin@example.com", "admin");
+```
+
+### Invite Multiple Users
+
+```javascript
+const usersToInvite = [
+  { email: "user1@example.com", role: "user" },
+  { email: "user2@example.com", role: "user" },
+  { email: "manager@example.com", role: "admin" }
+];
+
+for (const user of usersToInvite) {
+  await base44.users.inviteUser(user.email, user.role);
+  console.log(`Invited ${user.email} as ${user.role}`);
+}
+```
+
+## Roles
+
+The `role` parameter must be one of:
+
+| Role | Description |
+|------|-------------|
+| `"user"` | Standard user with default permissions |
+| `"admin"` | Administrator with elevated permissions |
+
+**Note:** Only `"user"` and `"admin"` are valid role values. An error will be thrown if you pass any other value.
+
+## Notes
+
+- **Email invitation**: The invited user receives an email with a link to join the app
+- **Duplicate handling**: Inviting an existing user will re-send the invitation
+- **Also available in auth**: `base44.auth.inviteUser()` provides the same functionality
+- **Role validation**: Only `"user"` or `"admin"` are accepted
+
+```javascript
+// These are equivalent:
+await base44.users.inviteUser("newuser@example.com", "user");
+await base44.auth.inviteUser("newuser@example.com", "user");
+```
+
+## Type Definitions
+
+```typescript
+/** Users module for inviting users to the app. */
+interface UsersModule {
+  /**
+   * Invite a user to the application.
+   * @param user_email - User's email address.
+   * @param role - User's role ('user' or 'admin').
+   * @returns Promise resolving when the invitation is sent.
+   * @throws Error if role is not 'user' or 'admin'.
+   */
+  inviteUser(user_email: string, role: "user" | "admin"): Promise<any>;
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-troubleshooter/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Base44 Troubleshooter"
+  short_description: "Debug Base44 production issues with function logs"
+  default_prompt: "Use Base44 troubleshooting guidance to inspect logs and diagnose this production issue."

data/.codex/.codex/.tmp/plugins/plugins/base44/skills/base44-troubleshooter/references/project-logs.md

@@ -0,0 +1,57 @@
+# base44 logs
+
+Fetch function logs for this app.
+
+## Syntax
+
+```bash
+npx base44 logs [options]
+```
+
+## Options
+
+| Option | Description | Required |
+|--------|-------------|----------|
+| `--function <names>` | Filter by function name(s), comma-separated. If omitted, fetches logs for all project functions | No |
+| `--since <datetime>` | Show logs from this time (ISO format) | No |
+| `--until <datetime>` | Show logs until this time (ISO format) | No |
+| `--level <level>` | Filter by log level: `log`, `info`, `warn`, `error`, `debug` | No |
+| `-n, --limit <n>` | Number of results to return (1-1000, default: 50) | No |
+| `--order <order>` | Sort order: `asc` or `desc` (default: `desc`) | No |
+
+## Examples
+
+```bash
+# Fetch logs for all project functions (last 50 entries)
+npx base44 logs
+
+# Fetch only errors
+npx base44 logs --level error
+
+# Fetch logs for a specific function
+npx base44 logs --function my-function
+
+# Fetch logs for multiple functions
+npx base44 logs --function send-email,process-payment
+
+# Fetch logs since a specific time
+npx base44 logs --since 2024-01-15T10:00:00
+
+# Fetch logs within a time range
+npx base44 logs --since 2024-01-15T10:00:00 --until 2024-01-15T12:00:00
+
+# Fetch last 100 log entries in ascending order
+npx base44 logs -n 100 --order asc
+
+# Last 10 errors for a specific function
+npx base44 logs --function myFunction --level error --limit 10
+```
+
+## Notes
+
+- **Authentication required.** You must be logged in before fetching logs.
+- **Project context required.** Must be run from the project directory (where `base44/.app.jsonc` exists).
+- When multiple functions are specified, logs are merged and sorted by timestamp.
+- If `--function` is omitted, logs are fetched for **all functions** defined in `base44/config.jsonc`.
+- The `--limit` applies after merging logs from all specified functions.
+- The `--since` and `--until` values are normalized to UTC if no timezone is provided (appends `Z`).

data/.codex/.codex/.tmp/plugins/plugins/carta-crm/.codex-plugin/plugin.json

@@ -0,0 +1,32 @@
+{
+  "name": "carta-crm",
+  "version": "1.0.3",
+  "description": "Carta CRM helps investment teams stay on top of deal flow by keeping deals, companies, and relationships in...",
+  "author": {
+    "name": "Carta Inc.",
+    "url": "https://carta.com"
+  },
+  "repository": "https://github.com/openai/plugins",
+  "license": "MIT",
+  "keywords": [],
+  "apps": "./.app.json",
+  "interface": {
+    "displayName": "Carta CRM",
+    "shortDescription": "Carta CRM helps investment teams stay on top of deal flow by keeping deals, companies, and relationships in...",
+    "longDescription": "Carta CRM helps investment teams stay on top of deal flow by keeping deals, companies, and relationships in one place. Track opportunities through each stage, capture meeting notes and key takeaways alongside the right deal or contact, and quickly find past context when you need it.",
+    "developerName": "Carta Inc.",
+    "category": "Business & Operations",
+    "capabilities": [],
+    "defaultPrompt": [
+      "Find the latest relationship context in Carta CRM"
+    ],
+    "screenshots": [],
+    "websiteURL": "https://carta.com",
+    "privacyPolicyURL": "https://carta.com/legal/privacy/privacy-policy/",
+    "termsOfServiceURL": "https://carta.com/legal/terms-agreements/terms-service/",
+    "composerIcon": "./assets/logo.png",
+    "logo": "./assets/logo.png",
+    "logoDark": "./assets/logo-dark.png"
+  },
+  "homepage": "https://carta.com"
+}

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/.codex-plugin/plugin.json

@@ -0,0 +1,47 @@
+{
+  "name": "cloudflare",
+  "version": "0.1.2",
+  "description": "Cloudflare platform plugin with curated skills for Workers, Wrangler, and Agents SDK plus the official Cloudflare API MCP server.",
+  "author": {
+    "name": "Cloudflare",
+    "url": "https://workers.cloudflare.com/"
+  },
+  "homepage": "https://workers.cloudflare.com/",
+  "repository": "https://github.com/openai/plugins",
+  "license": "MIT",
+  "keywords": [
+    "cloudflare",
+    "workflow",
+    "deployment",
+    "edge-functions",
+    "edge",
+    "analytics",
+    "wrangler",
+    "agents-sdk",
+    "serverless",
+    "ai-gateway"
+  ],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "Cloudflare",
+    "shortDescription": "Cloudflare platform guidance with official MCP",
+    "longDescription": "Bring Cloudflare platform guidance into Codex with curated skills for the broader platform, Wrangler CLI, and the Agents SDK, plus the official Cloudflare API MCP server for authenticated access to live account data and workflows across Workers, Pages, storage, AI, networking, security, and analytics services.",
+    "developerName": "Cloudflare",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive",
+      "Write"
+    ],
+    "websiteURL": "https://workers.cloudflare.com/",
+    "privacyPolicyURL": "https://www.cloudflare.com/privacypolicy/",
+    "termsOfServiceURL": "https://www.cloudflare.com/website-terms/",
+    "defaultPrompt": [
+      "Help me choose the right Cloudflare product, configure Wrangler, and use Cloudflare MCP to inspect or deploy this project"
+    ],
+    "composerIcon": "./assets/cloudflare-small.svg",
+    "logo": "./assets/cloudflare.png",
+    "screenshots": [],
+    "brandColor": "#F48120"
+  }
+}

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/commands/build-agent.md

@@ -0,0 +1,40 @@
+---
+description: Build an AI agent on Cloudflare using the Agents SDK
+argument-hint: [agent-description]
+allowed-tools: [Read, Glob, Grep, Bash, Write, Edit, WebFetch]
+---
+
+# Build AI Agent on Cloudflare
+
+This command helps you build AI agents using the Cloudflare Agents SDK with state management, real-time WebSockets, scheduled tasks, and tool integration.
+
+## Arguments
+
+The user invoked this command with: $ARGUMENTS
+
+## Instructions
+
+When this command is invoked:
+
+1. Read the skill file at `skills/building-ai-agent-on-cloudflare/SKILL.md` for core guidance
+2. Reference `skills/building-ai-agent-on-cloudflare/references/examples.md` for templates
+3. Use `skills/building-ai-agent-on-cloudflare/references/agent-patterns.md` for tool calling and patterns
+4. Use `skills/building-ai-agent-on-cloudflare/references/state-patterns.md` for state management
+5. Consult `skills/building-ai-agent-on-cloudflare/references/troubleshooting.md` for common issues
+
+## Capabilities
+
+- Stateful AI agents with persistent memory
+- Real-time WebSocket communication
+- Scheduled tasks and cron jobs
+- Tool integration and function calling
+- Multi-agent orchestration
+- RAG (Retrieval Augmented Generation) patterns
+
+## Example Usage
+
+```
+/cloudflare:build-agent a customer support chatbot
+/cloudflare:build-agent real-time coding assistant with WebSocket
+/cloudflare:build-agent multi-agent workflow orchestrator
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/commands/build-mcp.md

@@ -0,0 +1,38 @@
+---
+description: Build a remote MCP server on Cloudflare with tools and OAuth
+argument-hint: [mcp-description]
+allowed-tools: [Read, Glob, Grep, Bash, Write, Edit, WebFetch]
+---
+
+# Build MCP Server on Cloudflare
+
+This command helps you build remote Model Context Protocol (MCP) servers on Cloudflare with tools, OAuth authentication, and production deployment.
+
+## Arguments
+
+The user invoked this command with: $ARGUMENTS
+
+## Instructions
+
+When this command is invoked:
+
+1. Read the skill file at `skills/building-mcp-server-on-cloudflare/SKILL.md` for core guidance
+2. Reference `skills/building-mcp-server-on-cloudflare/references/examples.md` for official templates
+3. Use `skills/building-mcp-server-on-cloudflare/references/oauth-setup.md` for security and OAuth
+4. Consult `skills/building-mcp-server-on-cloudflare/references/troubleshooting.md` for common issues
+
+## Capabilities
+
+- Remote MCP server deployment on Cloudflare Workers
+- OAuth 2.0 authentication setup
+- Tool definition and implementation
+- Production-ready deployment patterns
+- Integration with Codex and other MCP clients
+
+## Example Usage
+
+```
+/cloudflare:build-mcp a GitHub integration server
+/cloudflare:build-mcp database query tool with OAuth
+/cloudflare:build-mcp file management MCP server
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/LICENSE.txt

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf of
+   any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don\'t include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: agents-sdk
+description: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, or chat applications. Covers Agent class, state management, callable RPC, Workflows integration, and React hooks. Biases towards retrieval from Cloudflare docs over pre-trained knowledge.
+---
+
+# Cloudflare Agents SDK
+
+Your knowledge of the Agents SDK may be outdated. **Prefer retrieval over pre-training** for any Agents SDK task.
+
+## Retrieval Sources
+
+Fetch current docs from `https://github.com/cloudflare/agents/tree/main/docs` before implementing.
+
+| Topic | Doc | Use for |
+|-------|-----|---------|
+| Getting started | `docs/getting-started.md` | First agent, project setup |
+| State | `docs/state.md` | `setState`, `validateStateChange`, persistence |
+| Routing | `docs/routing.md` | URL patterns, `routeAgentRequest`, `basePath` |
+| Callable methods | `docs/callable-methods.md` | `@callable`, RPC, streaming, timeouts |
+| Scheduling | `docs/scheduling.md` | `schedule()`, `scheduleEvery()`, cron |
+| Workflows | `docs/workflows.md` | `AgentWorkflow`, durable multi-step tasks |
+| HTTP/WebSockets | `docs/http-websockets.md` | Lifecycle hooks, hibernation |
+| Email | `docs/email.md` | Email routing, secure reply resolver |
+| MCP client | `docs/mcp-client.md` | Connecting to MCP servers |
+| MCP server | `docs/mcp-servers.md` | Building MCP servers with `McpAgent` |
+| Client SDK | `docs/client-sdk.md` | `useAgent`, `useAgentChat`, React hooks |
+| Human-in-the-loop | `docs/human-in-the-loop.md` | Approval flows, pausing workflows |
+| Resumable streaming | `docs/resumable-streaming.md` | Stream recovery on disconnect |
+
+Cloudflare docs: https://developers.cloudflare.com/agents/
+
+## Capabilities
+
+The Agents SDK provides:
+
+- **Persistent state** - SQLite-backed, auto-synced to clients
+- **Callable RPC** - `@callable()` methods invoked over WebSocket
+- **Scheduling** - One-time, recurring (`scheduleEvery`), and cron tasks
+- **Workflows** - Durable multi-step background processing via `AgentWorkflow`
+- **MCP integration** - Connect to MCP servers or build your own with `McpAgent`
+- **Email handling** - Receive and reply to emails with secure routing
+- **Streaming chat** - `AIChatAgent` with resumable streams
+- **React hooks** - `useAgent`, `useAgentChat` for client apps
+
+## FIRST: Verify Installation
+
+```bash
+npm ls agents  # Should show agents package
+```
+
+If not installed:
+```bash
+npm install agents
+```
+
+## Wrangler Configuration
+
+```jsonc
+{
+  "durable_objects": {
+    "bindings": [{ "name": "MyAgent", "class_name": "MyAgent" }]
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["MyAgent"] }]
+}
+```
+
+## Agent Class
+
+```typescript
+import { Agent, routeAgentRequest, callable } from "agents";
+
+type State = { count: number };
+
+export class Counter extends Agent<Env, State> {
+  initialState = { count: 0 };
+
+  // Validation hook - runs before state persists (sync, throwing rejects the update)
+  validateStateChange(nextState: State, source: Connection | "server") {
+    if (nextState.count < 0) throw new Error("Count cannot be negative");
+  }
+
+  // Notification hook - runs after state persists (async, non-blocking)
+  onStateUpdate(state: State, source: Connection | "server") {
+    console.log("State updated:", state);
+  }
+
+  @callable()
+  increment() {
+    this.setState({ count: this.state.count + 1 });
+    return this.state.count;
+  }
+}
+
+export default {
+  fetch: (req, env) => routeAgentRequest(req, env) ?? new Response("Not found", { status: 404 })
+};
+```
+
+## Routing
+
+Requests route to `/agents/{agent-name}/{instance-name}`:
+
+| Class | URL |
+|-------|-----|
+| `Counter` | `/agents/counter/user-123` |
+| `ChatRoom` | `/agents/chat-room/lobby` |
+
+Client: `useAgent({ agent: "Counter", name: "user-123" })`
+
+## Core APIs
+
+| Task | API |
+|------|-----|
+| Read state | `this.state.count` |
+| Write state | `this.setState({ count: 1 })` |
+| SQL query | `` this.sql`SELECT * FROM users WHERE id = ${id}` `` |
+| Schedule (delay) | `await this.schedule(60, "task", payload)` |
+| Schedule (cron) | `await this.schedule("0 * * * *", "task", payload)` |
+| Schedule (interval) | `await this.scheduleEvery(30, "poll")` |
+| RPC method | `@callable() myMethod() { ... }` |
+| Streaming RPC | `@callable({ streaming: true }) stream(res) { ... }` |
+| Start workflow | `await this.runWorkflow("ProcessingWorkflow", params)` |
+
+## React Client
+
+```tsx
+import { useAgent } from "agents/react";
+
+function App() {
+  const [state, setLocalState] = useState({ count: 0 });
+
+  const agent = useAgent({
+    agent: "Counter",
+    name: "my-instance",
+    onStateUpdate: (newState) => setLocalState(newState),
+    onIdentity: (name, agentType) => console.log(`Connected to ${name}`)
+  });
+
+  return (
+    <button onClick={() => agent.setState({ count: state.count + 1 })}>
+      Count: {state.count}
+    </button>
+  );
+}
+```
+
+## References
+
+- **[references/workflows.md](references/workflows.md)** - Durable Workflows integration
+- **[references/callable.md](references/callable.md)** - RPC methods, streaming, timeouts
+- **[references/state-scheduling.md](references/state-scheduling.md)** - State persistence, scheduling
+- **[references/streaming-chat.md](references/streaming-chat.md)** - AIChatAgent, resumable streams
+- **[references/mcp.md](references/mcp.md)** - MCP server integration
+- **[references/email.md](references/email.md)** - Email routing and handling
+- **[references/codemode.md](references/codemode.md)** - Code Mode (experimental)

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "Agents SDK"
+  short_description: "Build stateful agents on Cloudflare Workers"
+  icon_small: "./assets/cloudflare-small.svg"
+  icon_large: "./assets/cloudflare.png"
+  default_prompt: "Use the Cloudflare Agents SDK to design or implement this agent on Workers with the right state, routing, and workflow patterns."

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/callable.md

@@ -0,0 +1,92 @@
+# Callable Methods
+
+Fetch `docs/callable-methods.md` from `https://github.com/cloudflare/agents/tree/main/docs` for complete documentation.
+
+## Overview
+
+`@callable()` exposes agent methods to clients via WebSocket RPC.
+
+```typescript
+import { Agent, callable } from "agents";
+
+export class MyAgent extends Agent<Env, State> {
+  @callable()
+  async greet(name: string): Promise<string> {
+    return `Hello, ${name}!`;
+  }
+
+  @callable()
+  async processData(data: unknown): Promise<Result> {
+    // Long-running work
+    return result;
+  }
+}
+```
+
+## Client Usage
+
+```typescript
+// Basic call
+const greeting = await agent.call("greet", ["World"]);
+
+// With timeout
+const result = await agent.call("processData", [data], {
+  timeout: 5000  // 5 second timeout
+});
+```
+
+## Streaming Responses
+
+```typescript
+import { Agent, callable, StreamingResponse } from "agents";
+
+export class MyAgent extends Agent<Env, State> {
+  @callable({ streaming: true })
+  async streamResults(stream: StreamingResponse, query: string) {
+    for await (const item of fetchResults(query)) {
+      stream.send(JSON.stringify(item));
+    }
+    stream.close();
+  }
+
+  @callable({ streaming: true })
+  async streamWithError(stream: StreamingResponse) {
+    try {
+      // ... work
+    } catch (error) {
+      stream.error(error.message);  // Signal error to client
+      return;
+    }
+    stream.close();
+  }
+}
+```
+
+Client with streaming:
+
+```typescript
+await agent.call("streamResults", ["search term"], {
+  stream: {
+    onChunk: (data) => console.log("Chunk:", data),
+    onDone: () => console.log("Complete"),
+    onError: (error) => console.error("Error:", error)
+  }
+});
+```
+
+## Introspection
+
+```typescript
+// Get list of callable methods on an agent
+const methods = await agent.call("getCallableMethods", []);
+// Returns: ["greet", "processData", "streamResults", ...]
+```
+
+## When to Use
+
+| Scenario | Use |
+|----------|-----|
+| Browser/mobile calling agent | `@callable()` |
+| External service calling agent | `@callable()` |
+| Worker calling agent (same codebase) | DO RPC directly |
+| Agent calling another agent | `getAgentByName()` + DO RPC |

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/codemode.md

@@ -0,0 +1,207 @@
+# Code Mode (Experimental)
+
+Code Mode generates executable JavaScript instead of making individual tool calls. This significantly reduces token usage and enables complex multi-tool workflows.
+
+## Why Code Mode?
+
+Traditional tool calling:
+- One tool call per LLM request
+- Multiple round-trips for chained operations
+- High token usage for complex workflows
+
+Code Mode:
+- LLM generates code that orchestrates multiple tools
+- Single execution for complex workflows
+- Self-debugging and error recovery
+- Ideal for MCP server orchestration
+
+## Setup
+
+### 1. Wrangler Config
+
+```jsonc
+{
+  "name": "my-agent-worker",
+  "compatibility_flags": ["experimental", "enable_ctx_exports"],
+  "durable_objects": {
+    // "class_name" must match your Agent class name exactly
+    "bindings": [{ "name": "MyAgent", "class_name": "MyAgent" }]
+  },
+  "migrations": [
+    // Required: list all Agent classes for SQLite storage
+    { "tag": "v1", "new_sqlite_classes": ["MyAgent"] }
+  ],
+  "services": [
+    {
+      "binding": "globalOutbound",
+      // "service" must match "name" above
+      "service": "my-agent-worker",
+      "entrypoint": "globalOutbound"
+    },
+    {
+      "binding": "CodeModeProxy",
+      "service": "my-agent-worker",
+      "entrypoint": "CodeModeProxy"
+    }
+  ],
+  "worker_loaders": [{ "binding": "LOADER" }]
+}
+```
+
+### 2. Export Required Classes
+
+```typescript
+// Export the proxy for tool execution (required for codemode)
+export { CodeModeProxy } from "@cloudflare/codemode/ai";
+
+// Define outbound fetch handler for security filtering
+export const globalOutbound = {
+  fetch: async (input: string | URL | RequestInfo, init?: RequestInit) => {
+    const url = new URL(
+      typeof input === "string"
+        ? input
+        : typeof input === "object" && "url" in input
+          ? input.url
+          : input.toString()
+    );
+    // Block certain domains if needed
+    if (url.hostname === "blocked.example.com") {
+      return new Response("Not allowed", { status: 403 });
+    }
+    return fetch(input, init);
+  }
+};
+```
+
+### 3. Install Dependencies
+
+```bash
+npm install @cloudflare/codemode ai @ai-sdk/openai zod
+```
+
+### 4. Use Code Mode in Agent
+
+```typescript
+import { Agent } from "agents";
+import { experimental_codemode as codemode } from "@cloudflare/codemode/ai";
+import { streamText, tool, convertToModelMessages } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { env } from "cloudflare:workers";
+import { z } from "zod";
+
+const tools = {
+  getWeather: tool({
+    description: "Get weather for a location",
+    parameters: z.object({ location: z.string() }),
+    execute: async ({ location }) => `Weather: ${location} 72°F`
+  }),
+  sendEmail: tool({
+    description: "Send an email",
+    parameters: z.object({ to: z.string(), subject: z.string(), body: z.string() }),
+    execute: async ({ to, subject, body }) => `Email sent to ${to}`
+  })
+};
+
+export class MyAgent extends Agent<Env, State> {
+  tools = {};
+
+  // Method called by codemode proxy
+  callTool(functionName: string, args: unknown[]) {
+    return this.tools[functionName]?.execute?.(args, {
+      abortSignal: new AbortController().signal,
+      toolCallId: "codemode",
+      messages: []
+    });
+  }
+
+  async onChatMessage() {
+    this.tools = { ...tools, ...this.mcp.getAITools() };
+
+    const { prompt, tools: wrappedTools } = await codemode({
+      prompt: "You are a helpful assistant...",
+      tools: this.tools,
+      globalOutbound: env.globalOutbound,
+      loader: env.LOADER,
+      proxy: this.ctx.exports.CodeModeProxy({
+        props: {
+          binding: "MyAgent",  // Class name
+          name: this.name,     // Instance name
+          callback: "callTool" // Method to call
+        }
+      })
+    });
+
+    const result = streamText({
+      system: prompt,
+      model: openai("gpt-4o"),
+      messages: await convertToModelMessages(this.state.messages),
+      tools: wrappedTools  // Use wrapped tools, not original
+    });
+
+    // ... handle stream
+  }
+}
+```
+
+## Generated Code Example
+
+When user asks "Check the weather in NYC and email me the forecast", codemode generates:
+
+```javascript
+async function executeTask() {
+  const weather = await codemode.getWeather({ location: "NYC" });
+
+  await codemode.sendEmail({
+    to: "user@example.com",
+    subject: "NYC Weather Forecast",
+    body: `Current weather: ${weather}`
+  });
+
+  return { success: true, weather };
+}
+```
+
+## MCP Server Orchestration
+
+Code Mode excels at orchestrating multiple MCP servers:
+
+```javascript
+async function executeTask() {
+  // Query file system MCP
+  const files = await codemode.listFiles({ path: "/projects" });
+
+  // Query database MCP
+  const status = await codemode.queryDatabase({
+    query: "SELECT * FROM projects WHERE name = ?",
+    params: [files[0].name]
+  });
+
+  // Conditional logic based on results
+  if (status.length === 0) {
+    await codemode.createTask({
+      title: `Review: ${files[0].name}`,
+      priority: "high"
+    });
+  }
+
+  return { files, status };
+}
+```
+
+## When to Use
+
+| Scenario | Use Code Mode? |
+|----------|---------------|
+| Single tool call | No |
+| Chained tool calls | Yes |
+| Conditional logic across tools | Yes |
+| MCP multi-server workflows | Yes |
+| Token budget constrained | Yes |
+| Simple Q&A chat | No |
+
+## Limitations
+
+- Experimental - API may change
+- Requires Cloudflare Workers
+- JavaScript execution only (Python planned)
+- Requires additional wrangler config

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/email.md

@@ -0,0 +1,146 @@
+# Email Handling
+
+Fetch `docs/email.md` from `https://github.com/cloudflare/agents/tree/main/docs` for complete documentation.
+
+## Overview
+
+Agents receive and reply to emails via Cloudflare Email Routing.
+
+## Wrangler Configuration
+
+```jsonc
+{
+  "durable_objects": {
+    "bindings": [{ "name": "EmailAgent", "class_name": "EmailAgent" }]
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["EmailAgent"] }],
+  "send_email": [
+    { "name": "SEB", "destination_address": "reply@yourdomain.com" }
+  ]
+}
+```
+
+## Basic Email Handler
+
+```typescript
+import { Agent } from "agents";
+import { type AgentEmail } from "agents/email";
+import PostalMime from "postal-mime";
+
+export class EmailAgent extends Agent<Env, State> {
+  async onEmail(email: AgentEmail) {
+    const raw = await email.getRaw();
+    const parsed = await PostalMime.parse(raw);
+
+    console.log("From:", email.from);
+    console.log("Subject:", parsed.subject);
+
+    await this.replyToEmail(email, {
+      fromName: "My Agent",
+      subject: `Re: ${parsed.subject}`,
+      body: "Thanks for your email!"
+    });
+  }
+}
+```
+
+## Routing Emails
+
+```typescript
+import { routeAgentRequest, routeAgentEmail } from "agents";
+import { createAddressBasedEmailResolver } from "agents/email";
+
+export default {
+  async email(message, env) {
+    await routeAgentEmail(message, env, {
+      resolver: createAddressBasedEmailResolver("EmailAgent")
+    });
+  },
+
+  async fetch(request, env) {
+    return routeAgentRequest(request, env) ?? new Response("Not found", { status: 404 });
+  }
+};
+```
+
+## Resolvers
+
+### Address-Based (Inbound Mail)
+
+Routes based on recipient address:
+
+```typescript
+import { createAddressBasedEmailResolver } from "agents/email";
+
+const resolver = createAddressBasedEmailResolver("EmailAgent");
+// support@example.com → EmailAgent, instance "support"
+// NotificationAgent+user123@example.com → NotificationAgent, instance "user123"
+```
+
+### Secure Reply (Reply Flows)
+
+Verifies replies are authentic using HMAC-SHA256 signatures:
+
+```typescript
+import { createSecureReplyEmailResolver } from "agents/email";
+
+const resolver = createSecureReplyEmailResolver(env.EMAIL_SECRET, {
+  maxAge: 7 * 24 * 60 * 60, // 7 days (default: 30 days)
+  onInvalidSignature: (email, reason) => {
+    console.warn(`Invalid signature from ${email.from}: ${reason}`);
+  }
+});
+```
+
+Sign outbound emails to enable secure reply routing:
+
+```typescript
+await this.replyToEmail(email, {
+  fromName: "My Agent",
+  body: "Thanks!",
+  secret: this.env.EMAIL_SECRET  // Signs headers for secure reply routing
+});
+```
+
+### Catch-All (Single Instance)
+
+Routes all emails to one agent instance:
+
+```typescript
+import { createCatchAllEmailResolver } from "agents/email";
+
+const resolver = createCatchAllEmailResolver("EmailAgent", "default");
+```
+
+### Combining Resolvers
+
+```typescript
+async email(message, env) {
+  const secureReply = createSecureReplyEmailResolver(env.EMAIL_SECRET);
+  const addressBased = createAddressBasedEmailResolver("EmailAgent");
+
+  await routeAgentEmail(message, env, {
+    resolver: async (email, env) => {
+      // Try secure reply first
+      const result = await secureReply(email, env);
+      if (result) return result;
+      // Fall back to address-based
+      return addressBased(email, env);
+    }
+  });
+}
+```
+
+## Utilities
+
+```typescript
+import { isAutoReplyEmail } from "agents/email";
+
+async onEmail(email: AgentEmail) {
+  if (isAutoReplyEmail(email.headers)) {
+    // Skip auto-replies (vacation, out-of-office, etc.)
+    return;
+  }
+  // Process email...
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/mcp.md

@@ -0,0 +1,154 @@
+# MCP Server Integration
+
+Fetch `docs/mcp-client.md` and `docs/mcp-servers.md` from `https://github.com/cloudflare/agents/tree/main/docs` for complete documentation.
+
+Agents include a multi-server MCP client for connecting to external MCP servers.
+
+## Add an MCP Server
+
+```typescript
+import { Agent, callable } from "agents";
+
+export class MyAgent extends Agent<Env, State> {
+  @callable()
+  async addServer(name: string, url: string) {
+    // Options-based API (recommended)
+    const result = await this.addMcpServer(name, url, {
+      callbackHost: "https://my-worker.workers.dev",
+      transport: { headers: { Authorization: "Bearer ..." } }
+    });
+
+    if (result.state === "authenticating") {
+      // OAuth required - redirect user to result.authUrl
+      return { needsAuth: true, authUrl: result.authUrl };
+    }
+
+    return { ready: true, id: result.id };
+  }
+}
+```
+
+## Use MCP Tools
+
+```typescript
+async onChatMessage() {
+  // Get AI-compatible tools from all connected MCP servers
+  const mcpTools = this.mcp.getAITools();
+
+  const allTools = {
+    ...localTools,
+    ...mcpTools
+  };
+
+  const result = streamText({
+    model: openai("gpt-4o"),
+    messages: await convertToModelMessages(this.messages),
+    tools: allTools
+  });
+
+  return result.toUIMessageStreamResponse();
+}
+```
+
+## List MCP Resources
+
+```typescript
+// List all registered servers
+const servers = this.mcp.listServers();
+
+// List tools from all servers
+const tools = this.mcp.listTools();
+
+// List resources
+const resources = this.mcp.listResources();
+
+// List prompts
+const prompts = this.mcp.listPrompts();
+```
+
+## Remove Server
+
+```typescript
+await this.removeMcpServer(serverId);
+```
+
+## Building an MCP Server
+
+Use `McpAgent` from the SDK to create an MCP server.
+
+**Install dependencies:**
+```bash
+npm install @modelcontextprotocol/sdk zod
+```
+
+**Wrangler config:**
+```jsonc
+{
+  "durable_objects": {
+    "bindings": [{ "name": "MyMCP", "class_name": "MyMCP" }]
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["MyMCP"] }]
+}
+```
+
+**Server implementation:**
+```typescript
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpAgent } from "agents/mcp";
+import { z } from "zod";
+
+type State = { counter: number };
+
+export class MyMCP extends McpAgent<Env, State, {}> {
+  server = new McpServer({
+    name: "MyMCPServer",
+    version: "1.0.0"
+  });
+
+  initialState = { counter: 0 };
+
+  async init() {
+    // Register a resource
+    this.server.resource("counter", "mcp://resource/counter", (uri) => ({
+      contents: [{ text: String(this.state.counter), uri: uri.href }]
+    }));
+
+    // Register a tool
+    this.server.registerTool(
+      "increment",
+      {
+        description: "Increment the counter",
+        inputSchema: { amount: z.number().default(1) }
+      },
+      async ({ amount }) => {
+        this.setState({ counter: this.state.counter + amount });
+        return {
+          content: [{ text: `Counter: ${this.state.counter}`, type: "text" }]
+        };
+      }
+    );
+  }
+}
+```
+
+## Serve MCP Server
+
+```typescript
+export default {
+  fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    const url = new URL(request.url);
+
+    // SSE transport (legacy)
+    if (url.pathname.startsWith("/sse")) {
+      return MyMCP.serveSSE("/sse", { binding: "MyMCP" }).fetch(request, env, ctx);
+    }
+
+    // Streamable HTTP transport (recommended)
+    if (url.pathname.startsWith("/mcp")) {
+      return MyMCP.serve("/mcp", { binding: "MyMCP" }).fetch(request, env, ctx);
+    }
+
+    return new Response("Not found", { status: 404 });
+  }
+};
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/state-scheduling.md

@@ -0,0 +1,164 @@
+# State & Scheduling
+
+Fetch `docs/state.md` and `docs/scheduling.md` from `https://github.com/cloudflare/agents/tree/main/docs` for complete documentation.
+
+## State Management
+
+State persists to SQLite and broadcasts to connected clients automatically.
+
+### Define Typed State
+
+```typescript
+type State = {
+  count: number;
+  items: string[];
+};
+
+export class MyAgent extends Agent<Env, State> {
+  initialState: State = { count: 0, items: [] };
+}
+```
+
+### Read and Update
+
+```typescript
+// Read (lazy-loaded from SQLite)
+const count = this.state.count;
+
+// Write (sync, persists, broadcasts)
+this.setState({ count: this.state.count + 1 });
+```
+
+### Validation Hook
+
+`validateStateChange()` runs synchronously before state persists. Throw to reject the update.
+
+```typescript
+validateStateChange(nextState: State, source: Connection | "server") {
+  if (nextState.count < 0) {
+    throw new Error("Count cannot be negative");
+  }
+}
+```
+
+### Execution Order
+
+1. `validateStateChange(nextState, source)` - sync, gating
+2. State persisted to SQLite
+3. State broadcast to connected clients
+4. `onStateUpdate(nextState, source)` - async via `ctx.waitUntil`, non-gating
+
+### Client-Side Sync (React)
+
+```tsx
+import { useAgent } from "agents/react";
+
+function App() {
+  const [state, setLocalState] = useState<State>({ count: 0 });
+
+  const agent = useAgent<State>({
+    agent: "MyAgent",
+    name: "instance-1",
+    onStateUpdate: (newState) => setLocalState(newState)
+  });
+
+  return <button onClick={() => agent.setState({ count: state.count + 1 })}>
+    Count: {state.count}
+  </button>;
+}
+```
+
+## SQL API
+
+Direct SQLite access for custom queries:
+
+```typescript
+// Create table
+this.sql`
+  CREATE TABLE IF NOT EXISTS items (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    created_at INTEGER DEFAULT (unixepoch())
+  )
+`;
+
+// Insert
+this.sql`INSERT INTO items (id, name) VALUES (${id}, ${name})`;
+
+// Query with types
+const items = this.sql<{ id: string; name: string }>`
+  SELECT * FROM items WHERE name LIKE ${`%${search}%`}
+`;
+```
+
+## Scheduling
+
+### Schedule Types
+
+| Mode | Syntax | Use Case |
+|------|--------|----------|
+| Delay | `this.schedule(60, ...)` | Run in 60 seconds |
+| Date | `this.schedule(new Date(...), ...)` | Run at specific time |
+| Cron | `this.schedule("0 8 * * *", ...)` | Recurring schedule |
+| Interval | `this.scheduleEvery(30, ...)` | Fixed interval (every 30s) |
+
+### Examples
+
+```typescript
+// Delay (seconds)
+await this.schedule(60, "checkStatus", { id: "abc123" });
+
+// Specific date
+await this.schedule(new Date("2025-12-25T00:00:00Z"), "sendGreeting", { to: "user" });
+
+// Cron (recurring)
+await this.schedule("0 9 * * 1-5", "weekdayReport", {});
+
+// Fixed interval (every 30 seconds, overlap prevention built-in)
+await this.scheduleEvery(30, "pollUpdates");
+await this.scheduleEvery(300, "syncData", { source: "api" });
+```
+
+### Handler
+
+```typescript
+async sendGreeting(payload: { to: string }, schedule: Schedule) {
+  console.log(`Sending greeting to ${payload.to}`);
+  // Cron schedules auto-reschedule; one-time schedules are deleted
+}
+```
+
+### Manage Schedules
+
+```typescript
+const schedules = this.getSchedules();
+const crons = this.getSchedules({ type: "cron" });
+await this.cancelSchedule(schedule.id);
+```
+
+## Lifecycle Callbacks
+
+```typescript
+export class MyAgent extends Agent<Env, State> {
+  async onStart() {
+    // Agent started or woke from hibernation
+  }
+
+  onConnect(conn: Connection, ctx: ConnectionContext) {
+    // WebSocket connected
+  }
+
+  onMessage(conn: Connection, message: WSMessage) {
+    // WebSocket message (non-RPC)
+  }
+
+  onStateUpdate(state: State, source: Connection | "server") {
+    // State changed (async, non-blocking)
+  }
+
+  onError(error: unknown) {
+    // Error handler
+    throw error; // Re-throw to propagate
+  }
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/streaming-chat.md

@@ -0,0 +1,178 @@
+# Streaming Chat with AIChatAgent
+
+Fetch `docs/resumable-streaming.md` and `docs/client-sdk.md` from `https://github.com/cloudflare/agents/tree/main/docs` for complete documentation.
+
+`AIChatAgent` provides streaming chat with automatic message persistence and resumable streams.
+
+## Basic Chat Agent
+
+```typescript
+import { AIChatAgent } from "@cloudflare/ai-chat";
+import { streamText, convertToModelMessages } from "ai";
+import { openai } from "@ai-sdk/openai";
+
+export class Chat extends AIChatAgent<Env> {
+  async onChatMessage(onFinish) {
+    const result = streamText({
+      model: openai("gpt-4o"),
+      messages: await convertToModelMessages(this.messages),
+      onFinish
+    });
+    return result.toUIMessageStreamResponse();
+  }
+}
+```
+
+## With Custom System Prompt
+
+```typescript
+export class Chat extends AIChatAgent<Env> {
+  async onChatMessage(onFinish) {
+    const result = streamText({
+      model: openai("gpt-4o"),
+      system: "You are a helpful assistant specializing in...",
+      messages: await convertToModelMessages(this.messages),
+      onFinish
+    });
+    return result.toUIMessageStreamResponse();
+  }
+}
+```
+
+## With Tools
+
+```typescript
+import { tool } from "ai";
+import { z } from "zod";
+
+const tools = {
+  getWeather: tool({
+    description: "Get weather for a location",
+    parameters: z.object({ location: z.string() }),
+    execute: async ({ location }) => `Weather in ${location}: 72°F, sunny`
+  })
+};
+
+export class Chat extends AIChatAgent<Env> {
+  async onChatMessage(onFinish) {
+    const result = streamText({
+      model: openai("gpt-4o"),
+      messages: await convertToModelMessages(this.messages),
+      tools,
+      onFinish
+    });
+    return result.toUIMessageStreamResponse();
+  }
+}
+```
+
+## Custom UI Message Stream
+
+For more control, use `createUIMessageStream`:
+
+```typescript
+import { createUIMessageStream, createUIMessageStreamResponse } from "ai";
+
+export class Chat extends AIChatAgent<Env> {
+  async onChatMessage(onFinish) {
+    const stream = createUIMessageStream({
+      execute: async ({ writer }) => {
+        const result = streamText({
+          model: openai("gpt-4o"),
+          messages: await convertToModelMessages(this.messages),
+          onFinish
+        });
+        writer.merge(result.toUIMessageStream());
+      }
+    });
+    return createUIMessageStreamResponse({ stream });
+  }
+}
+```
+
+## Resumable Streaming
+
+Streams automatically resume if client disconnects and reconnects:
+
+1. Chunks buffered to SQLite during streaming
+2. On reconnect, buffered chunks sent immediately
+3. Live streaming continues from where it left off
+
+**Enabled by default.** To disable:
+
+```tsx
+const { messages } = useAgentChat({ agent, resume: false });
+```
+
+## React Client
+
+```tsx
+import { useAgent } from "agents/react";
+import { useAgentChat } from "@cloudflare/ai-chat/react";
+
+function ChatUI() {
+  const agent = useAgent({
+    agent: "Chat",
+    name: "my-chat-session"
+  });
+
+  const {
+    messages,
+    input,
+    handleInputChange,
+    handleSubmit,
+    status
+  } = useAgentChat({ agent });
+
+  return (
+    <div>
+      {messages.map((m) => (
+        <div key={m.id}>
+          <strong>{m.role}:</strong> {m.content}
+        </div>
+      ))}
+
+      <form onSubmit={handleSubmit}>
+        <input
+          value={input}
+          onChange={handleInputChange}
+          disabled={status === "streaming"}
+        />
+        <button type="submit">Send</button>
+      </form>
+    </div>
+  );
+}
+```
+
+## Streaming RPC Methods
+
+For non-chat streaming, use `@callable({ streaming: true })`:
+
+```typescript
+import { Agent, callable, StreamingResponse } from "agents";
+
+export class MyAgent extends Agent<Env> {
+  @callable({ streaming: true })
+  async streamData(stream: StreamingResponse, query: string) {
+    for (let i = 0; i < 10; i++) {
+      stream.send(`Result ${i}: ${query}`);
+      await sleep(100);
+    }
+    stream.close();
+  }
+}
+```
+
+Client receives streamed messages via WebSocket RPC.
+
+## Status Values
+
+`useAgentChat` status:
+
+| Status | Meaning |
+|--------|---------|
+| `ready` | Idle, ready for input |
+| `streaming` | Response streaming |
+| `submitted` | Request sent, waiting |
+| `error` | Error occurred |

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/agents-sdk/references/workflows.md

@@ -0,0 +1,132 @@
+# Workflows Integration
+
+Fetch `docs/workflows.md` from `https://github.com/cloudflare/agents/tree/main/docs` for complete documentation.
+
+## Overview
+
+Agents handle real-time communication; Workflows handle durable execution. Together they enable:
+
+- Long-running background tasks with automatic retries
+- Human-in-the-loop approval flows
+- Multi-step pipelines that survive failures
+
+| Use Case | Recommendation |
+|----------|----------------|
+| Chat/messaging | Agent only |
+| Quick API calls (<30s) | Agent only |
+| Background processing (<30s) | Agent `queue()` |
+| Long-running tasks (>30s) | Agent + Workflow |
+| Human approval flows | Agent + Workflow |
+
+## AgentWorkflow Base Class
+
+```typescript
+import { AgentWorkflow } from "agents/workflows";
+import type { AgentWorkflowEvent, AgentWorkflowStep } from "agents/workflows";
+
+type TaskParams = { taskId: string; data: string };
+
+export class ProcessingWorkflow extends AgentWorkflow<MyAgent, TaskParams> {
+  async run(event: AgentWorkflowEvent<TaskParams>, step: AgentWorkflowStep) {
+    const params = event.payload;
+
+    // Durable step - retries on failure
+    const result = await step.do("process", async () => {
+      return processData(params.data);
+    });
+
+    // Non-durable: progress reporting
+    await this.reportProgress({ step: "process", percent: 0.5 });
+
+    // Non-durable: broadcast to connected clients
+    this.broadcastToClients({ type: "update", taskId: params.taskId });
+
+    // Durable: merge state via step
+    await step.mergeAgentState({ lastProcessed: params.taskId });
+
+    // Durable: report completion
+    await step.reportComplete(result);
+
+    return result;
+  }
+}
+```
+
+## Wrangler Configuration
+
+```jsonc
+{
+  "workflows": [
+    { "name": "processing-workflow", "binding": "PROCESSING_WORKFLOW", "class_name": "ProcessingWorkflow" }
+  ],
+  "durable_objects": {
+    "bindings": [{ "name": "MyAgent", "class_name": "MyAgent" }]
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["MyAgent"] }]
+}
+```
+
+## Agent Methods for Workflows
+
+```typescript
+// Start a workflow
+const instance = await this.runWorkflow("ProcessingWorkflow", { taskId: "123", data: "..." });
+
+// Send event to waiting workflow
+await this.sendWorkflowEvent("ProcessingWorkflow", workflowId, { type: "approve" });
+
+// Query workflows
+const workflow = await this.getWorkflow(workflowId);
+const workflows = await this.getWorkflows({ status: "running" });
+
+// Control workflows
+await this.approveWorkflow(workflowId);
+await this.rejectWorkflow(workflowId);
+await this.terminateWorkflow(workflowId);
+await this.pauseWorkflow(workflowId);
+await this.resumeWorkflow(workflowId);
+
+// Delete workflows
+await this.deleteWorkflow(workflowId);
+await this.deleteWorkflows({ status: "complete", before: new Date(...) });
+```
+
+## Lifecycle Callbacks
+
+```typescript
+export class MyAgent extends Agent<Env, State> {
+  async onWorkflowProgress(workflowName: string, workflowId: string, progress: unknown) {
+    // Workflow reported progress via this.reportProgress()
+    this.broadcast({ type: "progress", workflowId, progress });
+  }
+
+  async onWorkflowComplete(workflowName: string, workflowId: string, result?: unknown) {
+    // Workflow finished successfully
+  }
+
+  async onWorkflowError(workflowName: string, workflowId: string, error: Error) {
+    // Workflow failed
+  }
+
+  async onWorkflowEvent(workflowName: string, workflowId: string, event: unknown) {
+    // Workflow received an event via sendWorkflowEvent()
+  }
+}
+```
+
+## Human-in-the-Loop
+
+```typescript
+// In workflow: wait for approval
+const approved = await step.waitForEvent<{ approved: boolean }>("approval", {
+  timeout: "7d"
+});
+
+if (!approved.approved) {
+  throw new Error("Rejected");
+}
+
+// From agent: approve or reject
+await this.approveWorkflow(workflowId);  // Sends { approved: true }
+await this.rejectWorkflow(workflowId);   // Sends { approved: false }
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-ai-agent-on-cloudflare/SKILL.md

@@ -0,0 +1,400 @@
+---
+name: building-ai-agent-on-cloudflare
+description: |
+  Builds AI agents on Cloudflare using the Agents SDK with state management,
+  real-time WebSockets, scheduled tasks, tool integration, and chat capabilities.
+  Generates production-ready agent code deployed to Workers.
+
+  Use when: user wants to "build an agent", "AI agent", "chat agent", "stateful
+  agent", mentions "Agents SDK", needs "real-time AI", "WebSocket AI", or asks
+  about agent "state management", "scheduled tasks", or "tool calling".
+  Biases towards retrieval from Cloudflare docs over pre-trained knowledge.
+---
+
+# Building Cloudflare Agents
+
+Your knowledge of the Agents SDK may be outdated. **Prefer retrieval over pre-training** for any agent-building task.
+
+## Retrieval Sources
+
+| Source | How to retrieve | Use for |
+|--------|----------------|---------|
+| Agents SDK docs | `https://github.com/cloudflare/agents/tree/main/docs` | SDK API, state, routing, scheduling |
+| Cloudflare Agents docs | `https://developers.cloudflare.com/agents/` | Platform integration, deployment |
+| Workers docs | Search tool or `https://developers.cloudflare.com/workers/` | Runtime APIs, bindings, config |
+
+## When to Use
+
+- User wants to build an AI agent or chatbot
+- User needs stateful, real-time AI interactions
+- User asks about the Cloudflare Agents SDK
+- User wants scheduled tasks or background AI work
+- User needs WebSocket-based AI communication
+
+## Prerequisites
+
+- Cloudflare account with Workers enabled
+- Node.js 18+ and npm/pnpm/yarn
+- Wrangler CLI (`npm install -g wrangler`)
+
+## Quick Start
+
+```bash
+npm create cloudflare@latest -- my-agent --template=cloudflare/agents-starter
+cd my-agent
+npm start
+```
+
+Agent runs at `http://localhost:8787`
+
+## Core Concepts
+
+### What is an Agent?
+
+An Agent is a stateful, persistent AI service that:
+- Maintains state across requests and reconnections
+- Communicates via WebSockets or HTTP
+- Runs on Cloudflare's edge via Durable Objects
+- Can schedule tasks and call tools
+- Scales horizontally (each user/session gets own instance)
+
+### Agent Lifecycle
+
+```
+Client connects → Agent.onConnect() → Agent processes messages
+                                    → Agent.onMessage()
+                                    → Agent.setState() (persists + syncs)
+Client disconnects → State persists → Client reconnects → State restored
+```
+
+## Basic Agent Structure
+
+```typescript
+import { Agent, Connection } from "agents";
+
+interface Env {
+  AI: Ai;  // Workers AI binding
+}
+
+interface State {
+  messages: Array<{ role: string; content: string }>;
+  preferences: Record<string, string>;
+}
+
+export class MyAgent extends Agent<Env, State> {
+  // Initial state for new instances
+  initialState: State = {
+    messages: [],
+    preferences: {},
+  };
+
+  // Called when agent starts or resumes
+  async onStart() {
+    console.log("Agent started with state:", this.state);
+  }
+
+  // Handle WebSocket connections
+  async onConnect(connection: Connection) {
+    connection.send(JSON.stringify({
+      type: "welcome",
+      history: this.state.messages,
+    }));
+  }
+
+  // Handle incoming messages
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "chat") {
+      await this.handleChat(connection, data.content);
+    }
+  }
+
+  // Handle disconnections
+  async onClose(connection: Connection) {
+    console.log("Client disconnected");
+  }
+
+  // React to state changes
+  onStateUpdate(state: State, source: string) {
+    console.log("State updated by:", source);
+  }
+
+  private async handleChat(connection: Connection, userMessage: string) {
+    // Add user message to history
+    const messages = [
+      ...this.state.messages,
+      { role: "user", content: userMessage },
+    ];
+
+    // Call AI
+    const response = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+      messages,
+    });
+
+    // Update state (persists and syncs to all clients)
+    this.setState({
+      ...this.state,
+      messages: [
+        ...messages,
+        { role: "assistant", content: response.response },
+      ],
+    });
+
+    // Send response
+    connection.send(JSON.stringify({
+      type: "response",
+      content: response.response,
+    }));
+  }
+}
+```
+
+## Entry Point Configuration
+
+```typescript
+// src/index.ts
+import { routeAgentRequest } from "agents";
+import { MyAgent } from "./agent";
+
+export default {
+  async fetch(request: Request, env: Env) {
+    // routeAgentRequest handles routing to /agents/:class/:name
+    return (
+      (await routeAgentRequest(request, env)) ||
+      new Response("Not found", { status: 404 })
+    );
+  },
+};
+
+export { MyAgent };
+```
+
+Clients connect via: `wss://my-agent.workers.dev/agents/MyAgent/session-id`
+
+## Wrangler Configuration
+
+```toml
+name = "my-agent"
+main = "src/index.ts"
+compatibility_date = "2024-12-01"
+
+[ai]
+binding = "AI"
+
+[durable_objects]
+bindings = [{ name = "AGENT", class_name = "MyAgent" }]
+
+[[migrations]]
+tag = "v1"
+new_classes = ["MyAgent"]
+```
+
+## State Management
+
+### Reading State
+
+```typescript
+// Current state is always available
+const currentMessages = this.state.messages;
+const userPrefs = this.state.preferences;
+```
+
+### Updating State
+
+```typescript
+// setState persists AND syncs to all connected clients
+this.setState({
+  ...this.state,
+  messages: [...this.state.messages, newMessage],
+});
+
+// Partial updates work too
+this.setState({
+  preferences: { ...this.state.preferences, theme: "dark" },
+});
+```
+
+### SQL Storage
+
+For complex queries, use the embedded SQLite database:
+
+```typescript
+// Create tables
+await this.sql`
+  CREATE TABLE IF NOT EXISTS documents (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    content TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`;
+
+// Insert
+await this.sql`
+  INSERT INTO documents (title, content)
+  VALUES (${title}, ${content})
+`;
+
+// Query
+const docs = await this.sql`
+  SELECT * FROM documents WHERE title LIKE ${`%${search}%`}
+`;
+```
+
+## Scheduled Tasks
+
+Agents can schedule future work:
+
+```typescript
+async onMessage(connection: Connection, message: string) {
+  const data = JSON.parse(message);
+
+  if (data.type === "schedule_reminder") {
+    // Schedule task for 1 hour from now
+    const { id } = await this.schedule(3600, "sendReminder", {
+      message: data.reminderText,
+      userId: data.userId,
+    });
+
+    connection.send(JSON.stringify({ type: "scheduled", taskId: id }));
+  }
+}
+
+// Called when scheduled task fires
+async sendReminder(data: { message: string; userId: string }) {
+  // Send notification, email, etc.
+  console.log(`Reminder for ${data.userId}: ${data.message}`);
+
+  // Can also update state
+  this.setState({
+    ...this.state,
+    lastReminder: new Date().toISOString(),
+  });
+}
+```
+
+### Schedule Options
+
+```typescript
+// Delay in seconds
+await this.schedule(60, "taskMethod", { data });
+
+// Specific date
+await this.schedule(new Date("2025-01-01T00:00:00Z"), "taskMethod", { data });
+
+// Cron expression (recurring)
+await this.schedule("0 9 * * *", "dailyTask", {});  // 9 AM daily
+await this.schedule("*/5 * * * *", "everyFiveMinutes", {});  // Every 5 min
+
+// Manage schedules
+const schedules = await this.getSchedules();
+await this.cancelSchedule(taskId);
+```
+
+## Chat Agent (AI-Powered)
+
+For chat-focused agents, extend `AIChatAgent`:
+
+```typescript
+import { AIChatAgent } from "agents/ai-chat-agent";
+
+export class ChatBot extends AIChatAgent<Env> {
+  // Called for each user message
+  async onChatMessage(message: string) {
+    const response = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+      messages: [
+        { role: "system", content: "You are a helpful assistant." },
+        ...this.messages,  // Automatic history management
+        { role: "user", content: message },
+      ],
+      stream: true,
+    });
+
+    // Stream response back to client
+    return response;
+  }
+}
+```
+
+Features included:
+- Automatic message history
+- Resumable streaming (survives disconnects)
+- Built-in `saveMessages()` for persistence
+
+## Client Integration
+
+### React Hook
+
+```tsx
+import { useAgent } from "agents/react";
+
+function Chat() {
+  const { state, send, connected } = useAgent({
+    agent: "my-agent",
+    name: userId,  // Agent instance ID
+  });
+
+  const sendMessage = (text: string) => {
+    send(JSON.stringify({ type: "chat", content: text }));
+  };
+
+  return (
+    <div>
+      {state.messages.map((msg, i) => (
+        <div key={i}>{msg.role}: {msg.content}</div>
+      ))}
+      <input onKeyDown={(e) => e.key === "Enter" && sendMessage(e.target.value)} />
+    </div>
+  );
+}
+```
+
+### Vanilla JavaScript
+
+```javascript
+const ws = new WebSocket("wss://my-agent.workers.dev/agents/MyAgent/user123");
+
+ws.onopen = () => {
+  console.log("Connected to agent");
+};
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  console.log("Received:", data);
+};
+
+ws.send(JSON.stringify({ type: "chat", content: "Hello!" }));
+```
+
+## Common Patterns
+
+See [references/agent-patterns.md](references/agent-patterns.md) for:
+- Tool calling and function execution
+- Multi-agent orchestration
+- RAG (Retrieval Augmented Generation)
+- Human-in-the-loop workflows
+
+## Deployment
+
+```bash
+# Deploy
+npx wrangler deploy
+
+# View logs
+wrangler tail
+
+# Test endpoint
+curl https://my-agent.workers.dev/agents/MyAgent/test-user
+```
+
+## Troubleshooting
+
+See [references/troubleshooting.md](references/troubleshooting.md) for common issues.
+
+## References
+
+- [references/examples.md](references/examples.md) — Official templates and production examples
+- [references/agent-patterns.md](references/agent-patterns.md) — Advanced patterns
+- [references/state-patterns.md](references/state-patterns.md) — State management strategies
+- [references/troubleshooting.md](references/troubleshooting.md) — Error solutions

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-ai-agent-on-cloudflare/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Building AI Agents on Cloudflare"
+  short_description: "Build stateful AI agents on Cloudflare Workers"

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-ai-agent-on-cloudflare/references/agent-patterns.md

@@ -0,0 +1,461 @@
+# Agent Patterns
+
+Advanced patterns for building sophisticated agents.
+
+## Tool Calling
+
+Agents can expose tools that AI models can call:
+
+```typescript
+import { Agent, Connection } from "agents";
+import { z } from "zod";
+
+interface Tool {
+  name: string;
+  description: string;
+  parameters: z.ZodSchema;
+  handler: (params: any) => Promise<string>;
+}
+
+export class ToolAgent extends Agent<Env, State> {
+  private tools: Map<string, Tool> = new Map();
+
+  async onStart() {
+    // Register tools
+    this.registerTool({
+      name: "get_weather",
+      description: "Get current weather for a city",
+      parameters: z.object({ city: z.string() }),
+      handler: async ({ city }) => {
+        const res = await fetch(`https://api.weather.com/${city}`);
+        return JSON.stringify(await res.json());
+      },
+    });
+
+    this.registerTool({
+      name: "search_database",
+      description: "Search the document database",
+      parameters: z.object({ query: z.string(), limit: z.number().default(10) }),
+      handler: async ({ query, limit }) => {
+        const results = await this.sql`
+          SELECT * FROM documents
+          WHERE content LIKE ${`%${query}%`}
+          LIMIT ${limit}
+        `;
+        return JSON.stringify(results);
+      },
+    });
+  }
+
+  private registerTool(tool: Tool) {
+    this.tools.set(tool.name, tool);
+  }
+
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "chat") {
+      await this.handleChatWithTools(connection, data.content);
+    }
+  }
+
+  private async handleChatWithTools(connection: Connection, userMessage: string) {
+    // Build tool descriptions for the AI
+    const toolDescriptions = Array.from(this.tools.values()).map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: JSON.parse(JSON.stringify(t.parameters)),
+      },
+    }));
+
+    // First AI call - may request tool use
+    const response = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+      messages: [
+        { role: "system", content: "You are a helpful assistant with access to tools." },
+        ...this.state.messages,
+        { role: "user", content: userMessage },
+      ],
+      tools: toolDescriptions,
+    });
+
+    // Check if AI wants to use a tool
+    if (response.tool_calls) {
+      for (const toolCall of response.tool_calls) {
+        const tool = this.tools.get(toolCall.function.name);
+        if (tool) {
+          const params = JSON.parse(toolCall.function.arguments);
+          const result = await tool.handler(params);
+
+          // Send tool result back to AI
+          const finalResponse = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+            messages: [
+              ...this.state.messages,
+              { role: "user", content: userMessage },
+              { role: "assistant", tool_calls: response.tool_calls },
+              { role: "tool", tool_call_id: toolCall.id, content: result },
+            ],
+          });
+
+          connection.send(JSON.stringify({
+            type: "response",
+            content: finalResponse.response,
+            toolUsed: toolCall.function.name,
+          }));
+        }
+      }
+    } else {
+      connection.send(JSON.stringify({
+        type: "response",
+        content: response.response,
+      }));
+    }
+  }
+}
+```
+
+## RAG (Retrieval Augmented Generation)
+
+Combine Vectorize with Agents for knowledge-grounded responses:
+
+```typescript
+interface Env {
+  AI: Ai;
+  VECTORIZE: VectorizeIndex;
+}
+
+export class RAGAgent extends Agent<Env, State> {
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "chat") {
+      // 1. Generate embedding for query
+      const embedding = await this.env.AI.run("@cf/baai/bge-base-en-v1.5", {
+        text: data.content,
+      });
+
+      // 2. Search vector database
+      const results = await this.env.VECTORIZE.query(embedding.data[0], {
+        topK: 5,
+        returnMetadata: true,
+      });
+
+      // 3. Build context from results
+      const context = results.matches
+        .map((m) => m.metadata?.text || "")
+        .join("\n\n");
+
+      // 4. Generate response with context
+      const response = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+        messages: [
+          {
+            role: "system",
+            content: `Answer based on this context:\n\n${context}\n\nIf the context doesn't contain relevant information, say so.`,
+          },
+          { role: "user", content: data.content },
+        ],
+      });
+
+      // 5. Update state and respond
+      this.setState({
+        messages: [
+          ...this.state.messages,
+          { role: "user", content: data.content },
+          { role: "assistant", content: response.response },
+        ],
+      });
+
+      connection.send(JSON.stringify({
+        type: "response",
+        content: response.response,
+        sources: results.matches.map((m) => m.metadata?.source),
+      }));
+    }
+  }
+
+  // Ingest documents into vector store
+  async ingestDocument(doc: { id: string; text: string; source: string }) {
+    const embedding = await this.env.AI.run("@cf/baai/bge-base-en-v1.5", {
+      text: doc.text,
+    });
+
+    await this.env.VECTORIZE.upsert([{
+      id: doc.id,
+      values: embedding.data[0],
+      metadata: { text: doc.text, source: doc.source },
+    }]);
+  }
+}
+```
+
+## Multi-Agent Orchestration
+
+Coordinate multiple specialized agents:
+
+```typescript
+interface Env {
+  RESEARCHER: DurableObjectNamespace;
+  WRITER: DurableObjectNamespace;
+  REVIEWER: DurableObjectNamespace;
+}
+
+export class OrchestratorAgent extends Agent<Env, State> {
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "create_article") {
+      connection.send(JSON.stringify({ type: "status", step: "researching" }));
+
+      // Step 1: Research agent gathers information
+      const researchResult = await this.callAgent(
+        this.env.RESEARCHER,
+        data.topic,
+        { action: "research", topic: data.topic }
+      );
+
+      connection.send(JSON.stringify({ type: "status", step: "writing" }));
+
+      // Step 2: Writer agent creates draft
+      const draftResult = await this.callAgent(
+        this.env.WRITER,
+        data.topic,
+        { action: "write", research: researchResult, topic: data.topic }
+      );
+
+      connection.send(JSON.stringify({ type: "status", step: "reviewing" }));
+
+      // Step 3: Reviewer agent improves draft
+      const finalResult = await this.callAgent(
+        this.env.REVIEWER,
+        data.topic,
+        { action: "review", draft: draftResult }
+      );
+
+      connection.send(JSON.stringify({
+        type: "complete",
+        article: finalResult,
+      }));
+    }
+  }
+
+  private async callAgent(
+    namespace: DurableObjectNamespace,
+    id: string,
+    payload: any
+  ): Promise<string> {
+    const agentId = namespace.idFromName(id);
+    const agent = namespace.get(agentId);
+
+    const response = await agent.fetch("http://agent/task", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    });
+
+    return response.text();
+  }
+}
+```
+
+## Human-in-the-Loop
+
+Pause agent execution for human approval:
+
+```typescript
+interface State {
+  pendingApprovals: Array<{
+    id: string;
+    action: string;
+    data: any;
+    requestedAt: string;
+  }>;
+}
+
+export class ApprovalAgent extends Agent<Env, State> {
+  initialState: State = { pendingApprovals: [] };
+
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "request_action") {
+      // Action requires approval
+      if (this.requiresApproval(data.action)) {
+        const approvalId = crypto.randomUUID();
+
+        this.setState({
+          pendingApprovals: [
+            ...this.state.pendingApprovals,
+            {
+              id: approvalId,
+              action: data.action,
+              data: data.payload,
+              requestedAt: new Date().toISOString(),
+            },
+          ],
+        });
+
+        connection.send(JSON.stringify({
+          type: "approval_required",
+          approvalId,
+          action: data.action,
+          description: this.describeAction(data.action, data.payload),
+        }));
+
+        return;
+      }
+
+      // Execute immediately if no approval needed
+      await this.executeAction(connection, data.action, data.payload);
+    }
+
+    if (data.type === "approve") {
+      const approval = this.state.pendingApprovals.find(
+        (a) => a.id === data.approvalId
+      );
+
+      if (approval) {
+        // Remove from pending
+        this.setState({
+          pendingApprovals: this.state.pendingApprovals.filter(
+            (a) => a.id !== data.approvalId
+          ),
+        });
+
+        // Execute the approved action
+        await this.executeAction(connection, approval.action, approval.data);
+      }
+    }
+
+    if (data.type === "reject") {
+      this.setState({
+        pendingApprovals: this.state.pendingApprovals.filter(
+          (a) => a.id !== data.approvalId
+        ),
+      });
+
+      connection.send(JSON.stringify({
+        type: "action_rejected",
+        approvalId: data.approvalId,
+      }));
+    }
+  }
+
+  private requiresApproval(action: string): boolean {
+    const sensitiveActions = ["delete", "send_email", "make_payment", "publish"];
+    return sensitiveActions.includes(action);
+  }
+
+  private describeAction(action: string, data: any): string {
+    // Generate human-readable description
+    return `${action}: ${JSON.stringify(data)}`;
+  }
+
+  private async executeAction(connection: Connection, action: string, data: any) {
+    // Execute the action
+    const result = await this.performAction(action, data);
+
+    connection.send(JSON.stringify({
+      type: "action_completed",
+      action,
+      result,
+    }));
+  }
+}
+```
+
+## Streaming Responses
+
+Stream AI responses in real-time:
+
+```typescript
+export class StreamingAgent extends Agent<Env, State> {
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "chat") {
+      // Start streaming response
+      const stream = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+        messages: [
+          { role: "system", content: "You are a helpful assistant." },
+          ...this.state.messages,
+          { role: "user", content: data.content },
+        ],
+        stream: true,
+      });
+
+      let fullResponse = "";
+
+      // Stream chunks to client
+      for await (const chunk of stream) {
+        if (chunk.response) {
+          fullResponse += chunk.response;
+          connection.send(JSON.stringify({
+            type: "stream",
+            content: chunk.response,
+            done: false,
+          }));
+        }
+      }
+
+      // Update state with complete response
+      this.setState({
+        messages: [
+          ...this.state.messages,
+          { role: "user", content: data.content },
+          { role: "assistant", content: fullResponse },
+        ],
+      });
+
+      // Signal completion
+      connection.send(JSON.stringify({
+        type: "stream",
+        content: "",
+        done: true,
+      }));
+    }
+  }
+}
+```
+
+## Connecting to MCP Servers
+
+Agents can connect to MCP servers as clients:
+
+```typescript
+export class MCPClientAgent extends Agent<Env, State> {
+  async onStart() {
+    // Connect to external MCP server
+    await this.addMcpServer(
+      "github",
+      "https://github-mcp.example.com/sse",
+      { headers: { Authorization: `Bearer ${this.env.GITHUB_TOKEN}` } }
+    );
+
+    await this.addMcpServer(
+      "database",
+      "https://db-mcp.example.com/sse"
+    );
+  }
+
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "use_tool") {
+      // Call tool on connected MCP server
+      const servers = await this.getMcpServers();
+      const server = servers.find((s) => s.name === data.server);
+
+      if (server) {
+        const result = await server.callTool(data.tool, data.params);
+        connection.send(JSON.stringify({ type: "tool_result", result }));
+      }
+    }
+  }
+
+  async onClose() {
+    // Cleanup MCP connections
+    await this.removeMcpServer("github");
+    await this.removeMcpServer("database");
+  }
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-ai-agent-on-cloudflare/references/examples.md

@@ -0,0 +1,188 @@
+# Project Bootstrapping
+
+Instructions for creating new agent projects.
+
+---
+
+## Create Command
+
+Execute in terminal to generate a new project:
+
+```bash
+npm create cloudflare@latest -- my-agent \
+  --template=cloudflare/agents-starter
+```
+
+Or use npx directly:
+
+```bash
+npx create-cloudflare@latest --template cloudflare/agents-starter
+```
+
+Includes:
+- Persistent data via `this.setState` and `this.sql`
+- WebSocket real-time connections
+- Workers AI bindings ready
+- React chat interface example
+
+---
+
+## Project Layout
+
+Generated structure:
+
+```
+my-agent/
+├── src/
+│   ├── app.tsx       # React chat interface
+│   ├── server.ts     # Agent implementation
+│   ├── tools.ts      # Tool definitions
+│   └── utils.ts      # Helpers
+├── wrangler.toml     # Platform configuration
+└── package.json
+```
+
+---
+
+## Agent Variations
+
+**Chat-focused:**
+
+Inherit from base `Agent` class, implement `onMessage` handler:
+- Manual conversation tracking
+- Full control over responses
+- Integrates with any AI provider
+
+**Persistent data:**
+
+Use `this.setState()` for automatic persistence:
+- JSON-serializable data
+- Auto-syncs to connected clients
+- Survives instance eviction
+
+**Per-session isolation:**
+
+Route by unique identifier in URL path:
+- Each identifier gets dedicated instance
+- Isolated data storage
+- Horizontal scaling automatic
+
+---
+
+## Platform Documentation
+
+- developers.cloudflare.com/agents/
+- developers.cloudflare.com/agents/getting-started/
+- developers.cloudflare.com/agents/api-reference/
+
+**Source repositories:**
+- `github.com/cloudflare/agents-starter` (starter template)
+- `github.com/cloudflare/agents/tree/main/examples` (reference implementations)
+
+**Related services:**
+
+- developers.cloudflare.com/workers-ai/ (AI models)
+- developers.cloudflare.com/vectorize/ (vector search)
+- developers.cloudflare.com/d1/ (SQL database)
+
+---
+
+## Reference Implementations
+
+Located at `github.com/cloudflare/agents/tree/main/examples`:
+
+| Example | Description |
+|---------|-------------|
+| `resumable-stream-chat` | Chat with reconnection-safe streaming |
+| `email-agent` | Handle incoming emails via Email Routing |
+| `mcp-client` | Connect agents to external MCP servers |
+| `mcp-worker` | Expose agent capabilities via MCP protocol |
+| `cross-domain` | Multi-domain authentication patterns |
+| `tictactoe` | Multiplayer game with shared state |
+| `a2a` | Agent-to-agent communication |
+| `codemode` | Code transformation workflows |
+| `playground` | Interactive testing sandbox |
+
+Browse each folder for complete implementation code and wrangler configuration.
+
+---
+
+## Selection Matrix
+
+| Goal | Approach |
+|------|----------|
+| Conversational bot | Agent + onMessage handler |
+| Custom data schema | Agent + setState() |
+| Knowledge retrieval | Agent + Vectorize |
+| Background jobs | Agent + schedule() |
+| External integrations | Agent + tool definitions |
+
+---
+
+## Commands Reference
+
+**Local execution:**
+
+```bash
+cd my-agent
+npm install
+npm start
+# Accessible at http://localhost:8787
+```
+
+**Production push:**
+
+```bash
+npx wrangler deploy
+# Accessible at https://[name].[subdomain].workers.dev
+```
+
+**WebSocket connection:**
+
+```javascript
+// URL pattern: /agents/:className/:instanceName
+const socket = new WebSocket("wss://my-agent.workers.dev/agents/MyAgent/session-123");
+
+socket.onmessage = (e) => {
+  console.log("Received:", JSON.parse(e.data));
+};
+
+socket.send(JSON.stringify({ type: "chat", content: "Hello" }));
+```
+
+**React integration:**
+
+```tsx
+import { useAgent } from "agents/react";
+
+function Chat() {
+  const { state, send } = useAgent({
+    agent: "my-agent",
+    name: "session-123",
+  });
+
+  // state auto-updates, send() dispatches messages
+}
+```
+
+---
+
+## Key Methods (from Agent class)
+
+| Method | Purpose |
+|--------|---------|
+| `onStart()` | Runs on instance startup |
+| `onConnect()` | Handles new WebSocket connections |
+| `onMessage()` | Processes incoming messages |
+| `onClose()` | Cleanup on disconnect |
+| `setState()` | Persist and broadcast data |
+| `this.sql` | Query embedded SQLite |
+| `schedule()` | Delayed/recurring tasks |
+| `broadcast()` | Message all connections |
+
+---
+
+## Help Channels
+
+- Cloudflare Discord
+- GitHub discussions on cloudflare/agents repository

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-ai-agent-on-cloudflare/references/state-patterns.md

@@ -0,0 +1,360 @@
+# State Management Patterns
+
+Strategies for managing state in Cloudflare Agents.
+
+## How State Works
+
+State is automatically persisted to the `cf_agents_state` SQL table. The `this.state` getter lazily loads from storage, while `this.setState()` serializes and persists changes. State survives Durable Object evictions.
+
+```typescript
+class MyAgent extends Agent<Env, { count: number }> {
+  initialState = { count: 0 };
+
+  increment() {
+    this.setState({ count: this.state.count + 1 });
+  }
+
+  onStateUpdate(state: State, source: string) {
+    console.log("State updated by:", source);
+  }
+}
+```
+
+## State vs SQL: When to Use Which
+
+### Use `this.state` + `setState()` When:
+
+- Data is small (< 1MB recommended)
+- Needs real-time sync to all connected clients
+- Simple key-value or object structure
+- Frequently read, occasionally updated
+
+```typescript
+interface State {
+  currentUser: { id: string; name: string };
+  preferences: Record<string, string>;
+  recentMessages: Message[];  // Keep limited, e.g., last 50
+  isTyping: boolean;
+}
+```
+
+### Use `this.sql` When:
+
+- Large datasets (many records)
+- Complex queries (JOINs, aggregations, filtering)
+- Historical data / audit logs
+- Data that doesn't need real-time sync
+
+```typescript
+// Good for SQL
+// - Full message history
+// - User documents
+// - Analytics events
+// - Search indexes
+```
+
+## Hybrid Pattern
+
+Combine both for optimal performance:
+
+```typescript
+interface State {
+  recentMessages: Message[];
+  onlineUsers: string[];
+  currentDocument: Document | null;
+}
+
+export class HybridAgent extends Agent<Env, State> {
+  initialState: State = {
+    recentMessages: [],
+    onlineUsers: [],
+    currentDocument: null,
+  };
+
+  async onStart() {
+    await this.sql`
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+
+    const recent = await this.sql`
+      SELECT * FROM messages
+      ORDER BY created_at DESC
+      LIMIT 50
+    `;
+
+    this.setState({
+      ...this.state,
+      recentMessages: recent.reverse(),
+    });
+  }
+
+  async addMessage(message: Message) {
+    await this.sql`
+      INSERT INTO messages (id, user_id, content)
+      VALUES (${message.id}, ${message.userId}, ${message.content})
+    `;
+
+    const recentMessages = [...this.state.recentMessages, message].slice(-50);
+    this.setState({ ...this.state, recentMessages });
+  }
+}
+```
+
+---
+
+## Queue System
+
+The SDK includes a built-in queue for background task processing. Tasks are stored in SQLite and processed in FIFO order.
+
+### Queue Methods
+
+| Method | Purpose |
+|--------|---------|
+| `queue(callback, payload)` | Add task, returns task ID |
+| `dequeue(id)` | Remove specific task |
+| `dequeueAll()` | Clear entire queue |
+| `dequeueAllByCallback(name)` | Remove tasks by callback name |
+| `getQueue(id)` | Get single task |
+| `getQueues(key, value)` | Find tasks by payload field |
+
+### Queue Example
+
+```typescript
+export class TaskAgent extends Agent<Env, State> {
+  async onMessage(connection: Connection, message: string) {
+    const data = JSON.parse(message);
+
+    if (data.type === "process_later") {
+      const taskId = await this.queue("processItem", {
+        itemId: data.itemId,
+        priority: data.priority,
+      });
+
+      connection.send(JSON.stringify({ queued: true, taskId }));
+    }
+  }
+
+  // Callback receives payload and QueueItem metadata
+  async processItem(payload: { itemId: string }, item: QueueItem) {
+    console.log(`Processing ${payload.itemId}, queued at ${item.createdAt}`);
+    // Successfully executed tasks are auto-removed
+  }
+}
+```
+
+**Queue characteristics:**
+- Sequential processing (no parallelization)
+- Persists across agent restarts
+- No built-in retry mechanism
+- Payloads must be JSON-serializable
+
+---
+
+## Context Management
+
+Custom methods automatically have full agent context. Use `getCurrentAgent()` to access context from external functions.
+
+```typescript
+import { getCurrentAgent } from "agents";
+
+// External utility function
+async function logActivity(action: string) {
+  const { agent } = getCurrentAgent<MyAgent>();
+  await agent.sql`
+    INSERT INTO activity_log (action, timestamp)
+    VALUES (${action}, ${Date.now()})
+  `;
+}
+
+export class MyAgent extends Agent<Env, State> {
+  async performAction() {
+    // Context automatically available
+    await logActivity("action_performed");
+  }
+}
+```
+
+`getCurrentAgent<T>()` returns:
+- `agent` - The current agent instance
+- `connection` - Connection object (if applicable)
+- `request` - Request object (if applicable)
+
+---
+
+## State Synchronization
+
+### Optimistic Updates
+
+Update UI immediately, then persist:
+
+```typescript
+async onMessage(connection: Connection, message: string) {
+  const data = JSON.parse(message);
+
+  if (data.type === "update_preference") {
+    this.setState({
+      ...this.state,
+      preferences: {
+        ...this.state.preferences,
+        [data.key]: data.value,
+      },
+    });
+
+    await this.sql`
+      INSERT OR REPLACE INTO preferences (key, value)
+      VALUES (${data.key}, ${data.value})
+    `;
+  }
+}
+```
+
+### Conflict Resolution
+
+Handle concurrent updates with versioning:
+
+```typescript
+interface State {
+  document: {
+    content: string;
+    version: number;
+    lastModifiedBy: string;
+  };
+}
+
+async updateDocument(userId: string, newContent: string, expectedVersion: number) {
+  if (this.state.document.version !== expectedVersion) {
+    throw new Error("Conflict: document was modified by another user");
+  }
+
+  this.setState({
+    ...this.state,
+    document: {
+      content: newContent,
+      version: expectedVersion + 1,
+      lastModifiedBy: userId,
+    },
+  });
+}
+```
+
+### Per-Connection State
+
+Track ephemeral state for each connected client:
+
+```typescript
+export class MultiUserAgent extends Agent<Env, State> {
+  private connectionState = new Map<string, {
+    userId: string;
+    cursor: { x: number; y: number };
+    lastActivity: number;
+  }>();
+
+  async onConnect(connection: Connection) {
+    this.connectionState.set(connection.id, {
+      userId: "",
+      cursor: { x: 0, y: 0 },
+      lastActivity: Date.now(),
+    });
+  }
+
+  async onClose(connection: Connection) {
+    this.connectionState.delete(connection.id);
+  }
+}
+```
+
+---
+
+## State Migration
+
+When state schema changes:
+
+```typescript
+interface StateV2 {
+  messages: Array<{ id: string; content: string; timestamp: string }>;
+  version: 2;
+}
+
+export class MigratingAgent extends Agent<Env, StateV2> {
+  initialState: StateV2 = {
+    messages: [],
+    version: 2,
+  };
+
+  async onStart() {
+    const rawState = this.state as any;
+
+    if (!rawState.version || rawState.version < 2) {
+      const migratedMessages = (rawState.messages || []).map(
+        (content: string, i: number) => ({
+          id: `migrated-${i}`,
+          content,
+          timestamp: new Date().toISOString(),
+        })
+      );
+
+      this.setState({
+        messages: migratedMessages,
+        version: 2,
+      });
+    }
+  }
+}
+```
+
+---
+
+## State Size Management
+
+Keep state lean for performance:
+
+```typescript
+export class LeanStateAgent extends Agent<Env, State> {
+  private readonly MAX_RECENT_MESSAGES = 100;
+
+  async addMessage(message: Message) {
+    await this.sql`INSERT INTO messages (id, content) VALUES (${message.id}, ${message.content})`;
+
+    let recentMessages = [...this.state.recentMessages, message];
+    if (recentMessages.length > this.MAX_RECENT_MESSAGES) {
+      recentMessages = recentMessages.slice(-this.MAX_RECENT_MESSAGES);
+    }
+
+    this.setState({
+      ...this.state,
+      recentMessages,
+      stats: {
+        ...this.state.stats,
+        totalMessages: this.state.stats.totalMessages + 1,
+        lastActivity: new Date().toISOString(),
+      },
+    });
+  }
+}
+```
+
+---
+
+## Debugging State
+
+```typescript
+async onMessage(connection: Connection, message: string) {
+  const data = JSON.parse(message);
+
+  if (data.type === "debug_state") {
+    connection.send(JSON.stringify({
+      type: "debug_response",
+      state: this.state,
+      stateSize: JSON.stringify(this.state).length,
+      sqlTables: await this.sql`
+        SELECT name FROM sqlite_master WHERE type='table'
+      `,
+    }));
+  }
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-ai-agent-on-cloudflare/references/troubleshooting.md

@@ -0,0 +1,362 @@
+# Agent Troubleshooting
+
+Common issues and solutions for Cloudflare Agents.
+
+## Connection Issues
+
+### "WebSocket connection failed"
+
+**Symptoms:** Client cannot connect to agent.
+
+**Causes & Solutions:**
+
+1. **Worker not deployed**
+   ```bash
+   wrangler deployments list
+   wrangler deploy  # If not deployed
+   ```
+
+2. **Wrong URL path**
+   ```javascript
+   // Ensure your routing handles the agent path
+   // Client:
+   new WebSocket("wss://my-worker.workers.dev/agent/user123");
+
+   // Worker must route to agent:
+   if (url.pathname.startsWith("/agent/")) {
+     const id = url.pathname.split("/")[2];
+     return env.AGENT.get(env.AGENT.idFromName(id)).fetch(request);
+   }
+   ```
+
+3. **CORS issues (browser clients)**
+   Agents handle WebSocket upgrades automatically, but ensure your entry worker doesn't block the request.
+
+### "Connection closed unexpectedly"
+
+1. **Agent threw an error**
+   ```bash
+   wrangler tail  # Check for exceptions
+   ```
+
+2. **Message handler crashed**
+   ```typescript
+   async onMessage(connection: Connection, message: string) {
+     try {
+       // Your logic
+     } catch (error) {
+       console.error("Message handling error:", error);
+       connection.send(JSON.stringify({ type: "error", message: error.message }));
+     }
+   }
+   ```
+
+3. **Hibernation woke agent with stale connection**
+   Ensure you handle reconnection gracefully in client code.
+
+## State Issues
+
+### "State not persisting"
+
+**Causes:**
+
+1. **Didn't call `setState()`**
+   ```typescript
+   // Wrong - direct mutation doesn't persist
+   this.state.messages.push(newMessage);
+
+   // Correct - use setState
+   this.setState({
+     ...this.state,
+     messages: [...this.state.messages, newMessage],
+   });
+   ```
+
+2. **Agent crashed before state saved**
+   `setState()` is durable, but if agent crashes during processing before `setState()`, changes are lost.
+
+3. **Wrong agent instance**
+   Each unique ID gets a separate agent. Ensure clients connect to the same ID.
+
+### "State out of sync between clients"
+
+`setState()` automatically syncs to all connected clients via `onStateUpdate()`. If sync isn't working:
+
+1. **Check `onStateUpdate` is implemented**
+   ```typescript
+   onStateUpdate(state: State, source: string) {
+     // This fires when state changes from any source
+     console.log("State updated:", state, "from:", source);
+   }
+   ```
+
+2. **Client not listening for state updates**
+   ```typescript
+   // React hook handles this automatically
+   const { state } = useAgent({ agent: "my-agent", name: id });
+
+   // Manual WebSocket - listen for state messages
+   ws.onmessage = (event) => {
+     const data = JSON.parse(event.data);
+     if (data.type === "state_update") {
+       updateLocalState(data.state);
+     }
+   };
+   ```
+
+### "State too large" / Performance issues
+
+State is serialized as JSON. Keep it small:
+
+```typescript
+// Bad - storing everything in state
+interface State {
+  allMessages: Message[];  // Could be thousands
+  allDocuments: Document[];
+}
+
+// Good - state for hot data, SQL for cold
+interface State {
+  recentMessages: Message[];  // Last 50 only
+  currentDocument: Document | null;
+}
+
+// Store full history in SQL
+await this.sql`INSERT INTO messages ...`;
+```
+
+## SQL Issues
+
+### "no such table"
+
+Table not created. Create in `onStart()`:
+
+```typescript
+async onStart() {
+  await this.sql`
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+}
+```
+
+### "SQL logic error"
+
+Check your query syntax. Use tagged templates correctly:
+
+```typescript
+// Wrong - string interpolation (SQL injection risk!)
+await this.sql`SELECT * FROM users WHERE id = '${userId}'`;
+
+// Correct - parameterized query
+await this.sql`SELECT * FROM users WHERE id = ${userId}`;
+```
+
+### SQL query returns empty
+
+1. **Wrong table name**
+2. **Data in different agent instance** (each agent ID has isolated storage)
+3. **Query conditions don't match**
+
+Debug:
+```typescript
+const tables = await this.sql`
+  SELECT name FROM sqlite_master WHERE type='table'
+`;
+console.log("Tables:", tables);
+
+const count = await this.sql`SELECT COUNT(*) as count FROM messages`;
+console.log("Message count:", count);
+```
+
+## Scheduled Task Issues
+
+### "Task never fires"
+
+1. **Method name mismatch**
+   ```typescript
+   // Schedule references method that must exist
+   await this.schedule(60, "sendReminder", { ... });
+
+   // Method must be defined on the class
+   async sendReminder(data: any) {
+     // This method MUST exist
+   }
+   ```
+
+2. **Cron syntax error**
+   ```typescript
+   // Invalid cron
+   await this.schedule("every 5 minutes", "task", {});  // Wrong
+
+   // Valid cron
+   await this.schedule("*/5 * * * *", "task", {});  // Every 5 minutes
+   ```
+
+3. **Task was cancelled**
+   ```typescript
+   const schedules = await this.getSchedules();
+   console.log("Active schedules:", schedules);
+   ```
+
+### "Task fires multiple times"
+
+If you schedule in `onStart()` without checking:
+
+```typescript
+async onStart() {
+  // Bad - schedules new task every time agent wakes
+  await this.schedule("0 9 * * *", "dailyTask", {});
+
+  // Good - check first
+  const schedules = await this.getSchedules();
+  const hasDaily = schedules.some(s => s.callback === "dailyTask");
+  if (!hasDaily) {
+    await this.schedule("0 9 * * *", "dailyTask", {});
+  }
+}
+```
+
+## Deployment Issues
+
+### "Class MyAgent is not exported"
+
+```typescript
+// src/index.ts - Must export the class
+export { MyAgent } from "./agent";
+
+// Or if defined in same file
+export class MyAgent extends Agent { ... }
+```
+
+### "Durable Object not found"
+
+Check `wrangler.toml`:
+
+```toml
+[durable_objects]
+bindings = [{ name = "AGENT", class_name = "MyAgent" }]
+
+[[migrations]]
+tag = "v1"
+new_classes = ["MyAgent"]
+```
+
+### "Migration required"
+
+When adding new Durable Object classes:
+
+```toml
+[[migrations]]
+tag = "v2"  # Increment from previous
+new_classes = ["NewAgentClass"]
+
+# Or for renames
+# renamed_classes = [{ from = "OldName", to = "NewName" }]
+```
+
+## AI Integration Issues
+
+### "AI binding not found"
+
+Add to `wrangler.toml`:
+
+```toml
+[ai]
+binding = "AI"
+```
+
+### "Model not found" / "Rate limited"
+
+```typescript
+// Check model name is correct
+const response = await this.env.AI.run(
+  "@cf/meta/llama-3-8b-instruct",  // Exact model name
+  { messages: [...] }
+);
+
+// Handle rate limits
+try {
+  const response = await this.env.AI.run(...);
+} catch (error) {
+  if (error.message.includes("rate limit")) {
+    // Retry with backoff or use queue
+  }
+}
+```
+
+### "Streaming not working"
+
+```typescript
+// Enable streaming
+const stream = await this.env.AI.run("@cf/meta/llama-3-8b-instruct", {
+  messages: [...],
+  stream: true,  // Must be true
+});
+
+// Iterate over stream
+for await (const chunk of stream) {
+  connection.send(JSON.stringify({ type: "chunk", content: chunk.response }));
+}
+```
+
+## Debugging Tips
+
+### Enable Verbose Logging
+
+```typescript
+export class MyAgent extends Agent<Env, State> {
+  async onStart() {
+    console.log("Agent starting, state:", JSON.stringify(this.state));
+  }
+
+  async onConnect(connection: Connection) {
+    console.log("Client connected:", connection.id);
+  }
+
+  async onMessage(connection: Connection, message: string) {
+    console.log("Received message:", message);
+    // ... handle
+    console.log("State after:", JSON.stringify(this.state));
+  }
+
+  async onClose(connection: Connection) {
+    console.log("Client disconnected:", connection.id);
+  }
+}
+```
+
+View logs:
+```bash
+wrangler tail --format pretty
+```
+
+### Test Locally First
+
+```bash
+npm start
+# Connect with test client or use browser console:
+# new WebSocket("ws://localhost:8787/agent/test")
+```
+
+### Inspect State
+
+Add a debug endpoint:
+
+```typescript
+async onRequest(request: Request) {
+  const url = new URL(request.url);
+
+  if (url.pathname === "/debug") {
+    return Response.json({
+      state: this.state,
+      schedules: await this.getSchedules(),
+    });
+  }
+
+  return new Response("Not found", { status: 404 });
+}
+```

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-mcp-server-on-cloudflare/SKILL.md

@@ -0,0 +1,266 @@
+---
+name: building-mcp-server-on-cloudflare
+description: |
+  Builds remote MCP (Model Context Protocol) servers on Cloudflare Workers
+  with tools, OAuth authentication, and production deployment. Generates
+  server code, configures auth providers, and deploys to Workers.
+
+  Use when: user wants to "build MCP server", "create MCP tools", "remote
+  MCP", "deploy MCP", add "OAuth to MCP", or mentions Model Context Protocol
+  on Cloudflare. Also triggers on "MCP authentication" or "MCP deployment".
+  Biases towards retrieval from Cloudflare docs over pre-trained knowledge.
+---
+
+# Building MCP Servers on Cloudflare
+
+Your knowledge of the MCP SDK and Cloudflare Workers integration may be outdated. **Prefer retrieval over pre-training** for any MCP server task.
+
+## Retrieval Sources
+
+| Source | How to retrieve | Use for |
+|--------|----------------|---------|
+| MCP docs | `https://developers.cloudflare.com/agents/mcp/` | Server setup, auth, deployment |
+| MCP spec | `https://modelcontextprotocol.io/` | Protocol spec, tool/resource definitions |
+| Workers docs | Search tool or `https://developers.cloudflare.com/workers/` | Runtime APIs, bindings, config |
+
+## When to Use
+
+- User wants to build a remote MCP server
+- User needs to expose tools via MCP
+- User asks about MCP authentication or OAuth
+- User wants to deploy MCP to Cloudflare Workers
+
+## Prerequisites
+
+- Cloudflare account with Workers enabled
+- Node.js 18+ and npm/pnpm/yarn
+- Wrangler CLI (`npm install -g wrangler`)
+
+## Quick Start
+
+### Option 1: Public Server (No Auth)
+
+```bash
+npm create cloudflare@latest -- my-mcp-server \
+  --template=cloudflare/ai/demos/remote-mcp-authless
+cd my-mcp-server
+npm start
+```
+
+Server runs at `http://localhost:8788/mcp`
+
+### Option 2: Authenticated Server (OAuth)
+
+```bash
+npm create cloudflare@latest -- my-mcp-server \
+  --template=cloudflare/ai/demos/remote-mcp-github-oauth
+cd my-mcp-server
+```
+
+Requires OAuth app setup. See [references/oauth-setup.md](references/oauth-setup.md).
+
+## Core Workflow
+
+### Step 1: Define Tools
+
+Tools are functions MCP clients can call. Define them using `server.tool()`:
+
+```typescript
+import { McpAgent } from "agents/mcp";
+import { z } from "zod";
+
+export class MyMCP extends McpAgent {
+  server = new Server({ name: "my-mcp", version: "1.0.0" });
+
+  async init() {
+    // Simple tool with parameters
+    this.server.tool(
+      "add",
+      { a: z.number(), b: z.number() },
+      async ({ a, b }) => ({
+        content: [{ type: "text", text: String(a + b) }],
+      })
+    );
+
+    // Tool that calls external API
+    this.server.tool(
+      "get_weather",
+      { city: z.string() },
+      async ({ city }) => {
+        const response = await fetch(`https://api.weather.com/${city}`);
+        const data = await response.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data) }],
+        };
+      }
+    );
+  }
+}
+```
+
+### Step 2: Configure Entry Point
+
+**Public server** (`src/index.ts`):
+
+```typescript
+import { MyMCP } from "./mcp";
+
+export default {
+  fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    const url = new URL(request.url);
+    if (url.pathname === "/mcp") {
+      return MyMCP.serveSSE("/mcp").fetch(request, env, ctx);
+    }
+    return new Response("MCP Server", { status: 200 });
+  },
+};
+
+export { MyMCP };
+```
+
+**Authenticated server** — See [references/oauth-setup.md](references/oauth-setup.md).
+
+### Step 3: Test Locally
+
+```bash
+# Start server
+npm start
+
+# In another terminal, test with MCP Inspector
+npx @modelcontextprotocol/inspector@latest
+# Open http://localhost:5173, enter http://localhost:8788/mcp
+```
+
+### Step 4: Deploy
+
+```bash
+npx wrangler deploy
+```
+
+Server accessible at `https://[worker-name].[account].workers.dev/mcp`
+
+### Step 5: Connect Clients
+
+**Codex MCP client setup:**
+
+```bash
+codex mcp add my-server -- npx mcp-remote https://my-mcp.workers.dev/mcp
+```
+
+Restart Codex after updating the MCP configuration.
+
+## Tool Patterns
+
+### Return Types
+
+```typescript
+// Text response
+return { content: [{ type: "text", text: "result" }] };
+
+// Multiple content items
+return {
+  content: [
+    { type: "text", text: "Here's the data:" },
+    { type: "text", text: JSON.stringify(data, null, 2) },
+  ],
+};
+```
+
+### Input Validation with Zod
+
+```typescript
+this.server.tool(
+  "create_user",
+  {
+    email: z.string().email(),
+    name: z.string().min(1).max(100),
+    role: z.enum(["admin", "user", "guest"]),
+    age: z.number().int().min(0).optional(),
+  },
+  async (params) => {
+    // params are fully typed and validated
+  }
+);
+```
+
+### Accessing Environment/Bindings
+
+```typescript
+export class MyMCP extends McpAgent<Env> {
+  async init() {
+    this.server.tool("query_db", { sql: z.string() }, async ({ sql }) => {
+      // Access D1 binding
+      const result = await this.env.DB.prepare(sql).all();
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+  }
+}
+```
+
+## Authentication
+
+For OAuth-protected servers, see [references/oauth-setup.md](references/oauth-setup.md).
+
+Supported providers:
+- GitHub
+- Google
+- Auth0
+- Stytch
+- WorkOS
+- Any OAuth 2.0 compliant provider
+
+## Wrangler Configuration
+
+Minimal `wrangler.toml`:
+
+```toml
+name = "my-mcp-server"
+main = "src/index.ts"
+compatibility_date = "2024-12-01"
+
+[durable_objects]
+bindings = [{ name = "MCP", class_name = "MyMCP" }]
+
+[[migrations]]
+tag = "v1"
+new_classes = ["MyMCP"]
+```
+
+With bindings (D1, KV, etc.):
+
+```toml
+[[d1_databases]]
+binding = "DB"
+database_name = "my-db"
+database_id = "xxx"
+
+[[kv_namespaces]]
+binding = "KV"
+id = "xxx"
+```
+
+## Common Issues
+
+### "Tool not found" in Client
+
+1. Verify tool name matches exactly (case-sensitive)
+2. Ensure `init()` registers tools before connections
+3. Check server logs: `wrangler tail`
+
+### Connection Fails
+
+1. Confirm endpoint path is `/mcp`
+2. Check CORS if browser-based client
+3. Verify Worker is deployed: `wrangler deployments list`
+
+### OAuth Redirect Errors
+
+1. Callback URL must match OAuth app config exactly
+2. Check `GITHUB_CLIENT_ID` and `GITHUB_CLIENT_SECRET` are set
+3. For local dev, use `http://localhost:8788/callback`
+
+## References
+
+- [references/examples.md](references/examples.md) — Official templates and production examples
+- [references/oauth-setup.md](references/oauth-setup.md) — OAuth provider configuration
+- [references/troubleshooting.md](references/troubleshooting.md) — Error codes and fixes

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-mcp-server-on-cloudflare/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Building MCP Servers on Cloudflare"
+  short_description: "Build remote MCP servers on Cloudflare Workers"

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-mcp-server-on-cloudflare/references/examples.md

@@ -0,0 +1,108 @@
+# Project Bootstrapping
+
+Instructions for creating new MCP server projects.
+
+---
+
+## Create Commands
+
+Execute in terminal to generate a new project:
+
+**Without authentication:**
+
+```bash
+npm create cloudflare@latest -- my-mcp-server \
+  --template=cloudflare/ai/demos/remote-mcp-authless
+```
+
+**With GitHub login:**
+
+```bash
+npm create cloudflare@latest -- my-mcp-server \
+  --template=cloudflare/ai/demos/remote-mcp-github-oauth
+```
+
+**With Google login:**
+
+```bash
+npm create cloudflare@latest -- my-mcp-server \
+  --template=cloudflare/ai/demos/remote-mcp-google-oauth
+```
+
+---
+
+## Additional Boilerplate Locations
+
+**Main repository:** `github.com/cloudflare/ai` (check demos directory)
+
+Other authentication providers:
+- Auth0
+- WorkOS AuthKit
+- Logto
+- Descope
+- Stytch
+
+**Cloudflare tooling:** `github.com/cloudflare/mcp-server-cloudflare`
+
+---
+
+## Selection Matrix
+
+| Goal | Boilerplate |
+|------|-------------|
+| Testing/learning | authless |
+| GitHub API access | github-oauth |
+| Google API access | google-oauth |
+| Enterprise auth | auth0 / authkit |
+| Slack apps | slack-oauth |
+| Zero Trust | cf-access |
+
+---
+
+## Platform Documentation
+
+- developers.cloudflare.com/agents/model-context-protocol/
+- developers.cloudflare.com/agents/guides/remote-mcp-server/
+- developers.cloudflare.com/agents/guides/test-remote-mcp-server/
+- developers.cloudflare.com/agents/model-context-protocol/authorization/
+
+---
+
+## Commands Reference
+
+**Local execution:**
+
+```bash
+cd my-mcp-server
+npm install
+npm start
+# Accessible at http://localhost:8788/mcp
+```
+
+**Production push:**
+
+```bash
+npx wrangler deploy
+# Accessible at https://[worker-name].[subdomain].workers.dev/mcp
+```
+
+**Codex MCP client setup:**
+
+```bash
+codex mcp add my-server -- npx mcp-remote https://my-mcp-server.my-account.workers.dev/mcp
+```
+
+**Inspector testing:**
+
+```bash
+npx @modelcontextprotocol/inspector@latest
+# Launch browser at http://localhost:5173
+# Input your server URL: http://localhost:8788/mcp
+```
+
+---
+
+## Help Channels
+
+- Cloudflare Discord
+- GitHub discussions on cloudflare/ai repository

data/.codex/.codex/.tmp/plugins/plugins/cloudflare/skills/building-mcp-server-on-cloudflare/references/oauth-setup.md

@@ -0,0 +1,338 @@
+# Securing MCP Servers
+
+MCP servers require authentication to ensure only trusted users can access them. The MCP specification uses OAuth 2.1 for authentication between clients and servers.
+
+Cloudflare's `workers-oauth-provider` handles token management, client registration, and access token validation automatically.
+
+## Basic Setup
+
+```typescript
+import { OAuthProvider } from "@cloudflare/workers-oauth-provider";
+import { createMcpHandler } from "agents/mcp";
+
+const apiHandler = {
+  async fetch(request: Request, env: unknown, ctx: ExecutionContext) {
+    return createMcpHandler(server)(request, env, ctx);
+  }
+};
+
+export default new OAuthProvider({
+  authorizeEndpoint: "/authorize",
+  tokenEndpoint: "/oauth/token",
+  clientRegistrationEndpoint: "/oauth/register",
+  apiRoute: "/mcp",
+  apiHandler: apiHandler,
+  defaultHandler: AuthHandler
+});
+```
+
+## Proxy Server Pattern
+
+MCP servers often act as OAuth clients too. Your server sits between Codex and a third-party API like GitHub. To Codex, you're a server. To GitHub, you're a client. This lets users authenticate with their GitHub credentials.
+
+Building a secure proxy server requires careful attention to several security concerns.
+
+---
+
+## Security Requirements
+
+### Redirect URI Validation
+
+The `workers-oauth-provider` validates that `redirect_uri` in authorization requests matches registered URIs. This prevents attackers from redirecting authorization codes to malicious endpoints.
+
+### Consent Dialog
+
+When proxying to third-party providers, implement your own consent dialog before forwarding users upstream. This prevents the "confused deputy" problem where attackers exploit cached consent.
+
+Your consent dialog should:
+- Identify the requesting MCP client by name
+- Display the specific scopes being requested
+
+---
+
+## CSRF Protection
+
+Prevent attackers from tricking users into approving malicious OAuth clients. Use a random token stored in a secure cookie.
+
+```typescript
+// Generate token when showing consent form
+function generateCSRFProtection(): { token: string; setCookie: string } {
+  const token = crypto.randomUUID();
+  const setCookie = `__Host-CSRF_TOKEN=${token}; HttpOnly; Secure; Path=/; SameSite=Lax; Max-Age=600`;
+  return { token, setCookie };
+}
+
+// Validate token when user approves
+function validateCSRFToken(formData: FormData, request: Request): { clearCookie: string } {
+  const tokenFromForm = formData.get("csrf_token");
+  const cookieHeader = request.headers.get("Cookie") || "";
+  const tokenFromCookie = cookieHeader
+    .split(";")
+    .find((c) => c.trim().startsWith("__Host-CSRF_TOKEN="))
+    ?.split("=")[1];
+
+  if (!tokenFromForm || !tokenFromCookie || tokenFromForm !== tokenFromCookie) {
+    throw new Error("CSRF token mismatch");
+  }
+
+  return {
+    clearCookie: `__Host-CSRF_TOKEN=; HttpOnly; Secure; Path=/; SameSite=Lax; Max-Age=0`
+  };
+}
+```
+
+Include the token as a hidden form field:
+
+```html
+<input type="hidden" name="csrf_token" value="${csrfToken}" />
+```
+
+---
+
+## Input Sanitization
+
+Client-controlled content (names, logos, URIs) can execute malicious scripts if not sanitized. Treat all client metadata as untrusted.
+
+```typescript
+function sanitizeText(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#039;");
+}
+
+function sanitizeUrl(url: string): string {
+  if (!url) return "";
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      return "";
+    }
+    return url;
+  } catch {
+    return "";
+  }
+}
+```
+
+**Required protections:**
+- Client names/descriptions: HTML-escape before rendering
+- Logo URLs: Allow only `http:` and `https:` schemes
+- Client URIs: Same as logo URLs
+- Scopes: Treat as text, HTML-escape
+
+---
+
+## Content Security Policy
+
+CSP headers block dangerous content and provide defense in depth.
+
+```typescript
+function buildSecurityHeaders(setCookie: string, nonce?: string): HeadersInit {
+  const cspDirectives = [
+    "default-src 'none'",
+    "script-src 'self'" + (nonce ? ` 'nonce-${nonce}'` : ""),
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' https:",
+    "font-src 'self'",
+    "form-action 'self'",
+    "frame-ancestors 'none'",
+    "base-uri 'self'",
+    "connect-src 'self'"
+  ].join("; ");
+
+  return {
+    "Content-Security-Policy": cspDirectives,
+    "X-Frame-Options": "DENY",
+    "X-Content-Type-Options": "nosniff",
+    "Content-Type": "text/html; charset=utf-8",
+    "Set-Cookie": setCookie
+  };
+}
+```
+
+---
+
+## State Management
+
+Ensure the same user that hits authorize reaches the callback. Use a random state token stored in KV with short expiration.
+
+```typescript
+// Create state before redirecting to upstream provider
+async function createOAuthState(
+  oauthReqInfo: AuthRequest,
+  kv: KVNamespace
+): Promise<{ stateToken: string }> {
+  const stateToken = crypto.randomUUID();
+  await kv.put(`oauth:state:${stateToken}`, JSON.stringify(oauthReqInfo), {
+    expirationTtl: 600
+  });
+  return { stateToken };
+}
+
+// Bind state to browser session via hashed cookie
+async function bindStateToSession(stateToken: string): Promise<{ setCookie: string }> {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(stateToken);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+
+  return {
+    setCookie: `__Host-CONSENTED_STATE=${hashHex}; HttpOnly; Secure; Path=/; SameSite=Lax; Max-Age=600`
+  };
+}
+
+// Validate in callback - check both KV and session cookie
+async function validateOAuthState(
+  request: Request,
+  kv: KVNamespace
+): Promise<{ oauthReqInfo: AuthRequest; clearCookie: string }> {
+  const url = new URL(request.url);
+  const stateFromQuery = url.searchParams.get("state");
+
+  if (!stateFromQuery) {
+    throw new Error("Missing state parameter");
+  }
+
+  // Check KV
+  const storedDataJson = await kv.get(`oauth:state:${stateFromQuery}`);
+  if (!storedDataJson) {
+    throw new Error("Invalid or expired state");
+  }
+
+  // Check session cookie matches
+  const cookieHeader = request.headers.get("Cookie") || "";
+  const consentedStateHash = cookieHeader
+    .split(";")
+    .find((c) => c.trim().startsWith("__Host-CONSENTED_STATE="))
+    ?.split("=")[1];
+
+  if (!consentedStateHash) {
+    throw new Error("Missing session binding cookie");
+  }
+
+  // Hash state and compare
+  const encoder = new TextEncoder();
+  const hashBuffer = await crypto.subtle.digest("SHA-256", encoder.encode(stateFromQuery));
+  const stateHash = Array.from(new Uint8Array(hashBuffer))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+
+  if (stateHash !== consentedStateHash) {
+    throw new Error("State token does not match session");
+  }
+
+  await kv.delete(`oauth:state:${stateFromQuery}`);
+
+  return {
+    oauthReqInfo: JSON.parse(storedDataJson),
+    clearCookie: `__Host-CONSENTED_STATE=; HttpOnly; Secure; Path=/; SameSite=Lax; Max-Age=0`
+  };
+}
+```
+
+---
+
+## Approved Clients Registry
+
+Maintain a registry of approved client IDs per user. Store in a cryptographically signed cookie with HMAC-SHA256.
+
+```typescript
+export async function addApprovedClient(
+  request: Request,
+  clientId: string,
+  cookieSecret: string
+): Promise<string> {
+  const existingClients = await getApprovedClientsFromCookie(request, cookieSecret) || [];
+  const updatedClients = Array.from(new Set([...existingClients, clientId]));
+
+  const payload = JSON.stringify(updatedClients);
+  const signature = await signData(payload, cookieSecret);
+  const cookieValue = `${signature}.${btoa(payload)}`;
+
+  return `__Host-APPROVED_CLIENTS=${cookieValue}; HttpOnly; Secure; Path=/; SameSite=Lax; Max-Age=2592000`;
+}
+```
+
+When reading the cookie, verify the signature before trusting data. If client isn't approved, show consent dialog.
+
+---
+
+## Cookie Security
+
+### Why `__Host-` prefix?
+
+The `__Host-` prefix prevents subdomain attacks on `*.workers.dev` domains. Requirements:
+- Must have `Secure` flag (HTTPS only)
+- Must have `Path=/`
+- Must not have `Domain` attribute
+
+Without this prefix, an attacker on `evil.workers.dev` could set cookies for your `mcp-server.workers.dev` domain.
+
+### Multiple OAuth Providers
+
+If running multiple OAuth flows on the same domain, namespace your cookies:
+- `__Host-CSRF_TOKEN_GITHUB` vs `__Host-CSRF_TOKEN_GOOGLE`
+- `__Host-APPROVED_CLIENTS_GITHUB` vs `__Host-APPROVED_CLIENTS_GOOGLE`
+
+---
+
+## Inline JavaScript
+
+If your consent dialog needs inline JavaScript, use data attributes and nonces:
+
+```typescript
+const nonce = crypto.randomUUID();
+
+const html = `
+  <script nonce="${nonce}" data-redirect-url="${sanitizeUrl(redirectUrl)}">
+    setTimeout(() => {
+      const script = document.querySelector('script[data-redirect-url]');
+      window.location.href = script.dataset.redirectUrl;
+    }, 2000);
+  </script>
+`;
+
+return new Response(html, {
+  headers: buildSecurityHeaders(setCookie, nonce)
+});
+```
+
+Data attributes store user-controlled data separately from executable code. Nonces with CSP allow your specific script while blocking injected scripts.
+
+---
+
+## Provider-Specific Setup
+
+### GitHub
+
+1. Create OAuth App at github.com/settings/developers
+2. Set callback URL: `https://[worker].workers.dev/callback`
+3. Store secrets:
+   ```bash
+   wrangler secret put GITHUB_CLIENT_ID
+   wrangler secret put GITHUB_CLIENT_SECRET
+   ```
+
+### Google
+
+1. Create OAuth Client at console.cloud.google.com/apis/credentials
+2. Set authorized redirect URI
+3. Scopes: `openid email profile`
+
+### Auth0
+
+1. Create Regular Web Application in Auth0 Dashboard
+2. Set allowed callback URLs
+3. Endpoints: `https://${AUTH0_DOMAIN}/authorize`, `/oauth/token`, `/userinfo`
+
+---
+
+## References
+
+- [MCP Authorization Spec](https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization)
+- [MCP Security Best Practices](https://modelcontextprotocol.io/specification/draft/basic/security_best_practices)
+- [RFC 9700 - OAuth Security](https://www.rfc-editor.org/rfc/rfc9700)