@pantheon.ai/mcp 0.0.2 → 0.0.4

package/dist/cli.js

@@ -0,0 +1,1072 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getErrorMessage } from "@ai-sdk/provider";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { parseTemplate } from "url-template";
+import z$1, { z } from "zod";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+//#region packages/sdk/src/lib/stream-parser.ts
+var StreamResponseParser = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async handleResponse(response, context) {
+		this.options.validateResponse?.(response);
+		if (!response.body) throw new Error("Response body is missing");
+		return this.options.pipe(response.body, Object.freeze({
+			...context,
+			response
+		}));
+	}
+};
+
+//#endregion
+//#region packages/sdk/src/lib/validator.ts
+const VALIDATOR_SYMBOL = Symbol("validator");
+function isValidator(object) {
+	return typeof object === "object" && object !== null && object[VALIDATOR_SYMBOL] === true && typeof object.parse === "function";
+}
+
+//#endregion
+//#region packages/sdk/src/lib/api.ts
+function typeOf() {
+	return null;
+}
+function createUrlTemplate(method) {
+	return function(arr, ...params) {
+		let url = arr[0];
+		let expandedPaths = false;
+		for (let i = 1; i < arr.length; i++) if (params[i - 1] === "path*") {
+			url += "<path*>";
+			expandedPaths = true;
+		} else url += "{" + params[i - 1].replace(/\?$/, "") + "}" + arr[i];
+		const [pathPart, searchPart] = url.split("?");
+		const pathPartTemplate = expandedPaths ? { expand: (context) => {
+			return parseTemplate(pathPart.replace(/<path\*>/, String(context["path*"]).replace(/^\//, ""))).expand(context);
+		} } : parseTemplate(pathPart);
+		const searchParamsBuilders = [];
+		if (searchPart) searchPart.split("&").forEach((entry) => {
+			const [key, value = ""] = entry.split("=").map(decodeURIComponent);
+			if (/^\{[^}]+}$/.test(value)) {
+				const templateValue = value.slice(1, -1);
+				searchParamsBuilders.push((usp, context) => {
+					if (templateValue in context) {
+						const value = context[templateValue];
+						if (value === void 0) return;
+						if (Array.isArray(value)) value.forEach((v) => usp.append(key, String(v)));
+						else usp.append(key, String(value));
+					}
+				});
+			} else if (value !== "") {
+				const template = parseTemplate(value);
+				searchParamsBuilders.push((usp, context) => {
+					usp.append(key, template.expand(context));
+				});
+			} else searchParamsBuilders.push((usp) => {
+				usp.append(key, "");
+			});
+		});
+		return {
+			method,
+			signature: `${method} ${url}`,
+			templateUrl: url,
+			template: { expand: (context) => {
+				const pathPart = pathPartTemplate.expand(context);
+				const usp = new URLSearchParams();
+				searchParamsBuilders.forEach((template) => {
+					template(usp, context);
+				});
+				if (Array.from(usp).length > 0) return pathPart + "?" + usp.toString();
+				else return pathPart;
+			} },
+			__params__: typeOf()
+		};
+	};
+}
+const get = createUrlTemplate("get");
+const post = createUrlTemplate("post");
+const put = createUrlTemplate("put");
+const del = createUrlTemplate("delete");
+const patch = createUrlTemplate("patch");
+function defineApi(urlTemplate, _type, responseSchema) {
+	const method = urlTemplate.method;
+	return {
+		method: urlTemplate.method,
+		signature: urlTemplate.signature,
+		url: ((params) => urlTemplate.template.expand(params ?? {})),
+		requestInit: (body) => {
+			if (method === "get" || method === "delete") return { method };
+			if (body instanceof ReadableStream) return {
+				method,
+				body,
+				duplex: "half"
+			};
+			else if (body instanceof FormData) return {
+				method,
+				body
+			};
+			else return {
+				method,
+				body: JSON.stringify(body),
+				headers: { "Content-Type": "application/json" }
+			};
+		},
+		handleResponse: async (response, context) => {
+			if (responseSchema instanceof StreamResponseParser) return responseSchema.handleResponse(response, context);
+			else if (responseSchema === "raw") return response;
+			else if (isValidator(responseSchema)) return responseSchema.parse(response);
+			else return responseSchema.parse(await response.json());
+		}
+	};
+}
+
+//#endregion
+//#region packages/sdk/src/lib/zod.ts
+var ZodStream = class extends TransformStream {
+	constructor({ schema, onParseFailed }) {
+		super({ async transform(chunk, controller) {
+			const result = await schema.safeParseAsync(chunk);
+			if (result.success) controller.enqueue(result.data);
+			else if (onParseFailed) onParseFailed(result.error, chunk, controller);
+			else controller.error(result.error);
+		} });
+	}
+};
+const zodJsonDate = z.string();
+
+//#endregion
+//#region packages/sdk/src/schemas/branch.ts
+const branchManifestArtifactSchema = z.object({
+	type: z.string(),
+	path: z.string(),
+	description: z.string()
+});
+const branchManifestSchema = z.object({
+	summary: z.string().optional(),
+	export: z.object({
+		include_patterns: z.string().array(),
+		exclude_patterns: z.string().array()
+	}).optional(),
+	artifacts: branchManifestArtifactSchema.array().optional()
+});
+const snapSchema = z.object({
+	snap_id: z.string(),
+	snap_status: z.string(),
+	snap_type: z.string(),
+	started_at: zodJsonDate,
+	finished_at: zodJsonDate,
+	exit_code: z.number().nullable(),
+	error: z.string().nullable(),
+	step_index: z.number(),
+	event_stream_id: z.string().nullable(),
+	tool_use_id: z.string().nullable(),
+	manifest_status: z.string().nullable(),
+	manifest_task_id: z.string().nullable(),
+	manifest_snap_id: z.string().nullable()
+});
+const snapDetailsSchema = snapSchema.extend({
+	output: z.string().nullable(),
+	command: z.string().array().nullable().optional()
+});
+const branchStatusSchema = z.enum([
+	"created",
+	"pending",
+	"running",
+	"ready_for_manifest",
+	"manifesting",
+	"succeed",
+	"failed"
+]);
+const branchSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	display_name: z.string(),
+	status: branchStatusSchema,
+	status_text: z.string().nullable(),
+	level: z.number(),
+	project_id: z.string(),
+	parent_id: z.string().nullable(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate,
+	latest_snap_id: z.string().nullable(),
+	latest_snap: snapSchema.nullable(),
+	manifest: branchManifestSchema.nullable()
+});
+const branchSnapsSchema = z.object({
+	branch_id: z.string(),
+	branch_name: z.string(),
+	branch_status: branchStatusSchema,
+	branch_status_text: z.string().nullable(),
+	steps: z.array(snapDetailsSchema),
+	steps_total: z.number()
+});
+
+//#endregion
+//#region packages/sdk/src/schemas/common.ts
+function paged(schema) {
+	return z.object({
+		items: z.array(schema),
+		total: z.number(),
+		page: z.number(),
+		size: z.number(),
+		pages: z.number()
+	});
+}
+
+//#endregion
+//#region packages/sdk/src/schemas/exploration.ts
+const explorationSchema = z.object({
+	id: z.string(),
+	project_id: z.string(),
+	parent_branch_id: z.string(),
+	tdd_baseline_branch_id: z.string().nullable(),
+	background_task_id: z.string().nullable(),
+	num_branches: z.number().int(),
+	shared_prompt_sequence: z.string().array(),
+	status_text: z.string(),
+	call_agent: z.string().nullable(),
+	started_at: zodJsonDate.nullable(),
+	ended_at: zodJsonDate.nullable(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate,
+	agent: z.string(),
+	status: z.string()
+});
+const explorationResultSchema = z.object({
+	id: z.string(),
+	project_id: z.string(),
+	parent_branch_id: z.string(),
+	baseline_branch_id: z.string().nullable(),
+	background_task_id: z.string().nullable(),
+	status: z.string(),
+	status_text: z.string(),
+	started_at: zodJsonDate,
+	ended_at: zodJsonDate.nullable(),
+	branches: z.object({
+		branch_id: z.string(),
+		branch_name: z.string(),
+		branch_display_name: z.string(),
+		latest_snap_id: z.string(),
+		execution_results: z.object({
+			execution_id: z.string(),
+			status: z.string(),
+			status_text: z.string(),
+			branch_id: z.string(),
+			snap_id: z.string(),
+			background_task_id: z.string().nullable(),
+			started_at: zodJsonDate,
+			last_polled_at: zodJsonDate,
+			ended_at: zodJsonDate.nullable(),
+			exit_code: z.number().nullable()
+		}).array()
+	}).array()
+});
+
+//#endregion
+//#region packages/sdk/src/schemas/fs.ts
+const fsEntrySchema = z.object({
+	name: z.string(),
+	is_dir: z.boolean(),
+	size: z.number(),
+	mode: z.string(),
+	mod_time: zodJsonDate
+});
+const FSResponseValidator = Object.freeze({
+	[VALIDATOR_SYMBOL]: true,
+	__phantom__: typeOf(),
+	async parse(response) {
+		if (response.headers.get("Content-Type") === "application/json+directory") {
+			const data = await response.json();
+			return fsEntrySchema.array().parse(data);
+		} else {
+			const blob = await response.blob();
+			return new File([blob], response.url.split("/").pop(), { type: response.headers.get("content-type") ?? "application/octet-stream" });
+		}
+	}
+});
+
+//#endregion
+//#region packages/sdk/src/schemas/ai.ts
+const providerMetadataSchema = z$1.record(z$1.string(), z$1.record(z$1.string(), z$1.any()));
+const messageMetadataSchema = z$1.object().loose();
+const toolsShapeMap = { fake: {
+	input: z$1.object({ fakeIn: z$1.string() }).loose(),
+	output: z$1.object({ fakeOut: z$1.string() }).loose()
+} };
+const dataTypes = {
+	delta: z$1.object().loose(),
+	"message-metadata": z$1.object().loose(),
+	"ui-collapsed": z$1.object({
+		toolParts: z$1.number(),
+		reasoningParts: z$1.number(),
+		collapsed: z$1.boolean(),
+		parts: z$1.object().loose().array()
+	}),
+	"ui-running-tools": z$1.object({
+		toolParts: z$1.object().loose().array(),
+		textParts: z$1.object().loose().array(),
+		reasoningParts: z$1.object().loose().array()
+	})
+};
+const chunksShapeMap = {
+	"text-start": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"text-delta": {
+		delta: z$1.string(),
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"text-end": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"reasoning-start": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"reasoning-delta": {
+		delta: z$1.string(),
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"reasoning-end": {
+		id: z$1.string(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	error: { errorText: z$1.string() },
+	"tool-input-available": {
+		toolCallId: z$1.string(),
+		toolName: z$1.string(),
+		input: z$1.unknown(),
+		providerExecuted: z$1.boolean().optional(),
+		providerMetadata: providerMetadataSchema.optional(),
+		dynamic: z$1.boolean().optional()
+	},
+	"tool-input-error": {
+		toolCallId: z$1.string(),
+		toolName: z$1.string(),
+		input: z$1.unknown(),
+		providerExecuted: z$1.boolean().optional(),
+		providerMetadata: providerMetadataSchema.optional(),
+		dynamic: z$1.boolean().optional(),
+		errorText: z$1.string()
+	},
+	"tool-output-available": {
+		toolCallId: z$1.string(),
+		output: z$1.unknown(),
+		providerExecuted: z$1.boolean().optional(),
+		dynamic: z$1.boolean().optional(),
+		preliminary: z$1.boolean().optional()
+	},
+	"tool-output-error": {
+		toolCallId: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		dynamic: z$1.boolean().optional(),
+		errorText: z$1.string()
+	},
+	"tool-input-start": {
+		toolCallId: z$1.string(),
+		toolName: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		dynamic: z$1.boolean().optional()
+	},
+	"tool-input-delta": {
+		toolCallId: z$1.string(),
+		inputTextDelta: z$1.string()
+	},
+	"source-url": {
+		sourceId: z$1.string(),
+		url: z$1.string(),
+		title: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"source-document": {
+		sourceId: z$1.string(),
+		mediaType: z$1.string(),
+		title: z$1.string(),
+		filename: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	file: {
+		url: z$1.string(),
+		mediaType: z$1.string()
+	},
+	"start-step": {},
+	"finish-step": {},
+	start: {
+		messageId: z$1.string().optional(),
+		messageMetadata: messageMetadataSchema.optional()
+	},
+	finish: { messageMetadata: messageMetadataSchema.optional() },
+	abort: {},
+	"message-metadata": { messageMetadata: messageMetadataSchema }
+};
+const unknownDataChunkSchema = z$1.object({
+	type: z$1.string().regex(/^data-/),
+	id: z$1.string().optional(),
+	data: z$1.unknown(),
+	transient: z$1.boolean().optional()
+});
+const dataChunkSchema = Object.entries(dataTypes).map(([name, schema]) => z$1.object({
+	type: z$1.literal(`data-${name}`),
+	id: z$1.string().optional(),
+	data: schema,
+	transient: z$1.boolean().optional()
+}));
+const chunkSchema = Object.entries(chunksShapeMap).map(([type, schema]) => z$1.object({
+	type: z$1.literal(type),
+	...schema
+}));
+const uiMessageChunkSchema = z$1.discriminatedUnion("type", [...chunkSchema, ...dataChunkSchema]);
+const partsShapeMap = {
+	text: {
+		text: z$1.string(),
+		state: z$1.enum(["streaming", "done"]).optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	reasoning: {
+		text: z$1.string(),
+		state: z$1.enum(["streaming", "done"]).optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"source-url": {
+		sourceId: z$1.string(),
+		url: z$1.string(),
+		title: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"source-document": {
+		sourceId: z$1.string(),
+		mediaType: z$1.string(),
+		title: z$1.string(),
+		filename: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	file: {
+		url: z$1.string(),
+		mediaType: z$1.string(),
+		filename: z$1.string().optional(),
+		providerMetadata: providerMetadataSchema.optional()
+	},
+	"step-start": {}
+};
+const dynamicToolSchema = z$1.discriminatedUnion("state", [
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-streaming"),
+		input: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		errorText: z$1.never().optional()
+	}),
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-available"),
+		input: z$1.unknown(),
+		output: z$1.never().optional(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	}),
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-available"),
+		input: z$1.unknown(),
+		output: z$1.unknown(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional(),
+		preliminary: z$1.boolean().optional()
+	}),
+	z$1.object({
+		type: z$1.literal("dynamic-tool"),
+		toolName: z$1.string(),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-error"),
+		input: z$1.unknown(),
+		output: z$1.never().optional(),
+		errorText: z$1.string(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	})
+]);
+const dataPartSchema = Object.entries(dataTypes).map(([name, schema]) => z$1.object({
+	type: z$1.literal(`data-${name}`),
+	id: z$1.string().optional(),
+	data: schema
+}));
+const notDefinedDataType = z$1.string().regex(/data-/).refine((type) => !Object.keys(dataTypes).includes(type.slice(5)));
+const unknownDataPartSchema = z$1.object({
+	type: notDefinedDataType,
+	id: z$1.string().optional(),
+	data: z$1.unknown()
+});
+const notDefinedToolType = z$1.string().regex(/tool-/).refine((type) => !Object.keys(toolsShapeMap).includes(type.slice(5)));
+const unknownToolPartSchema = z$1.discriminatedUnion("state", [
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-streaming"),
+		input: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional()
+	}),
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-available"),
+		input: z$1.unknown(),
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	}),
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-available"),
+		input: z$1.unknown(),
+		output: z$1.unknown(),
+		errorText: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional(),
+		preliminary: z$1.boolean().optional()
+	}),
+	z$1.object({
+		type: notDefinedToolType,
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-error"),
+		input: z$1.unknown().optional(),
+		rawInput: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		errorText: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	})
+]);
+const partSchema = Object.entries(partsShapeMap).map(([type, schema]) => z$1.object({
+	type: z$1.literal(type),
+	...schema
+}));
+const toolsPartSchema = Object.entries(toolsShapeMap).map(([type, schema]) => z$1.discriminatedUnion("state", [
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-streaming"),
+		input: schema.input.partial().optional(),
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional()
+	}),
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("input-available"),
+		input: schema.input,
+		output: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		errorText: z$1.never().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	}),
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-available"),
+		input: schema.input,
+		output: schema.output,
+		errorText: z$1.never().optional(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional(),
+		preliminary: z$1.boolean().optional()
+	}),
+	z$1.object({
+		type: z$1.literal(`tool-${type}`),
+		toolCallId: z$1.string(),
+		state: z$1.literal("output-error"),
+		input: schema.input.optional(),
+		rawInput: z$1.unknown().optional(),
+		output: z$1.never().optional(),
+		errorText: z$1.string(),
+		providerExecuted: z$1.boolean().optional(),
+		callProviderMetadata: providerMetadataSchema.optional()
+	})
+]));
+const uiMessagePartSchema = z$1.discriminatedUnion("type", [
+	...partSchema,
+	...toolsPartSchema,
+	...dataPartSchema,
+	dynamicToolSchema
+]);
+
+//#endregion
+//#region packages/sdk/src/schemas/project.ts
+const projectSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	display_name: z.string(),
+	category: z.string(),
+	description: z.string(),
+	user_id: z.string(),
+	root_branch_id: z.string().nullable(),
+	ongoing_stream_id: z.string().nullable(),
+	status: z.enum([
+		"CREATED",
+		"PROVISIONING",
+		"READY",
+		"RUNNING",
+		"PAUSED",
+		"FAILED",
+		"ARCHIVED"
+	]).nullable().optional(),
+	error_message: z.string().nullable().optional(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate
+});
+const projectMessageSchema = z.object({
+	id: z.string(),
+	role: z.enum([
+		"system",
+		"user",
+		"assistant"
+	]),
+	metadata: messageMetadataSchema.nullable().optional(),
+	parts: z.array(z.object().loose()),
+	ordinal: z.number(),
+	project_id: z.string(),
+	source_request_id: z.string().nullable().optional(),
+	event_stream_id: z.string().nullable(),
+	status: z.string().nullable(),
+	is_finished: z.boolean(),
+	created_at: zodJsonDate,
+	updated_at: zodJsonDate
+});
+const projectMessageStreamParser = new StreamResponseParser({ pipe: (input) => {
+	return input.pipeThrough(new TextDecoderStream()).pipeThrough(new BufferedLinesStream("\n\n")).pipeThrough(new SSEDataDecoderStream()).pipeThrough(new ZodStream({ schema: z.object().loose() }));
+} });
+const projectRawMessageStreamParser = new StreamResponseParser({ pipe: (input) => {
+	return input.pipeThrough(new TextDecoderStream()).pipeThrough(new BufferedLinesStream("\n\n")).pipeThrough(new SSEDataDecoderStream()).pipeThrough(new ZodStream({ schema: z.object().loose() }));
+} });
+const projectQueuedRequestSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	payload: z.unknown(),
+	requested_at: zodJsonDate,
+	summary: z.string()
+});
+const projectBackgroundTaskSchema = z.object({
+	task_id: z.string(),
+	name: z.string().nullable(),
+	action_type: z.enum(["execution", "exploration"]),
+	action_id: z.string(),
+	status: z.enum([
+		"SUCCESS",
+		"FAILURE",
+		"PENDING",
+		"STARTED"
+	]).nullable(),
+	result: z.object().loose().nullable(),
+	retries: z.number().nullable(),
+	started_at: zodJsonDate.nullable(),
+	last_polled_at: zodJsonDate.nullable(),
+	ended_at: zodJsonDate.nullable()
+});
+var BufferedLinesStream = class extends TransformStream {
+	constructor(sep = "\n") {
+		let buffer = "";
+		super({
+			transform(chunk, controller) {
+				chunk = buffer += chunk;
+				while (true) {
+					const index = chunk.indexOf(sep);
+					if (index === -1) {
+						buffer = chunk;
+						break;
+					}
+					const line = chunk.slice(0, index).trim();
+					if (line) controller.enqueue(line);
+					chunk = chunk.slice(index + sep.length);
+				}
+			},
+			flush() {
+				if (buffer) console.warn("buffered lines stream has unprocessed lines:", buffer);
+			}
+		});
+	}
+};
+var SSEDataDecoderStream = class extends TransformStream {
+	constructor() {
+		let handle = void 0;
+		super({ transform: (chunk, controller) => {
+			clearTimeout(handle);
+			handle = setTimeout(() => {
+				controller.error(/* @__PURE__ */ new Error("Read timeout, please retry."));
+			}, 15e3);
+			if (/^data:/.test(chunk)) {
+				const part = chunk.replace(/^data: /, "").trim();
+				if (part === "[DONE]") {} else try {
+					controller.enqueue(JSON.parse(part));
+				} catch (e) {
+					console.error("invalid sse chunk", chunk, e);
+					controller.error(e);
+				}
+			} else console.debug("ignore sse comment", chunk);
+		} });
+	}
+};
+
+//#endregion
+//#region packages/sdk/src/api/projects.ts
+const listProjects = defineApi(get`/api/v1/projects?page=${"page"}&size=${"size"}&user_id=${"user_id?"}&category=${"category?"}`, null, paged(projectSchema));
+const getProject = defineApi(get`/api/v1/projects/${"projectId"}`, null, projectSchema);
+const createProject = defineApi(post`/api/v1/projects`, typeOf(), projectSchema);
+const listProjectMessages = defineApi(get`/api/v1/projects/${"projectId"}/messages`, null, z.object({
+	messages: projectMessageSchema.array(),
+	ongoing_stream_id: z.string().nullable()
+}));
+const deleteProjectMessage = defineApi(del`/api/v1/projects/${"projectId"}/messages/${"messageId"}`, null, "raw");
+const postProjectMessage = defineApi(post`/api/v1/projects/${"projectId"}`, typeOf(), z.object({
+	messages: projectMessageSchema.array(),
+	ongoing_stream_id: z.string().nullable()
+}));
+const continueProject = defineApi(post`/api/v1/projects/${"projectId"}/continue`, typeOf(), "raw");
+const stopProject = defineApi(post`/api/v1/projects/${"projectId"}/stop`, typeOf(), "raw");
+const getProjectBranch = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}`, null, branchSchema);
+const getProjectBranchOutput = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/output?full_output=${"fullOutput?"}`, null, z.string());
+const listProjectBranches = defineApi(get`/api/v1/projects/${"projectId"}/branches?page=${"page"}&size=${"size"}`, null, paged(branchSchema));
+const listProjectBranchSnaps = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/snaps`, null, branchSnapsSchema);
+const listProjectBackgroundTasks = defineApi(get`/api/v1/projects/${"projectId"}/background_tasks?statuses=${"statuses?"}`, null, z.array(projectBackgroundTaskSchema));
+const createProjectExploration = defineApi(post`/api/v1/projects/${"projectId"}/explorations`, typeOf(), explorationSchema);
+const listProjectExplorations = defineApi(get`/api/v1/projects/${"projectId"}/explorations`, null, explorationSchema.array());
+const getProjectExplorationResult = defineApi(get`/api/v1/projects/${"projectId"}/explorations/${"explorationId"}/result`, null, explorationResultSchema);
+const getProjectBranchFs = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/fs/${"path*"}`, null, FSResponseValidator);
+const getProjectBranchFsPreview = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/preview/${"path*"}`, null, FSResponseValidator);
+
+//#endregion
+//#region packages/sdk/src/api/connectors.ts
+const getGithubUser = defineApi(get`/api/v1/connectors/github/user`, null, z.object({ github_username: z.string() }).nullable());
+const listGithubRepositories = defineApi(get`/api/v1/user/github/repositories?page=${"page"}&size=${"size"}`, null, paged(z.object({
+	repo_id: z.number(),
+	repo_name: z.string(),
+	public: z.boolean(),
+	installation_id: z.number()
+})));
+
+//#endregion
+//#region packages/sdk/src/api/stream-proxy.ts
+const readMessageStream = defineApi(get`/ai_stream_proxy/v2/streams/${"streamId"}/stream?format=vercel-ai-ui-message-stream-v1&skip=${"skip?"}`, null, projectMessageStreamParser);
+const readRawMessageStream = defineApi(get`/ai_stream_proxy/v2/streams/${"streamId"}/stream?format=opaque-stream-json`, null, projectRawMessageStreamParser);
+
+//#endregion
+//#region packages/sdk/src/api/auth.ts
+const login = defineApi(post`/api/v1/auth/login`, typeOf(), "raw");
+const logout = defineApi(post`/api/v1/auth/logout`, null, "raw");
+const getMe = defineApi(get`/api/v1/users/me`, null, z.object({
+	id: z.string(),
+	email: z.string(),
+	is_active: z.boolean(),
+	is_superuser: z.boolean(),
+	is_verified: z.boolean()
+}));
+
+//#endregion
+//#region packages/sdk/src/lib/api-executor.ts
+var ApiError = class extends Error {
+	response;
+	context;
+	responseBody;
+	constructor(response, context, responseBody) {
+		super(`${context.request.method} ${context.url}: ${response.status} ${response.statusText} ${getServerErrorMessage(responseBody)}`);
+		this.response = response;
+		this.context = context;
+		this.responseBody = responseBody;
+	}
+};
+function createApiExecutor({ baseUrl, headers, validateResponse }) {
+	const errorCallbacks = [];
+	function onError(callback) {
+		errorCallbacks.push(callback);
+		return () => {
+			const index = errorCallbacks.indexOf(callback);
+			if (index !== -1) errorCallbacks.splice(index, 1);
+		};
+	}
+	async function execute(api, params, requestBody, requestInit) {
+		const url = baseUrl ? new URL(api.url(params), baseUrl).toString() : api.url(params);
+		const { headers: initHeaders, ...init } = api.requestInit(requestBody);
+		const executorHeaders = new Headers(headers);
+		if (initHeaders) new Headers(initHeaders).forEach((value, key) => {
+			executorHeaders.set(key, value);
+		});
+		const request = new Request(url, {
+			...requestInit,
+			...init,
+			headers: executorHeaders,
+			credentials: "include"
+		});
+		const context = Object.freeze({
+			api,
+			params,
+			requestBody,
+			url,
+			request
+		});
+		try {
+			const response = await fetch(request);
+			await validateResponse(response, context);
+			return await api.handleResponse(response, context);
+		} catch (error) {
+			for (const callback of errorCallbacks) callback(error, context);
+			return Promise.reject(error);
+		}
+	}
+	return Object.freeze({
+		execute,
+		onError
+	});
+}
+async function validateResponse(response, context) {
+	if (!response.ok) throw new ApiError(response, context, await response.clone().json().catch(() => response.clone().text()).catch(() => void 0));
+}
+function getServerErrorMessage(error) {
+	if (error == null) return "No error message.";
+	if (typeof error === "string") return error;
+	if (typeof error === "object") {
+		for (const key of [
+			"message",
+			"error",
+			"errMsg",
+			"errorMsg",
+			"detail",
+			"details"
+		]) if (key in error) return String(error[key]);
+		return JSON.stringify(error, void 0, 2);
+	}
+	return String(error);
+}
+
+//#endregion
+//#region package.json
+var version = "0.0.3";
+
+//#endregion
+//#region src/mcp/mcp.ts
+async function mcpServer({ authorizationHeader }) {
+	const executor = createApiExecutor({
+		baseUrl: "https://pantheon-ai.tidb.ai/",
+		headers: authorizationHeader ? { "Authorization": authorizationHeader } : void 0,
+		validateResponse
+	});
+	try {
+		await executor.execute(getMe, null, null);
+	} catch {
+		throw 401;
+	}
+	const mcpServer = new McpServer({
+		name: "Pantheon MCP",
+		version,
+		websiteUrl: "https://pantheon-ai.tidb.ai/"
+	});
+	function registerApiTool(name, api, { paramsSchema, bodySchema, ...options }) {
+		mcpServer.registerTool(name, {
+			...options,
+			inputSchema: z.object({
+				params: paramsSchema,
+				body: bodySchema
+			})
+		}, async ({ params, body }) => {
+			try {
+				const result = await executor.execute(api, params, body);
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result)
+					}],
+					structuredContent: result
+				};
+			} catch (e) {
+				return { content: [{
+					type: "text",
+					text: getErrorMessage(e)
+				}] };
+			}
+		});
+	}
+	registerApiTool("listProjects", listProjects, {
+		title: "List pantheon projects",
+		paramsSchema: pageParams,
+		bodySchema: z.null(),
+		outputSchema: paged(projectSchema)
+	});
+	registerApiTool("createProject", createProject, {
+		title: "Create pantheon project",
+		paramsSchema: z.null(),
+		bodySchema: z.object({
+			first_prompt: z.string(),
+			project_type: z.enum(["general", "github"]),
+			github_repo_id: z.number().optional(),
+			github_installation_id: z.number().optional(),
+			env_id: z.string().optional()
+		}),
+		outputSchema: projectSchema
+	});
+	registerApiTool("listProjectBranches", listProjectBranches, {
+		title: "List project branches",
+		paramsSchema: pageParams.extend({ projectId: z.string() }),
+		bodySchema: z.null(),
+		outputSchema: paged(branchSchema)
+	});
+	registerApiTool("getProject", getProject, {
+		title: "Get pantheon project",
+		paramsSchema: z.object({ projectId: z.string() }),
+		bodySchema: z.null(),
+		outputSchema: projectSchema
+	});
+	registerApiTool("getProjectBranch", getProjectBranch, {
+		title: "Get pantheon project branch info",
+		paramsSchema: z.object({
+			projectId: z.string(),
+			branchId: z.string()
+		}),
+		bodySchema: z.null(),
+		outputSchema: branchSchema
+	});
+	registerApiTool("getProjectBranchOutput", getProjectBranchOutput, {
+		title: "Get pantheon project branch output",
+		paramsSchema: z.object({
+			projectId: z.string(),
+			branchId: z.string(),
+			fullOutput: z.boolean().optional().default(false)
+		}),
+		bodySchema: z.null(),
+		outputSchema: z.string()
+	});
+	registerApiTool("createProjectExploration", createProjectExploration, {
+		title: "Create pantheon project exploration",
+		paramsSchema: z.object({ projectId: z.string() }),
+		bodySchema: z.object({
+			parent_branch_id: z.string(),
+			shared_prompt_sequence: z.string().array().min(1).max(4),
+			num_branches: z.number().int().min(1).max(50).optional().default(3),
+			agent: z.string().optional()
+		}),
+		outputSchema: explorationSchema
+	});
+	registerApiTool("listProjectExplorations", listProjectExplorations, {
+		title: "List project explorations",
+		paramsSchema: z.object({ projectId: z.string() }),
+		bodySchema: z.null(),
+		outputSchema: explorationSchema.array()
+	});
+	registerApiTool("getProjectExplorationResult", getProjectExplorationResult, {
+		title: "Get project exploration result",
+		paramsSchema: z.object({
+			projectId: z.string(),
+			explorationId: z.string()
+		}),
+		bodySchema: z.null(),
+		outputSchema: explorationResultSchema
+	});
+	return mcpServer;
+}
+const pageParams = z.object({
+	page: z.number().int().min(1),
+	size: z.number().int().min(1).max(100)
+});
+
+//#endregion
+//#region src/stdio.ts
+async function startStdio({ apiKey }) {
+	const stdio = new StdioServerTransport();
+	await (await mcpServer({ authorizationHeader: `Bearer ${apiKey}` })).connect(stdio);
+}
+
+//#endregion
+//#region src/streamableHttp.ts
+const port = process.env.PORT ? parseInt(process.env.PORT) : 9986;
+async function startStreamableHttpServer({ apiKey }) {
+	const app = createMcpExpressApp();
+	app.all("/mcp", async (req, res) => {
+		const authorizationHeader = req.get("authorization") ?? (apiKey ? `Bearer ${apiKey}` : void 0);
+		let server;
+		try {
+			server = await mcpServer({ authorizationHeader });
+		} catch (e) {
+			if (e === 401) {
+				res.status(400).send("401 Need Login");
+				return;
+			} else {
+				console.error("Error creating MCP server:", e);
+				res.status(500).send("Internal server error");
+				return;
+			}
+		}
+		const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+		try {
+			await server.connect(transport);
+			await transport.handleRequest(req, res, req.body);
+			res.on("close", () => {
+				transport.close();
+				server.close();
+			});
+		} catch (error) {
+			console.error("Error handling MCP request:", error);
+			if (!res.headersSent) res.status(500).json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32603,
+					message: "Internal server error"
+				},
+				id: null
+			});
+			transport.close().catch(() => {});
+			server.close().catch(() => {});
+		}
+	});
+	app.listen(port);
+	console.log("Listening on port 3001");
+}
+
+//#endregion
+//#region src/index.ts
+const args = process.argv.slice(2);
+function printHelp(message) {
+	console.error(`${message || "Usage"}
+npx @pantheon.ai/mcp stdio <Api-Key>
+PORT=10086 npx @pantheon.ai/mcp http [Optional Api-Key]
+`);
+}
+if (args.includes("--help") || args.includes("-h") || !args.length) {
+	printHelp();
+	process.exit(0);
+}
+if (args.includes("--version")) {
+	console.error(version);
+	process.exit(0);
+}
+switch (args[0]) {
+	case "stdio":
+		if (!args[1]) {
+			printHelp("Api-Key is required for stdio mode");
+			process.exit(1);
+		}
+		await startStdio({ apiKey: args[1] });
+		break;
+	case "http":
+		if (!args[1]) console.error("API Key not provided, client connections must provide authentication header.");
+		await startStreamableHttpServer({ apiKey: args[1] });
+		break;
+	default:
+		printHelp();
+		process.exit(1);
+}
+
+//#endregion
+export {  };