@frontmcp/skills 1.0.0-beta.13 → 1.0.0-beta.14

package/catalog/frontmcp-deployment/examples/deploy-to-vercel-config/vercel-config-with-security-headers.md

@@ -0,0 +1,92 @@
+---
+name: vercel-config-with-security-headers
+reference: deploy-to-vercel-config
+level: intermediate
+description: 'A complete `vercel.json` with per-route security headers for health, MCP, and all other endpoints.'
+tags: [deployment, vercel, cache, security, config, headers]
+features:
+  - 'Per-route header configuration: `/health` and `/mcp` get `Cache-Control: no-store` to prevent caching'
+  - 'Global security headers (`X-Frame-Options`, `X-Content-Type-Options`, `Referrer-Policy`) applied to all routes'
+  - 'Setting `framework: null` to tell Vercel this is not a framework project'
+---
+
+# vercel.json with Security Headers
+
+A complete `vercel.json` with per-route security headers for health, MCP, and all other endpoints.
+
+## Code
+
+```json
+// vercel.json
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "framework": null,
+  "buildCommand": "frontmcp build --target vercel",
+  "outputDirectory": "dist",
+  "rewrites": [
+    {
+      "source": "/(.*)",
+      "destination": "/api/frontmcp"
+    }
+  ],
+  "functions": {
+    "api/frontmcp.js": {
+      "memory": 512,
+      "maxDuration": 30
+    }
+  },
+  "regions": ["iad1"],
+  "headers": [
+    {
+      "source": "/health",
+      "headers": [
+        {
+          "key": "Cache-Control",
+          "value": "no-store"
+        }
+      ]
+    },
+    {
+      "source": "/mcp",
+      "headers": [
+        {
+          "key": "Cache-Control",
+          "value": "no-store"
+        },
+        {
+          "key": "X-Content-Type-Options",
+          "value": "nosniff"
+        }
+      ]
+    },
+    {
+      "source": "/(.*)",
+      "headers": [
+        {
+          "key": "X-Frame-Options",
+          "value": "DENY"
+        },
+        {
+          "key": "X-Content-Type-Options",
+          "value": "nosniff"
+        },
+        {
+          "key": "Referrer-Policy",
+          "value": "strict-origin-when-cross-origin"
+        }
+      ]
+    }
+  ]
+}
+```
+
+## What This Demonstrates
+
+- Per-route header configuration: `/health` and `/mcp` get `Cache-Control: no-store` to prevent caching
+- Global security headers (`X-Frame-Options`, `X-Content-Type-Options`, `Referrer-Policy`) applied to all routes
+- Setting `framework: null` to tell Vercel this is not a framework project
+
+## Related
+
+- See `deploy-to-vercel-config` for the full reference configuration
+- See `deploy-to-vercel` for the complete deployment guide

package/catalog/frontmcp-deployment/references/build-for-browser.md

@@ -137,6 +137,16 @@ ls dist/browser/
 | Bundle too large            | All server-side code included             | Use `--target browser` and a dedicated client entry file         |
 | `@frontmcp/utils` fs throws | File system ops called in browser         | Remove fs calls; use API endpoints or in-memory alternatives     |
 
+## Examples
+
+| Example                                                                                               | Level        | Description                                                                                           |
+| ----------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------- |
+| [`browser-build-with-custom-entry`](../examples/build-for-browser/browser-build-with-custom-entry.md) | Intermediate | Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports.          |
+| [`browser-crypto-and-storage`](../examples/build-for-browser/browser-crypto-and-storage.md)           | Advanced     | Use `@frontmcp/utils` crypto functions (WebCrypto API) and in-memory storage in browser environments. |
+| [`react-provider-setup`](../examples/build-for-browser/react-provider-setup.md)                       | Basic        | Connect a React application to a remote FrontMCP server using `@frontmcp/react`.                      |
+
+> See all examples in [`examples/build-for-browser/`](../examples/build-for-browser/)
+
 ## Reference
 
 - **Docs:** <https://docs.agentfront.dev/frontmcp/deployment/browser-compatibility>

package/catalog/frontmcp-deployment/references/build-for-cli.md

@@ -185,6 +185,15 @@ frontmcp service uninstall my-server
 | Permission denied on binary  | Missing execute permission                  | Run `chmod +x dist/my-server`                               |
 | Binary fails on different OS | SEA binaries are platform-specific          | Build on the target OS or use CI matrix builds              |
 
