npm - @belgie/mcp - Versions diffs - 0.1.0 → 0.32.0 - Mend

@belgie/mcp 0.1.0 → 0.32.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/dist/index.js +16 -231
package/dist/index.js.map +1 -1
package/dist/vite.js +13 -13
package/dist/vite.js.map +1 -1
package/package.json +19 -43
package/types/html.d.ts +10 -0
package/types/index.d.ts +29 -0
package/types/scan-widgets.d.ts +15 -0
package/types/validate-widget.d.ts +1 -0
package/types/vite.d.ts +5 -0
package/README.md +0 -98
package/dist/cli.d.ts +0 -10
package/dist/cli.js +0 -119
package/dist/cli.js.map +0 -1
package/dist/codegen-DnMS1wg_.js +0 -688
package/dist/codegen-DnMS1wg_.js.map +0 -1
package/dist/codegen.d.ts +0 -11
package/dist/codegen.js +0 -2
package/dist/index.d.ts +0 -60
package/dist/internal.d.ts +0 -12
package/dist/internal.js +0 -37
package/dist/internal.js.map +0 -1
package/dist/tool-result-source-DTFIKHfH.js +0 -99
package/dist/tool-result-source-DTFIKHfH.js.map +0 -1
package/dist/tool-result-source-niHoRYxM.d.ts +0 -42
package/dist/vite.d.ts +0 -9

package/dist/codegen-DnMS1wg_.js DELETED Viewed

