@jrmc/adonis-mcp 1.0.0-alpha.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jeremy Chaufourier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,292 @@
+# @jrmc/adonis-mcp
+
+[![npm version](https://badge.fury.io/js/%40jrmc%2Fadonis-mcp.svg)](https://badge.fury.io/js/%40jrmc%2Fadonis-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+AdonisJS MCP - Server MCP for your AdonisJS applications.
+
+## Roadmap
+
+- [x] MCP prompts support
+- [ ] MCP resources support
+- [ ] MCP prompts support
+- [ ] Alternative transports support SSE
+- [x] Alternative transports support stdio
+- [x] Advanced pagination support
+- [ ] Automatic schema validation with Vine ??
+- [ ] Fake transport
+- [ ] Documentation
+
+## Installation & Configuration
+
+```bash
+node ace add @jrmc/adonis-mcp
+```
+
+This will create a configuration file `config/mcp.ts`:
+
+```typescript
+import { defineConfig } from '@jrmc/adonis-mcp'
+
+export default defineConfig({
+  name: 'adonis-mcp-server',
+  version: '1.0.0',
+  path: 'app/mcp', // Path where your tools will be stored
+})
+```
+
+## Usage
+
+### Creating a Tool
+
+To create a new tool, use the Ace command:
+
+```bash
+node ace make:mcp-tool my_tool
+```
+
+This command will create a file in `app/mcp/tools/my_tool.ts` with a base template:
+
+```typescript
+import type { McpContext } from '@jrmc/adonis-mcp/types/context'
+import type { BaseSchema, InferJSONSchema } from '@jrmc/adonis-mcp/types/method'
+
+import { Tool } from '@jrmc/adonis-mcp'
+
+type Schema = BaseSchema<{
+  text: { type: "string" }
+}>
+
+type Context = McpContext & { args: InferJSONSchema<Schema> }
+
+export default class MyToolTool implements Tool<Schema> {
+  name = 'tool_name'
+  title = 'Tool title'
+  description = 'Tool description'
+
+  async handle({ args }: Context) {
+    console.log(args.text)
+  }
+
+  schema() {
+    return {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "Description text argument"
+        },
+      },
+      required: ["text"]
+    } as Schema
+  }
+}
+```
+
+### Schema Definition
+
+The schema defines the input parameters of your tool. It follows the [JSON Schema](https://json-schema.org/) specification:
+
+```typescript
+schema() {
+  return {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Bookmark title"
+      },
+      url: {
+        type: "string",
+        description: "Bookmark URL"
+      }
+    },
+    required: ["title", "url"]
+  } as Schema
+}
+```
+
+You can also use Zod to define your schema:
+
+```typescript
+import * as z from 'zod'
+
+const zodSchema = z.object({
+  page: z.number().optional(),
+  perPage: z.number().optional()
+})
+
+schema() {
+  return z.toJSONSchema(
+    zodSchema,
+    { io: "input" }
+  ) as Schema
+}
+```
+
+### Handler Implementation
+
+The `handle` method contains your tool's logic. It receives a typed context with validated arguments:
+
+```typescript
+async handle({ args, response, auth, bouncer }: Context) {
+  // Your logic here
+  const result = await SomeModel.query().where('id', args.id)
+  
+  return response.text(JSON.stringify({ result }))
+}
+```
+
+### Setting up Authentication and Bouncer
+
+To use `auth` and `bouncer` in your MCP tools, add the following TypeScript declaration in your middleware (e.g., in your Bouncer initialization middleware):
+
+```typescript
+declare module '@jrmc/adonis-mcp/types/context' {
+  export interface McpContext {
+    auth?: {
+      user?: HttpContext['auth']['user']
+    }
+    bouncer?: Bouncer<
+      Exclude<HttpContext['auth']['user'], undefined>,
+      typeof abilities,
+      typeof policies
+    >
+  }
+}
+```
+
+The MCP context automatically binds `auth` and `bouncer` from the `HttpContext` if they are available, so make sure your middleware initializes them on the `HttpContext` first.
+
+#### Registering the MCP Route
+
+In your `start/routes.ts` file, register the MCP route and apply middleware:
+
+```typescript
+import { middleware } from '#start/kernel'
+import router from '@adonisjs/core/services/router'
+
+// Register MCP route (defaults to /mcp, or specify a custom path)
+router.mcp().use(middleware.auth())
+```
+
+You can also specify a custom path:
+
+```typescript
+router.mcp('/custom-mcp-path').use(middleware.auth())
+```
+
+### Using Authentication
+
+The MCP context automatically includes the `auth` instance from the `HttpContext` if available. You can use it to access the authenticated user:
+
+```typescript
+async handle({ args, auth }: Context) {
+  const user = auth?.user
+  
+  if (!user) {
+    throw new Error('User not authenticated')
+  }
+  
+  // Use the authenticated user
+  const bookmark = await Bookmark.create({
+    title: args.title,
+    userId: user.id,
+  })
+  
+  return response.text(JSON.stringify({ bookmark }))
+}
+```
+
+### Using Bouncer
+
+The MCP context automatically includes the `bouncer` instance from the `HttpContext` if available. You can use it to check permissions:
+
+```typescript
+async handle({ args, bouncer }: Context) {
+  // Check a permission
+  await bouncer.authorize('viewUsers')
+  
+  // Or use a policy
+  const user = await User.findOrFail(args.userId)
+  await bouncer.with(UserPolicy).authorize('view', user)
+  
+  return response.text(JSON.stringify({ user }))
+}
+```
+
+### Response Return
+
+The context includes a `response` instance to format your responses. The most common method is `text()`:
+
+```typescript
+async handle({ args, response }: Context) {
+  const data = { success: true, message: 'Operation completed' }
+  
+  return response.text(JSON.stringify(data))
+}
+```
+
+### Complete Example
+
+Here is a complete example of a tool that creates a bookmark:
+
+```typescript
+import type { McpContext } from '@jrmc/adonis-mcp/types/context'
+import type { BaseSchema, InferJSONSchema } from '@jrmc/adonis-mcp/types/method'
+
+import { Tool } from '@jrmc/adonis-mcp'
+import Bookmark from '#models/bookmark'
+
+type Schema = BaseSchema<{
+  title: { type: "string" }
+  url: { type: "string" }
+}>
+
+type Context = McpContext & { args: InferJSONSchema<Schema> }
+
+export default class AddBookmarkTool implements Tool<Schema> {
+  name = 'create_bookmark'
+  title = 'Create Bookmark'
+  description = 'Create a new bookmark'
+
+  async handle({ args, response, auth }: Context) {
+    const bookmark = await Bookmark.create({
+      title: args.title,
+      text: args.url,
+      userId: auth?.user?.id,
+    })
+
+    return response.text(JSON.stringify({ bookmark }))
+  }
+
+  schema() {
+    return {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Bookmark title"
+        },
+        url: {
+          type: "string",
+          description: "Bookmark URL"
+        }
+      },
+      required: ["title", "url"]
+    } as Schema
+  }
+}
+```
+
+### Pagination
+
+The `tools/list` method supports cursor-based pagination to handle large numbers of tools efficiently. This is particularly useful when you have many tools registered in your application. [More information](https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/pagination)
+
+## Support
+
+For any questions or issues, please open an issue on the [GitHub repository](https://github.com/batosai/adonis-mcp).
+
+## Inspiration
+
+This package is inspired by [laravel/mcp](https://github.com/laravel/mcp).

package/build/commands/commands.json

@@ -0,0 +1 @@
+{"commands":[{"commandName":"make:mcp-tool","description":"Create a new MCP tool","help":"","namespace":"make","aliases":[],"flags":[],"args":[{"name":"name","argumentName":"name","required":true,"description":"Name of the tool","type":"string"}],"options":{"startApp":true},"filePath":"make/tool.js"},{"commandName":"mcp:start","description":"Start the MCP server stdio transport","help":"","namespace":"mcp","aliases":[],"flags":[],"args":[],"options":{"startApp":true},"filePath":"start.js"}],"version":1}

package/build/commands/main.d.ts

@@ -0,0 +1,4 @@
+import { CommandMetaData, Command } from '@adonisjs/ace/types';
+
+export function getMetaData(): Promise<CommandMetaData[]>
+export function getCommand(metaData: CommandMetaData): Promise<Command | null>

package/build/commands/main.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * In-memory cache of commands after they have been loaded
+ */
+let commandsMetaData
+
+/**
+ * Reads the commands from the "./commands.json" file. Since, the commands.json
+ * file is generated automatically, we do not have to validate its contents
+ */
+export async function getMetaData() {
+  if (commandsMetaData) {
+    return commandsMetaData
+  }
+
+  const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8')
+  commandsMetaData = JSON.parse(commandsIndex).commands
+
+  return commandsMetaData
+}
+
+/**
+ * Imports the command by lookingup its path from the commands
+ * metadata
+ */
+export async function getCommand(metaData) {
+  const commands = await getMetaData()
+  const command = commands.find(({ commandName }) => metaData.commandName === commandName)
+  if (!command) {
+    return null
+  }
+
+  const { default: commandConstructor } = await import(new URL(command.filePath, import.meta.url).href)
+  return commandConstructor
+}

package/build/commands/make/tool.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class MakeTool extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    name: string;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=tool.d.ts.map

package/build/commands/make/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../commands/make/tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAG9D,OAAO,EAAQ,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAItD,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,WAAW;IAC/C,MAAM,CAAC,WAAW,SAAkB;IACpC,MAAM,CAAC,WAAW,SAA0B;IAE5C,MAAM,CAAC,OAAO,EAAE,cAAc,CAE7B;IAGO,IAAI,EAAE,MAAM,CAAA;IAEd,GAAG;CAYV"}

package/build/commands/make/tool.js

@@ -0,0 +1,35 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { args, BaseCommand } from '@adonisjs/core/ace';
+import string from '@adonisjs/core/helpers/string';
+import { stubsRoot } from '../../stubs/main.js';
+export default class MakeTool extends BaseCommand {
+    static commandName = 'make:mcp-tool';
+    static description = 'Create a new MCP tool';
+    static options = {
+        startApp: true,
+    };
+    async run() {
+        const config = this.app.config.get('mcp', { path: 'app/mcp' });
+        const codemods = await this.createCodemods();
+        const stubPath = `make/mcp/tools/main.ts.stub`;
+        await codemods.makeUsingStub(stubsRoot, stubPath, {
+            name: string.pascalCase(this.name),
+            basePath: config.path,
+        });
+        this.logger.success(`Tool created successfully for: ${this.name}`);
+    }
+}
+__decorate([
+    args.string({ description: 'Name of the tool' })
+], MakeTool.prototype, "name", void 0);

package/build/commands/start.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class MakeTool extends BaseCommand {
+    #private;
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=start.d.ts.map

package/build/commands/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../commands/start.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAG9D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAKhD,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,WAAW;;IAC/C,MAAM,CAAC,WAAW,SAAc;IAChC,MAAM,CAAC,WAAW,SAAyC;IAE3D,MAAM,CAAC,OAAO,EAAE,cAAc,CAG7B;IAIK,GAAG;CAaV"}

package/build/commands/start.js

@@ -0,0 +1,30 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { BaseCommand } from '@adonisjs/core/ace';
+import StdioTransport from '../src/server/transports/stdio_transport.js';
+export default class MakeTool extends BaseCommand {
+    static commandName = 'mcp:start';
+    static description = 'Start the MCP server stdio transport';
+    static options = {
+        startApp: true,
+        // stayAlive: true,
+    };
+    #server = null;
+    async run() {
+        try {
+            this.#server = await this.app.container.make('jrmc.mcp');
+            const transport = new StdioTransport();
+            await this.#server.connect(transport);
+            transport.on('mcp:stdio:transport:message', async (message) => {
+                await this.#server?.handle(message);
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

package/build/configure.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type Configure from '@adonisjs/core/commands/configure';
+export declare function configure(command: Configure): Promise<void>;
+//# sourceMappingURL=configure.d.ts.map

package/build/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,SAAS,MAAM,mCAAmC,CAAA;AAG9D,wBAAsB,SAAS,CAAC,OAAO,EAAE,SAAS,iBAejD"}

package/build/configure.js

@@ -0,0 +1,21 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import { stubsRoot } from './stubs/main.js';
+export async function configure(command) {
+    const codemods = await command.createCodemods();
+    /**
+     * Create default config file
+     */
+    await codemods.makeUsingStub(stubsRoot, 'config.ts.stub', {});
+    /**
+     * Register provider
+     */
+    await codemods.updateRcFile((rcFile) => {
+        rcFile.addProvider('@jrmc/adonis-mcp/mcp_provider');
+        rcFile.addCommand('@jrmc/adonis-mcp/commands');
+    });
+}

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export { configure } from './configure.js';
+export { Tool } from './src/server/tool.js';
+export * as McpResponse from './src/response.js';
+export { defineConfig } from './src/define_config.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAC3C,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA"}

package/build/index.js

@@ -0,0 +1,4 @@
+export { configure } from './configure.js';
+export { Tool } from './src/server/tool.js';
+export * as McpResponse from './src/response.js';
+export { defineConfig } from './src/define_config.js';

package/build/providers/mcp_provider.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { RouteGroup } from '@adonisjs/core/http';
+import McpServer from '../src/server.js';
+export default class McpProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    register(): void;
+    start(): Promise<void>;
+    registerTools(): Promise<void>;
+}
+declare module '@adonisjs/core/http' {
+    interface Router {
+        mcp: (pattern?: string) => RouteGroup;
+    }
+}
+declare module '@adonisjs/core/types' {
+    interface ContainerBindings {
+        'jrmc.mcp': McpServer;
+    }
+}
+//# sourceMappingURL=mcp_provider.d.ts.map

package/build/providers/mcp_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp_provider.d.ts","sourceRoot":"","sources":["../../providers/mcp_provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAKrD,OAAO,SAAS,MAAM,kBAAkB,CAAA;AAExC,MAAM,CAAC,OAAO,OAAO,WAAW;IAClB,SAAS,CAAC,GAAG,EAAE,kBAAkB;gBAAvB,GAAG,EAAE,kBAAkB;IAE7C,QAAQ;IAQF,KAAK;IAeL,aAAa;CA4CpB;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,MAAM;QACd,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,UAAU,CAAA;KACtC;CACF;AAED,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,iBAAiB;QACzB,UAAU,EAAE,SAAS,CAAA;KACtB;CACF"}

package/build/providers/mcp_provider.js

@@ -0,0 +1,48 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+// import type { Tool } from '../src/types.js'
+import { fsReadAll } from '@adonisjs/core/helpers';
+import McpServer from '../src/server.js';
+export default class McpProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    register() {
+        this.app.container.singleton('jrmc.mcp', async () => {
+            const config = this.app.config.get('mcp', {});
+            return new McpServer(config);
+        });
+    }
+    async start() {
+        const router = await this.app.container.make('router');
+        const McpController = () => import('../src/server/controllers/mcp_controller.js');
+        router.mcp = (pattern = '/mcp') => {
+            return router.group(() => {
+                router.post(pattern, [McpController, 'post']);
+            });
+        };
+        await this.registerTools();
+        // await this.registerResources()
+        // await this.registerPrompts()
+    }
+    async registerTools() {
+        const server = await this.app.container.make('jrmc.mcp');
+        const path = this.app.makePath(server.config.path);
+        const files = await fsReadAll(path, {
+            filter: (filePath) => filePath.includes('_tool.ts'),
+        });
+        await Promise.all(files.map(async (file) => {
+            const path = this.app.makePath(server.config.path, file);
+            const { default: tool } = await import(path);
+            const toolInstance = new tool();
+            server.addTool({
+                [toolInstance.name]: path,
+            });
+        }));
+    }
+}

package/build/src/define_config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+import type { McpConfig } from './types/config.js';
+export declare function defineConfig<T extends McpConfig>(config: T): T;
+//# sourceMappingURL=define_config.d.ts.map

package/build/src/define_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define_config.d.ts","sourceRoot":"","sources":["../../src/define_config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAElD,wBAAgB,YAAY,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAK9D"}

package/build/src/define_config.js

@@ -0,0 +1,12 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export function defineConfig(config) {
+    if (!config.path) {
+        config.path = 'app/mcp';
+    }
+    return config;
+}

package/build/src/enums/error.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export declare enum ErrorCode {
+    ConnectionClosed = -32000,
+    RequestTimeout = -32001,
+    ParseError = -32700,
+    InvalidRequest = -32600,
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    InternalError = -32603
+}
+//# sourceMappingURL=error.d.ts.map

package/build/src/enums/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/enums/error.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oBAAY,SAAS;IAEnB,gBAAgB,SAAS;IACzB,cAAc,SAAS;IAGvB,UAAU,SAAS;IACnB,cAAc,SAAS;IACvB,cAAc,SAAS;IACvB,aAAa,SAAS;IACtB,aAAa,SAAS;CACvB"}

package/build/src/enums/error.js

@@ -0,0 +1,18 @@
+/**
+ * @jrmc/adonis-mcp
+ *
+ * @license MIT
+ * @copyright Jeremy Chaufourier <jeremy@chaufourier.fr>
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // SDK error codes
+    ErrorCode[ErrorCode["ConnectionClosed"] = -32000] = "ConnectionClosed";
+    ErrorCode[ErrorCode["RequestTimeout"] = -32001] = "RequestTimeout";
+    // Standard JSON-RPC error codes
+    ErrorCode[ErrorCode["ParseError"] = -32700] = "ParseError";
+    ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+    ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+    ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+    ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
+})(ErrorCode || (ErrorCode = {}));