@cutoptim/mcp 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CutOptim
+
+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

@@ -1,3 +1,73 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<p align="center">
+  <a href="https://cutoptim.com/engine"><img src="https://raw.githubusercontent.com/cutoptim/engine-mcp/main/.github/logo.png" width="88" height="88" alt="CutOptim"></a>
+</p>
+
+<h1 align="center">CutOptim MCP server</h1>
+
+<p align="center">
+  Cutting optimization as tools for AI assistants: <b>2D panels</b>, <b>1D bars</b>, <b>timber</b> and <b>true-shape nesting</b>,<br>
+  through the <a href="https://cutoptim.com/engine">CutOptim Engine API</a> and the Model Context Protocol.
+</p>
+
+<p align="center">
+  <a href="https://cutoptim.com/engine/reference/guides/mcp">MCP guide</a> ·
+  <a href="https://cutoptim.com/engine/reference">API reference</a> ·
+  <a href="https://cutoptim.com/dashboard?api=test#api-keys">Get a free test key</a>
+</p>
+
+---
+
+## Two ways to connect
+
+**Hosted (no install)** — point your MCP client at `https://api.cutoptim.com/mcp` with the header
+`Authorization: Bearer <your API key>`. Configurations for Claude Code, Cursor, VS Code and Claude Desktop are in the
+[MCP guide](https://cutoptim.com/engine/reference/guides/mcp).
+
+**Local (this package, stdio)** — runs on your machine and calls the same API with your key:
+
+```json
+{
+  "mcpServers": {
+    "cutoptim": {
+      "command": "npx",
+      "args": ["-y", "@cutoptim/mcp"],
+      "env": { "CUTOPTIM_API_KEY": "co_test_YOUR_KEY" }
+    }
+  }
+}
+```
+
+Claude Code: `claude mcp add cutoptim --env CUTOPTIM_API_KEY=co_test_YOUR_KEY -- npx -y @cutoptim/mcp`
+
+| Variable | Meaning |
+|---|---|
+| `CUTOPTIM_API_KEY` | your key: `co_live_…`, `co_test_…` (never billed) or the public demo key. Without one, only the `validate_*` tools work. |
+| `CUTOPTIM_BASE_URL` | default `https://api.cutoptim.com` |
+
+Node 18 or newer.
+
+## Tools
+
+| Tool | What it does | Cost |
+|---|---|---|
+| `optimize_2d` | rectangular parts from sheets: layout, cut plan, yield | one API call |
+| `optimize_1d` | lengths from bars, tubes, profiles | one API call |
+| `optimize_wood` | timber parts by cross-section | one API call |
+| `optimize_nest` | free-form polygon parts on sheets | one API call |
+| `validate_2d` · `validate_1d` · `validate_wood` · `validate_nest` | check a request without solving it | free |
+| `get_job` | read an async `engine: "max"` job | free |
+| `get_usage` | calls used and left this month | free |
+
+The arguments of each tool are exactly the request body of its endpoint — the schemas are generated from the
+[OpenAPI document](https://cutoptim.com/engine/openapi.json). Every result carries a short summary for the assistant
+and the API's JSON answer as `structuredContent`.
+
+## Quota and billing
+
+One tool call is one Engine API call: the same key, quota, rate limits and billing as calling the REST API yourself.
+The client sends an `Idempotency-Key` with every optimize call, so its own retries are never charged twice.
+
+## License and support
+
+MIT. This repository is published from the CutOptim monorepo; report a bug in
+[Issues](https://github.com/cutoptim/engine-mcp/issues) or write to support@cutoptim.com.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// npx @cutoptim/mcp — the CutOptim MCP server over stdio.
+//   CUTOPTIM_API_KEY   your key (co_live_…, co_test_…, or the public demo key); not needed for validate_*
+//   CUTOPTIM_BASE_URL  default https://api.cutoptim.com
+// stdout carries the MCP protocol only; diagnostics go to stderr.
+import { CutOptim } from '@cutoptim/engine';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createCutOptimToolServer, VERSION } from './server.js';
+const client = new CutOptim({
+    apiKey: process.env.CUTOPTIM_API_KEY || undefined,
+    baseUrl: process.env.CUTOPTIM_BASE_URL || undefined,
+});
+const server = createCutOptimToolServer(client);
+await server.connect(new StdioServerTransport());
+console.error(`cutoptim-mcp ${VERSION} ready (stdio)${process.env.CUTOPTIM_API_KEY ? '' : ' — no CUTOPTIM_API_KEY: only validate_* will work'}`);

package/dist/core.gen.d.ts

@@ -0,0 +1,53 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export interface ToolDef {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    /** The REST operation behind the tool. `pathParam` names the argument that fills the `{id}` segment. */
+    http: {
+        method: 'GET' | 'POST';
+        path: string;
+        operationId: string;
+        pathParam?: string;
+    };
+}
+/** The REST request a tool call becomes. `args` are the tool arguments as received (a client SDK may dispatch on them). */
+export interface ApiRequest {
+    method: 'GET' | 'POST';
+    path: string;
+    body?: unknown;
+    operationId: string;
+    args: Record<string, unknown>;
+}
+export interface ApiAnswer {
+    status: number;
+    body: unknown;
+    /** X-RateLimit-Remaining when the API sent it (monthly calls left, or the demo key's daily allowance). */
+    remaining?: number | null;
+    /** True when the public demo key answered. */
+    demo?: boolean;
+}
+export type ApiCall = (req: ApiRequest, signal?: AbortSignal) => Promise<ApiAnswer>;
+export declare const SERVER_NAME = "cutoptim";
+export declare const SERVER_INSTRUCTIONS: string;
+export declare function createCutOptimMcpServer(opts: {
+    tools: ToolDef[];
+    call: ApiCall;
+    version: string;
+}): Server;
+/** Arguments → the documented REST request. POST tools send the arguments verbatim as the JSON body. */
+export declare function toApiRequest(tool: ToolDef, args: Record<string, unknown>): ApiRequest | {
+    error: string;
+};
+export declare function toToolResult(tool: ToolDef, a: ApiAnswer): CallToolResult;
+export declare function summarize(tool: ToolDef, a: ApiAnswer, b: Record<string, any>): string;

package/dist/core.gen.js

@@ -0,0 +1,167 @@
+// GENERATED copy of the hosted server's MCP core by scripts/gen-mcp.ts — DO NOT EDIT.
+// CutOptim MCP core: the tool dispatcher and the result formatter.
+//
+// ONE file, shared by the hosted server (https://api.cutoptim.com/mcp) and the local stdio package
+// (@cutoptim/mcp). The package carries a byte-identical copy (core.gen.ts, written by `npm run gen:mcp`),
+// so this file imports nothing but the MCP SDK and must stay free of server-only code.
+//
+// A tool call is exactly one Engine API call: the dispatcher turns the arguments into the HTTP request the
+// REST API documents and hands it to `call`, which the host implements (the hosted server: a loopback request
+// into the engine itself, so auth, rate limits, quota and billing are the REST ones; the stdio package: the
+// official TypeScript client). Nothing here decides what is billed.
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
+export const SERVER_NAME = 'cutoptim';
+export const SERVER_INSTRUCTIONS = 'CutOptim cutting optimization: 2D panels (optimize_2d), 1D bars and profiles (optimize_1d), timber with ' +
+    'cross-sections (optimize_wood) and true-shape nesting (optimize_nest). Every optimize_* call is one metered ' +
+    'Engine API call; validate_* is free and checks a request without solving it, so validate first when unsure. ' +
+    'All sizes are unit-agnostic numbers: keep one unit (e.g. mm) across parts, stock and kerf. ' +
+    'engine "max" runs asynchronously: the answer is a jobId, poll it with get_job. ' +
+    'get_usage shows the calls left this month. Reference: https://cutoptim.com/engine/reference';
+/** Export strings that are elided from the JSON text block (they stay in structuredContent). */
+const EXPORT_FIELDS = ['svg', 'dxf', 'csv', 'pdf', 'labelsPdf'];
+const MAX_TABLE_ROWS = 25;
+export function createCutOptimMcpServer(opts) {
+    const byName = new Map(opts.tools.map((t) => [t.name, t]));
+    const server = new Server({ name: SERVER_NAME, title: 'CutOptim Engine', version: opts.version }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: opts.tools.map((t) => ({
+            name: t.name, title: t.title, description: t.description,
+            inputSchema: t.inputSchema,
+            ...(t.outputSchema ? { outputSchema: t.outputSchema } : {}),
+            annotations: t.annotations,
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        const tool = byName.get(request.params.name);
+        if (!tool)
+            throw new McpError(ErrorCode.InvalidParams, `unknown tool: ${request.params.name}`);
+        const args = (request.params.arguments ?? {});
+        const req = toApiRequest(tool, args);
+        if ('error' in req)
+            return errorResult(req.error);
+        let answer;
+        try {
+            answer = await opts.call(req, extra.signal);
+        }
+        catch (e) {
+            return errorResult(`The CutOptim Engine API could not be reached: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return toToolResult(tool, answer);
+    });
+    return server;
+}
+/** Arguments → the documented REST request. POST tools send the arguments verbatim as the JSON body. */
+export function toApiRequest(tool, args) {
+    const { method, path, operationId, pathParam } = tool.http;
+    if (pathParam) {
+        const v = args[pathParam];
+        if (typeof v !== 'string' || v === '')
+            return { error: `${tool.name} needs "${pathParam}" (a string).` };
+        return { method, operationId, args, path: path.replace(/\{[^}]+\}/, encodeURIComponent(v)) };
+    }
+    return method === 'POST' ? { method, path, operationId, args, body: args } : { method, path, operationId, args };
+}
+function errorResult(text) {
+    return { isError: true, content: [{ type: 'text', text }] };
+}
+export function toToolResult(tool, a) {
+    const body = (a.body && typeof a.body === 'object' ? a.body : {});
+    if (a.status < 200 || a.status > 299) {
+        const code = typeof body.error === 'string' ? body.error : `http_${a.status}`;
+        const msg = typeof body.message === 'string' ? body.message : 'no message';
+        const lines = [`CutOptim API error ${a.status} ${code}: ${msg}`];
+        if (body.details != null)
+            lines.push(`details: ${JSON.stringify(body.details)}`);
+        if (a.status === 401)
+            lines.push('Send your API key as "Authorization: Bearer co_live_… / co_test_…" in the MCP client configuration. A free test key (never billed): https://cutoptim.com/dashboard?api=test#api-keys');
+        return errorResult(lines.join('\n'));
+    }
+    const content = [{ type: 'text', text: summarize(tool, a, body) }];
+    const elided = { ...body };
+    for (const f of EXPORT_FIELDS) {
+        if (typeof body[f] === 'string')
+            elided[f] = `[${f}: ${body[f].length} characters, in structuredContent]`;
+    }
+    content.push({ type: 'text', text: JSON.stringify(elided) });
+    if (typeof body.svg === 'string') {
+        content.push({ type: 'resource', resource: { uri: `cutoptim://layout/${tool.name}.svg`, mimeType: 'image/svg+xml', text: body.svg } });
+    }
+    return { content, structuredContent: body };
+}
+// ── human summaries ────────────────────────────────────────────────────────────────────────────────
+const n = (v) => (typeof v === 'number' && Number.isFinite(v) ? String(Math.round(v * 100) / 100) : '–');
+const list = (v) => (Array.isArray(v) ? v : []);
+export function summarize(tool, a, b) {
+    const out = [];
+    const op = tool.http.operationId;
+    if (a.status === 202 && typeof b.jobId === 'string') {
+        out.push(`Job queued: ${b.jobId} (engine ${b.engine ?? 'max'}, mode ${b.mode ?? '?'}). Poll it with get_job after about ${Math.ceil((Number(b.pollAfterMs) || 1000) / 1000)} s.`);
+    }
+    else if (op.startsWith('validate')) {
+        out.push(b.valid === true
+            ? `Valid ${b.mode ?? ''} request: ${n(b.parts?.rows)} part rows (${n(b.parts?.total)} pieces), ${n(b.stock?.rows)} stock rows. Not solved and not billed.`
+            : `Request is not valid: ${JSON.stringify(b)}`);
+        warnings(out, b);
+    }
+    else if (op === 'getUsage') {
+        out.push(`Plan ${b.plan ?? '?'}: ${n(b.used)} of ${n(b.limit)} calls used this period, ${n(b.remaining)} left (period ends ${b.periodEnd ?? '?'}, key ${b.keyPrefix ?? '?'}…).`);
+    }
+    else if (op === 'getJob') {
+        out.push(`Job ${b.jobId ?? '?'}: ${b.status ?? '?'} (engine ${b.engine ?? '?'}, mode ${b.mode ?? '?'}).`);
+        if (b.status === 'queued' || b.status === 'running')
+            out.push('Not finished yet: poll get_job again in a few seconds.');
+        if (b.status === 'failed' && b.error)
+            out.push(`Error: ${b.error}`);
+        if (b.result && typeof b.result === 'object')
+            planSummary(out, b.mode === 'nest' ? 'nest' : '2d', b.result);
+    }
+    else {
+        planSummary(out, op === 'optimize1d' ? '1d' : op === 'optimizeWood' ? 'wood' : op === 'optimizeNest' ? 'nest' : '2d', b);
+    }
+    if (a.remaining != null)
+        out.push(a.demo ? `Demo key: ${a.remaining} demo calls left today from this address.` : `Calls left this month: ${a.remaining}.`);
+    return out.join('\n');
+}
+function planSummary(out, mode, b) {
+    const m = b.metrics ?? {};
+    const price = typeof m.totalPrice === 'number' && m.totalPrice > 0 ? `, total price ${n(m.totalPrice)}` : '';
+    if (mode === '2d') {
+        out.push(`2D plan (engine ${b.engine ?? '?'}): ${n(m.placed)}/${n(m.total)} parts on ${n(m.sheetCount)} sheets, yield ${n(m.yieldPct)}%, ${n(m.cutLines)} cuts${price}.`);
+        table(out, ['sheet', 'size', 'parts', 'offcuts'], list(b.sheets).map((s, i) => [String(i + 1), `${n(s.w)} × ${n(s.h)}`, String(list(s.parts).length), String(list(s.offcuts).length)]));
+    }
+    else if (mode === '1d') {
+        out.push(`1D plan (engine ${b.engine ?? '?'}): ${n(m.placed)}/${n(m.total)} parts on ${n(m.rodCount)} bars, yield ${n(m.yieldPct)}%, ${n(m.cuts)} cuts${price}.`);
+        table(out, ['bar', 'length', 'parts', 'remaining'], list(b.rods).map((r, i) => [String(i + 1), n(r.length), String(list(r.parts).length), n(r.remaining)]));
+    }
+    else if (mode === 'wood') {
+        out.push(`Timber plan (engine ${b.engine ?? '?'}): ${n(m.placed)}/${n(m.total)} parts in ${n(m.sectionCount)} cross-sections on ${n(m.rodCount)} pieces of stock, yield ${n(m.yieldPct)}%${price}.`);
+        table(out, ['section', 'stock', 'pieces', 'yield %'], list(b.sections).map((s) => [String(s.section ?? `${n(s.sw)}×${n(s.sh)}`), String(s.stockName ?? '–'), String(list(s.rods).length), n(s.metrics?.yieldPct)]));
+        if (list(b.unmatched).length)
+            out.push(`No stock for: ${list(b.unmatched).map((u) => u.section ?? u.name ?? JSON.stringify(u)).join(', ')}`);
+    }
+    else {
+        out.push(`Nesting plan (engine ${b.engine ?? '?'}): ${n(m.placed)}/${n(m.total)} parts on ${n(m.sheetCount)} sheets, density ${n((Number(m.density) || 0) * 100)}%${price}.`);
+        table(out, ['sheet', 'size', 'parts', 'density %'], list(b.sheets).map((s, i) => [String(i + 1), `${n(s.w)} × ${n(s.h)}`, String(list(s.parts).length), n((Number(s.density) || 0) * 100)]));
+    }
+    const unplaced = list(b.unplaced);
+    if (unplaced.length)
+        out.push(`Not placed (${unplaced.length}): ${unplaced.slice(0, 10).map((u) => `${u.name ?? u.id ?? '?'}${u.qty ? ` ×${u.qty}` : ''}${u.reason ? ` (${u.reason})` : ''}`).join(', ')}${unplaced.length > 10 ? ', …' : ''}`);
+    warnings(out, b);
+    if (typeof b.svg === 'string')
+        out.push('An SVG drawing of the layout is attached.');
+}
+function warnings(out, b) {
+    const w = list(b.warnings).filter((x) => typeof x === 'string');
+    if (w.length)
+        out.push(`Warnings: ${w.join(' | ')}`);
+}
+function table(out, head, rows) {
+    if (!rows.length)
+        return;
+    out.push(`| ${head.join(' | ')} |`, `|${head.map(() => '---').join('|')}|`);
+    for (const r of rows.slice(0, MAX_TABLE_ROWS))
+        out.push(`| ${r.join(' | ')} |`);
+    if (rows.length > MAX_TABLE_ROWS)
+        out.push(`(${rows.length - MAX_TABLE_ROWS} more rows in the JSON)`);
+}

package/dist/server.d.ts

@@ -0,0 +1,56 @@
+import { type ApiAnswer, type ApiRequest } from './core.gen.js';
+import { TOOLS } from './tools.gen.js';
+import { VERSION } from './version.js';
+export { TOOLS, VERSION };
+type Opts = {
+    signal?: AbortSignal;
+};
+/** The part of the @cutoptim/engine client (`new CutOptim(...)`) the tools use. */
+export interface EngineClient {
+    optimize2d(body: any, opts?: Opts): Promise<unknown>;
+    optimize1d(body: any, opts?: Opts): Promise<unknown>;
+    optimizeWood(body: any, opts?: Opts): Promise<unknown>;
+    optimizeNest(body: any, opts?: Opts): Promise<unknown>;
+    validate2d(body: any, opts?: Opts): Promise<unknown>;
+    validate1d(body: any, opts?: Opts): Promise<unknown>;
+    validateWood(body: any, opts?: Opts): Promise<unknown>;
+    validateNest(body: any, opts?: Opts): Promise<unknown>;
+    getJob(jobId: string, opts?: Opts): Promise<unknown>;
+    usage(opts?: Opts): Promise<unknown>;
+}
+export declare function dispatch(client: EngineClient, req: ApiRequest, signal?: AbortSignal): Promise<ApiAnswer>;
+/** An MCP server (not yet connected) whose tools call the CutOptim Engine API through `client`. */
+export declare function createCutOptimToolServer(client: EngineClient): import("@modelcontextprotocol/sdk/server").Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>;

package/dist/server.js

@@ -0,0 +1,43 @@
+// @cutoptim/mcp — the CutOptim tools as a local MCP server, on top of the official @cutoptim/engine client.
+//
+// The tool list (tools.gen.ts) and the dispatcher/formatter (core.gen.ts) are the ones the hosted server at
+// https://api.cutoptim.com/mcp runs — generated from the same source, so both answer the same way. Every tool call is
+// exactly one Engine API call through the client: same key, quota and billing as calling the REST API yourself; the
+// client adds an Idempotency-Key to optimize calls, so its own retries are never charged twice.
+import { createCutOptimMcpServer } from './core.gen.js';
+import { TOOLS } from './tools.gen.js';
+import { VERSION } from './version.js';
+export { TOOLS, VERSION };
+const OPS = {
+    optimize2d: (c, a, o) => c.optimize2d(a, o),
+    optimize1d: (c, a, o) => c.optimize1d(a, o),
+    optimizeWood: (c, a, o) => c.optimizeWood(a, o),
+    optimizeNest: (c, a, o) => c.optimizeNest(a, o),
+    validate2D: (c, a, o) => c.validate2d(a, o),
+    validate1D: (c, a, o) => c.validate1d(a, o),
+    validateWood: (c, a, o) => c.validateWood(a, o),
+    validateNest: (c, a, o) => c.validateNest(a, o),
+    getJob: (c, a, o) => c.getJob(String(a.jobId), o),
+    getUsage: (c, _a, o) => c.usage(o),
+};
+const isJobAccepted = (r) => !!r && typeof r === 'object' && typeof r.jobId === 'string' && r.status === 'queued';
+export async function dispatch(client, req, signal) {
+    const op = OPS[req.operationId];
+    if (!op)
+        return { status: 400, body: { error: 'invalid_request', message: `no client method for ${req.operationId}` } };
+    try {
+        const body = await op(client, req.args, { signal });
+        return { status: req.operationId.startsWith('optimize') && isJobAccepted(body) ? 202 : 200, body };
+    }
+    catch (e) {
+        // CutOptimError (status, code, details) → the API's error envelope; anything else (network) propagates.
+        if (e && typeof e.status === 'number' && typeof e.code === 'string') {
+            return { status: e.status || 504, body: { error: e.code, message: e.message, ...(e.details != null ? { details: e.details } : {}) } };
+        }
+        throw e;
+    }
+}
+/** An MCP server (not yet connected) whose tools call the CutOptim Engine API through `client`. */
+export function createCutOptimToolServer(client) {
+    return createCutOptimMcpServer({ tools: TOOLS, version: VERSION, call: (req, signal) => dispatch(client, req, signal) });
+}

package/dist/tools.gen.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDef } from './core.gen.js';
+export declare const TOOLS: ToolDef[];