@ttsc/graph 0.16.4 → 0.16.6

package/lib/server/createServer.js

@@ -0,0 +1,1726 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const _a = __importStar(require("typia/lib/internal/_llmApplicationFinalize"));
+const _b = __importStar(require("typia/lib/internal/_validateReport"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const typia_1 = __importDefault(require("typia"));
+const TtscGraphApplication_1 = require("../TtscGraphApplication");
+const instructions_1 = require("./instructions");
+/**
+ * Build the MCP server for a graph. `typia.llm.controller` reflects
+ * {@link ITtscGraphApplication} into a validated tool application. Every tool's
+ * JSON schema and argument validator is generated from the method's TypeScript
+ * types and JSDoc, so there is no hand-written schema. The list/call handlers
+ * below are the minimal standalone registration: list the generated functions,
+ * and on a call validate the arguments (returning typia's errors for the model
+ * to self-correct) before invoking the method.
+ *
+ * Registration is inlined rather than pulled from `@typia/mcp` to keep the
+ * dependency surface to `typia` plus the MCP SDK and avoid version-pinning the
+ * wider typia ecosystem; the shape it relies on is `typia.llm.controller`'s
+ * public output.
+ */
+function createServer(graph, version) {
+    const controller = {
+        "protocol": "class",
+        "name": "graph",
+        "execute": new TtscGraphApplication_1.TtscGraphApplication(graph),
+        "application": _a._llmApplicationFinalize({
+            functions: [
+                {
+                    description: "Query the TypeScript project graph for code evidence.\n\nUse this before answering TypeScript codebase questions. It returns\nchecker-resolved symbols, dependency paths, edge evidence ranges, and\nsourceSpan anchors from the resident graph, avoiding assumptions, shell\nsearch, or file reads when graph evidence is enough.\n\nFill properties in order: question, graphNeed, draft, review, request.\nWrite `draft.reason` before `draft.type`, then choose `entrypoints`,\n`lookup`, `trace`, `details`, `overview`, or `escape`.\n\nMost answers should need 1-3 calls; four is the hard stop for one answer.\nKeep slices small, prefer defaults, and stop once file/symbol/range\nevidence is enough.",
+                    name: "query",
+                    output: {
+                        type: "object",
+                        properties: {
+                            result: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/ITtscGraphDetails"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEscape"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphLookup"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphOverview"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTrace"
+                                    }
+                                ],
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/ITtscGraphDetails",
+                                        entrypoints: "#/$defs/ITtscGraphEntrypoints",
+                                        escape: "#/$defs/ITtscGraphEscape",
+                                        lookup: "#/$defs/ITtscGraphLookup",
+                                        overview: "#/$defs/ITtscGraphOverview",
+                                        trace: "#/$defs/ITtscGraphTrace"
+                                    },
+                                    propertyName: "type"
+                                }
+                            }
+                        },
+                        required: [
+                            "result"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            ITtscGraphDecorator: {
+                                type: "object",
+                                properties: {
+                                    arguments: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator.IArgument"
+                                        },
+                                        description: "The literal call arguments, in source order. Empty for a bare decorator."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The decorator name as written, qualified through its access path:\n`Controller`, `Get`, `TypedRoute.Get`, `MessagePattern`."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "arguments"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphDecorator.IArgument": {
+                                type: "object",
+                                properties: {
+                                    literal: {
+                                        anyOf: [
+                                            {
+                                                type: "string"
+                                            },
+                                            {
+                                                type: "number"
+                                            },
+                                            {
+                                                type: "boolean"
+                                            }
+                                        ],
+                                        description: "The statically-resolved literal value, when the argument is a literal."
+                                    }
+                                },
+                                required: [],
+                                additionalProperties: false
+                            },
+                            ITtscGraphDetails: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    nodes: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.INode"
+                                        }
+                                    },
+                                    unknown: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Handles that resolved to no node, or that were ambiguous."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "nodes",
+                                    "unknown"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphDetails.IMember": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this member, when any."
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The member's declaration signature."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "kind"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphDetails.INode": {
+                                type: "object",
+                                properties: {
+                                    calls: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Direct execution dependencies in source order, with edge evidence."
+                                    },
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Symbols that use this node (incoming dependency edges)."
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Symbols this node uses (outgoing dependency edges)."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    implementation: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Assigned implementation span, when source comes from one."
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    literals: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "String literal values from the signature."
+                                    },
+                                    members: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IMember"
+                                        },
+                                        description: "For a container or object-literal variable: the owned symbol or top-level\nproperty outline a consumer reaches for, without bodies."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The declaration signature: its first line(s) up to the body."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickITtscGraphEvidenceendLinefilestartLine",
+                                        description: "The declaration or implementation file and line range, when known."
+                                    },
+                                    types: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Direct type dependencies in source order, with edge evidence."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphDetails.IReference": {
+                                type: "object",
+                                properties: {
+                                    aliases: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Stable access-path aliases derived from edge evidence. For example, an\nedge to `Owner.member` through `obj.slot.member` may expose\n`Owner.slot.member` so answers can preserve both the resolved symbol and\nthe source access path."
+                                    },
+                                    evidence: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Source span for the expression that produced this relationship. It lets\nan agent see why the edge exists without opening the file."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    relation: {
+                                        type: "string",
+                                        description: "The edge kind connecting the two (`calls`, `type_ref`, ...)."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "relation"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphEntrypoints: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    hits: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IHit"
+                                        },
+                                        description: "Ranked symbols relevant to the query."
+                                    },
+                                    mentions: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IMention"
+                                        },
+                                        description: "Code handles written directly in the query, resolved when possible."
+                                    },
+                                    neighborhood: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.INeighborhood"
+                                        },
+                                        description: "Direct dependency context for the resolved mentions and highest hits."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.INext",
+                                        description: "Follow-up handles for deeper graph calls."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "The original question/search phrase the entrypoints were built for."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when result caps hid additional seeds or references."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query",
+                                    "hits",
+                                    "mentions",
+                                    "neighborhood",
+                                    "next"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IHit": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "score"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IMention": {
+                                type: "object",
+                                properties: {
+                                    candidates: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.INode"
+                                        }
+                                    },
+                                    handle: {
+                                        type: "string"
+                                    },
+                                    node: {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.INode"
+                                    }
+                                },
+                                required: [
+                                    "handle"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.INeighborhood": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IReference"
+                                        }
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IReference"
+                                        }
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "dependsOn",
+                                    "dependedOnBy"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.INext": {
+                                type: "object",
+                                properties: {
+                                    details: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `details` for source-free symbol facts."
+                                    },
+                                    traceFrom: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `trace` when following dependency flow."
+                                    }
+                                },
+                                required: [
+                                    "details",
+                                    "traceFrom"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.INode": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IReference": {
+                                type: "object",
+                                properties: {
+                                    evidence: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Source span for the expression that produced this relationship. It lets\nan agent see why the edge exists without opening the file."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    relation: {
+                                        type: "string"
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "relation"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphEscape: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "The next non-graph step, if useful."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run."
+                                    },
+                                    skipped: {
+                                        type: "boolean",
+                                        "enum": [
+                                            true
+                                        ],
+                                        description: "Always true so callers can distinguish an intentional no-op."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "skipped",
+                                    "reason"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphEvidence: {
+                                type: "object",
+                                properties: {
+                                    endCol: {
+                                        type: "number",
+                                        description: "1-based column where the span ends, when known."
+                                    },
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based line where the span ends, when it differs from `startLine`."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the span lives in."
+                                    },
+                                    startCol: {
+                                        type: "number",
+                                        description: "1-based column where the span starts, when known."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based line where the span starts."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "startLine"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphLookup: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
+                                    },
+                                    hits: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphLookup.IHit"
+                                        }
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphLookup.INext",
+                                        description: "Follow-up handles for selected symbol details."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "hits",
+                                    "next"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphLookup.IHit": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The hit's declaration signature, so you can often answer without\nrequesting details."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "score"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphLookup.INext": {
+                                type: "object",
+                                properties: {
+                                    details: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `details` for source-free symbol facts."
+                                    },
+                                    traceFrom: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `trace` when following dependency flow."
+                                    }
+                                },
+                                required: [
+                                    "details",
+                                    "traceFrom"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphOverview: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "overview"
+                                        ],
+                                        description: "Discriminator for source-free project overview."
+                                    },
+                                    counts: {
+                                        $ref: "#/$defs/ITtscGraphOverview.ICounts",
+                                        description: "Size of the graph."
+                                    },
+                                    hotspots: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphOverview.IHotspot"
+                                        },
+                                        description: "Highest-dependency symbols, busiest first."
+                                    },
+                                    layers: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphOverview.ILayer"
+                                        },
+                                        description: "Folder layering, largest first."
+                                    },
+                                    project: {
+                                        type: "string",
+                                        description: "Absolute project root."
+                                    },
+                                    publicApi: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphOverview.INode"
+                                        },
+                                        description: "Exported API symbols, most-depended-on first."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "project",
+                                    "counts"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.ICounts": {
+                                type: "object",
+                                properties: {
+                                    byKind: {
+                                        $ref: "#/$defs/Recordstringnumber",
+                                        description: "Node count per kind."
+                                    },
+                                    edges: {
+                                        type: "number"
+                                    },
+                                    files: {
+                                        type: "number"
+                                    },
+                                    nodes: {
+                                        type: "number"
+                                    }
+                                },
+                                required: [
+                                    "files",
+                                    "nodes",
+                                    "edges",
+                                    "byKind"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.IHotspot": {
+                                type: "object",
+                                properties: {
+                                    fanIn: {
+                                        type: "number",
+                                        description: "Non-structural edges pointing at this symbol."
+                                    },
+                                    fanOut: {
+                                        type: "number",
+                                        description: "Non-structural edges leaving this symbol."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "fanIn",
+                                    "fanOut"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.ILayer": {
+                                type: "object",
+                                properties: {
+                                    dir: {
+                                        type: "string",
+                                        description: "Directory, project-relative."
+                                    },
+                                    exported: {
+                                        type: "number",
+                                        description: "Exported symbols declared under it."
+                                    },
+                                    files: {
+                                        type: "number",
+                                        description: "Distinct source files under it."
+                                    }
+                                },
+                                required: [
+                                    "dir",
+                                    "files",
+                                    "exported"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.INode": {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphTrace: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
+                                    },
+                                    candidates: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "When `from` was an ambiguous name, the matches to disambiguate with."
+                                    },
+                                    direction: {
+                                        type: "string"
+                                    },
+                                    hops: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.IHop"
+                                        },
+                                        description: "Edges traversed, in breadth-first order."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INext",
+                                        description: "Follow-up handles for inspecting or continuing the trace."
+                                    },
+                                    path: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "When `to` was given: the ordered dependency path from `from` to `to`\n(`from` first, `to` last), or empty when `to` is not reachable from\n`from`."
+                                    },
+                                    reached: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "Unique nodes reached (excluding the start), each with its depth and roles."
+                                    },
+                                    start: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INode",
+                                        description: "The resolved start node, or undefined when `from` matched nothing."
+                                    },
+                                    steps: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Compact hop summaries preserving node names and edge evidence, capped."
+                                    },
+                                    target: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INode",
+                                        description: "The resolved `to` target, when a path was requested."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when the trace hit maxNodes or maxDepth and more flow exists."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "direction",
+                                    "hops",
+                                    "reached",
+                                    "truncated"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTrace.IHop": {
+                                type: "object",
+                                properties: {
+                                    aliases: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Stable access-path aliases derived from edge evidence. These preserve a\nresolved member's owner and the concrete property path used at the call\nsite."
+                                    },
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start (1 = direct)."
+                                    },
+                                    evidence: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Source span for the expression that produced this hop. It lets an agent\nexplain why the trace moves from one symbol to the next without opening\nthe file."
+                                    },
+                                    from: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    to: {
+                                        type: "string"
+                                    }
+                                },
+                                required: [
+                                    "from",
+                                    "to",
+                                    "kind",
+                                    "depth"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTrace.INext": {
+                                type: "object",
+                                properties: {
+                                    details: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `details` for selected symbol details."
+                                    },
+                                    traceFrom: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Continue tracing from these ids when the current result is intermediate."
+                                    }
+                                },
+                                required: [
+                                    "details",
+                                    "traceFrom"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTrace.INode": {
+                                type: "object",
+                                properties: {
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start, on a reached node."
+                                    },
+                                    file: {
+                                        type: "string"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    roles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Why this node matters to an impact trace: `exported`, `test`."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The node's signature, carried on path nodes so the path explains itself."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file"
+                                ],
+                                additionalProperties: false
+                            },
+                            PickITtscGraphEvidenceendLinefilestartLine: {
+                                type: "object",
+                                properties: {
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based line where the span ends, when it differs from `startLine`."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the span lives in."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based line where the span starts."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "startLine"
+                                ],
+                                additionalProperties: false
+                            },
+                            Recordstringnumber: {
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    type: "number"
+                                }
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            draft: {
+                                $ref: "#/$defs/ITtscGraphApplication.IRequestDraft",
+                                description: "First request-type decision before arguments are filled.\n\nExplain why one operation class is smaller than the alternatives, then\nname it in `draft.type`. This is only the draft; the final arguments are\nin `request` after `review`."
+                            },
+                            graphNeed: {
+                                type: "string",
+                                description: "Why the resident graph is the next evidence source.\n\nState what graph evidence is needed and why assumptions or broad shell\nsearch are not the next step for this call. Name the smallest evidence\nthat would let the agent stop. If graph is not actually the right source,\nsay that and use `escape`."
+                            },
+                            question: {
+                                type: "string",
+                                description: "User's TypeScript code question.\n\nRestate the codebase question being answered. Keep this about TypeScript\nsource, symbols, call flow, type flow, or architecture. If the user is\nasking about scripts, config, generated output, or documentation instead,\nsay that boundary here."
+                            },
+                            request: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/ITtscGraphDetails.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphLookup.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphOverview.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTrace.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEscape.IRequest"
+                                    }
+                                ],
+                                description: "The graph operation chosen from the reasoning above, or a no-op escape.",
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/ITtscGraphDetails.IRequest",
+                                        entrypoints: "#/$defs/ITtscGraphEntrypoints.IRequest",
+                                        escape: "#/$defs/ITtscGraphEscape.IRequest",
+                                        lookup: "#/$defs/ITtscGraphLookup.IRequest",
+                                        overview: "#/$defs/ITtscGraphOverview.IRequest",
+                                        trace: "#/$defs/ITtscGraphTrace.IRequest"
+                                    },
+                                    propertyName: "type"
+                                }
+                            },
+                            review: {
+                                type: "string",
+                                description: "Critical review of the draft request.\n\nCheck whether the draft avoids overfetch, non-graph fallback, broad\nreads, and unnecessary neighbor expansion. If this would be a fourth\nbroad lookup, trace, or details call, prefer answering from evidence in\nhand or choose `escape`. Do not spend graph calls only to hunt for tests.\nIf the draft is wrong, choose the corrected type in `request`."
+                            }
+                        },
+                        required: [
+                            "question",
+                            "graphNeed",
+                            "draft",
+                            "review",
+                            "request"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "ITtscGraphApplication.IRequestDraft": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details",
+                                            "entrypoints",
+                                            "escape",
+                                            "lookup",
+                                            "overview",
+                                            "trace"
+                                        ],
+                                        description: "Draft discriminator for the intended graph operation."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why this operation type is the smallest useful next step."
+                                    }
+                                },
+                                required: [
+                                    "reason",
+                                    "type"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphDetails.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    dependencyLimit: {
+                                        type: "number",
+                                        description: "Maximum direct execution and type references to return per group. Raise\nonly when the first dependency slice is not enough."
+                                    },
+                                    handles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Node ids from another tool, or dotted symbol handles such as\n`OrderService.create`. Pass the few handles you need for source-free\ndetails; use `trace` when you need a path instead of widening this call."
+                                    },
+                                    memberLimit: {
+                                        type: "number",
+                                        description: "Maximum owned members to return for a container or object literal. Raise\nonly when the first outline is truncated."
+                                    },
+                                    neighborLimit: {
+                                        type: "number",
+                                        description: "Maximum dependencies and dependents to return per side when\n`neighbors:true`."
+                                    },
+                                    neighbors: {
+                                        type: "boolean",
+                                        description: "Also list each node's direct dependencies and dependents (the symbols it\nuses and the symbols that use it). The list is capped; raise\n`neighborLimit` only when the first slice is not enough."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "handles"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum ranked hits to return."
+                                    },
+                                    neighbors: {
+                                        type: "number",
+                                        description: "Maximum direct dependencies and dependents to return per indexed symbol.\nThis is an orientation slice, not a dependency dump; use `trace` or\n`details` with `neighbors:true` after choosing the specific handles."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "A natural code question or search phrase. Mix prose with code handles,\nfor example `how Repository.find loads relations` or\n`SelectQueryBuilder.setFindOptions join aliases`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEscape.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "The next non-graph step, if useful.\n\nKeep this short. Examples: `answer from the prior graph result`, `inspect\npackage.json`, or `ask the user for a concrete symbol`."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run.\n\nUse this when the review finds the user is asking about package scripts,\nconfig files, generated output, prose documentation, or an answer that\nthe current graph result already settled."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "reason"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphLookup.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum hits to return."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "What to find, in natural language and code vocabulary mixed freely: a\nsymbol name, a dotted member (`OrderService.create`), or a phrase\n(`shopping order create`, `repository find relations`). Exact names are\nnot required; subword and CamelCase matches rank too."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "overview"
+                                        ],
+                                        description: "Discriminator for source-free project overview."
+                                    },
+                                    aspect: {
+                                        type: "string",
+                                        "enum": [
+                                            "all",
+                                            "hotspots",
+                                            "layers",
+                                            "publicApi"
+                                        ],
+                                        description: "The facet to project, or `all` for every facet. `layers` is the folder\nlayering, `hotspots` the highest-dependency symbols, `publicApi` the\nexported API symbols ranked by how depended-on they are."
+                                    }
+                                },
+                                required: [
+                                    "type"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTrace.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
+                                    },
+                                    direction: {
+                                        type: "string",
+                                        "enum": [
+                                            "forward",
+                                            "impact",
+                                            "reverse"
+                                        ],
+                                        description: "`forward` follows what the start uses (callees, instantiations, renders);\n`reverse` follows what uses the start (callers); `impact` is a reverse\ntrace that flags the public API and tests a change would reach."
+                                    },
+                                    focus: {
+                                        type: "string",
+                                        "enum": [
+                                            "all",
+                                            "execution",
+                                            "types"
+                                        ],
+                                        description: "Which non-structural edge family to follow: `execution` follows runtime\ncalls, instantiations, property access, and JSX renders; `types` follows\ntype references and inheritance; `all` preserves the full graph."
+                                    },
+                                    from: {
+                                        type: "string",
+                                        description: "Where to start: a node id from another tool, a simple symbol name, or a\ndotted member name such as `OrderService.create`. An ambiguous name\nreturns its candidates instead of a trace."
+                                    },
+                                    maxDepth: {
+                                        type: "number",
+                                        description: "How many hops deep to follow. Open traces are capped at 2; path mode is\ncapped at 12."
+                                    },
+                                    maxNodes: {
+                                        type: "number",
+                                        description: "Cap on reached nodes; the trace stops and marks itself truncated past it.\nOpen traces are capped at 10 nodes so a broad graph cannot flood\ncontext."
+                                    },
+                                    to: {
+                                        type: "string",
+                                        description: "A target symbol: node id, simple symbol name, or dotted member name. When\ngiven, the tool returns the dependency path from `from` to this target,\nthe one-call answer for \"how does A reach B\", instead of an open-ended\ntrace."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "from"
+                                ],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    validate: (() => {
+                        const _io0 = input => "string" === typeof input.question && "string" === typeof input.graphNeed && ("object" === typeof input.draft && null !== input.draft && _io1(input.draft)) && "string" === typeof input.review && ("object" === typeof input.request && null !== input.request && _iu0(input.request));
+                        const _io1 = input => "string" === typeof input.reason && ("details" === input.type || "entrypoints" === input.type || "escape" === input.type || "lookup" === input.type || "overview" === input.type || "trace" === input.type);
+                        const _io2 = input => "details" === input.type && (Array.isArray(input.handles) && input.handles.every(elem => "string" === typeof elem)) && (undefined === input.neighbors || "boolean" === typeof input.neighbors) && (undefined === input.neighborLimit || "number" === typeof input.neighborLimit) && (undefined === input.memberLimit || "number" === typeof input.memberLimit) && (undefined === input.dependencyLimit || "number" === typeof input.dependencyLimit);
+                        const _io3 = input => "entrypoints" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.neighbors || "number" === typeof input.neighbors);
+                        const _io4 = input => "lookup" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit);
+                        const _io5 = input => "overview" === input.type && (undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect);
+                        const _io6 = input => "trace" === input.type && "string" === typeof input.from && (undefined === input.to || "string" === typeof input.to) && (undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction) && (undefined === input.focus || "all" === input.focus || "execution" === input.focus || "types" === input.focus) && (undefined === input.maxDepth || "number" === typeof input.maxDepth) && (undefined === input.maxNodes || "number" === typeof input.maxNodes);
+                        const _io7 = input => "escape" === input.type && "string" === typeof input.reason && (undefined === input.nextStep || "string" === typeof input.nextStep);
+                        const _iu0 = input => (() => {
+                            if ("details" === input.type)
+                                return _io2(input);
+                            else if ("entrypoints" === input.type)
+                                return _io3(input);
+                            else if ("lookup" === input.type)
+                                return _io4(input);
+                            else if ("overview" === input.type)
+                                return _io5(input);
+                            else if ("trace" === input.type)
+                                return _io6(input);
+                            else if ("escape" === input.type)
+                                return _io7(input);
+                            else
+                                return false;
+                        })();
+                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.question || _report(_exceptionable, {
+                                path: _path + ".question",
+                                expected: "string",
+                                value: input.question
+                            }), "string" === typeof input.graphNeed || _report(_exceptionable, {
+                                path: _path + ".graphNeed",
+                                expected: "string",
+                                value: input.graphNeed
+                            }), ("object" === typeof input.draft && null !== input.draft || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "ITtscGraphApplication.IRequestDraft",
+                                value: input.draft
+                            })) && _vo1(input.draft, _path + ".draft", true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "ITtscGraphApplication.IRequestDraft",
+                                value: input.draft
+                            }), "string" === typeof input.review || _report(_exceptionable, {
+                                path: _path + ".review",
+                                expected: "string",
+                                value: input.review
+                            }), ("object" === typeof input.request && null !== input.request || _report(_exceptionable, {
+                                path: _path + ".request",
+                                expected: "(ITtscGraphDetails.IRequest | ITtscGraphEntrypoints.IRequest | ITtscGraphEscape.IRequest | ITtscGraphLookup.IRequest | ITtscGraphOverview.IRequest | ITtscGraphTrace.IRequest)",
+                                value: input.request
+                            })) && _vu0(input.request, _path + ".request", true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + ".request",
+                                expected: "(ITtscGraphDetails.IRequest | ITtscGraphEntrypoints.IRequest | ITtscGraphEscape.IRequest | ITtscGraphLookup.IRequest | ITtscGraphOverview.IRequest | ITtscGraphTrace.IRequest)",
+                                value: input.request
+                            })].every(flag => flag);
+                        const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
+                                path: _path + ".reason",
+                                expected: "string",
+                                value: input.reason
+                            }), "details" === input.type || "entrypoints" === input.type || "escape" === input.type || "lookup" === input.type || "overview" === input.type || "trace" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "(\"details\" | \"entrypoints\" | \"escape\" | \"lookup\" | \"overview\" | \"trace\")",
+                                value: input.type
+                            })].every(flag => flag);
+                        const _vo2 = (input, _path, _exceptionable = true) => ["details" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"details\"",
+                                value: input.type
+                            }), (Array.isArray(input.handles) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            })) && input.handles.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
+                                path: _path + ".handles[" + _index2 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            }), undefined === input.neighbors || "boolean" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(boolean | undefined)",
+                                value: input.neighbors
+                            }), undefined === input.neighborLimit || "number" === typeof input.neighborLimit || _report(_exceptionable, {
+                                path: _path + ".neighborLimit",
+                                expected: "(number | undefined)",
+                                value: input.neighborLimit
+                            }), undefined === input.memberLimit || "number" === typeof input.memberLimit || _report(_exceptionable, {
+                                path: _path + ".memberLimit",
+                                expected: "(number | undefined)",
+                                value: input.memberLimit
+                            }), undefined === input.dependencyLimit || "number" === typeof input.dependencyLimit || _report(_exceptionable, {
+                                path: _path + ".dependencyLimit",
+                                expected: "(number | undefined)",
+                                value: input.dependencyLimit
+                            })].every(flag => flag);
+                        const _vo3 = (input, _path, _exceptionable = true) => ["entrypoints" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"entrypoints\"",
+                                value: input.type
+                            }), "string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            }), undefined === input.neighbors || "number" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(number | undefined)",
+                                value: input.neighbors
+                            })].every(flag => flag);
+                        const _vo4 = (input, _path, _exceptionable = true) => ["lookup" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"lookup\"",
+                                value: input.type
+                            }), "string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            })].every(flag => flag);
+                        const _vo5 = (input, _path, _exceptionable = true) => ["overview" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"overview\"",
+                                value: input.type
+                            }), undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect || _report(_exceptionable, {
+                                path: _path + ".aspect",
+                                expected: "(\"all\" | \"hotspots\" | \"layers\" | \"publicApi\" | undefined)",
+                                value: input.aspect
+                            })].every(flag => flag);
+                        const _vo6 = (input, _path, _exceptionable = true) => ["trace" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"trace\"",
+                                value: input.type
+                            }), "string" === typeof input.from || _report(_exceptionable, {
+                                path: _path + ".from",
+                                expected: "string",
+                                value: input.from
+                            }), undefined === input.to || "string" === typeof input.to || _report(_exceptionable, {
+                                path: _path + ".to",
+                                expected: "(string | undefined)",
+                                value: input.to
+                            }), undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction || _report(_exceptionable, {
+                                path: _path + ".direction",
+                                expected: "(\"forward\" | \"impact\" | \"reverse\" | undefined)",
+                                value: input.direction
+                            }), undefined === input.focus || "all" === input.focus || "execution" === input.focus || "types" === input.focus || _report(_exceptionable, {
+                                path: _path + ".focus",
+                                expected: "(\"all\" | \"execution\" | \"types\" | undefined)",
+                                value: input.focus
+                            }), undefined === input.maxDepth || "number" === typeof input.maxDepth || _report(_exceptionable, {
+                                path: _path + ".maxDepth",
+                                expected: "(number | undefined)",
+                                value: input.maxDepth
+                            }), undefined === input.maxNodes || "number" === typeof input.maxNodes || _report(_exceptionable, {
+                                path: _path + ".maxNodes",
+                                expected: "(number | undefined)",
+                                value: input.maxNodes
+                            })].every(flag => flag);
+                        const _vo7 = (input, _path, _exceptionable = true) => ["escape" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"escape\"",
+                                value: input.type
+                            }), "string" === typeof input.reason || _report(_exceptionable, {
+                                path: _path + ".reason",
+                                expected: "string",
+                                value: input.reason
+                            }), undefined === input.nextStep || "string" === typeof input.nextStep || _report(_exceptionable, {
+                                path: _path + ".nextStep",
+                                expected: "(string | undefined)",
+                                value: input.nextStep
+                            })].every(flag => flag);
+                        const _vu0 = (input, _path, _exceptionable = true) => (() => {
+                            if ("details" === input.type)
+                                return _vo2(input, _path, true && _exceptionable);
+                            else if ("entrypoints" === input.type)
+                                return _vo3(input, _path, true && _exceptionable);
+                            else if ("lookup" === input.type)
+                                return _vo4(input, _path, true && _exceptionable);
+                            else if ("overview" === input.type)
+                                return _vo5(input, _path, true && _exceptionable);
+                            else if ("trace" === input.type)
+                                return _vo6(input, _path, true && _exceptionable);
+                            else if ("escape" === input.type)
+                                return _vo7(input, _path, true && _exceptionable);
+                            else
+                                return _report(_exceptionable, {
+                                    path: _path,
+                                    expected: "(ITtscGraphDetails.IRequest | ITtscGraphEntrypoints.IRequest | ITtscGraphLookup.IRequest | ITtscGraphOverview.IRequest | ITtscGraphTrace.IRequest | ITtscGraphEscape.IRequest)",
+                                    value: input
+                                });
+                        })();
+                        const __is = input => "object" === typeof input && null !== input && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphApplication.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ITtscGraphApplication.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                }
+            ]
+        })
+    };
+    const functions = controller.application.functions;
+    const execute = controller.execute;
+    const server = new mcp_js_1.McpServer({ name: "ttsc-graph", version }, { capabilities: { tools: {} }, instructions: instructions_1.instructions });
+    const raw = server.server;
+    raw.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools: functions.map((func) => ({
+            name: func.name,
+            description: func.description,
+            inputSchema: {
+                type: "object",
+                properties: func.parameters.properties,
+                required: func.parameters.required,
+                additionalProperties: false,
+                $defs: func.parameters.$defs,
+            },
+        })),
+    }));
+    raw.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const func = functions.find((f) => f.name === request.params.name);
+        const method = execute[request.params.name];
+        if (func === undefined || method === undefined) {
+            return error(`Unknown tool: ${request.params.name}`);
+        }
+        // Validate an empty object when a client omits `arguments`, so typia can
+        // return field-level errors instead of a generic "expected object".
+        const validation = func.validate(request.params.arguments ?? {});
+        if (!validation.success) {
+            // Hand typia's validation errors back so the model can correct its call.
+            return error(JSON.stringify(validation.errors, null, 2));
+        }
+        try {
+            const result = await method.call(execute, validation.data);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result === undefined ? "Success" : JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (exception) {
+            return error(exception instanceof Error
+                ? `${exception.name}: ${exception.message}`
+                : String(exception));
+        }
+    });
+    return server;
+}
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+//# sourceMappingURL=createServer.js.map