@frontmcp/skills 1.0.0-beta.9 → 1.0.0

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

@@ -1,3 +1,8 @@
+---
+name: deploy-to-lambda
+description: Deploy a FrontMCP server to AWS Lambda with API Gateway using SAM or CDK
+---
+
 # Deploy a FrontMCP Server to AWS Lambda
 
 This skill walks you through deploying a FrontMCP server to AWS Lambda with API Gateway using SAM or CDK.
@@ -29,7 +34,7 @@ This skill walks you through deploying a FrontMCP server to AWS Lambda with API
 - AWS account with appropriate IAM permissions
 - AWS CLI configured: `aws configure`
 - SAM CLI installed: `brew install aws-sam-cli` (macOS) or see AWS docs
-- Node.js 22 or later
+- Node.js 24 or later
 - A FrontMCP project ready to build
 
 ## Step 1: Build for Lambda
@@ -52,7 +57,7 @@ Description: FrontMCP server on AWS Lambda
 Globals:
   Function:
     Timeout: 30
-    Runtime: nodejs22.x
+    Runtime: nodejs24.x
     MemorySize: 512
     Environment:
       Variables:
@@ -202,7 +207,7 @@ import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 import * as integrations from 'aws-cdk-lib/aws-apigatewayv2-integrations';
 
 const fn = new lambda.Function(this, 'FrontMcpHandler', {
-  runtime: lambda.Runtime.NODEJS_22_X,
+  runtime: lambda.Runtime.NODEJS_24_X,
   handler: 'handler.handler',
   code: lambda.Code.fromAsset('.'),
   memorySize: 512,
@@ -311,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

@@ -1,6 +1,11 @@
+---
+name: deploy-to-node-dockerfile
+description: Multi-stage Dockerfile for building and running a FrontMCP server in production
+---
+
 # ---- Build Stage ----
 
-FROM node:22-alpine AS builder
+FROM node:24-alpine AS builder
 
 WORKDIR /app
 
@@ -16,7 +21,7 @@ RUN yarn frontmcp build --target node
 
 # ---- Production Stage ----
 
-FROM node:22-alpine AS production
+FROM node:24-alpine AS production
 
 WORKDIR /app
 
@@ -52,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

@@ -1,3 +1,8 @@
+---
+name: deploy-to-node
+description: Deploy a FrontMCP server as a standalone Node.js app with Docker and process managers
+---
+
 # Deploy a FrontMCP Server to Node.js
 
 This skill walks you through deploying a FrontMCP server as a standalone Node.js application, optionally containerized with Docker for production use.
@@ -26,7 +31,7 @@ This skill walks you through deploying a FrontMCP server as a standalone Node.js
 
 ## Prerequisites
 
-- Node.js 22 or later
+- Node.js 24 or later
 - Docker and Docker Compose (recommended for production)
 - A FrontMCP project ready to build
 
@@ -44,7 +49,7 @@ Create a multi-stage `Dockerfile` in your project root:
 
 ```dockerfile
 # Stage 1: Build
-FROM node:22-alpine AS builder
+FROM node:24-alpine AS builder
 WORKDIR /app
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
@@ -52,7 +57,7 @@ COPY . .
 RUN npx frontmcp build --target node
 
 # Stage 2: Production
-FROM node:22-alpine AS production
+FROM node:24-alpine AS production
 WORKDIR /app
 ENV NODE_ENV=production
 COPY --from=builder /app/dist ./dist
@@ -215,7 +220,7 @@ services:
 | Pattern                   | Correct                              | Incorrect                                        | Why                                                                 |
 | ------------------------- | ------------------------------------ | ------------------------------------------------ | ------------------------------------------------------------------- |
 | Build command             | `frontmcp build --target node`       | `tsc && node dist/main.js`                       | The FrontMCP build bundles deps and produces an optimized output    |
-| Docker base image         | `node:22-alpine` (multi-stage)       | `node:22` (single stage with dev deps)           | Multi-stage keeps the production image small and secure             |
+| Docker base image         | `node:24-alpine` (multi-stage)       | `node:24` (single stage with dev deps)           | Multi-stage keeps the production image small and secure             |
 | Process manager           | PM2 with `-i max` cluster mode       | Running `node dist/main.js` directly via `nohup` | PM2 handles restarts, logging, and multi-core clustering            |
 | Redis hostname in Compose | Service name `redis`                 | `localhost` or `127.0.0.1`                       | Containers communicate via Docker's internal DNS, not localhost     |
 | Environment config        | `.env` file or orchestrator env vars | Hardcoded values in source code                  | Keeps secrets out of the codebase and allows per-environment config |
@@ -251,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

@@ -1,3 +1,8 @@
+---
+name: deploy-to-vercel-config
+description: Reference vercel.json configuration for deploying a FrontMCP server to Vercel
+---
+
 {
 "$schema": "https://openapi.vercel.sh/vercel.json",
 "framework": null,
@@ -58,3 +63,12 @@
 }
 ]
 }
+
+## 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

@@ -1,3 +1,8 @@
+---
+name: deploy-to-vercel
+description: Deploy a FrontMCP server to Vercel serverless functions with Vercel KV storage
+---
+
 # Deploy a FrontMCP Server to Vercel
 
 This skill guides you through deploying a FrontMCP server to Vercel serverless functions with Vercel KV for persistent storage.
@@ -218,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

@@ -1,12 +1,15 @@
 ---
 name: frontmcp-development
-description: "Domain router for building MCP components \u2014 tools, resources, prompts, agents, providers, jobs, workflows, and skills. Use when starting any FrontMCP development task and need to find the right skill."
+description: 'Use when you want to create a tool, add a resource, build a prompt, write a provider, implement an adapter, add OpenAPI integration, create a plugin, agent, job, or workflow. The skill for BUILDING any FrontMCP component.'
 tags: [router, development, tools, resources, prompts, agents, skills, guide]
+category: development
+targets: [all]
+bundle: [recommended, minimal, full]
 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
@@ -37,20 +40,25 @@ Entry point for building MCP server components. This skill helps you find the ri
 
 ## Scenario Routing Table
 
-| Scenario                                                 | Skill                     | Description                                                                          |
-| -------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------ |
-| Expose an executable action that AI clients can call     | `create-tool`             | Class-based or function-style tools with Zod input/output validation                 |
-| Expose read-only data via a URI                          | `create-resource`         | Static resources or URI template resources for dynamic data                          |
-| Create a reusable conversation template or system prompt | `create-prompt`           | Prompt entries with arguments and multi-turn message sequences                       |
-| Build an autonomous AI loop that orchestrates tools      | `create-agent`            | Agent entries with LLM config, inner tools, and swarm handoff                        |
-| Register shared services or configuration via DI         | `create-provider`         | Dependency injection tokens, lifecycle hooks, factory providers                      |
-| Run a background task with progress and retries          | `create-job`              | Job entries with attempt tracking, retry config, and progress                        |
-| Chain multiple jobs into a sequential pipeline           | `create-workflow`         | Workflow entries that compose jobs with data passing                                 |
-| Write instruction-only AI guidance (no code execution)   | `create-skill`            | Skill entries with markdown instructions from files, strings, or URLs                |
-| Write AI guidance that also orchestrates tools           | `create-skill-with-tools` | Skill entries that combine instructions with registered tools                        |
-| Look up any decorator signature or option                | `decorators-guide`        | Complete reference for @Tool, @Resource, @Prompt, @Agent, @App, @FrontMcp, and more  |
-| Integrate an external API via OpenAPI spec               | `official-adapters`       | OpenApiAdapter with auth, polling, inline specs, and multiple API composition        |
-| Use official plugins (caching, remember, feature flags)  | `official-plugins`        | Built-in plugins for caching, session memory, approval, feature flags, and dashboard |
+| Scenario                                                 | Skill                             | Description                                                                                   |
+| -------------------------------------------------------- | --------------------------------- | --------------------------------------------------------------------------------------------- |
+| Expose an executable action that AI clients can call     | `create-tool`                     | Class-based or function-style tools with Zod input/output validation                          |
+| Expose read-only data via a URI                          | `create-resource`                 | Static resources or URI template resources for dynamic data                                   |
+| Create a reusable conversation template or system prompt | `create-prompt`                   | Prompt entries with arguments and multi-turn message sequences                                |
+| Build an autonomous AI loop that orchestrates tools      | `create-agent`                    | Agent entries with LLM config, inner tools, and swarm handoff                                 |
+| Register shared services or configuration via DI         | `create-provider`                 | Dependency injection tokens, lifecycle hooks, factory providers                               |
+| Run a background task with progress and retries          | `create-job`                      | Job entries with attempt tracking, retry config, and progress                                 |
+| Chain multiple jobs into a sequential pipeline           | `create-workflow`                 | Workflow entries that compose jobs with data passing                                          |
+| Write instruction-only AI guidance (no code execution)   | `create-skill`                    | Skill entries with markdown instructions from files, strings, or URLs                         |
+| Write AI guidance that also orchestrates tools           | `create-skill-with-tools`         | Skill entries that combine instructions with registered tools                                 |
+| Look up any decorator signature or option                | `decorators-guide`                | Complete reference for @Tool, @Resource, @Prompt, @Agent, @App, @FrontMcp, and more           |
+| Integrate an external API via OpenAPI spec               | `official-adapters`               | OpenapiAdapter with auth, polling, inline specs, and multiple API composition                 |
+| Use official plugins (caching, remember, feature flags)  | `official-plugins`                | Built-in plugins for caching, session memory, approval, and feature flags (dashboard is beta) |
+| Connect to an external data source via a custom adapter  | `create-adapter`                  | Create custom adapters for external data sources                                              |
+| Configure LLM settings for an agent component            | `create-agent-llm-config`         | Configure LLM settings for agent components                                                   |
+| Add will/did/around lifecycle hooks to a plugin          | `create-plugin-hooks`             | Add lifecycle hooks to plugins (will/did/around)                                              |
+| Annotate tools with client hints for AI clients          | `create-tool-annotations`         | Add MCP tool annotations for client hints                                                     |
+| Define typed output schemas for tool responses           | `create-tool-output-schema-types` | Define typed output schemas for tools                                                         |
 
 ## Recommended Reading Order
 
@@ -114,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