+## Examples
+
+| Example                                                                 | Level        | Description                                                                                                  |
+| ----------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------ |
+| [`cli-binary-build`](../examples/build-for-cli/cli-binary-build.md)     | Basic        | Build a FrontMCP server as a standalone binary using Node.js Single Executable Applications (SEA).           |
+| [`unix-socket-daemon`](../examples/build-for-cli/unix-socket-daemon.md) | Intermediate | Run a FrontMCP server as a local daemon accessible via Unix socket for IDE extensions and local MCP clients. |
+
+> See all examples in [`examples/build-for-cli/`](../examples/build-for-cli/)
+
 ## Reference
 
 - **Docs:** <https://docs.agentfront.dev/frontmcp/deployment/production-build>

package/catalog/frontmcp-deployment/references/build-for-sdk.md

@@ -258,6 +258,16 @@ node -e "const { create } = require('./dist/my-sdk.cjs.js'); ..."
 | `connectOpenAI()` format wrong  | Using raw `listTools()` instead of platform client | Use `connectOpenAI()` which formats tools for OpenAI automatically  |
 | Bundle includes `@frontmcp/*`   | Build config missing externals                     | Verify `--target sdk` is set; it marks `@frontmcp/*` as external    |
 
+## Examples
+
+| Example                                                                         | Level        | Description                                                                                                |
+| ------------------------------------------------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------- |
+| [`connect-openai`](../examples/build-for-sdk/connect-openai.md)                 | Intermediate | Use `connectOpenAI()` to get tools formatted for OpenAI's function-calling API.                            |
+| [`create-flat-config`](../examples/build-for-sdk/create-flat-config.md)         | Basic        | Spin up an in-memory FrontMCP server from a flat config object using `create()`.                           |
+| [`multi-platform-connect`](../examples/build-for-sdk/multi-platform-connect.md) | Advanced     | Connect the same FrontMCP server to multiple LLM platforms using platform-specific `connect*()` functions. |
+
+> See all examples in [`examples/build-for-sdk/`](../examples/build-for-sdk/)
+
 ## Reference
 
 - **Docs:** <https://docs.agentfront.dev/frontmcp/deployment/direct-client>

package/catalog/frontmcp-deployment/references/deploy-to-cloudflare.md

@@ -212,6 +212,16 @@ curl -X POST https://frontmcp-worker.your-subdomain.workers.dev/mcp \
 - [ ] SSE streaming works end-to-end (if using SSE transport)
 - [ ] Custom domain resolves correctly (if configured)
 
+## Examples
+
+| Example                                                                                | Level        | Description                                                                                             |
+| -------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------- |
+| [`basic-worker-deploy`](../examples/deploy-to-cloudflare/basic-worker-deploy.md)       | Basic        | Deploy a FrontMCP server to Cloudflare Workers with a minimal configuration.                            |
+| [`worker-custom-domain`](../examples/deploy-to-cloudflare/worker-custom-domain.md)     | Advanced     | Scaffold a FrontMCP project targeting Cloudflare, configure a custom domain, and verify the deployment. |
+| [`worker-with-kv-storage`](../examples/deploy-to-cloudflare/worker-with-kv-storage.md) | Intermediate | Deploy a FrontMCP server to Cloudflare Workers with KV namespace for session and state storage.         |
+
+> See all examples in [`examples/deploy-to-cloudflare/`](../examples/deploy-to-cloudflare/)
+
 ## Reference
 
 - **Docs:** <https://docs.agentfront.dev/frontmcp/deployment/serverless>

package/catalog/frontmcp-deployment/references/deploy-to-lambda.md

@@ -316,6 +316,16 @@ Lambda cold starts occur when a new execution environment is initialized. Strate
 | Redis connection refused from Lambda | Lambda not in the same VPC as ElastiCache                       | Place the Lambda in the ElastiCache VPC with appropriate security group rules                             |
 | `sam deploy` fails with IAM error    | Insufficient permissions for CloudFormation stack creation      | Ensure the deploying IAM user/role has `cloudformation:*`, `lambda:*`, `apigateway:*`, and `iam:PassRole` |
 