@@ -1,688 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { z } from "zod";
-import { randomBytes } from "node:crypto";
-import { createServer } from "node:http";
-//#region src/oauth.ts
-const CALLBACK_TIMEOUT_MS = 300 * 1e3;
-var MemoryOAuthProvider = class {
-	#redirectUrl;
-	#metadata;
-	#state;
-	#openBrowser;
-	#clientInformation;
-	#tokens;
-	#codeVerifier;
-	constructor(options) {
-		this.#redirectUrl = options.redirectUrl;
-		this.#state = options.state;
-		this.#openBrowser = options.openBrowser;
-		this.#metadata = {
-			client_name: "Belgie MCP Tool Codegen",
-			redirect_uris: [options.redirectUrl],
-			grant_types: ["authorization_code", "refresh_token"],
-			response_types: ["code"],
-			token_endpoint_auth_method: "none"
-		};
-	}
-	get redirectUrl() {
-		return this.#redirectUrl;
-	}
-	get clientMetadata() {
-		return this.#metadata;
-	}
-	state() {
-		return this.#state;
-	}
-	clientInformation() {
-		return this.#clientInformation;
-	}
-	saveClientInformation(clientInformation) {
-		this.#clientInformation = clientInformation;
-	}
-	tokens() {
-		return this.#tokens;
-	}
-	saveTokens(tokens) {
-		this.#tokens = tokens;
-	}
-	async redirectToAuthorization(authorizationUrl) {
-		if (!this.#openBrowser) {
-			process.stderr.write(`Authorize MCP code generation at:\n${authorizationUrl.toString()}\n`);
-			return;
-		}
-		const { default: open } = await import("open");
-		await open(authorizationUrl.toString());
-	}
-	saveCodeVerifier(codeVerifier) {
-		this.#codeVerifier = codeVerifier;
-	}
-	codeVerifier() {
-		if (this.#codeVerifier === void 0) throw new Error("OAuth code verifier was not saved");
-		return this.#codeVerifier;
-	}
-};
-function closeServer(server) {
-	if (!server.listening) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		server.close((error) => {
-			if (error) reject(error);
-			else resolve();
-		});
-	});
-}
-async function startOAuthCallbackServer(state) {
-	let resolveCode;
-	let rejectCode;
-	const codePromise = new Promise((resolve, reject) => {
-		resolveCode = resolve;
-		rejectCode = reject;
-	});
-	const server = createServer((request, response) => {
-		const url = new URL(request.url ?? "/", "http://127.0.0.1");
-		if (url.pathname !== "/callback") {
-			response.writeHead(404).end("Not found");
-			return;
-		}
-		if (url.searchParams.get("state") !== state) {
-			response.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
-			response.end("Invalid OAuth state");
-			return;
-		}
-		if (url.searchParams.has("error")) {
-			const description = url.searchParams.get("error_description");
-			const error = url.searchParams.get("error");
-			response.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
-			response.end("OAuth authorization failed");
-			rejectCode?.(new Error(description ? `${error}: ${description}` : error));
-			return;
-		}
-		const code = url.searchParams.get("code");
-		if (code === null || code.length === 0) {
-			response.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
-			response.end("Missing OAuth authorization code");
-			rejectCode?.(/* @__PURE__ */ new Error("Missing OAuth authorization code"));
-			return;
-		}
-		response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-		response.end("<!doctype html><title>Belgie MCP authorization complete</title><p>Authorization complete. You can close this window.</p>");
-		resolveCode?.(code);
-	});
-	await new Promise((resolve, reject) => {
-		const onError = (error) => {
-			server.off("listening", onListening);
-			reject(error);
-		};
-		const onListening = () => {
-			server.off("error", onError);
-			resolve();
-		};
-		server.once("error", onError);
-		server.once("listening", onListening);
-		server.listen(0, "127.0.0.1");
-	});
-	const address = server.address();
-	if (address === null || typeof address === "string") {
-		await closeServer(server);
-		throw new Error("OAuth callback server did not expose a loopback port");
-	}
-	return {
-		redirectUrl: `http://127.0.0.1:${address.port}/callback`,
-		waitForCode: async () => {
-			let timeout;
-			const timeoutPromise = new Promise((_resolve, reject) => {
-				timeout = setTimeout(() => {
-					reject(/* @__PURE__ */ new Error("Timed out waiting for the OAuth callback"));
-				}, CALLBACK_TIMEOUT_MS);
-			});
-			try {
-				return await Promise.race([codePromise, timeoutPromise]);
-			} finally {
-				if (timeout !== void 0) clearTimeout(timeout);
-			}
-		},
-		close: () => closeServer(server)
-	};
-}
-function oauthState() {
-	return randomBytes(32).toString("base64url");
-}
-//#endregion
-//#region src/schema.ts
-const UNSUPPORTED_KEYWORDS = [
-	"contains",
-	"dependencies",
-	"dependentSchemas",
-	"definitions",
-	"else",
-	"if",
-	"not",
-	"patternProperties",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-];
-const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
-	"$comment",
-	"$defs",
-	"$id",
-	"$schema",
-	"default",
-	"deprecated",
-	"description",
-	"examples",
-	"readOnly",
-	"title",
-	"writeOnly"
-]);
-const STRUCTURAL_KEYWORDS = /* @__PURE__ */ new Set([
-	"$ref",
-	"additionalItems",
-	"additionalProperties",
-	"allOf",
-	"anyOf",
-	"const",
-	"enum",
-	"items",
-	"nullable",
-	"oneOf",
-	"prefixItems",
-	"properties",
-	"required",
-	"type"
-]);
-const RESERVED_VALUE_IDENTIFIERS = /* @__PURE__ */ new Set([
-	"abstract",
-	"any",
-	"arguments",
-	"as",
-	"asserts",
-	"await",
-	"bigint",
-	"boolean",
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"declare",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"infer",
-	"intrinsic",
-	"instanceof",
-	"interface",
-	"is",
-	"keyof",
-	"let",
-	"module",
-	"namespace",
-	"never",
-	"new",
-	"null",
-	"number",
-	"object",
-	"out",
-	"override",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"readonly",
-	"require",
-	"return",
-	"satisfies",
-	"set",
-	"static",
-	"string",
-	"super",
-	"switch",
-	"symbol",
-	"this",
-	"throw",
-	"true",
-	"try",
-	"type",
-	"typeof",
-	"undefined",
-	"unique",
-	"unknown",
-	"using",
-	"var",
-	"void",
-	"while",
-	"with",
-	"yield"
-]);
-var IdentifierAllocator = class {
-	#uses = /* @__PURE__ */ new Map();
-	allocate(preferred) {
-		const safe = identifier(preferred);
-		const count = (this.#uses.get(safe) ?? 0) + 1;
-		this.#uses.set(safe, count);
-		return count === 1 ? safe : `${safe}${count}`;
-	}
-};
-var ValueIdentifierAllocator = class {
-	#uses = /* @__PURE__ */ new Map();
-	allocate(value) {
-		const safe = valueIdentifier(value);
-		const count = (this.#uses.get(safe) ?? 0) + 1;
-		this.#uses.set(safe, count);
-		return count === 1 ? safe : `${safe}${count}`;
-	}
-};
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function schemaObject(value, location) {
-	if (!isObject(value)) throw new Error(`${location} must be a JSON Schema object`);
-	return value;
-}
-function schemaArray(value, location) {
-	if (!Array.isArray(value)) throw new Error(`${location} must be an array of JSON Schemas`);
-	return value.map((item, index) => {
-		if (typeof item !== "boolean" && !isObject(item)) throw new Error(`${location}[${index}] must be a JSON Schema`);
-		return item;
-	});
-}
-function identifierWords(value) {
-	return value.match(/[\p{L}\p{N}]+/gu) ?? [];
-}
-function identifier(value) {
-	const result = identifierWords(value).map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`).join("") || "Schema";
-	return /^\p{N}/u.test(result) ? `Schema${result}` : result;
-}
-function valueIdentifier(value) {
-	let result = identifierWords(value).map((word, index) => {
-		const first = word.slice(0, 1);
-		const rest = word.slice(1);
-		return index === 0 ? `${first.toLocaleLowerCase("en-US")}${rest}` : `${first.toLocaleUpperCase("en-US")}${rest}`;
-	}).join("");
-	if (!result) result = "tool";
-	else if (/^\p{N}/u.test(result)) result = `tool${result}`;
-	else if (RESERVED_VALUE_IDENTIFIERS.has(result)) result = `tool${result.slice(0, 1).toLocaleUpperCase("en-US")}${result.slice(1)}`;
-	return result;
-}
-function typeIdentifier(value) {
-	return identifier(value);
-}
-function decodePointer(value) {
-	return decodeURIComponent(value).replaceAll("~1", "/").replaceAll("~0", "~");
-}
-function union(types) {
-	const unique = [...new Set(types)];
-	if (unique.includes("unknown")) return "unknown";
-	return unique.length === 0 ? "never" : unique.map((type) => hasTopLevelOperator(type, " & ") ? `(${type})` : type).join(" | ");
-}
-function intersection(types) {
-	const unique = [...new Set(types.filter((type) => type !== "unknown"))];
-	if (unique.includes("never")) return "never";
-	if (unique.length <= 1) return unique[0] ?? "unknown";
-	return unique.map((type) => parenthesize(type)).join(" & ");
-}
-function parenthesize(type) {
-	return hasTopLevelOperator(type, " | ") ? `(${type})` : type;
-}
-function arrayElement(type) {
-	return hasTopLevelOperator(type, " | ") || hasTopLevelOperator(type, " & ") ? `(${type})` : type;
-}
-function hasTopLevelOperator(type, operator) {
-	let depth = 0;
-	let quote;
-	for (let index = 0; index < type.length; index += 1) {
-		const character = type[index];
-		if (quote !== void 0) {
-			if (character === "\\") index += 1;
-			else if (character === quote) quote = void 0;
-			continue;
-		}
-		if (character === "\"" || character === "'") quote = character;
-		else if (character === "{" || character === "[" || character === "(") depth += 1;
-		else if (character === "}" || character === "]" || character === ")") depth -= 1;
-		else if (depth === 0 && type.startsWith(operator, index)) return true;
-	}
-	return false;
-}
-function indentType(type, spaces) {
-	return type.replaceAll("\n", `\n${" ".repeat(spaces)}`);
-}
-function literal(value, location) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error(`${location} contains a non-finite number`);
-		return String(value);
-	}
-	if (Array.isArray(value)) return `readonly [${value.map((item, index) => literal(item, `${location}[${index}]`)).join(", ")}]`;
-	if (isObject(value)) return `{ ${Object.keys(value).sort().map((key) => `readonly ${JSON.stringify(key)}: ${literal(value[key], `${location}.${key}`)}`).join("; ")} }`;
-	throw new Error(`${location} is not a JSON value`);
-}
-function strip(schema, keys) {
-	return Object.fromEntries(Object.entries(schema).filter(([key]) => !keys.has(key)));
-}
-function hasStructuralKeywords(schema) {
-	return Object.keys(schema).some((key) => STRUCTURAL_KEYWORDS.has(key));
-}
-var SchemaCompiler = class {
-	#rootName;
-	#definitions;
-	#definitionNames;
-	constructor(rootName, schema, allocator) {
-		this.#rootName = rootName;
-		const definitionsValue = schema.$defs;
-		if (definitionsValue === void 0) this.#definitions = /* @__PURE__ */ new Map();
-		else {
-			const definitions = schemaObject(definitionsValue, "$defs");
-			this.#definitions = new Map(Object.keys(definitions).sort().map((name) => {
-				const value = definitions[name];
-				if (typeof value !== "boolean" && !isObject(value)) throw new Error(`$defs.${name} must be a JSON Schema`);
-				return [name, value];
-			}));
-		}
-		this.#definitionNames = new Map([...this.#definitions].map(([name]) => [name, allocator.allocate(`${rootName}${identifier(name)}`)]));
-	}
-	declarations(schema) {
-		const rootSchema = { ...schema };
-		delete rootSchema.$defs;
-		const declarations = [`export type ${this.#rootName} = ${this.compile(rootSchema, this.#rootName)};`];
-		for (const [name, definition] of this.#definitions) declarations.push(`export type ${this.#definitionNames.get(name)} = ${this.compile(definition, `$defs.${name}`)};`);
-		return declarations;
-	}
-	compile(schema, location) {
-		if (schema === true) return "unknown";
-		if (schema === false) return "never";
-		for (const keyword of UNSUPPORTED_KEYWORDS) if (keyword in schema) throw new Error(`${location} uses unsupported JSON Schema keyword ${JSON.stringify(keyword)}`);
-		const parts = [];
-		if (schema.$ref !== void 0) {
-			parts.push(this.reference(schema.$ref, location));
-			const rest = strip(schema, /* @__PURE__ */ new Set(["$ref", ...ANNOTATION_KEYWORDS]));
-			if (hasStructuralKeywords(rest)) parts.push(this.compile(rest, location));
-			return this.nullable(intersection(parts), schema);
-		}
-		if (schema.const !== void 0) parts.push(literal(schema.const, `${location}.const`));
-		else if (schema.enum !== void 0) {
-			if (!Array.isArray(schema.enum) || schema.enum.length === 0) throw new Error(`${location}.enum must be a non-empty array`);
-			parts.push(union(schema.enum.map((item, index) => literal(item, `${location}.enum[${index}]`))));
-		}
-		for (const keyword of ["oneOf", "anyOf"]) if (schema[keyword] !== void 0) parts.push(union(schemaArray(schema[keyword], `${location}.${keyword}`).map((item, index) => this.compile(item, `${location}.${keyword}[${index}]`))));
-		if (schema.allOf !== void 0) parts.push(intersection(schemaArray(schema.allOf, `${location}.allOf`).map((item, index) => this.compile(item, `${location}.allOf[${index}]`))));
-		const typeSchema = strip(schema, /* @__PURE__ */ new Set([
-			"allOf",
-			"anyOf",
-			"const",
-			"enum",
-			"nullable",
-			"oneOf",
-			...ANNOTATION_KEYWORDS
-		]));
-		if (typeSchema.type !== void 0) parts.push(this.explicitType(typeSchema, location));
-		else if (typeSchema.properties !== void 0 || typeSchema.additionalProperties !== void 0 || typeSchema.required !== void 0) parts.push(this.object(typeSchema, location));
-		else if (typeSchema.items !== void 0 || typeSchema.prefixItems !== void 0) parts.push(this.array(typeSchema, location));
-		const result = intersection(parts);
-		return this.nullable(result, schema);
-	}
-	explicitType(schema, location) {
-		const value = schema.type;
-		const types = Array.isArray(value) ? value : [value];
-		if (types.length === 0 || types.some((type) => typeof type !== "string")) throw new Error(`${location}.type must be a string or non-empty string array`);
-		return union(types.map((type) => this.singleType(type, schema, location)));
-	}
-	singleType(type, schema, location) {
-		switch (type) {
-			case "array": return this.array(schema, location);
-			case "boolean": return "boolean";
-			case "integer":
-			case "number": return "number";
-			case "null": return "null";
-			case "object": return this.object(schema, location);
-			case "string": return "string";
-			default: throw new Error(`${location}.type contains unsupported type ${JSON.stringify(type)}`);
-		}
-	}
-	object(schema, location) {
-		const propertiesValue = schema.properties;
-		const properties = propertiesValue === void 0 ? {} : schemaObject(propertiesValue, `${location}.properties`);
-		const requiredValue = schema.required;
-		if (requiredValue !== void 0 && (!Array.isArray(requiredValue) || requiredValue.some((item) => typeof item !== "string"))) throw new Error(`${location}.required must be an array of property names`);
-		const required = new Set(requiredValue ?? []);
-		for (const name of required) if (!(name in properties)) throw new Error(`${location}.required references missing property ${JSON.stringify(name)}`);
-		const propertyTypes = [];
-		let hasOptional = false;
-		const members = Object.keys(properties).sort().map((name) => {
-			const property = properties[name];
-			if (typeof property !== "boolean" && !isObject(property)) throw new Error(`${location}.properties.${name} must be a JSON Schema`);
-			const optional = !required.has(name);
-			if (optional) hasOptional = true;
-			const propertyType = this.compile(property, `${location}.properties.${name}`);
-			propertyTypes.push(propertyType);
-			return `  ${JSON.stringify(name)}${optional ? "?" : ""}: ${indentType(propertyType, 2)};`;
-		});
-		const objectType = members.length === 0 ? "Record<string, never>" : `{\n${members.join("\n")}\n}`;
-		const additional = schema.additionalProperties;
-		if (additional === void 0 || additional === false) return objectType;
-		const valueType = additional === true ? "unknown" : this.compile(schemaObject(additional, `${location}.additionalProperties`), `${location}.additionalProperties`);
-		if (members.length === 0) return `Record<string, ${valueType}>`;
-		const indexTypes = [...propertyTypes, valueType];
-		if (hasOptional) indexTypes.push("undefined");
-		const indexType = union(indexTypes);
-		return `{\n${members.join("\n")}\n  [key: string]: ${indentType(indexType, 2)};\n}`;
-	}
-	array(schema, location) {
-		if (schema.prefixItems !== void 0) {
-			const prefixItems = schemaArray(schema.prefixItems, `${location}.prefixItems`);
-			const elements = prefixItems.map((item, index) => this.compile(item, `${location}.prefixItems[${index}]`));
-			const rest = schema.items;
-			if (!(schema.maxItems === prefixItems.length) && rest !== false) {
-				const restType = rest === void 0 || rest === true ? "unknown" : this.compile(schemaObject(rest, `${location}.items`), `${location}.items`);
-				elements.push(`...${arrayElement(restType)}[]`);
-			}
-			return `readonly [${elements.join(", ")}]`;
-		}
-		const items = schema.items;
-		if (Array.isArray(items)) {
-			const elements = schemaArray(items, `${location}.items`).map((item, index) => this.compile(item, `${location}.items[${index}]`));
-			const additional = schema.additionalItems;
-			if (!(schema.maxItems === elements.length) && additional !== false) {
-				const restType = additional === void 0 || additional === true ? "unknown" : this.compile(schemaObject(additional, `${location}.additionalItems`), `${location}.additionalItems`);
-				elements.push(`...${arrayElement(restType)}[]`);
-			}
-			return `readonly [${elements.join(", ")}]`;
-		}
-		if (schema.additionalItems !== void 0) throw new Error(`${location} uses additionalItems without a tuple-form items schema`);
-		if (items === void 0 || items === true) return "readonly unknown[]";
-		if (items === false) return "readonly never[]";
-		return `readonly ${arrayElement(this.compile(schemaObject(items, `${location}.items`), `${location}.items`))}[]`;
-	}
-	reference(value, location) {
-		if (typeof value !== "string") throw new Error(`${location}.$ref must be a string`);
-		if (value === "#") return this.#rootName;
-		if (!value.startsWith("#/$defs/")) throw new Error(`${location} contains unsupported external or non-$defs reference ${JSON.stringify(value)}`);
-		const name = decodePointer(value.slice(8));
-		const reference = this.#definitionNames.get(name);
-		if (reference === void 0) throw new Error(`${location} references missing $defs entry ${JSON.stringify(name)}`);
-		return reference;
-	}
-	nullable(type, schema) {
-		return schema.nullable === true ? union([type, "null"]) : type;
-	}
-};
-function compileSchema(schema, rootName, allocator) {
-	const root = schemaObject(schema, rootName);
-	return {
-		declarations: new SchemaCompiler(rootName, root, allocator).declarations(root),
-		rootName
-	};
-}
-//#endregion
-//#region src/codegen.ts
-function endpoint(value) {
-	let url;
-	try {
-		url = value instanceof URL ? new URL(value) : new URL(value);
-	} catch (cause) {
-		throw new Error(`Invalid MCP URL ${JSON.stringify(String(value))}`, { cause });
-	}
-	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`MCP URL must use http or https, received ${JSON.stringify(url.protocol)}`);
-	if (url.username || url.password) throw new Error("MCP URL must not contain credentials; use headers instead");
-	return url;
-}
-function jsDoc(description) {
-	const lines = description.replaceAll("*/", "* /").replaceAll("\r", "").split("\n");
-	if (lines.length === 1) return [`/** ${lines[0]} */`];
-	return [
-		"/**",
-		...lines.map((line) => ` * ${line}`),
-		" */"
-	];
-}
-function compareStrings(left, right) {
-	if (left < right) return -1;
-	if (left > right) return 1;
-	return 0;
-}
-function canonicalize(value) {
-	if (Array.isArray(value)) return value.map((item) => canonicalize(item));
-	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).sort(([left], [right]) => compareStrings(left, right)).map(([key, item]) => [key, canonicalize(item)]));
-	return value;
-}
-function renderSchema(schema) {
-	return JSON.stringify(canonicalize(schema), null, 2).split("\n").map((line) => `  ${line}`);
-}
-function compileToolSchema(tool, schemaName, schema, rootName, allocator) {
-	try {
-		return compileSchema(schema, rootName, allocator).declarations;
-	} catch (cause) {
-		const message = cause instanceof Error ? cause.message : String(cause);
-		throw new Error(`MCP tool ${JSON.stringify(tool.name)} has an ${schemaName} TypeScript cannot compile: ${message}`, { cause });
-	}
-}
-function renderToolTypes(tools) {
-	const allocator = new IdentifierAllocator();
-	const valueAllocator = new ValueIdentifierAllocator();
-	const names = /* @__PURE__ */ new Map();
-	for (const tool of tools) {
-		const base = typeIdentifier(tool.name);
-		names.set(tool.name, {
-			call: valueAllocator.allocate(tool.name),
-			input: allocator.allocate(`${base}Input`),
-			output: allocator.allocate(`${base}Output`)
-		});
-	}
-	let hasRawTools = false;
-	let hasStructuredTools = false;
-	const declarations = [];
-	for (const tool of tools) {
-		const toolNames = names.get(tool.name);
-		declarations.push(...compileToolSchema(tool, "inputSchema", tool.inputSchema, toolNames.input, allocator));
-		if (tool.outputSchema === void 0) {
-			hasRawTools = true;
-			declarations.push(`export type ${toolNames.output} = RawToolResult;`);
-		} else {
-			hasStructuredTools = true;
-			try {
-				z.fromJSONSchema(tool.outputSchema);
-			} catch (cause) {
-				const message = cause instanceof Error ? cause.message : String(cause);
-				throw new Error(`MCP tool ${JSON.stringify(tool.name)} has an outputSchema Zod cannot compile: ${message}`, { cause });
-			}
-			declarations.push(...compileToolSchema(tool, "outputSchema", tool.outputSchema, toolNames.output, allocator));
-		}
-	}
-	const calls = [];
-	for (const tool of tools) {
-		if (tool.description) calls.push(...jsDoc(tool.description));
-		const toolNames = names.get(tool.name);
-		if (tool.outputSchema === void 0) calls.push(`export const ${toolNames.call} = createGeneratedRawTool<${toolNames.input}>(`, `  ${JSON.stringify(tool.name)},`, ");", "");
-		else calls.push(`export const ${toolNames.call} = createGeneratedTool<${toolNames.input}, ${toolNames.output}>(`, `  ${JSON.stringify(tool.name)},`, ...renderSchema(tool.outputSchema), ");", "");
-	}
-	const factoryImports = [...hasRawTools ? ["createGeneratedRawTool"] : [], ...hasStructuredTools ? ["createGeneratedTool"] : []].join(", ");
-	return [
-		...hasRawTools ? ["import type { RawToolResult } from \"@belgie/mcp\";"] : [],
-		`import { ${factoryImports} } from "@belgie/mcp/internal";`,
-		"",
-		...declarations.flatMap((declaration) => [declaration, ""]),
-		...calls
-	].join("\n");
-}
-function createConnection(url, headers, provider) {
-	return {
-		client: new Client({
-			name: "belgie-mcp-codegen",
-			version: "0.1.0"
-		}, { capabilities: {} }),
-		transport: new StreamableHTTPClientTransport(url, {
-			...provider === void 0 ? {} : { authProvider: provider },
-			requestInit: { headers: new Headers(headers) }
-		})
-	};
-}
-async function discoverTools(client) {
-	const tools = /* @__PURE__ */ new Map();
-	const cursors = /* @__PURE__ */ new Set();
-	let cursor;
-	do {
-		const page = await client.listTools(cursor === void 0 ? void 0 : { cursor });
-		for (const tool of page.tools) {
-			if (tools.has(tool.name)) throw new Error(`MCP server exposed duplicate tool name ${JSON.stringify(tool.name)}`);
-			tools.set(tool.name, tool);
-		}
-		cursor = page.nextCursor;
-		if (cursor !== void 0 && cursors.has(cursor)) throw new Error(`MCP server repeated tools/list cursor ${JSON.stringify(cursor)}`);
-		if (cursor !== void 0) cursors.add(cursor);
-	} while (cursor !== void 0);
-	if (tools.size === 0) throw new Error("MCP server exposed no tools");
-	return [...tools.values()].sort((left, right) => compareStrings(left.name, right.name));
-}
-async function generateToolTypes(options) {
-	const url = endpoint(options.url);
-	const headers = options.headers ?? {};
-	const useOAuth = options.oauth ?? true;
-	const state = oauthState();
-	const callback = useOAuth ? await startOAuthCallbackServer(state) : void 0;
-	const provider = callback === void 0 ? void 0 : new MemoryOAuthProvider({
-		redirectUrl: callback.redirectUrl,
-		state,
-		openBrowser: options.openBrowser ?? true
-	});
-	let connection;
-	try {
-		connection = createConnection(url, headers, provider);
-		try {
-			await connection.client.connect(connection.transport);
-		} catch (cause) {
-			if (!(cause instanceof UnauthorizedError) || provider === void 0 || callback === void 0) throw cause;
-			const code = await callback.waitForCode();
-			await connection.transport.finishAuth(code);
-			await connection.client.close();
-			connection = createConnection(url, headers, provider);
-			await connection.client.connect(connection.transport);
-		}
-		return renderToolTypes(await discoverTools(connection.client));
-	} catch (cause) {
-		if (cause instanceof Error) throw new Error(`Failed to generate MCP tool types from ${url.toString()}: ${cause.message}`, { cause });
-		throw cause;
-	} finally {
-		await Promise.allSettled([connection?.client.close(), callback?.close()]);
-	}
-}
-//#endregion
-export { generateToolTypes as t };
-//# sourceMappingURL=codegen-DnMS1wg_.js.map