@frontmcp/skills 1.0.4 → 1.1.0-beta.1

package/catalog/frontmcp-development/examples/official-plugins/cache-and-feature-flags.md

@@ -21,9 +21,9 @@ Demonstrates combining the Cache plugin for tool result caching with the Feature
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App } from '@frontmcp/sdk';
 import CachePlugin from '@frontmcp/plugin-cache';
 import FeatureFlagPlugin from '@frontmcp/plugin-feature-flags';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({
   name: 'api',
@@ -55,8 +55,7 @@ class MyServer {}
 
 ```typescript
 // src/tools/get-weather.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 // Per-tool cache metadata with custom TTL and sliding window
 @Tool({
@@ -80,8 +79,7 @@ class GetWeatherTool extends ToolContext {
 
 ```typescript
 // src/tools/beta-search.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 // Tool gated behind a feature flag -- hidden from list_tools when flag is off
 @Tool({

package/catalog/frontmcp-development/examples/official-plugins/production-multi-plugin-setup.md

@@ -24,12 +24,12 @@ Demonstrates a production-ready server configuration combining CodeCall, Remembe
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App } from '@frontmcp/sdk';
-import CodeCallPlugin from '@frontmcp/plugin-codecall';
-import RememberPlugin from '@frontmcp/plugin-remember';
 import { ApprovalPlugin } from '@frontmcp/plugin-approval';
 import CachePlugin from '@frontmcp/plugin-cache';
+import CodeCallPlugin from '@frontmcp/plugin-codecall';
 import FeatureFlagPlugin from '@frontmcp/plugin-feature-flags';
+import RememberPlugin from '@frontmcp/plugin-remember';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({ name: 'core', tools: [ReadDataTool, WriteDataTool, DeleteDataTool] })
 class CoreApp {}
@@ -89,8 +89,7 @@ class ProductionServer {}
 
 ```typescript
 // src/tools/delete-data.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'delete_data',

package/catalog/frontmcp-development/examples/official-plugins/remember-plugin-session-memory.md

@@ -20,8 +20,8 @@ Demonstrates installing the Remember plugin and using `this.remember` in tools t
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App } from '@frontmcp/sdk';
 import RememberPlugin from '@frontmcp/plugin-remember';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({ name: 'my-app', tools: [PreferencesTool, GreetingTool] })
 class MyApp {}
@@ -41,8 +41,7 @@ class MyServer {}
 
 ```typescript
 // src/tools/preferences.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'set_preferences',
@@ -64,8 +63,7 @@ class PreferencesTool extends ToolContext {
 
 ```typescript
 // src/tools/greeting.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'get_greeting',

package/catalog/frontmcp-development/references/create-agent.md

@@ -43,8 +43,7 @@ Agents are autonomous AI entities that use an LLM to reason, plan, and invoke in
 Create a class extending `AgentContext<In, Out>` and optionally override the `execute(input: In): Promise<Out>` method. The `@Agent` decorator requires `name`, `description`, and `llm` configuration.
 
 ```typescript
-import { Agent, AgentContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Agent, AgentContext, z } from '@frontmcp/sdk';
 
 @Agent({
   name: 'code_reviewer',
@@ -242,8 +241,7 @@ async execute(input: { text: string }) {
 The `tools` array in `@Agent` metadata defines tools that the agent itself can invoke during its reasoning loop. These are NOT exposed to external callers -- they are private to the agent.
 
 ```typescript
-import { Tool, ToolContext, Agent, AgentContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Agent, AgentContext, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'fetch_pr',
@@ -406,8 +404,7 @@ class BillingAgent extends AgentContext {}
 For agents that do not need a class, use the `agent()` function builder.
 
 ```typescript
-import { agent } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { agent, z } from '@frontmcp/sdk';
 
 const QuickSummarizer = agent({
   name: 'quick_summarizer',
@@ -458,7 +455,7 @@ Both return values that can be registered in `agents: [ExternalAgent, CloudAgent
 Add agent classes (or function-style agents) to the `agents` array in `@FrontMcp` or `@App`.
 
 ```typescript
-import { FrontMcp, App } from '@frontmcp/sdk';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({
   name: 'review-app',

package/catalog/frontmcp-development/references/create-job.md

@@ -50,8 +50,7 @@ Create a class extending `JobContext<In, Out>` and implement the `execute(input:
 ### Basic Example
 
 ```typescript
-import { Job, JobContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Job, JobContext, z } from '@frontmcp/sdk';
 
 @Job({
   name: 'generate-report',
@@ -339,8 +338,7 @@ permissions: {
 For simple jobs that do not need a class, use the `job()` function builder. The callback receives `(input, ctx)` where `ctx` provides all `JobContext` methods.
 
 ```typescript
-import { job } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { job, z } from '@frontmcp/sdk';
 
 const CleanupTempFiles = job({
   name: 'cleanup-temp-files',
@@ -444,8 +442,7 @@ This creates the job file, spec file, and updates barrel exports.
 ## Complete Example: Data Pipeline Job
 
 ```typescript
-import { Job, JobContext, FrontMcp, App, job } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Job, job, JobContext, z } from '@frontmcp/sdk';
 
 @Job({
   name: 'etl-pipeline',

package/catalog/frontmcp-development/references/create-plugin-hooks.md

@@ -72,7 +72,7 @@ In addition to flow-based hooks, plugins can register callbacks for server lifec
 Runs after the HTTP server is fully initialized and listening. Use for warming caches, starting background indexing, or logging readiness.
 
 ```typescript
-import { Plugin, DynamicPlugin } from '@frontmcp/sdk';
+import { DynamicPlugin, Plugin } from '@frontmcp/sdk';
 
 @Plugin({
   name: 'cache-warmer',
@@ -105,12 +105,12 @@ For convenience, FrontMCP exports typed aliases so you do not need to call `Flow
 
 ```typescript
 import {
-  ToolHook, // FlowHooksOf('tools:call-tool')
-  ListToolsHook, // FlowHooksOf('tools:list-tools')
-  ResourceHook, // FlowHooksOf('resources:read-resource')
-  ListResourcesHook, // FlowHooksOf('resources:list-resources')
   AgentCallHook, // FlowHooksOf('agents:call-agent')
   HttpHook, // FlowHooksOf('http:request')
+  ListResourcesHook, // FlowHooksOf('resources:list-resources')
+  ListToolsHook, // FlowHooksOf('tools:list-tools')
+  ResourceHook, // FlowHooksOf('resources:read-resource')
+  ToolHook, // FlowHooksOf('tools:call-tool')
 } from '@frontmcp/sdk';
 ```
 
@@ -152,8 +152,7 @@ Both `@Will` and `@Did` (and `@Around`) accept an optional options object:
 ### Logging Plugin
 
 ```typescript
-import { Plugin } from '@frontmcp/sdk';
-import { ToolHook } from '@frontmcp/sdk';
+import { Plugin, ToolHook } from '@frontmcp/sdk';
 
 const { Will, Did } = ToolHook;
 
@@ -174,8 +173,7 @@ export class LoggingPlugin {
 ### Authorization Check Plugin
 
 ```typescript
-import { Plugin } from '@frontmcp/sdk';
-import { ToolHook } from '@frontmcp/sdk';
+import { Plugin, ToolHook } from '@frontmcp/sdk';
 
 const { Will } = ToolHook;
 
@@ -194,8 +192,7 @@ export class AuthCheckPlugin {
 ### Caching Plugin with @Around
 
 ```typescript
-import { Plugin } from '@frontmcp/sdk';
-import { ToolHook } from '@frontmcp/sdk';
+import { Plugin, ToolHook } from '@frontmcp/sdk';
 
 const { Around } = ToolHook;
 
@@ -227,8 +224,7 @@ export class CachePlugin {
 ### Stage Replacement
 
 ```typescript
-import { Plugin } from '@frontmcp/sdk';
-import { ToolHook } from '@frontmcp/sdk';
+import { Plugin, ToolHook } from '@frontmcp/sdk';
 
 const { Stage } = ToolHook;
 
@@ -249,8 +245,9 @@ Register plugins in your `@App` decorator:
 
 ```typescript
 import { App } from '@frontmcp/sdk';
-import { LoggingPlugin } from './plugins/logging.plugin';
+
 import { CachePlugin } from './plugins/cache.plugin';
+import { LoggingPlugin } from './plugins/logging.plugin';
 
 @App({
   name: 'my-app',
@@ -266,8 +263,7 @@ Plugins are initialized in array order. Hook priority determines execution order
 You can add hook methods directly on a `@Tool` class to intercept its own execution flow. The hooks apply only when **this tool** is called:
 
 ```typescript
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 const { Will, Did } = ToolHook;
 

package/catalog/frontmcp-development/references/create-skill-with-tools.md

@@ -431,7 +431,7 @@ Both return values that can be registered in `skills: [ExternalSkill, CloudSkill
 Add skill classes (or function-style skills) to the `skills` array in `@FrontMcp` or `@App`.
 
 ```typescript
-import { FrontMcp, App } from '@frontmcp/sdk';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({
   name: 'devops-app',
@@ -505,8 +505,7 @@ GET /skills
 ## Complete Example: Multi-Tool Orchestration Skill
 
 ```typescript
-import { Skill, SkillContext, Tool, ToolContext, FrontMcp, App } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Skill, SkillContext, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 // Define the tools that the skill references
 

package/catalog/frontmcp-development/references/create-tool.md

@@ -34,8 +34,7 @@ Tools are the primary way to expose executable actions to AI clients in the MCP
 Create a class extending `ToolContext<In, Out>` and implement the `execute(input: In): Promise<Out>` method. The `@Tool` decorator requires at minimum a `name` and an `inputSchema`.
 
 ```typescript
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'greet_user',
@@ -158,6 +157,65 @@ class GetWeatherTool extends ToolContext {
 - CodeCall cannot infer return types for chaining tool calls in VM scripts
 - No compile-time type checking on the return value
 
+### Typed Output Patterns
+
+The `Out` generic on `ToolContext<InSchema, OutSchema, In, Out>` is inferred from `outputSchema`. You can wire the generics explicitly for full type safety — no `as any` casts needed:
+
+```typescript
+const inputSchema = {
+  city: z.string(),
+};
+
+const outputSchema = {
+  temperature: z.number(),
+  unit: z.enum(['celsius', 'fahrenheit']),
+};
+
+@Tool({
+  name: 'get_weather',
+  inputSchema,
+  outputSchema,
+})
+// No generics needed — ToolContext infers types from the @Tool decorator
+class GetWeatherTool extends ToolContext {
+  async execute(input: { city: string }) {
+    // Return type is inferred as { temperature: number; unit: 'celsius' | 'fahrenheit' }
+    // TypeScript will error if you return the wrong shape
+    return { temperature: 22, unit: 'celsius' as const };
+  }
+}
+```
+
+**`return` vs `this.respond()`** — Both work and both are validated against `outputSchema` in the finalize stage:
+
+```typescript
+// Option 1: return (preferred — simpler, same validation)
+async execute(input: Input) {
+  return { temperature: 22, unit: 'celsius' };
+}
+
+// Option 2: this.respond() — useful for early exit (throws FlowControl.respond internally)
+async execute(input: Input) {
+  if (someCondition) {
+    this.respond({ temperature: 0, unit: 'celsius' }); // never returns
+  }
+  return { temperature: 22, unit: 'celsius' };
+}
+```
+
+**Early returns from elicitation** must still match the output schema:
+
+```typescript
+async execute(input: Input) {
+  const result = await this.elicit('Confirm?', { confirm: z.boolean() });
+  if (result.action !== 'accept') {
+    // Must return a value matching outputSchema, not a raw string
+    return { temperature: 0, unit: 'celsius' as const };
+  }
+  // ... normal execution
+}
+```
+
 Supported `outputSchema` types:
 
 - **Zod raw shapes** (recommended): `{ field: z.string(), count: z.number() }` — structured JSON output with validation
@@ -263,7 +321,7 @@ class DeleteRecordTool extends ToolContext {
 For MCP-specific errors, use error classes with JSON-RPC codes:
 
 ```typescript
-import { ResourceNotFoundError, PublicMcpError, MCP_ERROR_CODES } from '@frontmcp/sdk';
+import { MCP_ERROR_CODES, PublicMcpError, ResourceNotFoundError } from '@frontmcp/sdk';
 
 this.fail(new ResourceNotFoundError(`Record ${input.id}`));
 ```
@@ -348,8 +406,7 @@ Annotation fields:
 For simple tools that do not need a class, use the `tool()` function builder. It returns a value you register the same way as a class tool.
 
 ```typescript
-import { tool } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { tool, z } from '@frontmcp/sdk';
 
 const AddNumbers = tool({
   name: 'add_numbers',
@@ -395,7 +452,7 @@ Both return values that can be registered in `tools: [RemoteTool, CloudTool]`.
 Add tool classes (or function-style tools) to the `tools` array in `@FrontMcp` or `@App`.
 
 ```typescript
-import { FrontMcp, App } from '@frontmcp/sdk';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({
   name: 'my-app',
@@ -549,7 +606,20 @@ if (this.isEnv('production')) {
 
 ## Elicitation (Interactive Input)
 
-Tools can request interactive input from users mid-execution using `this.elicit()`. Requires `elicitation` to be enabled at server level.
+Tools can request interactive input from users mid-execution using `this.elicit()`.
+
+> **Prerequisite:** Elicitation must be enabled at server level:
+>
+> ```typescript
+> @FrontMcp({
+>   elicitation: { enabled: true },
+>   // ... rest of config
+> })
+> ```
+>
+> See `configure-elicitation` for full configuration options including Redis-backed elicitation stores.
+>
+> **What happens without it:** Calling `this.elicit()` throws `ElicitationDisabledError` at runtime with the message: _"Elicitation is disabled in server configuration. Enable it via @FrontMcp({ elicitation: { enabled: true } })"_. The tool call fails and the error is returned to the client. There is no compile-time or startup warning — the error only occurs when the tool is actually invoked.
 
 ```typescript
 @Tool({
@@ -573,8 +643,6 @@ class ConfirmDeleteTool extends ToolContext {
 }
 ```
 
-> **Note:** Elicitation must be enabled at server level: `@FrontMcp({ elicitation: { enabled: true } })`. See `configure-elicitation` for full configuration options.
-
 ## Tool Examples
 
 Provide usage examples for documentation and discovery:
@@ -607,13 +675,14 @@ class ConvertCurrencyTool extends ToolContext {
 
 ## Common Patterns
 
-| Pattern        | Correct                                         | Incorrect                                     | Why                                                           |
-| -------------- | ----------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------- |
-| Input schema   | `inputSchema: { name: z.string() }` (raw shape) | `inputSchema: z.object({ name: z.string() })` | Framework wraps in `z.object()` internally                    |
-| Output schema  | Always define `outputSchema`                    | Omit `outputSchema`                           | Prevents data leaks and enables CodeCall chaining             |
-| DI resolution  | `this.get(TOKEN)` with proper error handling    | `this.tryGet(TOKEN)!` with non-null assertion | `get` throws a clear error; non-null assertions mask failures |
-| Error handling | `this.fail(new ResourceNotFoundError(...))`     | `throw new Error(...)`                        | `this.fail` triggers the error flow with MCP error codes      |
-| Tool naming    | `snake_case` names: `get_weather`               | `camelCase` or `PascalCase`: `getWeather`     | MCP protocol convention for tool names                        |
+| Pattern              | Correct                                         | Incorrect                                              | Why                                                                              |
+| -------------------- | ----------------------------------------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------- |
+| Input schema         | `inputSchema: { name: z.string() }` (raw shape) | `inputSchema: z.object({ name: z.string() })`          | Framework wraps in `z.object()` internally                                       |
+| Output schema        | Always define `outputSchema`                    | Omit `outputSchema`                                    | Prevents data leaks and enables CodeCall chaining                                |
+| DI resolution        | `this.get(TOKEN)` with proper error handling    | `this.tryGet(TOKEN)!` with non-null assertion          | `get` throws a clear error; non-null assertions mask failures                    |
+| Error handling       | `this.fail(new ResourceNotFoundError(...))`     | `throw new Error(...)`                                 | `this.fail` triggers the error flow with MCP error codes                         |
+| Tool naming          | `snake_case` names: `get_weather`               | `camelCase` or `PascalCase`: `getWeather`              | MCP protocol convention for tool names                                           |
+| ToolContext generics | `class MyTool extends ToolContext`              | `class MyTool extends ToolContext<typeof inputSchema>` | Types are auto-inferred from `@Tool` decorator — explicit generics are redundant |
 
 ## Verification Checklist
 
@@ -634,13 +703,14 @@ class ConvertCurrencyTool extends ToolContext {
 
 ## Troubleshooting
 
-| Problem                                          | Cause                                       | Solution                                                                     |
-| ------------------------------------------------ | ------------------------------------------- | ---------------------------------------------------------------------------- |
-| Tool not appearing in `tools/list`               | Not registered in `tools` array             | Add tool class to `@App` or `@FrontMcp` `tools` array                        |
-| Zod validation error on valid input              | Using `z.object()` wrapper in `inputSchema` | Use raw shape: `{ field: z.string() }` not `z.object({ field: z.string() })` |
-| `this.get(TOKEN)` throws DependencyNotFoundError | Provider not registered in scope            | Register provider in `providers` array of `@App` or `@FrontMcp`              |
-| Output contains unexpected fields                | No `outputSchema` defined                   | Add `outputSchema` to strip unvalidated fields from response                 |
-| Tool times out                                   | No timeout configured for long operation    | Add `timeout: { executeMs: 30_000 }` to `@Tool` options                      |
+| Problem                                           | Cause                                       | Solution                                                                     |
+| ------------------------------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------- |
+| Tool not appearing in `tools/list`                | Not registered in `tools` array             | Add tool class to `@App` or `@FrontMcp` `tools` array                        |
+| Zod validation error on valid input               | Using `z.object()` wrapper in `inputSchema` | Use raw shape: `{ field: z.string() }` not `z.object({ field: z.string() })` |
+| `this.get(TOKEN)` throws DependencyNotFoundError  | Provider not registered in scope            | Register provider in `providers` array of `@App` or `@FrontMcp`              |
+| Output contains unexpected fields                 | No `outputSchema` defined                   | Add `outputSchema` to strip unvalidated fields from response                 |
+| Tool times out                                    | No timeout configured for long operation    | Add `timeout: { executeMs: 30_000 }` to `@Tool` options                      |
+| `this.elicit()` throws `ElicitationDisabledError` | Elicitation not enabled at server level     | Add `elicitation: { enabled: true }` to `@FrontMcp` config                   |
 
 ## Examples
 

package/catalog/frontmcp-development/references/create-workflow.md

@@ -422,7 +422,7 @@ Register it the same way as a class workflow: `workflows: [QuickDeploy]`.
 Add workflow classes (or function-style workflows) to the `workflows` array in `@App`. Workflows require jobs to be enabled since each step runs a named job.
 
 ```typescript
-import { FrontMcp, App } from '@frontmcp/sdk';
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({
   name: 'pipeline-app',
@@ -462,8 +462,7 @@ This creates the workflow file, spec file, and updates barrel exports.
 ## Complete Example: CI/CD Pipeline
 
 ```typescript
-import { Workflow, Job, JobContext, FrontMcp, App, workflow } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Job, JobContext, Workflow, workflow, z } from '@frontmcp/sdk';
 
 // --- Jobs ---
 

package/catalog/frontmcp-development/references/decorators-guide.md

@@ -61,32 +61,32 @@ FrontMCP uses a hierarchical decorator system. The nesting order is:
 
 **Key fields:**
 
-| Field           | Description                                                                      |
-| --------------- | -------------------------------------------------------------------------------- |
-| `info`          | Server name, version, and description                                            |
-| `apps`          | Array of `@App` classes to mount                                                 |
-| `serve?`        | Auto-start HTTP server (default: `true`). Set `false` for programmatic usage     |
-| `splitByApp?`   | If `true`, each app gets its own scope and basePath. Default: `false`            |
-| `redis?`        | Redis / Vercel KV connection for sessions, transport persistence, auth tokens    |
-| `plugins?`      | Global plugins (instantiated per scope)                                          |
-| `providers?`    | Global DI providers available to all apps                                        |
-| `tools?`        | Standalone tools (outside apps, merged with app tools)                           |
-| `resources?`    | Standalone resources (merged with app resources)                                 |
-| `skills?`       | Standalone skills (merged with app skills)                                       |
-| `skillsConfig?` | Skills HTTP endpoints (`/llm.txt`, `/skills`) and MCP tool config                |
-| `transport?`    | Transport preset (`'modern'`, `'legacy'`, `'stateless-api'`, `'full'`) or object |
-| `auth?`         | Authentication mode: `'public'`, `'transparent'`, `'local'`, `'remote'`          |
-| `http?`         | HTTP server options (port, host, cors, socketPath)                               |
-| `logging?`      | Logging configuration (transports and levels)                                    |
-| `elicitation?`  | Enable interactive user input during tool execution                              |
-| `sqlite?`       | SQLite storage for local deployments (sessions, events)                          |
-| `pubsub?`       | Redis pub/sub for resource subscriptions (falls back to `redis` config)          |
-| `jobs?`         | Background jobs/workflows system (`{ enabled, store? }`)                         |
-| `throttle?`     | Server-level guard config (see note below)                                       |
-| `pagination?`   | List operation pagination (`tools/list` endpoint)                                |
-| `ui?`           | UI rendering config (CDN overrides for widget imports)                           |
-| `extApps?`      | Widget-to-host MCP Apps communication (host capabilities, session validation)    |
-| `loader?`       | Default npm/ESM package loader for `App.esm()` / `App.remote()` apps             |
+| Field           | Description                                                                                                                                                          |
+| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `info`          | Server name, version, and description                                                                                                                                |
+| `apps`          | Array of `@App` classes to mount                                                                                                                                     |
+| `serve?`        | Auto-start HTTP server (default: `true`). Set `false` for programmatic usage                                                                                         |
+| `splitByApp?`   | If `true`, each app gets its own scope and basePath. Default: `false`                                                                                                |
+| `redis?`        | Redis / Vercel KV connection for sessions, transport persistence, auth tokens                                                                                        |
+| `plugins?`      | Global plugins (instantiated per scope)                                                                                                                              |
+| `providers?`    | Global DI providers available to all apps                                                                                                                            |
+| `tools?`        | Standalone tools (outside apps, merged with app tools)                                                                                                               |
+| `resources?`    | Standalone resources (merged with app resources)                                                                                                                     |
+| `skills?`       | Standalone skills (merged with app skills)                                                                                                                           |
+| `skillsConfig?` | Skills HTTP endpoints (`/llm.txt`, `/skills`) and MCP tool config                                                                                                    |
+| `transport?`    | Transport preset (`'modern'`, `'legacy'`, `'stateless-api'`, `'full'`) or object                                                                                     |
+| `auth?`         | Authentication mode: `'public'`, `'transparent'`, `'local'`, `'remote'`                                                                                              |
+| `http?`         | HTTP server options (port, host, cors, socketPath)                                                                                                                   |
+| `logging?`      | Logging configuration (transports and levels)                                                                                                                        |
+| `elicitation?`  | Enable interactive user input during tool execution                                                                                                                  |
+| `sqlite?`       | SQLite storage for local deployments (sessions, events)                                                                                                              |
+| `pubsub?`       | Redis pub/sub for distributed resource subscriptions across multiple instances (single-server deployments use in-memory subscriptions; falls back to `redis` config) |
+| `jobs?`         | Background jobs/workflows system (`{ enabled, store? }`)                                                                                                             |
+| `throttle?`     | Server-level guard config (see note below)                                                                                                                           |
+| `pagination?`   | List operation pagination (`tools/list` endpoint)                                                                                                                    |
+| `ui?`           | UI rendering config (CDN overrides for widget imports)                                                                                                               |
+| `extApps?`      | Widget-to-host MCP Apps communication (host capabilities, session validation)                                                                                        |
+| `loader?`       | Default npm/ESM package loader for `App.esm()` / `App.remote()` apps                                                                                                 |
 
 > **Throttle vs per-tool guards:** Server-level `throttle` is a `GuardConfig` object with `global`, `defaultRateLimit`, `defaultConcurrency`, `defaultTimeout` sub-fields that set server-wide defaults. Tool-level `rateLimit`, `concurrency`, `timeout` fields (on `@Tool`) override these defaults per tool.
 
@@ -172,8 +172,7 @@ class AnalyticsApp {}
 | `ui?`                | UI widget configuration for tool rendering                           |
 
 ```typescript
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'search_users',
@@ -293,7 +292,7 @@ class AppConfigResource extends ResourceContext {
 | `icons?`       | Array of Icon objects for UI representation                     |
 
 ```typescript
-import { ResourceTemplate, ResourceContext } from '@frontmcp/sdk';
+import { ResourceContext, ResourceTemplate } from '@frontmcp/sdk';
 
 @ResourceTemplate({
   name: 'user_profile',
@@ -332,8 +331,7 @@ class UserProfileResource extends ResourceContext {
 | `swarm?`        | Multi-agent swarm configuration                        |
 
 ```typescript
-import { Agent, AgentContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Agent, AgentContext, z } from '@frontmcp/sdk';
 
 @Agent({
   name: 'research_agent',
@@ -499,8 +497,7 @@ class DatabaseProvider {}
 | `access`       | Access control configuration        |
 
 ```typescript
-import { Flow } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Flow, z } from '@frontmcp/sdk';
 
 @Flow({
   name: 'approval-flow',
@@ -536,8 +533,7 @@ class ApprovalFlow {}
 | `permissions?`       | Access control: `[{ action: 'execute', roles: ['admin'] }]`   |
 
 ```typescript
-import { Job, JobContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Job, JobContext, z } from '@frontmcp/sdk';
 
 @Job({
   name: 'sync_data',
@@ -630,7 +626,7 @@ class DeployPipeline {}
 | `@Around` | Wrapping | Wraps the flow, controlling execution     |
 
 ```typescript
-import { Will, Did, Stage, Around, HookContext } from '@frontmcp/sdk';
+import { Around, Did, HookContext, Stage, Will } from '@frontmcp/sdk';
 
 class AuditHooks {
   @Will('tools:call-tool')

package/catalog/frontmcp-extensibility/examples/vectoriadb/product-catalog-search.md

@@ -21,9 +21,9 @@ Shows advanced VectoriaDB usage with typed document metadata, batch operations,
 
 ```typescript
 // src/providers/product-search.provider.ts
+import { FileStorageAdapter, VectoriaDB, type DocumentMetadata } from 'vectoriadb';
+
 import { Provider, ProviderScope } from '@frontmcp/sdk';
-import { VectoriaDB, FileStorageAdapter } from 'vectoriadb';
-import type { DocumentMetadata } from 'vectoriadb';
 
 export const ProductSearch = Symbol('ProductSearch');
 
@@ -104,8 +104,8 @@ export class ProductSearchProvider {
 
 ```typescript
 // src/tools/find-products.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
+
 import { ProductSearch } from '../providers/product-search.provider';
 
 @Tool({

package/catalog/frontmcp-extensibility/examples/vectoriadb/semantic-search-with-persistence.md

@@ -21,9 +21,9 @@ Shows how to use `VectoriaDB` for semantic search with transformer models, filte
 
 ```typescript
 // src/providers/knowledge-base.provider.ts
+import { FileStorageAdapter, VectoriaDB, type DocumentMetadata } from 'vectoriadb';
+
 import { Provider, ProviderScope } from '@frontmcp/sdk';
-import { VectoriaDB, FileStorageAdapter } from 'vectoriadb';
-import type { DocumentMetadata } from 'vectoriadb';
 
 export const KnowledgeBase = Symbol('KnowledgeBase');
 
@@ -80,8 +80,8 @@ export class KnowledgeBaseProvider {
 
 ```typescript
 // src/tools/semantic-search.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
+
 import { KnowledgeBase } from '../providers/knowledge-base.provider';
 
 @Tool({

package/catalog/frontmcp-extensibility/examples/vectoriadb/tfidf-keyword-search.md

@@ -20,9 +20,10 @@ Shows how to use `TFIDFVectoria` for zero-dependency keyword search in a FrontMC
 
 ```typescript
 // src/providers/faq-search.provider.ts
-import { Provider, ProviderScope } from '@frontmcp/sdk';
 import { TFIDFVectoria } from 'vectoriadb';
 
+import { Provider, ProviderScope } from '@frontmcp/sdk';
+
 export const FAQSearch = Symbol('FAQSearch');
 
 @Provider({ name: 'faq-search', provide: FAQSearch, scope: ProviderScope.GLOBAL })
@@ -55,8 +56,8 @@ export class FAQSearchProvider {
 
 ```typescript
 // src/tools/search-faq.tool.ts
-import { Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { Tool, ToolContext, z } from '@frontmcp/sdk';
+
 import { FAQSearch } from '../providers/faq-search.provider';
 
 @Tool({