+## Examples
+
+| Example                                                                                | Level        | Description                                                                                           |
+| -------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------- |
+| [`cdk-deployment`](../examples/deploy-to-lambda/cdk-deployment.md)                     | Advanced     | Deploy a FrontMCP server to AWS Lambda using CDK with provisioned concurrency and secrets management. |
+| [`lambda-handler-with-cors`](../examples/deploy-to-lambda/lambda-handler-with-cors.md) | Intermediate | Create a custom Lambda handler with an explicit API Gateway definition for CORS support.              |
+| [`sam-template-basic`](../examples/deploy-to-lambda/sam-template-basic.md)             | Basic        | Deploy a FrontMCP server to AWS Lambda with API Gateway using a SAM template.                         |
+
+> See all examples in [`examples/deploy-to-lambda/`](../examples/deploy-to-lambda/)
+
 ## Reference
 
 - **Docs:** https://docs.agentfront.dev/frontmcp/deployment/serverless

package/catalog/frontmcp-deployment/references/deploy-to-node-dockerfile.md

@@ -57,3 +57,12 @@ HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
 
 CMD ["node", "dist/main.js"]
+
+## Examples
+
+| Example                                                                                               | Level    | Description                                                                                |
+| ----------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------ |
+| [`basic-multistage-dockerfile`](../examples/deploy-to-node-dockerfile/basic-multistage-dockerfile.md) | Basic    | A minimal multi-stage Dockerfile for building and running a FrontMCP server in production. |
+| [`secure-nonroot-dockerfile`](../examples/deploy-to-node-dockerfile/secure-nonroot-dockerfile.md)     | Advanced | A production Dockerfile with a non-root user, proper ownership, and security hardening.    |
+
+> See all examples in [`examples/deploy-to-node-dockerfile/`](../examples/deploy-to-node-dockerfile/)

package/catalog/frontmcp-deployment/references/deploy-to-node.md

@@ -256,6 +256,16 @@ services:
 | Out of memory (OOM kill)     | Container memory limit is too low            | Increase the memory limit in Docker or set `NODE_OPTIONS="--max-old-space-size=1024"`       |
 | PM2 not restarting on reboot | Startup hook was not saved                   | Run `pm2 save && pm2 startup` to persist the process list across reboots                    |
 
+## Examples
+
+| Example                                                                                | Level        | Description                                                                                               |
+| -------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------- |
+| [`docker-compose-with-redis`](../examples/deploy-to-node/docker-compose-with-redis.md) | Basic        | Deploy a FrontMCP server with Redis using Docker Compose for production.                                  |
+| [`pm2-with-nginx`](../examples/deploy-to-node/pm2-with-nginx.md)                       | Intermediate | Deploy a FrontMCP server on bare metal using PM2 for process management and NGINX for TLS termination.    |
+| [`resource-limits`](../examples/deploy-to-node/resource-limits.md)                     | Advanced     | Configure resource limits, health checks, and environment variables for a production FrontMCP deployment. |
+
+> See all examples in [`examples/deploy-to-node/`](../examples/deploy-to-node/)
+
 ## Reference
 
 - **Docs:** https://docs.agentfront.dev/frontmcp/deployment/production-build

package/catalog/frontmcp-deployment/references/deploy-to-vercel-config.md

@@ -63,3 +63,12 @@ description: Reference vercel.json configuration for deploying a FrontMCP server
 }
 ]
 }
+
+## Examples
+
+| Example                                                                                                             | Level        | Description                                                                                        |
+| ------------------------------------------------------------------------------------------------------------------- | ------------ | -------------------------------------------------------------------------------------------------- |
+| [`minimal-vercel-config`](../examples/deploy-to-vercel-config/minimal-vercel-config.md)                             | Basic        | The minimum `vercel.json` needed to deploy a FrontMCP server to Vercel.                            |
+| [`vercel-config-with-security-headers`](../examples/deploy-to-vercel-config/vercel-config-with-security-headers.md) | Intermediate | A complete `vercel.json` with per-route security headers for health, MCP, and all other endpoints. |
+
+> See all examples in [`examples/deploy-to-vercel-config/`](../examples/deploy-to-vercel-config/)

package/catalog/frontmcp-deployment/references/deploy-to-vercel.md

@@ -223,6 +223,16 @@ Serverless functions are stateless between invocations. All persistent state mus
 | Bundle too large     | Unnecessary dependencies included             | Review dependencies and remove unused packages to reduce bundle size                           |
 | Cold starts too slow | Low function memory or large bundle           | Increase memory to 1024 MB; audit dependencies; consider Vercel Fluid Compute                  |
 
