@flyle/ai-contact-center-mcp 0.0.0

package/dist/main.js

@@ -0,0 +1,2207 @@
+#!/usr/bin/env node
+import { homedir, hostname, userInfo } from "node:os";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import * as path from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, open, readFile, realpath, unlink, writeFile } from "node:fs/promises";
+import { constants, readFileSync } from "node:fs";
+import { McpServer, fromJsonSchema } from "@modelcontextprotocol/server";
+//#region package.json
+var version = "0.0.0";
+//#endregion
+//#region src/constants.ts
+const MCP_SERVER_NAME = "flyle-ai-contact-center";
+const MCP_SERVER_VERSION = version;
+/** 公開 API の鍵形式（設計書 §6.1）。形式が違う値は API に送る前に拒否する。 */
+const API_KEY_PATTERN = /^flyle_ai_contact_center_sa_[0-9A-Za-z]{43}$/;
+/** auth のテナント名規則（公開 API の `tenantName` パス変数と同じ）。 */
+const TENANT_NAME_PATTERN = /^[a-z0-9](-?[a-z0-9])*$/;
+/** 公開 API のパス変数名。ツール引数からは受けない（設計書 §7.2）。 */
+const TENANT_PATH_PARAM = "tenantName";
+const REDACTED_PLACEHOLDER = "[redacted]";
+/** 応答本文（JSON）の上限。公開 API の `limit` 上限 100 件で十分に収まる。 */
+const MAX_JSON_RESPONSE_BYTES = 16777216;
+/** SSE を終端まで収集する上限。検証の「試す」は数分で終わる想定。 */
+const SSE_TOTAL_TIMEOUT_MS = 9e5;
+const SSE_MAX_EVENTS = 1e4;
+const SSE_MAX_BYTES = 33554432;
+/** 応答ヘッダが返るまでの待ち時間。公開 API 側の request timeout（30 秒）より長く取る。 */
+const RESPONSE_HEADERS_TIMEOUT_MS = 6e4;
+const BINARY_TOTAL_TIMEOUT_MS = 6e5;
+const MAX_DOWNLOAD_BYTES = 536870912;
+const MAX_UPLOAD_BYTES = 536870912;
+/** 署名付き URL を「応答由来」と認める期限。S3 の presign 既定より短く取る。 */
+const PRESIGNED_URL_TTL_MS = 9e5;
+const PRESIGNED_URL_REGISTRY_MAX = 1e3;
+/** 保存するツール結果ファイルの上限。SSE 32 MiB / JSON 16 MiB の応答上限を compact JSON で収める。 */
+const MAX_TOOL_RESULT_FILE_BYTES = 67108864;
+/** 応答に埋め込まれた base64（音声 delta 等）をファイルに書き出すときの累積上限。 */
+const MAX_INLINE_FILE_OUTPUT_BYTES = 33554432;
+//#endregion
+//#region src/errors.ts
+var ManifestLoadError = class extends Error {
+	name = "ManifestLoadError";
+};
+var ConfigError = class extends Error {
+	name = "ConfigError";
+};
+/** 公開 API が 4xx / 5xx を返した。 */
+var ApiError = class extends Error {
+	name = "ApiError";
+	info;
+	constructor(info) {
+		super(`${info.status} ${info.code ?? "http_error"}: ${info.message}`);
+		this.info = info;
+	}
+};
+/** 応答が公開 API の契約どおりでない、または届かなかった。 */
+var TransportError = class extends Error {
+	name = "TransportError";
+	kind;
+	status;
+	constructor(kind, message, status = null) {
+		super(message);
+		this.kind = kind;
+		this.status = status;
+	}
+};
+var TransferError = class extends Error {
+	name = "TransferError";
+	kind;
+	status;
+	constructor(kind, message, status = null) {
+		super(message);
+		this.kind = kind;
+		this.status = status;
+	}
+};
+var LocalFileError = class extends Error {
+	name = "LocalFileError";
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.kind = kind;
+	}
+};
+var InlineFileError = class extends Error {
+	name = "InlineFileError";
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.kind = kind;
+	}
+};
+var InvalidArgumentsError = class extends Error {
+	name = "InvalidArgumentsError";
+};
+/** 応答は受け取れたが操作としては失敗（SSE の成否判定が success でない等）。payload をそのまま isError で返す。 */
+var OperationFailedError = class extends Error {
+	name = "OperationFailedError";
+	payload;
+	constructor(message, payload) {
+		super(message);
+		this.payload = payload;
+	}
+};
+/** 作業ディレクトリとテナントの 1 対 1 束縛が崩れる。テナント間のデータ持ち込みを防ぐため起動・操作を止める。 */
+var WorkspaceBindingError = class extends Error {
+	name = "WorkspaceBindingError";
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.kind = kind;
+	}
+};
+//#endregion
+//#region src/config.ts
+const ENV_KEYS = {
+	baseUrl: "FLYLE_AI_CONTACT_CENTER_API_BASE_URL",
+	tenantName: "FLYLE_AI_CONTACT_CENTER_TENANT_NAME",
+	apiKey: "FLYLE_AI_CONTACT_CENTER_API_KEY",
+	outputDir: "FLYLE_AI_CONTACT_CENTER_MCP_OUTPUT_DIR",
+	fileRoots: "FLYLE_AI_CONTACT_CENTER_MCP_FILE_ROOTS",
+	storageHosts: "FLYLE_AI_CONTACT_CENTER_MCP_STORAGE_HOSTS",
+	allowInsecureHttp: "FLYLE_AI_CONTACT_CENTER_MCP_ALLOW_INSECURE_HTTP"
+};
+const DEFAULT_OUTPUT_DIR = ".flyle-ai-contact-center-mcp/downloads";
+/** 署名付き転送 URL のホストとして許すサフィックス。S3（各リージョン・仮想ホスト形式）を既定にする。 */
+const DEFAULT_STORAGE_HOST_SUFFIXES = [".amazonaws.com"];
+const LOCAL_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+const trimTrailingSlashes = (value) => {
+	let end = value.length;
+	while (end > 0 && value[end - 1] === "/") end -= 1;
+	return value.slice(0, end);
+};
+const readRequired = (env, key) => {
+	const value = env[key];
+	if (value == null || value.trim() === "") throw new ConfigError(`environment variable ${key} is required`);
+	return value.trim();
+};
+const isLocalHost = (hostname) => LOCAL_HOSTS.has(hostname);
+const parseBaseUrl = (raw, allowInsecureHttp) => {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new ConfigError(`${ENV_KEYS.baseUrl} is not a valid URL`);
+	}
+	if (url.search !== "" || url.hash !== "" || url.username !== "" || url.password !== "") throw new ConfigError(`${ENV_KEYS.baseUrl} must not contain query, hash, or credentials`);
+	const insecureLocalhost = url.protocol === "http:" && allowInsecureHttp && isLocalHost(url.hostname);
+	if (url.protocol !== "https:" && !insecureLocalhost) throw new ConfigError(`${ENV_KEYS.baseUrl} must use https (http is allowed only for localhost with ${ENV_KEYS.allowInsecureHttp}=1)`);
+	const normalizedPath = trimTrailingSlashes(url.pathname);
+	return new URL(`${url.origin}${normalizedPath}`);
+};
+const parseTenantName = (raw) => {
+	if (raw.length < 2 || raw.length > 32 || !TENANT_NAME_PATTERN.test(raw)) throw new ConfigError(`${ENV_KEYS.tenantName} is not a valid tenant name`);
+	return raw;
+};
+const parseApiKey = (raw) => {
+	if (!API_KEY_PATTERN.test(raw)) throw new ConfigError(`${ENV_KEYS.apiKey} does not look like a Flyle AI Contact Center service account key`);
+	return raw;
+};
+const parseList = (raw) => {
+	if (raw == null) return null;
+	const items = raw.split(",").map((item) => item.trim()).filter((item) => item !== "");
+	return items.length === 0 ? null : items;
+};
+const parseBoolean = (raw) => raw === "1" || raw === "true";
+const loadConfig = (env, cwd) => {
+	const allowInsecureHttp = parseBoolean(env[ENV_KEYS.allowInsecureHttp]);
+	const baseUrl = parseBaseUrl(readRequired(env, ENV_KEYS.baseUrl), allowInsecureHttp);
+	const tenantName = parseTenantName(readRequired(env, ENV_KEYS.tenantName));
+	const apiKey = parseApiKey(readRequired(env, ENV_KEYS.apiKey));
+	const outputDirSetting = env[ENV_KEYS.outputDir]?.trim();
+	return {
+		baseUrl,
+		tenantName,
+		apiKey,
+		outputDir: path.resolve(cwd, outputDirSetting == null || outputDirSetting === "" ? DEFAULT_OUTPUT_DIR : outputDirSetting),
+		fileRoots: (parseList(env[ENV_KEYS.fileRoots]) ?? [cwd]).map((root) => path.resolve(cwd, root)),
+		storageHostSuffixes: (parseList(env[ENV_KEYS.storageHosts]) ?? DEFAULT_STORAGE_HOST_SUFFIXES).map((host) => host.toLowerCase()),
+		allowInsecureHttp
+	};
+};
+//#endregion
+//#region src/http/cleanup.ts
+const ignoreCleanupError = () => {};
+//#endregion
+//#region src/http/sse.ts
+const DEFAULT_EVENT_NAME = "message";
+const LINE_BREAK_PATTERN = /\r\n|\n|\r/;
+const createSseParser = () => {
+	let buffer = "";
+	let skipLeadingLf = false;
+	let eventName = "";
+	let dataLines = [];
+	let lastEventId = null;
+	const dispatch = () => {
+		if (dataLines.length === 0) {
+			eventName = "";
+			return null;
+		}
+		const event = {
+			event: eventName === "" ? DEFAULT_EVENT_NAME : eventName,
+			data: dataLines.join("\n"),
+			id: lastEventId
+		};
+		eventName = "";
+		dataLines = [];
+		return event;
+	};
+	const consumeLine = (line) => {
+		if (line === "") return dispatch();
+		if (line.startsWith(":")) return null;
+		const colon = line.indexOf(":");
+		const field = colon === -1 ? line : line.slice(0, colon);
+		let value = colon === -1 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "event") eventName = value;
+		else if (field === "data") dataLines.push(value);
+		else if (field === "id" && !value.includes("\0")) lastEventId = value;
+		return null;
+	};
+	const push = (chunk) => {
+		buffer += chunk;
+		if (skipLeadingLf) {
+			skipLeadingLf = false;
+			if (buffer.startsWith("\n")) buffer = buffer.slice(1);
+		}
+		const events = [];
+		let newlineIndex = buffer.search(LINE_BREAK_PATTERN);
+		while (newlineIndex !== -1) {
+			const line = buffer.slice(0, newlineIndex);
+			if (buffer[newlineIndex] === "\r" && newlineIndex === buffer.length - 1) skipLeadingLf = true;
+			const separatorLength = buffer.startsWith("\r\n", newlineIndex) ? 2 : 1;
+			buffer = buffer.slice(newlineIndex + separatorLength);
+			const event = consumeLine(line);
+			if (event != null) events.push(event);
+			newlineIndex = buffer.search(LINE_BREAK_PATTERN);
+		}
+		return events;
+	};
+	return {
+		push,
+		hasPendingIncomplete: () => buffer !== "" || dataLines.length > 0,
+		flush: () => {
+			buffer = "";
+			skipLeadingLf = false;
+			eventName = "";
+			dataLines = [];
+			return [];
+		}
+	};
+};
+const readWithDeadline$1 = async (reader, remainingMs) => {
+	if (remainingMs <= 0) return "deadline";
+	let timer = null;
+	const deadline = new Promise((resolve) => {
+		timer = setTimeout(() => resolve("deadline"), remainingMs);
+	});
+	try {
+		return await Promise.race([reader.read(), deadline]);
+	} finally {
+		if (timer != null) clearTimeout(timer);
+	}
+};
+/** SSE を終端まで収集する。上限に達したらストリームを cancel して打ち切り、集まった分を返す。 */
+const collectSseEvents = async (stream, options) => {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder("utf-8");
+	const parser = createSseParser();
+	const events = [];
+	let bytes = 0;
+	const stop = async (reason) => {
+		await reader.cancel().catch(ignoreCleanupError);
+		return {
+			events,
+			truncated: true,
+			reason,
+			discardedIncomplete: false
+		};
+	};
+	for (;;) {
+		const result = await readWithDeadline$1(reader, options.deadlineAt - options.now());
+		if (result === "deadline") return await stop("deadline");
+		if (result.done) {
+			events.push(...parser.push(decoder.decode()));
+			const discardedIncomplete = parser.hasPendingIncomplete();
+			parser.flush();
+			return {
+				events,
+				truncated: false,
+				reason: "end",
+				discardedIncomplete
+			};
+		}
+		bytes += result.value.byteLength;
+		if (bytes > options.maxBytes) return await stop("max_bytes");
+		events.push(...parser.push(decoder.decode(result.value, { stream: true })));
+		if (events.length > options.maxEvents) {
+			events.length = options.maxEvents;
+			return await stop("max_events");
+		}
+	}
+};
+//#endregion
+//#region src/http/api-client.ts
+const JSON_CONTENT_TYPE = "application/json";
+const SSE_CONTENT_TYPE = "text/event-stream";
+const REQUEST_ID_HEADER = "x-request-id";
+const RETRY_AFTER_HEADER = "retry-after";
+const MAX_ERROR_TEXT_CHARS = 500;
+/** 作業ディレクトリの不透明 ID。公開 API が「同じ作業場所から複数テナントへ」の操作を検知する（設計書 §7.4）。 */
+const CLIENT_WORKSPACE_HEADER = "x-flyle-client-workspace";
+const DEFAULT_API_CLIENT_LIMITS = {
+	headersTimeoutMs: RESPONSE_HEADERS_TIMEOUT_MS,
+	maxJsonBytes: MAX_JSON_RESPONSE_BYTES,
+	sseTotalMs: SSE_TOTAL_TIMEOUT_MS,
+	sseMaxEvents: SSE_MAX_EVENTS,
+	sseMaxBytes: SSE_MAX_BYTES,
+	maxRetryAfterSeconds: 30
+};
+/** Authorization を付ける通信先は起動設定の origin だけ（INV-C01 / 設計書 §17）。 */
+const assertFixedOrigin = (url, baseUrl) => {
+	if (url.origin !== baseUrl.origin) throw new TransportError("network", "refusing to send credentials outside the configured API origin");
+};
+const buildRequestUrl = (baseUrl, request) => {
+	const prefix = trimTrailingSlashes(baseUrl.pathname);
+	const url = new URL(`${prefix}${request.path}`, baseUrl);
+	for (const [name, value] of request.query) url.searchParams.append(name, value);
+	assertFixedOrigin(url, baseUrl);
+	return url;
+};
+const acceptFor = (kind) => {
+	switch (kind) {
+		case "json":
+		case "empty": return JSON_CONTENT_TYPE;
+		case "sse": return SSE_CONTENT_TYPE;
+		case "binary": return "*/*";
+		default: throw new Error(`unknown response kind ${String(kind)}`);
+	}
+};
+/** 本文を上限付きで読む。`content-length` が無い応答でも上限を超えたら切る。 */
+const readBodyWithLimit = async (response, maxBytes) => {
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > maxBytes) {
+		await response.body?.cancel().catch(ignoreCleanupError);
+		throw new TransportError("response_too_large", `response exceeds ${maxBytes} bytes`, response.status);
+	}
+	if (response.body == null) return /* @__PURE__ */ new Uint8Array(0);
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > maxBytes) {
+			await reader.cancel().catch(ignoreCleanupError);
+			throw new TransportError("response_too_large", `response exceeds ${maxBytes} bytes`, response.status);
+		}
+		chunks.push(value);
+	}
+	const merged = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return merged;
+};
+const decodeUtf8 = (bytes) => new TextDecoder("utf-8").decode(bytes);
+const hasContentType = (response, expected) => (response.headers.get("content-type") ?? "").toLowerCase().startsWith(expected);
+const parseRetryAfter = (raw) => {
+	if (raw == null) return null;
+	const seconds = Number(raw);
+	return Number.isInteger(seconds) && seconds >= 0 ? seconds : null;
+};
+const readStringField = (record, key) => {
+	const value = record[key];
+	return typeof value === "string" ? value : null;
+};
+const isRecord = (value) => typeof value === "object" && value != null && !Array.isArray(value);
+const toApiError = async (response, maxBytes) => {
+	const requestId = response.headers.get(REQUEST_ID_HEADER);
+	const retryAfterSeconds = parseRetryAfter(response.headers.get(RETRY_AFTER_HEADER));
+	let text;
+	try {
+		text = decodeUtf8(await readBodyWithLimit(response, maxBytes));
+	} catch {
+		text = "";
+	}
+	if (hasContentType(response, JSON_CONTENT_TYPE)) try {
+		const parsed = JSON.parse(text);
+		const envelope = isRecord(parsed) && isRecord(parsed["error"]) ? parsed["error"] : null;
+		if (envelope != null) return new ApiError({
+			status: response.status,
+			code: readStringField(envelope, "code"),
+			message: readStringField(envelope, "message") ?? response.statusText,
+			detail: readStringField(envelope, "detail"),
+			requestId: readStringField(envelope, "requestId") ?? requestId,
+			retryAfterSeconds
+		});
+	} catch {}
+	return new ApiError({
+		status: response.status,
+		code: null,
+		message: text.slice(0, MAX_ERROR_TEXT_CHARS) || response.statusText || "HTTP error",
+		detail: null,
+		requestId,
+		retryAfterSeconds
+	});
+};
+const parseContentDispositionFileName = (header) => {
+	if (header == null) return null;
+	const encoded = /filename\*=UTF-8''([^;]+)/i.exec(header);
+	if (encoded?.[1] != null) try {
+		return decodeURIComponent(encoded[1].trim());
+	} catch {
+		return null;
+	}
+	return /filename="?([^";]+)"?/i.exec(header)?.[1]?.trim() ?? null;
+};
+const toTransportError = (error) => {
+	if (error instanceof TransportError) return error;
+	if (error instanceof Error && error.name === "AbortError") return new TransportError("timeout", "the API did not respond in time");
+	return new TransportError("network", error instanceof Error ? error.message : "network failure");
+};
+const createApiClient = (deps, limits = DEFAULT_API_CLIENT_LIMITS) => {
+	const { config, workspaceId, fetch, now, sleep, logger } = deps;
+	const performOnce = async (request) => {
+		const url = buildRequestUrl(config.baseUrl, request);
+		const headers = new Headers({
+			authorization: `Bearer ${config.apiKey}`,
+			accept: acceptFor(request.responseKind),
+			"user-agent": `flyle-ai-contact-center-mcp/${MCP_SERVER_VERSION}`,
+			[CLIENT_WORKSPACE_HEADER]: workspaceId
+		});
+		let bodyText;
+		if (request.hasBody) {
+			bodyText = JSON.stringify(request.body ?? {});
+			headers.set("content-type", JSON_CONTENT_TYPE);
+		}
+		const controller = new AbortController();
+		const headersTimer = setTimeout(() => controller.abort(), limits.headersTimeoutMs);
+		let response;
+		try {
+			response = await fetch(url, {
+				method: request.method,
+				headers,
+				...bodyText == null ? {} : { body: bodyText },
+				redirect: "manual",
+				signal: controller.signal
+			});
+		} catch (err) {
+			clearTimeout(headersTimer);
+			throw toTransportError(err);
+		}
+		if (response.status >= 300 && response.status < 400) {
+			clearTimeout(headersTimer);
+			await response.body?.cancel().catch(ignoreCleanupError);
+			throw new TransportError("redirect_not_followed", "redirect responses are not followed", response.status);
+		}
+		if (!response.ok) try {
+			throw await toApiError(response, limits.maxJsonBytes);
+		} finally {
+			clearTimeout(headersTimer);
+		}
+		const requestId = response.headers.get(REQUEST_ID_HEADER);
+		switch (request.responseKind) {
+			case "json": try {
+				if (!hasContentType(response, JSON_CONTENT_TYPE)) {
+					await response.body?.cancel().catch(ignoreCleanupError);
+					throw new TransportError("unexpected_content_type", "expected an application/json response", response.status);
+				}
+				const text = decodeUtf8(await readBodyWithLimit(response, limits.maxJsonBytes));
+				let body;
+				try {
+					body = JSON.parse(text);
+				} catch {
+					throw new TransportError("invalid_json", "the response body is not valid JSON", response.status);
+				}
+				return {
+					kind: "json",
+					status: response.status,
+					requestId,
+					body
+				};
+			} catch (err) {
+				throw toTransportError(err);
+			} finally {
+				clearTimeout(headersTimer);
+			}
+			case "empty":
+				clearTimeout(headersTimer);
+				await response.body?.cancel().catch(ignoreCleanupError);
+				return {
+					kind: "empty",
+					status: response.status,
+					requestId
+				};
+			case "sse": {
+				clearTimeout(headersTimer);
+				if (!hasContentType(response, SSE_CONTENT_TYPE)) {
+					await response.body?.cancel().catch(ignoreCleanupError);
+					throw new TransportError("unexpected_content_type", "expected a text/event-stream response", response.status);
+				}
+				if (response.body == null) throw new TransportError("empty_body", "the stream has no body", response.status);
+				const collected = await collectSseEvents(response.body, {
+					deadlineAt: now() + limits.sseTotalMs,
+					maxEvents: limits.sseMaxEvents,
+					maxBytes: limits.sseMaxBytes,
+					now
+				});
+				return {
+					kind: "sse",
+					status: response.status,
+					requestId,
+					...collected
+				};
+			}
+			case "binary":
+				clearTimeout(headersTimer);
+				if (response.body == null) throw new TransportError("empty_body", "the download has no body", response.status);
+				return {
+					kind: "binary",
+					status: response.status,
+					requestId,
+					contentType: response.headers.get("content-type"),
+					fileName: parseContentDispositionFileName(response.headers.get("content-disposition")),
+					body: response.body
+				};
+			default:
+				request.responseKind;
+				throw new Error(`unknown response kind ${String(request.responseKind)}`);
+		}
+	};
+	/**
+	* 再送は「GET かつ本文が JSON / 空」の要求だけ、429（`Retry-After` が上限内）と接続失敗で 1 回。
+	* 書き込みは冪等でも再送しない（設計書 INV-C06「クライアントは書き込みを自動再送しない」）。
+	*/
+	const request = async (req) => {
+		const canRetry = req.method === "GET" && (req.responseKind === "json" || req.responseKind === "empty");
+		try {
+			return await performOnce(req);
+		} catch (err) {
+			if (!canRetry) throw err;
+			if (err instanceof ApiError && err.info.status === 429 && err.info.retryAfterSeconds != null && err.info.retryAfterSeconds <= limits.maxRetryAfterSeconds) {
+				logger.warn("rate limited; retrying once", {
+					path: req.path,
+					retryAfterSeconds: err.info.retryAfterSeconds
+				});
+				await sleep(err.info.retryAfterSeconds * 1e3);
+				return await performOnce(req);
+			}
+			if (err instanceof TransportError && err.kind === "network") {
+				logger.warn("network failure; retrying once", { path: req.path });
+				return await performOnce(req);
+			}
+			throw err;
+		}
+	};
+	return { request };
+};
+//#endregion
+//#region ../../../packages/universal/utils/src/object.ts
+function hasOwn(obj, key) {
+	return Object.hasOwn(obj, key);
+}
+/** 指定した key が object の own property かどうかを判定する。 */
+const isOwnKey = (object, key) => hasOwn(object, key);
+/**
+* Object.keys の型安全な代替関数。
+* Object.keys は string[] を返すが、この関数はオブジェクトのキーの型を保持した配列を返す。
+*/
+const objectKeys = (object) => {
+	const keys = [];
+	for (const key in object) if (isOwnKey(object, key)) keys.push(key);
+	return keys;
+};
+/**
+* Object.entries の型安全な代替関数。
+* Object.entries は [string, T][] を返すが、この関数はキーの型を保持したペア配列を返す。
+*/
+const objectEntries = (object) => {
+	const entries = [];
+	for (const key in object) if (isOwnKey(object, key)) {
+		const value = Reflect.get(object, key);
+		entries.push([key, value]);
+	}
+	return entries;
+};
+/**
+* unknown 値が非配列の plain object であるかを判定する型ガード。
+* `typeof === 'object'` + `null` チェック + `Array.isArray` を一括で行い、
+* `as Record<string, unknown>` キャストを不要にする。
+*/
+const isPlainObject = (value) => {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+};
+//#endregion
+//#region src/workspace.ts
+/** 作業ディレクトリ直下に置く MCP の状態ディレクトリ。ダウンロード既定先もこの下。 */
+const WORKSPACE_STATE_DIR = ".flyle-ai-contact-center-mcp";
+const BINDING_FILE = "workspace.json";
+const BINDING_FILE_VERSION = 1;
+const WORKSPACE_ID_LENGTH = 32;
+const bindingFilePath = (dir) => path.join(dir, WORKSPACE_STATE_DIR, BINDING_FILE);
+const isNotFound = (err) => err instanceof Error && hasOwn(err, "code") && err.code === "ENOENT";
+const isAlreadyExists = (err) => err instanceof Error && hasOwn(err, "code") && err.code === "EEXIST";
+/** 束縛ファイルの tenantName。無ければ null。壊れていたら上書きせず止める（黙って別テナントに付け替えない）。 */
+const readBoundTenant = async (dir) => {
+	let raw;
+	try {
+		raw = await readFile(bindingFilePath(dir), "utf8");
+	} catch (err) {
+		if (isNotFound(err)) return null;
+		throw err;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		parsed = null;
+	}
+	if (!isPlainObject(parsed) || typeof parsed["tenantName"] !== "string") throw new WorkspaceBindingError("corrupted", `${bindingFilePath(dir)} is not a valid workspace binding. Inspect it manually; the MCP server never overwrites it.`);
+	return parsed["tenantName"];
+};
+const mismatchError = (dir, boundTenant, tenantName) => new WorkspaceBindingError("tenant_mismatch", `${dir} is dedicated to tenant "${boundTenant}", but this server is configured for "${tenantName}". Use a separate directory (and a separate Claude Code session) for each tenant.`);
+const ancestorsOf = (dir) => {
+	const result = [];
+	let current = path.dirname(dir);
+	while (current !== path.dirname(current)) {
+		result.push(current);
+		current = path.dirname(current);
+	}
+	result.push(current);
+	return result;
+};
+/** 別テナントのディレクトリの中に入れ子で作業させない。 */
+const assertNoForeignAncestor = async (root, tenantName) => {
+	const bound = await Promise.all(ancestorsOf(root).map(async (dir) => ({
+		dir,
+		tenant: await readBoundTenant(dir)
+	})));
+	for (const { dir, tenant } of bound) if (tenant != null && tenant !== tenantName) throw mismatchError(dir, tenant, tenantName);
+};
+const computeWorkspaceId = (env, root) => createHash("sha256").update(`${env.hostname}\0${env.username}\0${root}`).digest("base64url").slice(0, WORKSPACE_ID_LENGTH);
+/** 束縛ファイルを排他作成する。同時起動した別テナントの MCP と競っても勝者は 1 つ。 */
+const claimOrVerify = async (root, tenantName, now) => {
+	const content = {
+		version: BINDING_FILE_VERSION,
+		tenantName,
+		boundAt: now.toISOString()
+	};
+	await mkdir(path.join(root, WORKSPACE_STATE_DIR), { recursive: true });
+	try {
+		await writeFile(bindingFilePath(root), `${JSON.stringify(content, null, 2)}\n`, { flag: "wx" });
+		return;
+	} catch (err) {
+		if (!isAlreadyExists(err)) throw err;
+	}
+	const bound = await readBoundTenant(root);
+	if (bound !== tenantName) throw mismatchError(root, bound ?? "(unknown)", tenantName);
+};
+/**
+* 作業ディレクトリを 1 テナント専用にする。Claude Code の記憶・会話履歴・CLAUDE.md・ダウンロード物は
+* ディレクトリ単位で残るので、ディレクトリを分ければテナントをまたいだ持ち込みの経路がまとめて切れる。
+*/
+const bindWorkspace = async (env, tenantName) => {
+	const root = await realpath(env.cwd);
+	if (root === await realpath(env.homeDir).catch(() => env.homeDir) || root === path.parse(root).root) throw new WorkspaceBindingError("shared_directory", `${root} is shared by everything you do and cannot be dedicated to one tenant. Create a directory for this tenant (e.g. ~/flyle-cs/<tenant>) and start the session there.`);
+	await assertNoForeignAncestor(root, tenantName);
+	await claimOrVerify(root, tenantName, env.now());
+	return {
+		root,
+		tenantName,
+		workspaceId: computeWorkspaceId(env, root)
+	};
+};
+/** 起動後に束縛ファイルが差し替えられていないかを操作ごとに確かめる。消えていれば同じテナントで張り直す。 */
+const assertWorkspaceBinding = async (workspace, now) => {
+	await claimOrVerify(workspace.root, workspace.tenantName, now);
+};
+const outsideWorkspaceError = (root, target, label) => new WorkspaceBindingError("outside_workspace", `${label} (${target}) must be inside the tenant workspace ${root}; a shared location could mix files between tenants.`);
+/** 起動設定のパス（ファイルの読込元・保存先）が作業ディレクトリの外を指していないか。未作成のパスもあるので字面で比べる。 */
+const assertConfiguredPathInsideWorkspace = (cwd, target, label) => {
+	const relative = path.relative(path.resolve(cwd), target);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw outsideWorkspaceError(cwd, target, label);
+};
+/** 読むファイルが、作業ディレクトリの中に作られた別テナントの作業ディレクトリに属していないか。 */
+const assertFileBelongsToWorkspace = async (workspace, realFilePath) => {
+	if (!realFilePath.startsWith(`${workspace.root}${path.sep}`)) throw outsideWorkspaceError(workspace.root, realFilePath, "the file");
+	const between = [];
+	for (let dir = path.dirname(realFilePath); dir !== workspace.root; dir = path.dirname(dir)) between.push(dir);
+	const bound = await Promise.all(between.map(async (dir) => ({
+		dir,
+		tenant: await readBoundTenant(dir)
+	})));
+	for (const { dir, tenant } of bound) if (tenant != null && tenant !== workspace.tenantName) throw mismatchError(dir, tenant, workspace.tenantName);
+};
+//#endregion
+//#region src/tools/local-files.ts
+/**
+* 通常ファイルだけを上限付きで読む。FIFO は open 自体が writer 待ちで止まるので O_NONBLOCK で開き、同じ handle の
+* fstat で種類と大きさを見る。最終要素のリンク差し替えは O_NOFOLLOW で拒み、stat 後に伸びた分は読後の再検査で弾く。
+*/
+const openRegularFile = async (filePath) => {
+	const handle = await open(filePath, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+	try {
+		const info = await handle.stat();
+		if (!info.isFile()) throw new LocalFileError("not_a_file", "only regular files can be read");
+		return {
+			handle,
+			size: info.size
+		};
+	} catch (err) {
+		await handle.close();
+		throw err;
+	}
+};
+const READ_CHUNK_BYTES = 1048576;
+const readRegularFileBounded = async (filePath, maxBytes) => {
+	const { handle, size } = await openRegularFile(filePath);
+	try {
+		if (size > maxBytes) throw new LocalFileError("too_large", `the file exceeds ${String(maxBytes)} bytes`);
+		const chunks = [];
+		let total = 0;
+		for (;;) {
+			const chunk = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, maxBytes - total + 1));
+			const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+			if (bytesRead === 0) break;
+			total += bytesRead;
+			if (total > maxBytes) throw new LocalFileError("too_large", `the file exceeds ${String(maxBytes)} bytes`);
+			chunks.push(chunk.subarray(0, bytesRead));
+		}
+		return Buffer.concat(chunks, total);
+	} finally {
+		await handle.close();
+	}
+};
+const isWithin = (target, root) => target === root || target.startsWith(`${root}${path.sep}`);
+/**
+* 利用者が信頼する roots を前提に、LLM が渡すパス文字列の範囲外参照を realpath で拒否する。
+* 検証から open までに親ディレクトリを差し替える並行ローカル主体は脅威モデルに含めない。
+*/
+const resolveWithinRoots = async (rawPath, roots, cwd, workspace) => {
+	const absolute = path.resolve(cwd, rawPath);
+	let real;
+	try {
+		real = await realpath(absolute);
+	} catch {
+		throw new LocalFileError("not_found", `file not found: ${rawPath}`);
+	}
+	if (!(await Promise.all(roots.map((root) => realpath(root).catch(() => root)))).some((root) => isWithin(real, root))) throw new LocalFileError("outside_roots", "the path is outside the configured file roots");
+	await assertFileBelongsToWorkspace(workspace, real);
+	return real;
+};
+const MIME_BY_EXTENSION = /* @__PURE__ */ new Map([
+	[".md", "text/markdown"],
+	[".markdown", "text/markdown"],
+	[".txt", "text/plain"],
+	[".csv", "text/csv"],
+	[".json", "application/json"],
+	[".html", "text/html"],
+	[".htm", "text/html"],
+	[".pdf", "application/pdf"],
+	[".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+	[".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+	[".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+	[".png", "image/png"],
+	[".jpg", "image/jpeg"],
+	[".jpeg", "image/jpeg"],
+	[".zip", "application/zip"]
+]);
+const DEFAULT_MIME_TYPE = "application/octet-stream";
+const guessMimeType = (fileName) => MIME_BY_EXTENSION.get(path.extname(fileName).toLowerCase()) ?? DEFAULT_MIME_TYPE;
+const hashStream = (stream) => new Promise((resolve, reject) => {
+	const hash = createHash("sha256");
+	stream.on("data", (chunk) => hash.update(chunk)).on("error", reject).on("end", () => resolve(hash.digest()));
+});
+/** アップロード前の申告値（名前・サイズ・sha256・MIME）をローカルで計算する。 */
+const inspectLocalFile = async (rawPath, roots, cwd, workspace) => {
+	const resolved = await resolveWithinRoots(rawPath, roots, cwd, workspace);
+	const { handle, size } = await openRegularFile(resolved);
+	let digest;
+	try {
+		digest = await hashStream(handle.createReadStream());
+	} finally {
+		await handle.close();
+	}
+	const fileName = path.basename(resolved);
+	return {
+		path: resolved,
+		fileName,
+		sizeBytes: size,
+		sha256Hex: digest.toString("hex"),
+		sha256Base64: digest.toString("base64"),
+		mimeType: guessMimeType(fileName)
+	};
+};
+//#endregion
+//#region src/http/transfer.ts
+const createPresignedUrlRegistry = (now, ttlMs = PRESIGNED_URL_TTL_MS, maxEntries = PRESIGNED_URL_REGISTRY_MAX) => {
+	const entries = /* @__PURE__ */ new Map();
+	const evictExpired = () => {
+		const current = now();
+		for (const [url, entry] of entries) if (entry.expiresAt <= current) entries.delete(url);
+	};
+	return {
+		get size() {
+			return entries.size;
+		},
+		register: (url, kind, headers) => {
+			evictExpired();
+			while (entries.size >= maxEntries) {
+				const oldest = entries.keys().next();
+				if (oldest.done) break;
+				entries.delete(oldest.value);
+			}
+			entries.delete(url);
+			entries.set(url, {
+				kind,
+				headers,
+				expiresAt: now() + ttlMs
+			});
+		},
+		take: (url, kind) => {
+			const entry = entries.get(url);
+			if (entry?.kind !== kind) throw new TransferError("unknown_url", "the URL was not returned by a recent API call for this kind of transfer");
+			entries.delete(url);
+			if (entry.expiresAt <= now()) throw new TransferError("expired_url", "the signed URL has expired; call the API again to get a new one");
+			return entry;
+		}
+	};
+};
+/** 署名付き URL は https かつ許可されたストレージホストに限る（設計書「MCP の実行契約」）。 */
+const assertAllowedStorageUrl = (raw, config) => {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new TransferError("not_allowed_host", "the transfer URL is not a valid URL");
+	}
+	const local = config.allowInsecureHttp && isLocalHost(url.hostname);
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) throw new TransferError("insecure_url", "transfer URLs must use https");
+	if (url.username !== "" || url.password !== "") throw new TransferError("not_allowed_host", "transfer URLs must not contain credentials");
+	const host = url.hostname.toLowerCase();
+	if (!(local || config.storageHostSuffixes.some((suffix) => suffix.startsWith(".") ? host.endsWith(suffix) : host === suffix))) throw new TransferError("not_allowed_host", `the host ${host} is not an allowed storage host`);
+	return url;
+};
+const unescapePointerToken$1 = (token) => token.replaceAll("~1", "/").replaceAll("~0", "~");
+const isUnknownArray = (value) => Array.isArray(value);
+/** JSON Pointer を辿る。`*` は配列の全要素に展開するので結果は配列。 */
+const resolvePointer = (body, pointer) => {
+	if (pointer === "") return [body];
+	const tokens = pointer.split("/").slice(1).map((token) => unescapePointerToken$1(token));
+	let current = [body];
+	for (const token of tokens) {
+		const next = [];
+		for (const node of current) if (token === "*") {
+			if (isUnknownArray(node)) next.push(...node);
+		} else if (isUnknownArray(node)) {
+			const index = Number(token);
+			if (Number.isInteger(index) && index >= 0 && index < node.length) next.push(node[index]);
+		} else if (isPlainObject(node) && hasOwn(node, token)) next.push(node[token]);
+		current = next;
+	}
+	return current;
+};
+const toStringHeaders = (value) => {
+	if (!isPlainObject(value)) return {};
+	const headers = {};
+	for (const [key, item] of objectEntries(value)) if (typeof item === "string") headers[key] = item;
+	return headers;
+};
+/**
+* 応答本文から署名付き URL を取り出す。`x-transfer` の pointer が指す位置だけを見る。注記の無い操作は
+* 何も取り出さない（本文中の任意の URL らしき値を転送先に昇格させない。利用者データ由来の URL が
+* upload 登録されると、後続の `upload_file` でローカルファイルを外へ送る経路になる）。
+*/
+const extractTransferUrls = (body, transfer) => {
+	if (transfer == null) return [];
+	const urls = resolvePointer(body, transfer.urlPointer).filter((value) => typeof value === "string");
+	const headerSets = transfer.headersPointer == null ? [] : resolvePointer(body, transfer.headersPointer).map((headers) => toStringHeaders(headers));
+	return urls.map((url, index) => ({
+		url,
+		kind: transfer.kind,
+		headers: headerSets.length === 1 ? headerSets[0] ?? {} : headerSets[index] ?? {}
+	}));
+};
+/** ストレージのエラー本文は先頭だけ読む（全量読みは上限外のメモリ消費になる）。 */
+const MAX_ERROR_TEXT_BYTES = 4096;
+const readErrorTextBounded = async (response) => {
+	if (response.body == null) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (total < MAX_ERROR_TEXT_BYTES) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+			total += value.byteLength;
+		}
+	} catch {} finally {
+		await reader.cancel().catch(ignoreCleanupError);
+	}
+	return new TextDecoder("utf-8").decode(Buffer.concat(chunks)).slice(0, MAX_ERROR_TEXT_BYTES);
+};
+const toTransferFetchError = (error) => {
+	if (error instanceof TransferError) return error;
+	if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) return new TransferError("timeout", "the storage did not respond in time");
+	return new TransferError("network", error instanceof Error ? error.message : "network failure");
+};
+/** 署名付き URL へのアップロード。Authorization は絶対に付けない（署名が認証そのもの）。 */
+const uploadFileToPresignedUrl = async (input) => {
+	if (objectKeys(input.headers).some((name) => name.toLowerCase() === "authorization")) throw new TransferError("invalid_headers", "transfer headers must not include authorization");
+	let bytes;
+	try {
+		bytes = await readRegularFileBounded(input.filePath, input.maxBytes);
+	} catch (err) {
+		if (err instanceof LocalFileError && (err.kind === "not_a_file" || err.kind === "too_large")) throw new TransferError(err.kind, err.kind === "not_a_file" ? "only regular files can be uploaded" : err.message);
+		throw err;
+	}
+	let response;
+	try {
+		response = await input.fetch(input.url, {
+			method: "PUT",
+			headers: input.headers,
+			body: bytes,
+			redirect: "manual",
+			signal: AbortSignal.timeout(input.timeoutMs)
+		});
+	} catch (err) {
+		throw toTransferFetchError(err);
+	}
+	if (response.status >= 300 && response.status < 400) {
+		await response.body?.cancel().catch(ignoreCleanupError);
+		throw new TransferError("redirect_not_followed", "redirect responses are not followed", response.status);
+	}
+	if (!response.ok) throw new TransferError("http_error", `upload failed: ${(await readErrorTextBounded(response)).slice(0, 300)}`, response.status);
+	await response.body?.cancel().catch(ignoreCleanupError);
+	return {
+		status: response.status,
+		etag: response.headers.get("etag"),
+		bytes: bytes.byteLength
+	};
+};
+const SAFE_FILE_NAME_PATTERN = /[^A-Za-z0-9._-]/g;
+const MAX_FILE_NAME_LENGTH = 120;
+const sanitizeFileName = (name, fallback) => {
+	const trimmed = path.basename(name ?? "").replace(SAFE_FILE_NAME_PATTERN, "_").replace(/^_+/, "").slice(0, MAX_FILE_NAME_LENGTH);
+	return trimmed === "" || /^\.+$/.test(trimmed) ? fallback : trimmed;
+};
+const buildUniqueFileName = (fileName) => {
+	return `${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}-${fileName}`;
+};
+const readWithDeadline = async (reader, remainingMs) => {
+	if (remainingMs <= 0) return "timeout";
+	let timer = null;
+	const deadline = new Promise((resolve) => {
+		timer = setTimeout(() => resolve("timeout"), remainingMs);
+	});
+	try {
+		return await Promise.race([reader.read(), deadline]);
+	} finally {
+		if (timer != null) clearTimeout(timer);
+	}
+};
+/**
+* ストリームを出力ディレクトリに書く。上限超過・期限切れは書きかけを消して失敗にする。
+* 応答ヘッダ後に送信が止まる相手でも `timeoutMs` で必ず戻る。
+*/
+const saveStreamToFile = async (stream, options) => {
+	await mkdir(options.outputDir, { recursive: true });
+	const target = path.join(options.outputDir, buildUniqueFileName(options.fileName));
+	const handle = await open(target, "wx");
+	const hash = createHash("sha256");
+	const reader = stream.getReader();
+	const deadlineAt = Date.now() + options.timeoutMs;
+	let bytes = 0;
+	try {
+		for (;;) {
+			const result = await readWithDeadline(reader, deadlineAt - Date.now());
+			if (result === "timeout") {
+				await reader.cancel().catch(ignoreCleanupError);
+				throw new TransferError("timeout", `the download did not finish within ${options.timeoutMs} ms`);
+			}
+			const { done, value } = result;
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > options.maxBytes) {
+				await reader.cancel().catch(ignoreCleanupError);
+				throw new TransferError("too_large", `the download exceeds ${options.maxBytes} bytes`);
+			}
+			hash.update(value);
+			await handle.write(value);
+		}
+	} catch (err) {
+		await handle.close();
+		await unlink(target).catch(ignoreCleanupError);
+		throw toTransferFetchError(err);
+	}
+	await handle.close();
+	return {
+		path: target,
+		bytes,
+		sha256Hex: hash.digest("hex")
+	};
+};
+/** 署名付き URL からのダウンロード。Authorization を付けず、リダイレクトも追跡しない。 */
+const downloadPresignedUrlToFile = async (input) => {
+	let response;
+	try {
+		response = await input.fetch(input.url, {
+			method: "GET",
+			redirect: "manual",
+			signal: AbortSignal.timeout(input.timeoutMs)
+		});
+	} catch (err) {
+		throw toTransferFetchError(err);
+	}
+	if (response.status >= 300 && response.status < 400) {
+		await response.body?.cancel().catch(ignoreCleanupError);
+		throw new TransferError("redirect_not_followed", "redirect responses are not followed", response.status);
+	}
+	if (!response.ok) throw new TransferError("http_error", `download failed: ${(await readErrorTextBounded(response)).slice(0, 300)}`, response.status);
+	if (response.body == null) throw new TransferError("network", "the download has no body", response.status);
+	return {
+		...await saveStreamToFile(response.body, {
+			outputDir: input.outputDir,
+			fileName: input.fileName,
+			maxBytes: input.maxBytes,
+			timeoutMs: input.timeoutMs
+		}),
+		status: response.status,
+		contentType: response.headers.get("content-type")
+	};
+};
+//#endregion
+//#region src/log.ts
+/** 秘密値（API キー）をどの経路でも出さないための置換。空文字は置換対象にしない。 */
+const redactSecrets = (text, secrets) => {
+	let result = text;
+	for (const secret of secrets) {
+		if (secret.length === 0) continue;
+		result = result.split(secret).join(REDACTED_PLACEHOLDER);
+	}
+	return result;
+};
+const formatLine = (level, message, fields, secrets) => {
+	const payload = {
+		level,
+		message,
+		...fields,
+		time: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return redactSecrets(JSON.stringify(payload), secrets);
+};
+/**
+* stdout は MCP の JSON-RPC 専用チャネルなので、ログは stderr にだけ書く。
+* `secrets` に渡した値は出力前に置換する。
+*/
+const createLogger = (secrets, sink = (line) => console.error(line)) => ({
+	info: (message, fields) => sink(formatLine("info", message, fields, secrets)),
+	warn: (message, fields) => sink(formatLine("warn", message, fields, secrets)),
+	error: (message, fields) => sink(formatLine("error", message, fields, secrets))
+});
+//#endregion
+//#region src/manifest/types.ts
+const HTTP_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+const RESPONSE_KINDS = [
+	"json",
+	"empty",
+	"sse",
+	"binary"
+];
+const TRANSFER_KINDS = ["upload", "download"];
+/** MCP に載せる操作の効果。live は複数顧客を扱う CS の誤操作が直ちに本番へ出るため、MCP からは呼べない。 */
+const MCP_OPERATION_EFFECTS = ["read", "draft"];
+const INLINE_FILE_INPUT_FORMATS = ["wav-pcm16", "base64"];
+const INLINE_FILE_OUTPUT_FORMATS = ["pcm16le", "base64"];
+//#endregion
+//#region src/manifest/load.ts
+const GENERATED_MANIFEST_URL = new URL("../generated/manifest.json", import.meta.url);
+const fail = (detail) => {
+	throw new ManifestLoadError(detail);
+};
+const isExplicitNull = (value) => value === null;
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+/** 生成器と同じ「2xx を昇順・重複なしで 1 つ以上」だけを受け付ける。 */
+const isSuccessStatusList = (value) => {
+	if (!Array.isArray(value) || value.length === 0) return false;
+	let previous = 0;
+	for (const status of value) {
+		if (typeof status !== "number" || !Number.isInteger(status)) return false;
+		if (status < 200 || status >= 300 || status <= previous) return false;
+		previous = status;
+	}
+	return true;
+};
+const isHttpMethod = (value) => typeof value === "string" && HTTP_METHODS.some((method) => method === value);
+const isResponseKind = (value) => typeof value === "string" && RESPONSE_KINDS.some((kind) => kind === value);
+const isTransferKind = (value) => typeof value === "string" && TRANSFER_KINDS.some((kind) => kind === value);
+const isMcpOperationEffect = (value) => typeof value === "string" && MCP_OPERATION_EFFECTS.some((effect) => effect === value);
+const parseTransfer = (value, where) => {
+	if (isExplicitNull(value)) return null;
+	if (!isPlainObject(value)) return fail(`${where}.transfer must be an object or null`);
+	const { kind, urlPointer, headersPointer } = value;
+	if (!isTransferKind(kind)) return fail(`${where}.transfer.kind is invalid`);
+	if (typeof urlPointer !== "string") return fail(`${where}.transfer.urlPointer is invalid`);
+	if (!isExplicitNull(headersPointer) && typeof headersPointer !== "string") return fail(`${where}.transfer.headersPointer is invalid`);
+	return {
+		kind,
+		urlPointer,
+		headersPointer
+	};
+};
+const isInlineFileInputFormat = (value) => typeof value === "string" && INLINE_FILE_INPUT_FORMATS.some((format) => format === value);
+const isInlineFileOutputFormat = (value) => typeof value === "string" && INLINE_FILE_OUTPUT_FORMATS.some((format) => format === value);
+const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+const parsePcm = (value, where) => {
+	if (isExplicitNull(value)) return null;
+	if (!isPlainObject(value)) return fail(`${where} must be an object or null`);
+	const { sampleRateHz, channels } = value;
+	if (!isPositiveInteger(sampleRateHz)) return fail(`${where}.sampleRateHz is invalid`);
+	if (!isPositiveInteger(channels)) return fail(`${where}.channels is invalid`);
+	return {
+		sampleRateHz,
+		channels
+	};
+};
+const parseInlineFileInput = (value, where) => {
+	if (!isPlainObject(value)) return fail(`${where} must be an object`);
+	const { pointer, format, maxBytes, pcm } = value;
+	if (typeof pointer !== "string" || !pointer.startsWith("/")) return fail(`${where}.pointer is invalid`);
+	if (!isInlineFileInputFormat(format)) return fail(`${where}.format is invalid`);
+	if (!isPositiveInteger(maxBytes)) return fail(`${where}.maxBytes is invalid`);
+	const parsedPcm = parsePcm(pcm, `${where}.pcm`);
+	if (format === "wav-pcm16" !== (parsedPcm != null)) return fail(`${where}.pcm does not match the format`);
+	return {
+		pointer,
+		format,
+		maxBytes,
+		pcm: parsedPcm
+	};
+};
+const parseInlineFileOutput = (value, where) => {
+	if (!isPlainObject(value)) return fail(`${where} must be an object`);
+	const { event, pointer, format, pcm, mediaType } = value;
+	if (!isExplicitNull(event) && typeof event !== "string") return fail(`${where}.event is invalid`);
+	if (typeof pointer !== "string" || !pointer.startsWith("/")) return fail(`${where}.pointer is invalid`);
+	if (!isInlineFileOutputFormat(format)) return fail(`${where}.format is invalid`);
+	if (!isExplicitNull(mediaType) && typeof mediaType !== "string") return fail(`${where}.mediaType is invalid`);
+	const parsedPcm = parsePcm(pcm, `${where}.pcm`);
+	if (format === "pcm16le" !== (parsedPcm != null)) return fail(`${where}.pcm does not match the format`);
+	if (format === "base64" !== (mediaType != null)) return fail(`${where}.mediaType does not match the format`);
+	return {
+		event,
+		pointer,
+		format,
+		pcm: parsedPcm,
+		mediaType
+	};
+};
+const parseInlineFiles = (value, where) => {
+	if (isExplicitNull(value)) return null;
+	if (!isPlainObject(value)) return fail(`${where}.inlineFiles must be an object or null`);
+	const { input, output } = value;
+	if (!Array.isArray(input) || !Array.isArray(output)) return fail(`${where}.inlineFiles is invalid`);
+	if (input.length === 0 && output.length === 0) return fail(`${where}.inlineFiles must declare input or output`);
+	return {
+		input: input.map((item, index) => parseInlineFileInput(item, `${where}.inlineFiles.input[${String(index)}]`)),
+		output: output.map((item, index) => parseInlineFileOutput(item, `${where}.inlineFiles.output[${String(index)}]`))
+	};
+};
+const parseSseOutcome = (value, where) => {
+	if (isExplicitNull(value)) return null;
+	if (!isPlainObject(value)) return fail(`${where}.sseOutcome must be an object or null`);
+	const { requiredEvents, terminalEvent, successPointer, successValue, failureEvents } = value;
+	if (!isStringArray(requiredEvents)) return fail(`${where}.sseOutcome.requiredEvents is invalid`);
+	if (typeof terminalEvent !== "string") return fail(`${where}.sseOutcome.terminalEvent is invalid`);
+	if (isExplicitNull(successPointer) && isExplicitNull(successValue)) {
+		if (!isStringArray(failureEvents)) return fail(`${where}.sseOutcome.failureEvents is invalid`);
+		return {
+			requiredEvents,
+			terminalEvent,
+			successPointer,
+			successValue,
+			failureEvents
+		};
+	}
+	if (typeof successPointer !== "string" || !successPointer.startsWith("/")) return fail(`${where}.sseOutcome.successPointer is invalid`);
+	if (typeof successValue !== "string" && typeof successValue !== "number" && typeof successValue !== "boolean") return fail(`${where}.sseOutcome.successValue is invalid`);
+	if (!isStringArray(failureEvents)) return fail(`${where}.sseOutcome.failureEvents is invalid`);
+	return {
+		requiredEvents,
+		terminalEvent,
+		successPointer,
+		successValue,
+		failureEvents
+	};
+};
+const parseOperation = (value, index) => {
+	const where = `operations[${index}]`;
+	if (!isPlainObject(value)) return fail(`${where} must be an object`);
+	const { operationId, method, pathTemplate, summary, description, permission, effect, responseKind, successStatuses, pathParams, queryParams, bodyFields, wholeBodyField, inputSchema, transfer, inlineFiles, sseOutcome } = value;
+	if (typeof operationId !== "string" || operationId === "") return fail(`${where}.operationId is invalid`);
+	if (!isHttpMethod(method)) return fail(`${where}.method is invalid`);
+	if (typeof pathTemplate !== "string" || !pathTemplate.startsWith("/")) return fail(`${where}.pathTemplate is invalid`);
+	if (typeof summary !== "string") return fail(`${where}.summary is invalid`);
+	if (!isExplicitNull(description) && typeof description !== "string") return fail(`${where}.description is invalid`);
+	if (!isExplicitNull(effect) && !isMcpOperationEffect(effect)) return fail(`${where}.effect is invalid`);
+	if (!isResponseKind(responseKind)) return fail(`${where}.responseKind is invalid`);
+	if (!isSuccessStatusList(successStatuses)) return fail(`${where}.successStatuses is invalid`);
+	if (!isStringArray(pathParams)) return fail(`${where}.pathParams is invalid`);
+	if (!isStringArray(queryParams)) return fail(`${where}.queryParams is invalid`);
+	if (!isExplicitNull(bodyFields) && !isStringArray(bodyFields)) return fail(`${where}.bodyFields is invalid`);
+	if (!isExplicitNull(wholeBodyField) && typeof wholeBodyField !== "string") return fail(`${where}.wholeBodyField is invalid`);
+	if (bodyFields != null && wholeBodyField != null) return fail(`${where} declares both bodyFields and wholeBodyField`);
+	if (!isPlainObject(inputSchema)) return fail(`${where}.inputSchema is invalid`);
+	return {
+		operationId,
+		method,
+		pathTemplate,
+		summary,
+		description,
+		permission: permission ?? null,
+		effect,
+		responseKind,
+		successStatuses,
+		pathParams,
+		queryParams,
+		bodyFields,
+		wholeBodyField,
+		inputSchema,
+		transfer: parseTransfer(transfer, where),
+		inlineFiles: parseInlineFiles(inlineFiles, where),
+		sseOutcome: parseSseOutcome(sseOutcome, where)
+	};
+};
+/** 生成物（JSON）を実行時の型に戻す。生成器と同じ形しか受け付けない。 */
+const parseManifest = (value) => {
+	if (!isPlainObject(value)) return fail("manifest must be an object");
+	const source = value["source"];
+	if (!isPlainObject(source) || typeof source["title"] !== "string" || typeof source["version"] !== "string") return fail("manifest.source is invalid");
+	const operations = value["operations"];
+	if (!Array.isArray(operations)) return fail("manifest.operations must be an array");
+	const parsed = operations.map((operation, index) => parseOperation(operation, index));
+	if (new Set(parsed.map((operation) => operation.operationId)).size !== parsed.length) return fail("manifest.operations has duplicate operationId");
+	return {
+		source: {
+			title: source["title"],
+			version: source["version"]
+		},
+		operations: parsed
+	};
+};
+const loadManifestFile = (url = GENERATED_MANIFEST_URL) => {
+	const text = readFileSync(url, "utf8");
+	let json;
+	try {
+		json = JSON.parse(text);
+	} catch {
+		return fail(`manifest at ${url.pathname} is not valid JSON`);
+	}
+	return parseManifest(json);
+};
+//#endregion
+//#region src/tools/inline-files.ts
+const PCM_ENCODING = "pcm16le";
+const BYTES_PER_SAMPLE = 2;
+const WAV_HEADER_BYTES = 44;
+const WAV_FORMAT_PCM = 1;
+const WAV_FORMAT_EXTENSIBLE = 65534;
+const BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+const readChunkHeader = (bytes, offset) => offset + 8 > bytes.length ? null : {
+	id: bytes.toString("latin1", offset, offset + 4),
+	size: bytes.readUInt32LE(offset + 4)
+};
+/** RIFF/WAVE を読み、PCM 16bit の生データと形式を返す。圧縮形式・浮動小数・8/24/32bit は受けない。 */
+const parseWavPcm16 = (bytes) => {
+	if (bytes.length < 12 || bytes.toString("latin1", 0, 4) !== "RIFF" || bytes.toString("latin1", 8, 12) !== "WAVE") throw new InlineFileError("not_wav", "the file is not a RIFF/WAVE file");
+	let format = null;
+	let pcm = null;
+	let offset = 12;
+	for (;;) {
+		const chunk = readChunkHeader(bytes, offset);
+		if (chunk == null) break;
+		const dataStart = offset + 8;
+		const dataEnd = dataStart + chunk.size;
+		if (dataEnd > bytes.length) throw new InlineFileError("not_wav", `the "${chunk.id}" chunk claims more bytes than the file holds`);
+		if (chunk.id === "fmt ") {
+			if (dataEnd - dataStart < 16) throw new InlineFileError("not_wav", "the fmt chunk is truncated");
+			const audioFormat = bytes.readUInt16LE(dataStart);
+			if ((audioFormat === WAV_FORMAT_EXTENSIBLE && dataEnd - dataStart >= 26 ? bytes.readUInt16LE(dataStart + 24) : audioFormat) !== WAV_FORMAT_PCM) throw new InlineFileError("unsupported_format", `unsupported WAV format code ${String(audioFormat)} (only PCM is accepted)`);
+			format = {
+				channels: bytes.readUInt16LE(dataStart + 2),
+				sampleRateHz: bytes.readUInt32LE(dataStart + 4),
+				bitsPerSample: bytes.readUInt16LE(dataStart + 14)
+			};
+		} else if (chunk.id === "data") pcm = bytes.subarray(dataStart, dataEnd);
+		offset = dataStart + chunk.size + chunk.size % 2;
+	}
+	if (format == null || pcm == null) throw new InlineFileError("not_wav", "the WAV file lacks a fmt or data chunk");
+	if (format.bitsPerSample !== 16) throw new InlineFileError("unsupported_format", `unsupported bit depth ${String(format.bitsPerSample)} (only 16-bit PCM is accepted)`);
+	if (pcm.length === 0) throw new InlineFileError("empty", "the WAV file has no audio samples");
+	if (pcm.length % (BYTES_PER_SAMPLE * format.channels) !== 0) throw new InlineFileError("not_wav", "the data chunk is not aligned to whole samples");
+	return {
+		sampleRateHz: format.sampleRateHz,
+		channels: format.channels,
+		pcm
+	};
+};
+/** PCM 16bit を 44 バイトヘッダの WAV に包む。 */
+const buildWavPcm16 = (pcm, format) => {
+	const header = Buffer.alloc(WAV_HEADER_BYTES);
+	const blockAlign = BYTES_PER_SAMPLE * format.channels;
+	header.write("RIFF", 0, "latin1");
+	header.writeUInt32LE(36 + pcm.length, 4);
+	header.write("WAVE", 8, "latin1");
+	header.write("fmt ", 12, "latin1");
+	header.writeUInt32LE(16, 16);
+	header.writeUInt16LE(WAV_FORMAT_PCM, 20);
+	header.writeUInt16LE(format.channels, 22);
+	header.writeUInt32LE(format.sampleRateHz, 24);
+	header.writeUInt32LE(format.sampleRateHz * blockAlign, 28);
+	header.writeUInt16LE(blockAlign, 32);
+	header.writeUInt16LE(16, 34);
+	header.write("data", 36, "latin1");
+	header.writeUInt32LE(pcm.length, 40);
+	return Buffer.concat([header, pcm]);
+};
+const durationMs = (pcmBytes, format) => Math.round(pcmBytes / (BYTES_PER_SAMPLE * format.channels * format.sampleRateHz) * 1e3);
+/** 根ディレクトリ配下の通常ファイルを上限付きで読む（FIFO・リンク差し替え・読中の伸長は local-files 側で拒む）。 */
+const readBoundedFile = async (rawPath, maxBytes, at, deps) => {
+	const real = await resolveWithinRoots(rawPath, deps.fileRoots, deps.cwd, deps.workspace);
+	try {
+		return await readRegularFileBounded(real, maxBytes);
+	} catch (err) {
+		if (err instanceof LocalFileError && err.kind === "too_large") throw new InlineFileError("too_large", `"${at}" exceeds ${String(maxBytes)} bytes`);
+		throw err;
+	}
+};
+/** 入力 1 件をローカルファイルから API 本文の値に組む。 */
+const encodeInlineInput = async (input, rawPath, at, deps) => {
+	if (typeof rawPath !== "string" || rawPath === "") throw new InlineFileError("not_a_path", `"${at}" must be a local file path`);
+	const bytes = await readBoundedFile(rawPath, input.format === "wav-pcm16" ? input.maxBytes + WAV_HEADER_BYTES : input.maxBytes, at, deps);
+	if (input.format === "base64") {
+		if (bytes.length === 0) throw new InlineFileError("empty", `"${at}" points at an empty file`);
+		return bytes.toString("base64");
+	}
+	const wav = parseWavPcm16(bytes);
+	const expected = input.pcm;
+	if (expected != null && (wav.sampleRateHz !== expected.sampleRateHz || wav.channels !== expected.channels)) throw new InlineFileError("unsupported_format", `"${at}" must be ${String(expected.sampleRateHz)} Hz / ${String(expected.channels)} channel PCM 16-bit WAV (got ${String(wav.sampleRateHz)} Hz / ${String(wav.channels)} channel)`);
+	if (wav.pcm.length > input.maxBytes) throw new InlineFileError("too_large", `"${at}" holds ${String(wav.pcm.length)} bytes of audio; at most ${String(input.maxBytes)} are accepted`);
+	return {
+		encoding: PCM_ENCODING,
+		sampleRateHz: wav.sampleRateHz,
+		channels: wav.channels,
+		data: wav.pcm.toString("base64")
+	};
+};
+const unescapePointerToken = (token) => token.replaceAll("~1", "/").replaceAll("~0", "~");
+/** pointer が指す値を置き換えた複製を返す。`*` は配列全要素。無い経路はそのまま残す（任意フィールド）。 */
+const replaceAtPointer = async (root, pointer, replace) => {
+	const walk = async (node, tokens, at) => {
+		const [token, ...rest] = tokens;
+		if (token == null) return replace(node, at);
+		if (token === "*") {
+			if (!Array.isArray(node)) return node;
+			const items = [];
+			for (const [index, item] of node.entries()) items.push(await walk(item, rest, `${at}/${String(index)}`));
+			return items;
+		}
+		if (Array.isArray(node)) {
+			const index = Number(token);
+			if (!Number.isInteger(index) || index < 0 || index >= node.length) return node;
+			const items = [...node];
+			items[index] = await walk(node[index], rest, `${at}/${token}`);
+			return items;
+		}
+		if (isPlainObject(node) && hasOwn(node, token)) return {
+			...node,
+			[token]: await walk(node[token], rest, `${at}/${token}`)
+		};
+		return node;
+	};
+	return walk(root, pointer.split("/").slice(1).map((token) => unescapePointerToken(token)), "");
+};
+/** ツール引数中のファイルパスを、宣言された pointer だけ base64 に置き換える。 */
+const applyInlineInputs = async (annotation, args, deps) => {
+	let current = args;
+	for (const input of annotation.input) current = await replaceAtPointer(current, input.pointer, (value, at) => encodeInlineInput(input, value, at, deps));
+	return isPlainObject(current) ? current : args;
+};
+const decodeBase64Chunk = (value, at) => {
+	if (typeof value !== "string" || value.length % 4 !== 0 || !BASE64_PATTERN.test(value)) throw new InlineFileError("invalid_base64", `"${at}" is not valid base64`);
+	return Buffer.from(value, "base64");
+};
+const EXTENSION_BY_MEDIA_TYPE = /* @__PURE__ */ new Map([
+	["audio/mpeg", ".mp3"],
+	["audio/mp4", ".m4a"],
+	["audio/ogg", ".ogg"],
+	["audio/wav", ".wav"],
+	["audio/webm", ".webm"],
+	["image/png", ".png"],
+	["image/jpeg", ".jpg"],
+	["image/webp", ".webp"],
+	["application/pdf", ".pdf"]
+]);
+/** 応答から集めた base64 チャンクを 1 ファイルに書く。pcm16le は WAV に包む。 */
+const saveChunks = async (output, chunks, options) => {
+	const buffers = [];
+	let total = 0;
+	for (const [index, chunk] of chunks.entries()) {
+		const decoded = decodeBase64Chunk(chunk, `${output.event ?? "body"}${output.pointer}[${String(index)}]`);
+		if (output.format === "pcm16le" && decoded.length % BYTES_PER_SAMPLE !== 0) throw new InlineFileError("unsupported_format", `${output.event ?? "body"}${output.pointer} chunk ${String(index)} is not whole PCM 16-bit samples`);
+		total += decoded.length;
+		if (total > options.maxBytes) throw new InlineFileError("too_large", `inline output exceeds ${String(options.maxBytes)} bytes`);
+		buffers.push(decoded);
+	}
+	const joined = Buffer.concat(buffers);
+	const pcm = output.pcm;
+	const isWav = output.format === "pcm16le" && pcm != null;
+	const bytes = isWav ? buildWavPcm16(joined, pcm) : joined;
+	const mediaType = isWav ? "audio/wav" : output.mediaType ?? "application/octet-stream";
+	const extension = isWav ? ".wav" : EXTENSION_BY_MEDIA_TYPE.get(mediaType) ?? ".bin";
+	return {
+		...await saveStreamToFile(new Blob([new Uint8Array(bytes)]).stream(), {
+			outputDir: options.outputDir,
+			fileName: sanitizeFileName(`${options.fileName}${extension}`, `inline${extension}`),
+			maxBytes: options.maxBytes + WAV_HEADER_BYTES,
+			timeoutMs: options.timeoutMs
+		}),
+		event: output.event,
+		pointer: output.pointer,
+		mediaType,
+		chunks: chunks.length,
+		durationMs: isWav ? durationMs(joined.length, pcm) : null
+	};
+};
+const tryParseJson$1 = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+/** SSE のうち宣言された event の base64 をファイルに落とし、そのイベントは結果から除く（usage 等の他イベントは残す）。 */
+const collectSseInlineOutputs = async (annotation, events, options) => {
+	const consumed = /* @__PURE__ */ new Set();
+	const files = [];
+	for (const output of annotation.output) {
+		if (output.event == null) continue;
+		consumed.add(output.event);
+		const chunks = events.filter((event) => event.event === output.event).flatMap((event) => resolvePointer(tryParseJson$1(event.data), output.pointer));
+		if (chunks.length === 0) continue;
+		files.push(await saveChunks(output, chunks, options));
+	}
+	return {
+		events: events.filter((event) => event.event == null || !consumed.has(event.event)),
+		files
+	};
+};
+/** JSON 応答の宣言位置の base64 をファイルに落とし、本文側は保存先の案内文に置き換える。 */
+const collectJsonInlineOutputs = async (annotation, body, options) => {
+	let current = body;
+	const files = [];
+	for (const output of annotation.output) {
+		if (output.event != null) continue;
+		const chunks = resolvePointer(current, output.pointer);
+		if (chunks.length === 0) continue;
+		const saved = await saveChunks(output, chunks, options);
+		files.push(saved);
+		current = await replaceAtPointer(current, output.pointer, () => Promise.resolve(`[saved to ${saved.path}]`));
+	}
+	return {
+		body: current,
+		files
+	};
+};
+/**
+* HTTP 200 と EOF だけでは成功にしない。最初の終端イベントで判定を確定し、それより前に必須イベントが揃い、
+* 失敗イベントが無く、終端の値が成功値のときだけ success。終端の後ろに何が来ても判定は変えない（吸収状態）。
+* 終端欠落や収集打ち切りは結果不明（unknown）で、いずれも呼び手は再送しない。
+*/
+const classifySseOutcome = (annotation, events, truncated) => {
+	const terminalIndex = events.findIndex((event) => event.event === annotation.terminalEvent);
+	const terminalEvent = terminalIndex === -1 ? null : events[terminalIndex];
+	const preceding = terminalIndex === -1 ? events : events.slice(0, terminalIndex);
+	const terminal = terminalEvent == null ? null : tryParseJson$1(terminalEvent.data);
+	const names = new Set(preceding.map((event) => event.event));
+	const failure = annotation.failureEvents.find((name) => names.has(name));
+	if (failure != null) return {
+		outcome: "failed",
+		reason: `received failure event "${failure}"`,
+		terminal
+	};
+	if (terminalEvent == null) {
+		if (truncated.truncated) return {
+			outcome: "unknown",
+			reason: `the stream was cut off by the client limit (${truncated.reason ?? "unknown"})`,
+			terminal
+		};
+		return {
+			outcome: "unknown",
+			reason: `the stream ended without the terminal event "${annotation.terminalEvent}"`,
+			terminal
+		};
+	}
+	const value = annotation.successPointer == null ? null : resolvePointer(terminal, annotation.successPointer)[0];
+	if (annotation.successPointer != null && value !== annotation.successValue) return {
+		outcome: "failed",
+		reason: `"${annotation.terminalEvent}" ended with ${annotation.successPointer}=${JSON.stringify(value)} (expected ${JSON.stringify(annotation.successValue)})`,
+		terminal
+	};
+	const missing = annotation.requiredEvents.filter((name) => !names.has(name));
+	if (missing.length > 0) return {
+		outcome: "failed",
+		reason: `required event(s) missing before "${annotation.terminalEvent}": ${missing.join(", ")}`,
+		terminal
+	};
+	return {
+		outcome: "success",
+		reason: null,
+		terminal
+	};
+};
+//#endregion
+//#region src/tools/invoke.ts
+const DEFAULT_TOOL_LIMITS = {
+	transferTimeoutMs: BINARY_TOTAL_TIMEOUT_MS,
+	maxDownloadBytes: MAX_DOWNLOAD_BYTES,
+	maxAutoDownloadsPerCall: 20,
+	maxInlineOutputBytes: MAX_INLINE_FILE_OUTPUT_BYTES
+};
+/** `{name}` を左から順に置き換える。空の `{}` はそのまま残す（正規表現の後退再試行を避けて手で走査する）。 */
+const fillPathTemplate = (template, resolve) => {
+	let result = "";
+	let cursor = 0;
+	let open = template.indexOf("{");
+	while (open !== -1) {
+		const close = template.indexOf("}", open + 1);
+		if (close === -1) break;
+		result += close === open + 1 ? template.slice(cursor, close + 1) : template.slice(cursor, open) + resolve(template.slice(open + 1, close));
+		cursor = close + 1;
+		open = template.indexOf("{", cursor);
+	}
+	return result + template.slice(cursor);
+};
+const stringifyParam = (name, value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	throw new InvalidArgumentsError(`argument "${name}" must be a string, number, or boolean`);
+};
+/** ツール引数を公開 API の要求に組む。`tenantName` は起動設定から埋め、引数からは受けない。 */
+const buildApiRequest = (config, entry, args) => {
+	if (hasOwn(args, "tenantName")) throw new InvalidArgumentsError(`"${TENANT_PATH_PARAM}" is fixed by the server configuration`);
+	const path = fillPathTemplate(entry.pathTemplate, (name) => {
+		if (name === "tenantName") return encodeURIComponent(config.tenantName);
+		const value = args[name];
+		if (value == null) throw new InvalidArgumentsError(`path parameter "${name}" is required`);
+		return encodeURIComponent(stringifyParam(name, value));
+	});
+	const query = [];
+	for (const name of entry.queryParams) {
+		const value = args[name];
+		if (value == null) continue;
+		if (Array.isArray(value)) for (const item of value) query.push([name, stringifyParam(name, item)]);
+		else query.push([name, stringifyParam(name, value)]);
+	}
+	let body = null;
+	let hasBody = false;
+	if (entry.wholeBodyField != null) {
+		if (!hasOwn(args, entry.wholeBodyField)) throw new InvalidArgumentsError(`argument "${entry.wholeBodyField}" is required`);
+		body = args[entry.wholeBodyField];
+		hasBody = true;
+	} else if (entry.bodyFields != null) {
+		const picked = {};
+		for (const name of entry.bodyFields) if (hasOwn(args, name)) picked[name] = args[name];
+		body = picked;
+		hasBody = true;
+	}
+	return {
+		method: entry.method,
+		path,
+		query,
+		hasBody,
+		body,
+		responseKind: entry.responseKind
+	};
+};
+const tryParseJson = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+const presentSseEvent = (event) => ({
+	event: event.event,
+	data: tryParseJson(event.data),
+	...event.id == null ? {} : { id: event.id }
+});
+const errorPayload = (error, secrets) => {
+	if (error instanceof ApiError) return {
+		isError: true,
+		payload: { error: {
+			kind: "api",
+			...error.info
+		} }
+	};
+	if (error instanceof TransportError) return {
+		isError: true,
+		payload: { error: {
+			kind: "transport",
+			failure: error.kind,
+			status: error.status,
+			message: error.message
+		} }
+	};
+	if (error instanceof TransferError) return {
+		isError: true,
+		payload: { error: {
+			kind: "transfer",
+			failure: error.kind,
+			status: error.status,
+			message: error.message
+		} }
+	};
+	if (error instanceof InvalidArgumentsError) return {
+		isError: true,
+		payload: { error: {
+			kind: "invalid_arguments",
+			message: error.message
+		} }
+	};
+	if (error instanceof LocalFileError) return {
+		isError: true,
+		payload: { error: {
+			kind: "local_file",
+			failure: error.kind,
+			message: error.message
+		} }
+	};
+	if (error instanceof InlineFileError) return {
+		isError: true,
+		payload: { error: {
+			kind: "inline_file",
+			failure: error.kind,
+			message: error.message
+		} }
+	};
+	if (error instanceof WorkspaceBindingError) return {
+		isError: true,
+		payload: { error: {
+			kind: "workspace",
+			failure: error.kind,
+			message: error.message
+		} }
+	};
+	if (error instanceof OperationFailedError) return {
+		isError: true,
+		payload: error.payload
+	};
+	if (error instanceof Error) return {
+		isError: true,
+		payload: { error: {
+			kind: "unexpected",
+			message: redactSecrets(error.message, secrets)
+		} }
+	};
+	throw error;
+};
+/** ツール実装の共通の受け皿。既知の失敗は `isError` 付きの構造化された payload に写す。 */
+const runTool = async (deps, operationId, body) => {
+	try {
+		await assertWorkspaceBinding(deps.workspace, new Date(deps.now()));
+		return {
+			isError: false,
+			payload: await body()
+		};
+	} catch (err) {
+		const secrets = [deps.config.apiKey];
+		const outcome = errorPayload(err, secrets);
+		const redacted = JSON.parse(redactSecrets(JSON.stringify(outcome.payload), secrets));
+		deps.logger.warn("tool call failed", {
+			operationId,
+			payload: redacted
+		});
+		return {
+			isError: true,
+			payload: redacted
+		};
+	}
+};
+const FAILED_DOWNLOAD_HINT = "The API response above is complete; only the automatic download failed. Retry it with download_file and the same URL.";
+/**
+* `x-transfer: download` の操作は署名付き URL を返すだけで終わらせず、その場でダウンロードして
+* ファイルパスを返す（手作業を要求しない）。upload は URL を登録し `upload_file` に委ねる。
+* ダウンロードの失敗は API 応答（原本テキスト等）を道連れにせず、結果に失敗種別として残す。
+*/
+const handleTransfers = async (deps, entry, body, limits) => {
+	const transfers = extractTransferUrls(body, entry.transfer);
+	if (transfers.length === 0) return {};
+	const uploads = [];
+	const downloads = [];
+	const failedDownloads = [];
+	const rejected = [];
+	for (const transfer of transfers) {
+		let url;
+		try {
+			url = assertAllowedStorageUrl(transfer.url, deps.config);
+		} catch (err) {
+			rejected.push({
+				url: transfer.url,
+				reason: err instanceof Error ? err.message : "rejected"
+			});
+			continue;
+		}
+		if (transfer.kind === "upload") {
+			deps.registry.register(transfer.url, "upload", transfer.headers);
+			uploads.push(transfer.url);
+			continue;
+		}
+		if (downloads.length >= limits.maxAutoDownloadsPerCall) {
+			deps.registry.register(transfer.url, "download", {});
+			continue;
+		}
+		const fileName = sanitizeFileName(url.pathname.split("/").at(-1) ?? null, `${entry.operationId}.bin`);
+		let saved;
+		try {
+			saved = await downloadPresignedUrlToFile({
+				url,
+				outputDir: deps.config.outputDir,
+				fileName,
+				fetch: deps.fetch,
+				maxBytes: limits.maxDownloadBytes,
+				timeoutMs: limits.transferTimeoutMs
+			});
+		} catch (err) {
+			if (!(err instanceof TransferError)) throw err;
+			deps.logger.warn("automatic download failed", {
+				operationId: entry.operationId,
+				host: url.hostname,
+				failure: err.kind
+			});
+			deps.registry.register(transfer.url, "download", {});
+			failedDownloads.push({
+				url: transfer.url,
+				failure: err.kind
+			});
+			continue;
+		}
+		downloads.push({
+			url: transfer.url,
+			path: saved.path,
+			bytes: saved.bytes,
+			sha256Hex: saved.sha256Hex,
+			contentType: saved.contentType
+		});
+	}
+	return {
+		...uploads.length === 0 ? {} : {
+			uploadUrls: uploads,
+			uploadHint: "Call upload_file with one of these URLs and a local file path."
+		},
+		...downloads.length === 0 ? {} : { downloads },
+		...failedDownloads.length === 0 ? {} : {
+			failedDownloads,
+			downloadHint: FAILED_DOWNLOAD_HINT
+		},
+		...rejected.length === 0 ? {} : { rejectedTransferUrls: rejected }
+	};
+};
+const inlineOutputOptions = (deps, entry, limits) => ({
+	outputDir: deps.config.outputDir,
+	fileName: entry.operationId,
+	maxBytes: limits.maxInlineOutputBytes,
+	timeoutMs: limits.transferTimeoutMs
+});
+const withFiles = (files) => files.length === 0 ? {} : { files };
+const invokeOperation = async (deps, entry, args, limits = DEFAULT_TOOL_LIMITS) => runTool(deps, entry.operationId, async () => {
+	const inlineFiles = entry.inlineFiles;
+	const preparedArgs = inlineFiles == null ? args : await applyInlineInputs(inlineFiles, args, {
+		fileRoots: deps.config.fileRoots,
+		cwd: deps.cwd,
+		workspace: deps.workspace
+	});
+	const request = buildApiRequest(deps.config, entry, preparedArgs);
+	const response = await deps.client.request(request);
+	switch (response.kind) {
+		case "json": {
+			const extra = await handleTransfers(deps, entry, response.body, limits);
+			const inline = inlineFiles == null ? {
+				body: response.body,
+				files: []
+			} : await collectJsonInlineOutputs(inlineFiles, response.body, inlineOutputOptions(deps, entry, limits));
+			return {
+				status: response.status,
+				requestId: response.requestId,
+				body: inline.body,
+				...extra,
+				...withFiles(inline.files)
+			};
+		}
+		case "empty": return {
+			status: response.status,
+			requestId: response.requestId
+		};
+		case "sse": {
+			const inline = inlineFiles == null ? {
+				events: response.events,
+				files: []
+			} : await collectSseInlineOutputs(inlineFiles, response.events, inlineOutputOptions(deps, entry, limits));
+			const payload = {
+				status: response.status,
+				requestId: response.requestId,
+				events: inline.events.map((event) => presentSseEvent(event)),
+				truncated: response.truncated,
+				stopReason: response.reason,
+				discardedIncomplete: response.discardedIncomplete,
+				...withFiles(inline.files)
+			};
+			if (entry.sseOutcome == null) return payload;
+			const verdict = classifySseOutcome(entry.sseOutcome, response.events, {
+				truncated: response.truncated,
+				reason: response.reason
+			});
+			const judged = {
+				...payload,
+				outcome: verdict.outcome,
+				outcomeReason: verdict.reason,
+				terminal: verdict.terminal
+			};
+			if (verdict.outcome !== "success") throw new OperationFailedError(verdict.reason ?? "operation failed", {
+				...judged,
+				retryHint: "Not retried automatically. Check the affected resource or execution history before running this operation again."
+			});
+			return judged;
+		}
+		case "binary": {
+			const saved = await saveStreamToFile(response.body, {
+				outputDir: deps.config.outputDir,
+				fileName: sanitizeFileName(response.fileName, `${entry.operationId}.bin`),
+				maxBytes: limits.maxDownloadBytes,
+				timeoutMs: limits.transferTimeoutMs
+			});
+			return {
+				status: response.status,
+				requestId: response.requestId,
+				file: {
+					...saved,
+					contentType: response.contentType,
+					fileName: response.fileName
+				}
+			};
+		}
+		default: throw new Error("unknown response kind");
+	}
+});
+//#endregion
+//#region src/server.ts
+const serverInstructions = (tenantName) => `Flyle AIコンタクトセンターの公開 API を呼ぶツール群です。
+- 接続先テナントは「${tenantName}」です。テナントと API キーはサーバー起動時に固定されており、ツール引数でテナントを指定することはできません。
+- この作業ディレクトリは「${tenantName}」専用です。別の顧客（テナント）の情報・ファイル・記憶をこのテナントへの書き込みに使わないでください。別テナントの作業は別ディレクトリの別セッションで行います。
+- 各ツール結果の tenantName は、その操作を実行したテナントです。
+- 書き込み系ツールは自動再送しません。タイムアウトや transport エラーの後は、対象を再取得して状態を確認してください。
+- 一覧は各ツールの入力スキーマと応答に従って取得してください。cursor / limit+offset / ページングなしの全件取得があります。
+- 大きな JSON 結果は出力ディレクトリに全文を保存し、保存先と先頭部分を返します。全文は保存ファイルを参照してください。
+- 改善要望は、現在の設定・既存ケースの取得 → create_eval_case / import_eval_cases でケースを保存 → 変更前の検証 → 修正 → プレビュー作成完了の確認 → 全ケースの再検証の順に進めます。create_improvement_analysis は分析結果を返すだけで、検証ケースや設定を保存しません。
+- 改善提案は内容と get_improvement_proposal_plan を確認し、根拠のある actionIndexes だけを resolve_improvement_proposal で適用してください。検証の受付だけで合格と判断せず、get_eval_run と list_eval_run_case_results で完了・ケース別結果を確認してください。
+- ファイル取込は inspect_local_file → create_knowledge_upload_urls → upload_file → create_knowledge_import の順に進め、取込と文書の処理完了を確認します。API の byteSize には sizeBytes、checksumSha256 には sha256Hex を渡します（sha256Base64 ではありません）。URL の発行と upload_file は同じ MCP 接続で行ってください。ダウンロード系はファイルパスを返します。`;
+/** JSON Schema らしさの最小検査。`fromJsonSchema` に渡す前に object スキーマであることを確かめる。 */
+const isObjectJsonSchema = (value) => isPlainObject(value) && value["type"] === "object" && isPlainObject(value["properties"]);
+const toJsonSchema = (schema, where) => {
+	if (!isObjectJsonSchema(schema)) throw new Error(`${where}: input schema must be an object schema`);
+	return schema;
+};
+const formatActions = (value) => {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value) && value.every((item) => typeof item === "string")) return value.join(", ");
+	return null;
+};
+const formatPermission = (permission) => {
+	if (!isPlainObject(permission)) return null;
+	const gate = permission["gate"];
+	if (gate === "none") return "認証のみ（ロール不要）";
+	const actions = formatActions(permission["action"] ?? permission["actions"]);
+	if (actions == null || typeof gate !== "string") return null;
+	if (gate === "any-resource") return `必要な権限: ${actions}（いずれかのエージェントで保持）`;
+	if (gate === "per-resource") return `必要な権限: ${actions}（対象エージェントに対して）`;
+	if (gate === "per-resource-all") return `必要な権限: ${actions} のすべて（対象エージェントに対して）`;
+	if (gate === "per-resource-any") return `必要な権限: ${actions} のいずれか（対象エージェントに対して）`;
+	return `必要な権限: ${actions}（${gate}）`;
+};
+const EFFECT_NOTES = {
+	read: null,
+	draft: "下書きへの変更です。公開版（利用者への配信）には publish まで反映されません。"
+};
+const effectNoteFor = (entry) => entry.effect == null ? null : EFFECT_NOTES[entry.effect];
+const describeOperation = (entry) => {
+	const lines = [entry.summary];
+	if (entry.description != null) lines.push("", entry.description);
+	lines.push("", `HTTP: ${entry.method} ${entry.pathTemplate}`);
+	const permission = formatPermission(entry.permission);
+	if (permission != null) lines.push(permission);
+	const effectNote = effectNoteFor(entry);
+	if (effectNote != null) lines.push("", effectNote);
+	if (entry.responseKind === "sse") lines.push("", "ストリーミング応答を終端まで収集してから返します（数分かかることがあります）。");
+	if (entry.responseKind === "binary") lines.push("", "ファイルを出力ディレクトリに保存し、パスと sha256 を返します。");
+	if (entry.transfer?.kind === "download") lines.push("", "応答に含まれる署名付き URL からその場でダウンロードし、ファイルパスを返します。");
+	if (entry.transfer?.kind === "upload") lines.push("", "応答のアップロード URL は upload_file ツールで使えます（15 分・1 回限り）。");
+	if (entry.wholeBodyField != null) lines.push("", `リクエストボディは "${entry.wholeBodyField}" 引数にそのまま渡します（判別共用体）。`);
+	for (const input of entry.inlineFiles?.input ?? []) lines.push("", input.format === "wav-pcm16" && input.pcm != null ? `"${input.pointer}" にはローカル WAV ファイルのパス（PCM 16bit / ${String(input.pcm.sampleRateHz)} Hz / ${String(input.pcm.channels)}ch、音声 ${String(input.maxBytes)} バイト以内）を渡します。base64 化はこのサーバーが行います。` : `"${input.pointer}" にはローカルファイルのパス（${String(input.maxBytes)} バイト以内）を渡します。base64 化はこのサーバーが行います。`);
+	if ((entry.inlineFiles?.output.length ?? 0) > 0) lines.push("", "応答に埋め込まれた音声 / ファイルは出力ディレクトリに保存し、パスだけを返します（base64 は結果に含めません）。");
+	if (entry.sseOutcome != null) {
+		const required = [...entry.sseOutcome.requiredEvents, entry.sseOutcome.successPointer == null ? entry.sseOutcome.terminalEvent : `${entry.sseOutcome.terminalEvent}{${entry.sseOutcome.successPointer}=${JSON.stringify(entry.sseOutcome.successValue)}}`];
+		lines.push("", `成功判定: ${required.join(" と ")} が揃ったときだけ outcome=success。欠落・異常終了・打ち切りは isError で返し、自動再送しません。`);
+	}
+	if (entry.method !== "GET") lines.push("", "この操作は自動再送しません。タイムアウト時は状態を再取得して確認してください。");
+	return lines.join("\n");
+};
+const annotationsFor = (entry) => ({
+	readOnlyHint: entry.method === "GET",
+	destructiveHint: entry.method === "DELETE",
+	idempotentHint: entry.method === "GET" || entry.method === "PUT" || entry.method === "DELETE",
+	openWorldHint: false
+});
+const TOOL_TEXT_PREVIEW_CHARS = 4096;
+const UTF16_HIGH_SURROGATE_FIRST = 55296;
+const UTF16_HIGH_SURROGATE_LAST = 56319;
+/** 先頭 4096 文字。UTF-16 の高サロゲートで終わったら 1 単位落とす（絵文字等の途中で切らない）。 */
+const previewOf = (text) => {
+	const sliced = text.slice(0, TOOL_TEXT_PREVIEW_CHARS);
+	const last = sliced.codePointAt(sliced.length - 1) ?? 0;
+	return last >= UTF16_HIGH_SURROGATE_FIRST && last <= UTF16_HIGH_SURROGATE_LAST ? sliced.slice(0, -1) : sliced;
+};
+const bytesToStream = (bytes) => new ReadableStream({ start(controller) {
+	controller.enqueue(bytes);
+	controller.close();
+} });
+const textResult = (tenantName, text, isError) => ({
+	content: [{
+		type: "text",
+		text: JSON.stringify({ tenantName })
+	}, {
+		type: "text",
+		text
+	}],
+	isError
+});
+/**
+* 応答テキストが上限を超えたら compact JSON をファイルに保存し、保存先と整形表記の先頭だけを返す
+* （整形は 2〜3 倍に膨らむのでファイルには書かない）。保存に失敗しても先頭と総文字数は返す。
+*/
+const toCallToolResult = async (outcome, options) => {
+	const { secrets } = options;
+	const pretty = redactSecrets(JSON.stringify(outcome.payload, null, 2) ?? "null", secrets);
+	if (pretty.length <= 1048576) return textResult(options.tenantName, pretty, outcome.isError);
+	const compact = Buffer.from(redactSecrets(JSON.stringify(outcome.payload) ?? "null", secrets), "utf8");
+	const summary = {
+		totalChars: pretty.length,
+		preview: previewOf(pretty)
+	};
+	try {
+		const file = await saveStreamToFile(bytesToStream(compact), {
+			outputDir: options.outputDir,
+			fileName: options.fileName,
+			maxBytes: options.maxFileBytes,
+			timeoutMs: BINARY_TOTAL_TIMEOUT_MS
+		});
+		return textResult(options.tenantName, JSON.stringify({
+			file: {
+				...file,
+				format: "json"
+			},
+			...summary
+		}, null, 2), outcome.isError);
+	} catch (err) {
+		const failure = err instanceof TransferError ? err.kind : "unexpected";
+		options.logger.warn("tool result could not be saved", {
+			fileName: options.fileName,
+			failure,
+			bytes: compact.byteLength
+		});
+		return textResult(options.tenantName, JSON.stringify({
+			error: {
+				kind: "result_not_saved",
+				failure,
+				message: "The full result was not saved; only the preview below is available. The operation may have completed; check its state before retrying."
+			},
+			...summary
+		}, null, 2), true);
+	}
+};
+const resultOptionsFor = (deps, name) => ({
+	tenantName: deps.config.tenantName,
+	outputDir: deps.config.outputDir,
+	fileName: `${name}.result.json`,
+	logger: deps.logger,
+	secrets: [deps.config.apiKey],
+	maxFileBytes: MAX_TOOL_RESULT_FILE_BYTES
+});
+const argumentsOf = (args) => isPlainObject(args) ? args : {};
+const requireStringArgument = (args, name) => {
+	const value = args[name];
+	if (typeof value !== "string" || value === "") throw new InvalidArgumentsError(`argument "${name}" is required`);
+	return value;
+};
+const LOCAL_TOOL_SCHEMAS = {
+	inspectLocalFile: {
+		type: "object",
+		properties: { path: {
+			type: "string",
+			description: "ローカルファイルのパス（相対パスは作業ディレクトリ基準）。"
+		} },
+		required: ["path"],
+		additionalProperties: false
+	},
+	uploadFile: {
+		type: "object",
+		properties: {
+			url: {
+				type: "string",
+				description: "直前の API 応答で返されたアップロード URL。"
+			},
+			path: {
+				type: "string",
+				description: "アップロードするローカルファイルのパス。"
+			}
+		},
+		required: ["url", "path"],
+		additionalProperties: false
+	},
+	downloadFile: {
+		type: "object",
+		properties: {
+			url: {
+				type: "string",
+				description: "直前の API 応答で返されたダウンロード URL。"
+			},
+			fileName: {
+				type: "string",
+				description: "保存名（省略時は URL の末尾から決める）。"
+			}
+		},
+		required: ["url"],
+		additionalProperties: false
+	}
+};
+const registerLocalTools = (server, deps) => {
+	server.registerTool("inspect_local_file", {
+		title: "ローカルファイルの検査",
+		description: "アップロード前にローカルファイルの名前・サイズ・sha256（hex / base64）・MIME を返します。API の byteSize には sizeBytes、checksumSha256 には sha256Hex を渡してください。読めるのは起動設定の根ディレクトリ配下だけです。",
+		inputSchema: fromJsonSchema(toJsonSchema(LOCAL_TOOL_SCHEMAS.inspectLocalFile, "inspect_local_file")),
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (rawArgs) => {
+		const args = argumentsOf(rawArgs);
+		return toCallToolResult(await runTool(deps, "inspect_local_file", () => inspectLocalFile(requireStringArgument(args, "path"), deps.config.fileRoots, deps.cwd, deps.workspace)), resultOptionsFor(deps, "inspect_local_file"));
+	});
+	server.registerTool("upload_file", {
+		title: "署名付き URL へアップロード",
+		description: "直前の API 応答で返されたアップロード URL へローカルファイルを PUT します。URL は応答由来のものだけを 15 分・1 回限りで受け付け、認証ヘッダは付けません。",
+		inputSchema: fromJsonSchema(toJsonSchema(LOCAL_TOOL_SCHEMAS.uploadFile, "upload_file")),
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async (rawArgs) => {
+		const args = argumentsOf(rawArgs);
+		return toCallToolResult(await runTool(deps, "upload_file", async () => {
+			const rawUrl = requireStringArgument(args, "url");
+			const filePath = await resolveWithinRoots(requireStringArgument(args, "path"), deps.config.fileRoots, deps.cwd, deps.workspace);
+			const registered = deps.registry.take(rawUrl, "upload");
+			return await uploadFileToPresignedUrl({
+				url: new URL(rawUrl),
+				headers: registered.headers,
+				filePath,
+				fetch: deps.fetch,
+				maxBytes: MAX_UPLOAD_BYTES,
+				timeoutMs: BINARY_TOTAL_TIMEOUT_MS
+			});
+		}), resultOptionsFor(deps, "upload_file"));
+	});
+	server.registerTool("download_file", {
+		title: "署名付き URL からダウンロード",
+		description: "直前の API 応答で返されたダウンロード URL からファイルを取得し、出力ディレクトリに保存してパスを返します。URL は応答由来のものだけを受け付けます。",
+		inputSchema: fromJsonSchema(toJsonSchema(LOCAL_TOOL_SCHEMAS.downloadFile, "download_file")),
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (rawArgs) => {
+		const args = argumentsOf(rawArgs);
+		return toCallToolResult(await runTool(deps, "download_file", async () => {
+			const rawUrl = requireStringArgument(args, "url");
+			deps.registry.take(rawUrl, "download");
+			const url = new URL(rawUrl);
+			const requestedName = typeof args["fileName"] === "string" ? args["fileName"] : null;
+			return await downloadPresignedUrlToFile({
+				url,
+				outputDir: deps.config.outputDir,
+				fileName: sanitizeFileName(requestedName ?? url.pathname.split("/").at(-1) ?? null, "download.bin"),
+				fetch: deps.fetch,
+				maxBytes: MAX_DOWNLOAD_BYTES,
+				timeoutMs: BINARY_TOTAL_TIMEOUT_MS
+			});
+		}), resultOptionsFor(deps, "download_file"));
+	});
+};
+/** 操作表の 1 行 = 1 ツール。表に無い操作は登録されない（任意 URL のプロキシを持たない）。 */
+const createFlygateMcpServer = (deps, manifest) => {
+	const server = new McpServer({
+		name: MCP_SERVER_NAME,
+		version: MCP_SERVER_VERSION
+	}, {
+		capabilities: { tools: {} },
+		instructions: serverInstructions(deps.config.tenantName)
+	});
+	for (const entry of manifest.operations) server.registerTool(entry.operationId, {
+		title: entry.summary,
+		description: describeOperation(entry),
+		inputSchema: fromJsonSchema(toJsonSchema(entry.inputSchema, entry.operationId)),
+		annotations: annotationsFor(entry)
+	}, async (rawArgs) => toCallToolResult(await invokeOperation(deps, entry, argumentsOf(rawArgs)), resultOptionsFor(deps, entry.operationId)));
+	registerLocalTools(server, deps);
+	return server;
+};
+//#endregion
+//#region src/main.ts
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const bootstrap = async () => {
+	const cwd = process.cwd();
+	let config;
+	let workspace;
+	try {
+		config = loadConfig(process.env, cwd);
+		assertConfiguredPathInsideWorkspace(cwd, config.outputDir, ENV_KEYS.outputDir);
+		for (const root of config.fileRoots) assertConfiguredPathInsideWorkspace(cwd, root, ENV_KEYS.fileRoots);
+		workspace = await bindWorkspace({
+			cwd,
+			homeDir: homedir(),
+			hostname: hostname(),
+			username: userInfo().username,
+			now: () => /* @__PURE__ */ new Date()
+		}, config.tenantName);
+	} catch (err) {
+		console.error(err instanceof ConfigError || err instanceof WorkspaceBindingError ? err.message : String(err));
+		process.exit(1);
+	}
+	const logger = createLogger([config.apiKey]);
+	const manifest = loadManifestFile();
+	const now = () => Date.now();
+	const deps = {
+		config,
+		client: createApiClient({
+			config,
+			workspaceId: workspace.workspaceId,
+			fetch: globalThis.fetch,
+			now,
+			sleep,
+			logger
+		}),
+		registry: createPresignedUrlRegistry(now),
+		fetch: globalThis.fetch,
+		logger,
+		now,
+		cwd,
+		workspace
+	};
+	const handle = serveStdio(() => createFlygateMcpServer(deps, manifest));
+	logger.info("flygate mcp server started", {
+		baseUrl: config.baseUrl.origin,
+		tenantName: config.tenantName,
+		workspace: workspace.root,
+		operations: manifest.operations.length
+	});
+	const shutdown = () => {
+		handle.close().catch(ignoreCleanupError).finally(() => process.exit(0));
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+};
+await bootstrap();
+//#endregion
+export {};