+## Examples
+
+| Example                                                                                | Level        | Description                                                                                     |
+| -------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------- |
+| [`vercel-mcp-endpoint-test`](../examples/deploy-to-vercel/vercel-mcp-endpoint-test.md) | Advanced     | Verify a Vercel-deployed FrontMCP server by testing health, tool listing, and tool invocation.  |
+| [`vercel-with-kv`](../examples/deploy-to-vercel/vercel-with-kv.md)                     | Basic        | Deploy a FrontMCP server to Vercel serverless functions with Vercel KV for session persistence. |
+| [`vercel-with-skills-cache`](../examples/deploy-to-vercel/vercel-with-skills-cache.md) | Intermediate | Deploy a FrontMCP server to Vercel with skills enabled and KV-backed skill caching.             |
+
+> See all examples in [`examples/deploy-to-vercel/`](../examples/deploy-to-vercel/)
+
 ## Reference
 
 - **Docs:** https://docs.agentfront.dev/frontmcp/deployment/serverless

package/catalog/frontmcp-development/SKILL.md

@@ -9,7 +9,7 @@ priority: 10
 visibility: both
 license: Apache-2.0
 metadata:
-  docs: https://docs.agentfront.dev/frontmcp/servers/overview
+  docs: https://docs.agentfront.dev/frontmcp/fundamentals/overview
 ---
 
 # FrontMCP Development Router
@@ -122,5 +122,5 @@ Entry point for building MCP server components. This skill helps you find the ri
 
 ## Reference
 
-- [Server Overview](https://docs.agentfront.dev/frontmcp/servers/overview)
+- [FrontMCP Overview](https://docs.agentfront.dev/frontmcp/fundamentals/overview)
 - Related skills: `create-tool`, `create-resource`, `create-prompt`, `create-agent`, `create-provider`, `create-job`, `create-workflow`, `create-skill`, `create-skill-with-tools`, `decorators-guide`, `official-adapters`, `official-plugins`

package/catalog/frontmcp-development/examples/create-adapter/basic-api-adapter.md

@@ -0,0 +1,92 @@
+---
+name: basic-api-adapter
+reference: create-adapter
+level: basic
+description: 'A minimal adapter that fetches operation definitions from an external API and generates MCP tools.'
+tags: [development, adapter, api]
+features:
+  - 'Extending `DynamicAdapter<TOptions>` with a typed options interface'
+  - 'Declaring `__options_brand` for proper TypeScript inference on `init()`'
+  - 'Implementing `fetch()` to return `FrontMcpAdapterResponse` with tools, resources, and prompts'
+  - 'Registering the adapter via the static `init()` method in the `adapters` array'
+---
+
+# Basic Dynamic Adapter
+
+A minimal adapter that fetches operation definitions from an external API and generates MCP tools.
+
+## Code
+
+```typescript
+// src/adapters/my-api.adapter.ts
+import { DynamicAdapter, type FrontMcpAdapterResponse } from '@frontmcp/sdk';
+
+interface MyAdapterOptions {
+  endpoint: string;
+  apiKey: string;
+}
+
+class MyApiAdapter extends DynamicAdapter<MyAdapterOptions> {
+  declare __options_brand: MyAdapterOptions;
+
+  async fetch(): Promise<FrontMcpAdapterResponse> {
+    // Fetch definitions from external source
+    const res = await globalThis.fetch(this.options.endpoint, {
+      headers: { Authorization: `Bearer ${this.options.apiKey}` },
+    });
+    const schema = await res.json();
+
+    // Convert to MCP tool definitions
+    return {
+      tools: schema.operations.map((op: { name: string; description: string; params: Record<string, unknown> }) => ({
+        name: op.name,
+        description: op.description,
+        inputSchema: this.convertParams(op.params),
+        execute: async (input: Record<string, unknown>) => {
+          return this.callApi(op.name, input);
+        },
+      })),
+      resources: [],
+      prompts: [],
+    };
+  }
+
+  private convertParams(params: Record<string, unknown>) {
+    // Convert external param definitions to Zod schemas
+    return {};
+  }
+
+  private async callApi(operation: string, input: Record<string, unknown>) {
+    // Call the external API
+    return {};
+  }
+}
+```
+
+```typescript
+// src/server.ts
+import { App } from '@frontmcp/sdk';
+
+@App({
+  name: 'MyApp',
+  adapters: [
+    MyApiAdapter.init({
+      name: 'my-api',
+      endpoint: 'https://api.example.com/schema',
+      apiKey: process.env.API_KEY!,
+    }),
+  ],
+})
+class MyApp {}
+```
+
+## What This Demonstrates
+
+- Extending `DynamicAdapter<TOptions>` with a typed options interface
+- Declaring `__options_brand` for proper TypeScript inference on `init()`
+- Implementing `fetch()` to return `FrontMcpAdapterResponse` with tools, resources, and prompts
+- Registering the adapter via the static `init()` method in the `adapters` array
+
+## Related
+
+- See `create-adapter` for namespacing, error handling, and the full adapter response interface

package/catalog/frontmcp-development/examples/create-adapter/namespaced-adapter.md

@@ -0,0 +1,124 @@
+---
+name: namespaced-adapter
+reference: create-adapter
+level: intermediate
+description: 'An adapter that namespaces generated tools to avoid collisions and includes proper error handling for startup failures.'
+tags: [development, adapter, namespaced]
+features:
+  - "Namespacing tools with `name: 'adapter-name:operation-name'` to prevent collisions"
+  - 'Throwing descriptive errors in `fetch()` so misconfigurations surface at startup'
+  - 'Registering multiple instances of the same adapter class with different configurations'
+  - 'Validating the external response shape before generating tool definitions'
+---
+
+# Namespaced Adapter with Error Handling
+
+An adapter that namespaces generated tools to avoid collisions and includes proper error handling for startup failures.
+
+## Code
+
+```typescript
+// src/adapters/graphql-api.adapter.ts
+import { DynamicAdapter, type FrontMcpAdapterResponse } from '@frontmcp/sdk';
+
+interface GraphqlAdapterOptions {
+  endpoint: string;
+  apiKey: string;
+  namespace?: string;
+}
+
+class GraphqlApiAdapter extends DynamicAdapter<GraphqlAdapterOptions> {
+  declare __options_brand: GraphqlAdapterOptions;
+
+  async fetch(): Promise<FrontMcpAdapterResponse> {
+    const namespace = this.options.namespace ?? this.options.name;
+
+    // Fetch schema from GraphQL introspection
+    const res = await globalThis.fetch(this.options.endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.options.apiKey}`,
+      },
+      body: JSON.stringify({
+        query: '{ __schema { queryType { fields { name description } } } }',
+      }),
+    });
+
+    if (!res.ok) {
+      throw new Error(`GraphQL adapter failed to fetch schema from ${this.options.endpoint}: HTTP ${res.status}`);
+    }
+
+    const schema = await res.json();
+    const fields = schema.data?.__schema?.queryType?.fields;
+
+    if (!fields || !Array.isArray(fields)) {
+      throw new Error(`GraphQL adapter received unexpected schema format from ${this.options.endpoint}`);
+    }
+
+    // Namespace tools to prevent collisions across adapters
+    return {
+      tools: fields.map((field: { name: string; description: string }) => ({
+        name: `${namespace}:${field.name}`,
+        description: field.description || `Query ${field.name} from GraphQL API`,
+        inputSchema: {},
+        execute: async (input: Record<string, unknown>) => {
+          return this.executeQuery(field.name, input);
+        },
+      })),
+    };
+  }
+
+  private async executeQuery(queryName: string, variables: Record<string, unknown>) {
+    const res = await globalThis.fetch(this.options.endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.options.apiKey}`,
+      },
+      body: JSON.stringify({ query: `{ ${queryName} }`, variables }),
+    });
+    return res.json();
+  }
+}
+```
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+
+@App({
+  name: 'DataApp',
+  adapters: [
+    // Each adapter uses its name for tool namespacing
+    GraphqlApiAdapter.init({
+      name: 'users-api',
+      endpoint: 'https://users.example.com/graphql',
+      apiKey: process.env.USERS_API_KEY!,
+    }),
+    GraphqlApiAdapter.init({
+      name: 'orders-api',
+      endpoint: 'https://orders.example.com/graphql',
+      apiKey: process.env.ORDERS_API_KEY!,
+    }),
+  ],
+})
+class DataApp {}
+
+@FrontMcp({
+  info: { name: 'data-server', version: '1.0.0' },
+  apps: [DataApp],
+})
+class DataServer {}
+```
+
+## What This Demonstrates
+
+- Namespacing tools with `name: 'adapter-name:operation-name'` to prevent collisions
+- Throwing descriptive errors in `fetch()` so misconfigurations surface at startup
+- Registering multiple instances of the same adapter class with different configurations
+- Validating the external response shape before generating tool definitions
+
+## Related
+
+- See `create-adapter` for the full `FrontMcpAdapterResponse` interface, Nx generator, and verification checklist

package/catalog/frontmcp-development/examples/create-agent/basic-agent-with-tools.md

@@ -0,0 +1,121 @@
+---
+name: basic-agent-with-tools
+reference: create-agent
+level: basic
+description: 'An autonomous agent that uses inner tools to review GitHub pull requests.'
+tags: [development, anthropic, agent, tools]
+features:
+  - 'Creating an agent with `@Agent` decorator, `llm` config, and `inputSchema`'
+  - 'Defining inner tools in the `tools` array that the agent can invoke during its reasoning loop'
+  - "Using `{ env: 'ANTHROPIC_API_KEY' }` for safe API key configuration"
+  - 'Inner tools are private to the agent and not exposed to external MCP clients'
+  - 'The default `execute()` runs the full agent loop without needing an override'
+---
+
+# Basic Agent with Inner Tools
+
+An autonomous agent that uses inner tools to review GitHub pull requests.
+
+## Code
+
+```typescript
+// src/apps/review/tools/fetch-pr.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'fetch_pr',
+  description: 'Fetch pull request details from GitHub',
+  inputSchema: {
+    owner: z.string(),
+    repo: z.string(),
+    number: z.number(),
+  },
+})
+class FetchPRTool extends ToolContext {
+  async execute(input: { owner: string; repo: string; number: number }) {
+    const response = await this.fetch(
+      `https://api.github.com/repos/${input.owner}/${input.repo}/pulls/${input.number}`,
+    );
+    return response.json();
+  }
+}
+```
+
+```typescript
+// src/apps/review/tools/post-review.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'post_review_comment',
+  description: 'Post a review comment on a PR',
+  inputSchema: {
+    owner: z.string(),
+    repo: z.string(),
+    number: z.number(),
+    body: z.string(),
+  },
+})
+class PostReviewCommentTool extends ToolContext {
+  async execute(input: { owner: string; repo: string; number: number; body: string }) {
+    await this.fetch(`https://api.github.com/repos/${input.owner}/${input.repo}/pulls/${input.number}/reviews`, {
+      method: 'POST',
+      body: JSON.stringify({ body: input.body, event: 'COMMENT' }),
+    });
+    return 'Comment posted';
+  }
+}
+```
+
+```typescript
+// src/apps/review/agents/pr-reviewer.agent.ts
+import { Agent, AgentContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Agent({
+  name: 'pr_reviewer',
+  description: 'Autonomously reviews GitHub pull requests',
+  llm: {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-20250514',
+    apiKey: { env: 'ANTHROPIC_API_KEY' },
+  },
+  inputSchema: {
+    owner: z.string().describe('Repository owner'),
+    repo: z.string().describe('Repository name'),
+    prNumber: z.number().describe('PR number to review'),
+  },
+  systemInstructions: 'You are a senior code reviewer. Fetch the PR, analyze changes, and post a thorough review.',
+  tools: [FetchPRTool, PostReviewCommentTool],
+})
+class PRReviewerAgent extends AgentContext {
+  // Default execute() runs the agent loop.
+  // The agent will autonomously call FetchPRTool, analyze the diff,
+  // and call PostReviewCommentTool to leave a review.
+}
+```
+
+```typescript
+// src/apps/review/index.ts
+import { App } from '@frontmcp/sdk';
+
+@App({
+  name: 'review-app',
+  agents: [PRReviewerAgent],
+})
+class ReviewApp {}
+```
+
+## What This Demonstrates
+
+- Creating an agent with `@Agent` decorator, `llm` config, and `inputSchema`
+- Defining inner tools in the `tools` array that the agent can invoke during its reasoning loop
+- Using `{ env: 'ANTHROPIC_API_KEY' }` for safe API key configuration
+- Inner tools are private to the agent and not exposed to external MCP clients
+- The default `execute()` runs the full agent loop without needing an override
+
+## Related
+
+- See `create-agent` for custom execute, sub-agents, swarm configuration, and exported tools
+- See `create-agent-llm-config` for all supported LLM providers and model options