@aigne/afs-aignehub 1.11.0-beta.10

package/dist/aignehub.mjs

@@ -0,0 +1,1635 @@
+import { aigneHubAuth } from "./auth.mjs";
+import { afsAigneHubOptionsSchema } from "./types.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { AFSBaseProvider, AFSNotFoundError, Actions, Explain, List, Meta, Read, Stat } from "@aigne/afs";
+import { zodParse } from "@aigne/afs/utils/zod";
+import { AIGNEHubChatModel, AIGNEHubImageModel, AIGNEHubVideoModel, AIGNE_HUB_URL } from "@aigne/aigne-hub";
+import { joinURL } from "ufo";
+import { z } from "zod";
+
+//#region src/aignehub.ts
+const MODEL_TYPES = [
+	"chat",
+	"image",
+	"video"
+];
+const CHAT_INPUT_PROPERTIES = {
+	prompt: {
+		type: "string",
+		description: "Your question or instruction (shorthand for single user message)"
+	},
+	image: {
+		type: "string",
+		description: "Image URL or base64 data URI for vision (used with prompt)"
+	},
+	messages: {
+		type: "array",
+		items: {
+			type: "object",
+			properties: {
+				role: {
+					type: "string",
+					description: "Message role (user, assistant, system)"
+				},
+				content: {
+					type: "string",
+					description: "Message content"
+				}
+			},
+			required: ["role", "content"]
+		},
+		description: "Full conversation messages array (takes priority over prompt)"
+	},
+	temperature: {
+		type: "number",
+		description: "Sampling temperature (0-2)"
+	},
+	topP: {
+		type: "number",
+		description: "Nucleus sampling parameter (0-1)"
+	},
+	frequencyPenalty: {
+		type: "number",
+		description: "Frequency penalty (-2 to 2)"
+	},
+	presencePenalty: {
+		type: "number",
+		description: "Presence penalty (-2 to 2)"
+	},
+	reasoningEffort: {
+		type: "string",
+		enum: [
+			"low",
+			"medium",
+			"high"
+		],
+		description: "Reasoning effort level for supported models"
+	},
+	responseFormat: {
+		type: "object",
+		properties: {
+			type: {
+				type: "string",
+				enum: ["text", "json_schema"]
+			},
+			jsonSchema: {
+				type: "object",
+				description: "JSON Schema when type is json_schema"
+			}
+		},
+		description: "Response format configuration"
+	},
+	tools: {
+		type: "array",
+		items: { type: "object" },
+		description: "Function tool definitions for tool-calling models"
+	},
+	toolChoice: {
+		type: "string",
+		enum: [
+			"auto",
+			"none",
+			"required"
+		],
+		description: "Tool choice strategy"
+	},
+	outputFileType: {
+		type: "string",
+		enum: [
+			"url",
+			"file",
+			"local"
+		],
+		description: "Output file type for generated content (url, file, or local)"
+	}
+};
+const CHAT_SCHEMA = {
+	type: "object",
+	properties: CHAT_INPUT_PROPERTIES
+};
+const GENERATE_IMAGE_SCHEMA = {
+	type: "object",
+	properties: {
+		prompt: {
+			type: "string",
+			description: "Image generation prompt"
+		},
+		n: {
+			type: "number",
+			description: "Number of images to generate"
+		},
+		size: {
+			type: "string",
+			description: "Image size (e.g. 1024x1024, 1024x1792)"
+		},
+		quality: {
+			type: "string",
+			description: "Image quality (e.g. standard, hd)"
+		},
+		style: {
+			type: "string",
+			description: "Image style (e.g. natural, vivid)"
+		},
+		outputFileType: {
+			type: "string",
+			enum: [
+				"url",
+				"file",
+				"local"
+			],
+			description: "Output file type for generated images (url, file, or local)"
+		}
+	},
+	required: ["prompt"]
+};
+const GENERATE_VIDEO_SCHEMA = {
+	type: "object",
+	properties: {
+		prompt: {
+			type: "string",
+			description: "Video generation prompt"
+		},
+		size: {
+			type: "string",
+			description: "Video resolution (e.g. 1920x1080)"
+		},
+		seconds: {
+			type: "string",
+			description: "Video duration"
+		},
+		outputFileType: {
+			type: "string",
+			enum: [
+				"url",
+				"file",
+				"local"
+			],
+			description: "Output file type for generated videos (url, file, or local)"
+		}
+	},
+	required: ["prompt"]
+};
+const ROOT_CHAT_SCHEMA = {
+	type: "object",
+	properties: {
+		model: {
+			type: "string",
+			description: "Model name (e.g. gpt-4o)"
+		},
+		...CHAT_INPUT_PROPERTIES
+	},
+	required: ["model"]
+};
+const ROOT_GENERATE_IMAGE_SCHEMA = {
+	type: "object",
+	properties: {
+		model: {
+			type: "string",
+			description: "Model name (e.g. gpt-image-1)"
+		},
+		...GENERATE_IMAGE_SCHEMA.properties
+	},
+	required: ["model", "prompt"]
+};
+const ROOT_GENERATE_VIDEO_SCHEMA = {
+	type: "object",
+	properties: {
+		model: {
+			type: "string",
+			description: "Model name (e.g. sora-2)"
+		},
+		...GENERATE_VIDEO_SCHEMA.properties
+	},
+	required: ["model", "prompt"]
+};
+const SET_DEFAULT_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+const SET_DEFAULT_MODEL_SCHEMA = {
+	type: "object",
+	properties: {
+		type: {
+			type: "string",
+			enum: [
+				"chat",
+				"image",
+				"video"
+			],
+			description: "Model type"
+		},
+		model: {
+			type: "string",
+			description: "Model name to set as default"
+		}
+	},
+	required: ["type", "model"]
+};
+const SET_DEFAULT_ACTION = {
+	name: "setDefault",
+	description: "Set this model as the default for its type",
+	schema: SET_DEFAULT_SCHEMA
+};
+function getActionsForType(type) {
+	if (type === "chat") return [{
+		name: "chat",
+		description: "Chat inference (prompt shorthand or full messages array)",
+		schema: CHAT_SCHEMA
+	}, SET_DEFAULT_ACTION];
+	if (type === "image") return [{
+		name: "generateImage",
+		description: "Generate images from a text prompt",
+		schema: GENERATE_IMAGE_SCHEMA
+	}, SET_DEFAULT_ACTION];
+	return [{
+		name: "generateVideo",
+		description: "Generate video from a text prompt",
+		schema: GENERATE_VIDEO_SCHEMA
+	}, SET_DEFAULT_ACTION];
+}
+/** Get the primary action name for a model type */
+function primaryActionForType(type) {
+	if (type === "chat") return "chat";
+	if (type === "image") return "generateImage";
+	return "generateVideo";
+}
+/** Root-level actions (includes model param as required) */
+const ROOT_ACTIONS = [
+	{
+		name: "chat",
+		description: "Chat inference (prompt shorthand or full messages array)",
+		schema: ROOT_CHAT_SCHEMA
+	},
+	{
+		name: "generateImage",
+		description: "Generate images from a text prompt",
+		schema: ROOT_GENERATE_IMAGE_SCHEMA
+	},
+	{
+		name: "generateVideo",
+		description: "Generate video from a text prompt",
+		schema: ROOT_GENERATE_VIDEO_SCHEMA
+	},
+	{
+		name: "setDefaultModel",
+		description: "Set the default model for a given type",
+		schema: SET_DEFAULT_MODEL_SCHEMA
+	},
+	{
+		name: "refresh",
+		description: "Clear model catalog cache and reload on next access",
+		schema: {
+			type: "object",
+			properties: {}
+		}
+	}
+];
+function missingParam(name) {
+	return {
+		success: false,
+		error: {
+			code: "MISSING_PARAM",
+			message: `The '${name}' parameter is required`
+		}
+	};
+}
+function inferenceError(modelName, err) {
+	return {
+		success: false,
+		error: {
+			code: "INFERENCE_ERROR",
+			message: `Inference failed for ${modelName}: ${err instanceof Error ? err.message : String(err)}`
+		}
+	};
+}
+/** Extract last segment of model name for use as a path segment */
+function modelPathSegment(model) {
+	const idx = model.model.lastIndexOf("/");
+	return idx >= 0 ? model.model.slice(idx + 1) : model.model;
+}
+/** Build multimodal message content from prompt + optional image */
+function buildMessageContent(prompt, image) {
+	if (!image) return prompt;
+	const parts = [{
+		type: "text",
+		text: prompt
+	}];
+	if (image.startsWith("data:")) parts.push({
+		type: "file",
+		data: image
+	});
+	else parts.push({
+		type: "url",
+		url: image
+	});
+	return parts;
+}
+/** Build SDK ChatModelInput from flat args */
+function buildChatSDKInput(args) {
+	const input = {};
+	const image = args.image;
+	if (Array.isArray(args.messages) && args.messages.length > 0) input.messages = args.messages;
+	else if (args.prompt !== void 0 && args.prompt !== null) input.messages = [{
+		role: "user",
+		content: buildMessageContent(String(args.prompt), image)
+	}];
+	const modelOptions = {};
+	for (const key of [
+		"temperature",
+		"topP",
+		"frequencyPenalty",
+		"presencePenalty",
+		"reasoningEffort"
+	]) if (args[key] !== void 0) modelOptions[key] = args[key];
+	if (Object.keys(modelOptions).length > 0) input.modelOptions = modelOptions;
+	if (args.responseFormat !== void 0) input.responseFormat = args.responseFormat;
+	if (args.tools !== void 0) input.tools = args.tools;
+	if (args.toolChoice !== void 0) input.toolChoice = args.toolChoice;
+	input.outputFileType = args.outputFileType ?? "url";
+	return input;
+}
+var AFSAigneHub = class AFSAigneHub extends AFSBaseProvider {
+	static schema() {
+		return afsAigneHubOptionsSchema;
+	}
+	static manifest() {
+		return {
+			name: "aignehub",
+			description: "AigneHub AI Model Gateway — discover and run AI models",
+			uriTemplate: "aignehub://{host?}",
+			category: "ai",
+			schema: z.object({
+				host: z.string().optional(),
+				apiKey: z.string().meta({ sensitive: true })
+			}),
+			tags: [
+				"ai",
+				"llm",
+				"model",
+				"aignehub"
+			]
+		};
+	}
+	static async load({ config } = {}) {
+		const cfg = { ...config ?? {} };
+		if (cfg.host && !cfg.url) cfg.url = `https://${cfg.host}`;
+		return new AFSAigneHub(await AFSAigneHub.schema().parseAsync(cfg));
+	}
+	static async auth(context) {
+		const host = context.resolved?.host;
+		return aigneHubAuth(context, host ? `https://${host}` : void 0);
+	}
+	name;
+	description;
+	accessMode = "readwrite";
+	apiKey;
+	baseURL;
+	needsURLDiscovery;
+	catalog = null;
+	/** Config-level defaults (from constructor options) */
+	configDefaults;
+	/** Runtime overrides (set via setDefault action, takes highest priority) */
+	runtimeDefaults = {};
+	/** Mount path captured from onMount (for config persistence) */
+	mountPath;
+	/** Injectable callback for persisting config changes */
+	updateConfigFn;
+	constructor(options) {
+		super();
+		const parsed = zodParse(afsAigneHubOptionsSchema, options);
+		this.name = parsed.name;
+		this.description = parsed.description;
+		this.apiKey = parsed.apiKey;
+		this.baseURL = parsed.url || AIGNE_HUB_URL;
+		this.needsURLDiscovery = !parsed.url;
+		this.configDefaults = {
+			...parsed.defaultChat ? { chat: parsed.defaultChat } : {},
+			...parsed.defaultImage ? { image: parsed.defaultImage } : {},
+			...parsed.defaultVideo ? { video: parsed.defaultVideo } : {}
+		};
+	}
+	async ready() {
+		if (this.needsURLDiscovery) {
+			const { getAIGNEHubMountPoint: getAIGNEHubMountPoint$1 } = await import("@aigne/aigne-hub");
+			const { AIGNE_HUB_BLOCKLET_DID } = await import("./auth.mjs");
+			this.baseURL = await getAIGNEHubMountPoint$1(this.baseURL, AIGNE_HUB_BLOCKLET_DID);
+		}
+	}
+	onMount(root, mountPath) {
+		this.mountPath = mountPath;
+		this.updateConfigFn = root.updateProviderConfig;
+	}
+	async ensureCatalog() {
+		if (this.catalog) return this.catalog;
+		const [chat, image, video] = await Promise.all([
+			this.fetchModels("chat"),
+			this.fetchModels("image"),
+			this.fetchModels("video")
+		]);
+		const catalog = {
+			chat,
+			image,
+			video
+		};
+		this.catalog = catalog;
+		return catalog;
+	}
+	async fetchModels(type) {
+		const url = joinURL(this.baseURL, "/api/ai/models");
+		const response = await fetch(`${url}?type=${type}`, { headers: { Authorization: `Bearer ${this.apiKey}` } });
+		if (!response.ok) throw new Error(`Failed to fetch ${type} models: ${response.status} ${response.statusText}`);
+		return (await response.json()).map((m) => ({
+			type,
+			model: m.model,
+			provider: m.provider,
+			inputCreditsPerToken: m.input_credits_per_token,
+			outputCreditsPerToken: m.output_credits_per_token,
+			providerDisplayName: m.providerDisplayName,
+			status: m.status,
+			modelMetadata: m.modelMetadata
+		}));
+	}
+	/** Get unique providers with their model counts */
+	getProviderStats(catalog) {
+		const map = /* @__PURE__ */ new Map();
+		for (const type of MODEL_TYPES) for (const m of catalog[type]) {
+			const existing = map.get(m.provider);
+			if (existing) existing.count++;
+			else map.set(m.provider, {
+				displayName: m.providerDisplayName,
+				count: 1
+			});
+		}
+		return Array.from(map.entries()).map(([name, v]) => ({
+			name,
+			displayName: v.displayName,
+			count: v.count
+		}));
+	}
+	/** Get all models for a specific provider */
+	getModelsForProvider(catalog, provider) {
+		return MODEL_TYPES.flatMap((type) => catalog[type].filter((m) => m.provider === provider));
+	}
+	/** Get default model for a type. Priority: runtime override > config > API first */
+	getDefaultModel(catalog, type) {
+		const models = catalog[type];
+		const name = this.runtimeDefaults[type] ?? this.configDefaults[type];
+		if (name) {
+			const found = models.find((m) => m.model === name);
+			if (found) return found;
+		}
+		return models[0];
+	}
+	/** Validate type param, throw AFSNotFoundError if invalid */
+	validateType(type) {
+		if (MODEL_TYPES.includes(type)) return type;
+		throw new AFSNotFoundError(joinURL("/types", type), `Type '${type}' not found. Available types: ${MODEL_TYPES.join(", ")}`);
+	}
+	async listRoot(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const providerCount = this.getProviderStats(catalog).length;
+		return { data: [
+			this.buildEntry("/defaults", { meta: {
+				childrenCount: MODEL_TYPES.length,
+				kind: "aignehub:directory"
+			} }),
+			this.buildEntry("/providers", { meta: {
+				childrenCount: providerCount,
+				kind: "aignehub:directory"
+			} }),
+			this.buildEntry("/types", { meta: {
+				childrenCount: MODEL_TYPES.length,
+				kind: "aignehub:directory"
+			} })
+		] };
+	}
+	async readRoot(_ctx) {
+		return this.buildEntry("/", {
+			content: {
+				provider: "aignehub",
+				description: "AigneHub AI Model Gateway"
+			},
+			meta: {
+				childrenCount: 3,
+				kind: "aignehub:root"
+			}
+		});
+	}
+	async rootMeta(_ctx) {
+		return this.buildEntry("/.meta", {
+			content: {
+				provider: "aignehub",
+				baseURL: this.baseURL,
+				description: "AigneHub AI Model Gateway"
+			},
+			meta: {
+				childrenCount: 3,
+				kind: "aignehub:root"
+			}
+		});
+	}
+	async readCapabilities(_ctx) {
+		const operations = this.getOperationsDeclaration();
+		const manifest = {
+			schemaVersion: 1,
+			provider: this.name,
+			description: this.description || "AigneHub AI Model Gateway",
+			tools: [],
+			operations,
+			actions: [{
+				description: "Root-level actions",
+				catalog: [
+					{
+						name: "chat",
+						description: "Chat inference (prompt shorthand or full messages array)",
+						inputSchema: ROOT_CHAT_SCHEMA
+					},
+					{
+						name: "generateImage",
+						description: "Generate images from a text prompt",
+						inputSchema: ROOT_GENERATE_IMAGE_SCHEMA
+					},
+					{
+						name: "generateVideo",
+						description: "Generate video from a text prompt",
+						inputSchema: ROOT_GENERATE_VIDEO_SCHEMA
+					},
+					{
+						name: "refresh",
+						description: "Clear model catalog cache",
+						inputSchema: {
+							type: "object",
+							properties: {}
+						}
+					}
+				],
+				discovery: {
+					pathTemplate: "/.actions",
+					note: "Root actions: chat, generateImage, generateVideo, refresh"
+				}
+			}, {
+				description: "Model-level actions (varies by model type)",
+				catalog: [
+					{
+						name: "chat",
+						description: "Chat inference (chat models)",
+						inputSchema: CHAT_SCHEMA
+					},
+					{
+						name: "generateImage",
+						description: "Generate images (image models)",
+						inputSchema: GENERATE_IMAGE_SCHEMA
+					},
+					{
+						name: "generateVideo",
+						description: "Generate video (video models)",
+						inputSchema: GENERATE_VIDEO_SCHEMA
+					}
+				],
+				discovery: {
+					pathTemplate: "/providers/:provider/:model/.actions",
+					note: "Actions depend on model type. Chat: chat; Image: generateImage; Video: generateVideo. Also accessible via /defaults/:type/.actions and /types/:type/:model/.actions."
+				}
+			}]
+		};
+		return this.buildEntry("/.meta/.capabilities", {
+			content: manifest,
+			meta: {
+				kind: "afs:capabilities",
+				...operations
+			}
+		});
+	}
+	async explainRoot(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const providers = this.getProviderStats(catalog);
+		return {
+			content: [
+				"# AigneHub AI Model Gateway",
+				"",
+				`Unified access to ${MODEL_TYPES.reduce((sum, t) => sum + catalog[t].length, 0)} AI models from ${providers.length} providers.`,
+				"",
+				"## Quick Start",
+				"",
+				"- Chat: `exec /defaults/chat/.actions/chat { \"prompt\": \"Hello\" }`",
+				"- Generate image: `exec /defaults/image/.actions/generateImage { \"prompt\": \"A sunset\" }`",
+				"- Generate video: `exec /defaults/video/.actions/generateVideo { \"prompt\": \"Ocean waves\" }`",
+				"",
+				"## Browse Models",
+				"",
+				"- `list /defaults` — Default models for quick access",
+				"- `list /providers` — Browse by provider",
+				"- `list /types` — Browse by capability (chat, image, video)",
+				"",
+				"## Root Actions",
+				"",
+				"- `exec /.actions/chat { \"model\": \"gpt-4o\", \"prompt\": \"Hello\" }`",
+				"- `exec /.actions/generateImage { \"model\": \"gpt-image-1\", \"prompt\": \"A cat\" }`",
+				"- `exec /.actions/refresh` — Reload model catalog"
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async statRoot(_ctx) {
+		return { data: this.buildEntry("/", { meta: {
+			childrenCount: 3,
+			kind: "aignehub:root"
+		} }) };
+	}
+	async listDefaults(_ctx) {
+		const catalog = await this.ensureCatalog();
+		return { data: MODEL_TYPES.map((type) => {
+			const model = this.getDefaultModel(catalog, type);
+			return this.buildEntry(joinURL("/defaults", type), { meta: {
+				childrenCount: 0,
+				kind: `aignehub:default-${type}`,
+				type,
+				...model ? {
+					model: model.model,
+					provider: model.provider
+				} : {}
+			} });
+		}) };
+	}
+	async readDefaults(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const defaults = {};
+		for (const type of MODEL_TYPES) defaults[type] = this.getDefaultModel(catalog, type)?.model ?? null;
+		return this.buildEntry("/defaults", {
+			content: { defaults },
+			meta: {
+				childrenCount: MODEL_TYPES.length,
+				kind: "aignehub:directory"
+			}
+		});
+	}
+	async defaultsMeta(_ctx) {
+		return this.buildEntry("/defaults/.meta", {
+			content: { description: "Default model shortcuts" },
+			meta: {
+				childrenCount: MODEL_TYPES.length,
+				kind: "aignehub:directory"
+			}
+		});
+	}
+	async statDefaults(_ctx) {
+		return { data: this.buildEntry("/defaults", { meta: {
+			childrenCount: MODEL_TYPES.length,
+			kind: "aignehub:directory"
+		} }) };
+	}
+	async explainDefaults(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const lines = [
+			"# Default Models",
+			"",
+			"Pre-selected models for quick access — one per type.",
+			"",
+			"## Examples",
+			""
+		];
+		for (const type of MODEL_TYPES) {
+			const model = this.getDefaultModel(catalog, type);
+			const action = primaryActionForType(type);
+			if (model) lines.push(`- **${type}** (${model.model}): \`exec /defaults/${type}/.actions/${action} { "prompt": "..." }\``);
+		}
+		lines.push("", "## Navigation", "");
+		for (const type of MODEL_TYPES) lines.push(`- \`explain /defaults/${type}\` — Default ${type} model details`);
+		return {
+			content: lines.join("\n"),
+			format: "markdown"
+		};
+	}
+	async listDefault(ctx) {
+		this.validateType(ctx.params.type);
+		return { data: [] };
+	}
+	async readDefault(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		if (!model) return this.buildEntry(joinURL("/defaults", type), {
+			content: {
+				type,
+				model: null,
+				message: `No ${type} models available`
+			},
+			meta: {
+				childrenCount: 0,
+				kind: `aignehub:default-${type}`
+			}
+		});
+		return this.buildModelEntry(joinURL("/defaults", type), model);
+	}
+	async statDefault(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		return { data: this.buildEntry(joinURL("/defaults", type), { meta: {
+			childrenCount: 0,
+			kind: `aignehub:default-${type}`,
+			type,
+			...model ? { model: model.model } : {}
+		} }) };
+	}
+	async defaultTypeMeta(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		return this.buildEntry(joinURL("/defaults", type, ".meta"), {
+			content: {
+				type,
+				model: model?.model ?? null
+			},
+			meta: {
+				childrenCount: 0,
+				kind: `aignehub:default-${type}`,
+				type,
+				...model ? { model: model.model } : {}
+			}
+		});
+	}
+	async explainDefault(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		if (!model) return {
+			content: `No default ${type} model available.`,
+			format: "text"
+		};
+		return this.buildModelExplain(joinURL("/defaults", type), model);
+	}
+	async listDefaultActions(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const basePath = joinURL("/defaults", type);
+		return { data: getActionsForType(type).map((action) => this.buildActionEntry(joinURL(basePath, ".actions", action.name), action.name, action.description, action.schema)) };
+	}
+	async execDefaultChat(ctx, args) {
+		const type = this.validateType(ctx.params.type);
+		if (type !== "chat") throw new AFSNotFoundError(joinURL("/defaults", type, ".actions/chat"), `Action 'chat' is not available for ${type} models.`);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		if (!model) return {
+			success: false,
+			error: {
+				code: "NO_DEFAULT",
+				message: `No default ${type} model available`
+			}
+		};
+		return this.runChat(model.model, args);
+	}
+	async execDefaultGenerateImage(ctx, args) {
+		const type = this.validateType(ctx.params.type);
+		if (type !== "image") throw new AFSNotFoundError(joinURL("/defaults", type, ".actions/generateImage"), `Action 'generateImage' is not available for ${type} models.`);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		if (!model) return {
+			success: false,
+			error: {
+				code: "NO_DEFAULT",
+				message: `No default ${type} model available`
+			}
+		};
+		return this.runImage(model.model, args);
+	}
+	async execDefaultGenerateVideo(ctx, args) {
+		const type = this.validateType(ctx.params.type);
+		if (type !== "video") throw new AFSNotFoundError(joinURL("/defaults", type, ".actions/generateVideo"), `Action 'generateVideo' is not available for ${type} models.`);
+		const catalog = await this.ensureCatalog();
+		const model = this.getDefaultModel(catalog, type);
+		if (!model) return {
+			success: false,
+			error: {
+				code: "NO_DEFAULT",
+				message: `No default ${type} model available`
+			}
+		};
+		return this.runVideo(model.model, args);
+	}
+	async listProviders(_ctx) {
+		const catalog = await this.ensureCatalog();
+		return { data: this.getProviderStats(catalog).map((p) => this.buildEntry(joinURL("/providers", p.name), { meta: {
+			childrenCount: p.count,
+			kind: "aignehub:provider",
+			providerDisplayName: p.displayName
+		} })) };
+	}
+	async readProviders(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const providers = this.getProviderStats(catalog);
+		const totalModels = MODEL_TYPES.reduce((sum, t) => sum + catalog[t].length, 0);
+		return this.buildEntry("/providers", {
+			content: {
+				providers: providers.map((p) => p.name),
+				totalModels
+			},
+			meta: {
+				childrenCount: providers.length,
+				kind: "aignehub:directory"
+			}
+		});
+	}
+	async providersMeta(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const providers = this.getProviderStats(catalog);
+		const totalModels = MODEL_TYPES.reduce((sum, t) => sum + catalog[t].length, 0);
+		return this.buildEntry("/providers/.meta", {
+			content: {
+				providers: providers.map((p) => p.name),
+				totalModels
+			},
+			meta: {
+				childrenCount: providers.length,
+				kind: "aignehub:directory"
+			}
+		});
+	}
+	async statProviders(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const providers = this.getProviderStats(catalog);
+		return { data: this.buildEntry("/providers", { meta: {
+			childrenCount: providers.length,
+			kind: "aignehub:directory"
+		} }) };
+	}
+	async explainProviders(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const providers = this.getProviderStats(catalog);
+		const totalModels = MODEL_TYPES.reduce((sum, t) => sum + catalog[t].length, 0);
+		return {
+			content: [
+				"# Providers",
+				"",
+				`${providers.length} providers, ${totalModels} models total.`,
+				"",
+				"## Available Providers",
+				"",
+				...providers.map((p) => `- **${p.displayName}** (\`${p.name}\`): ${p.count} models`),
+				"",
+				"## Example",
+				"",
+				`\`list /providers/${providers[0]?.name ?? "openai"}\` — List models from a provider`
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async listProvider(ctx) {
+		const catalog = await this.ensureCatalog();
+		const models = this.getModelsForProvider(catalog, ctx.params.provider);
+		if (models.length === 0) throw new AFSNotFoundError(joinURL("/providers", ctx.params.provider), `Provider '${ctx.params.provider}' not found.`);
+		return { data: models.map((m) => this.buildEntry(joinURL("/providers", ctx.params.provider, modelPathSegment(m)), { meta: {
+			childrenCount: 0,
+			kind: `aignehub:${m.type}-model`,
+			type: m.type
+		} })) };
+	}
+	async readProvider(ctx) {
+		const catalog = await this.ensureCatalog();
+		const models = this.getModelsForProvider(catalog, ctx.params.provider);
+		if (models.length === 0) throw new AFSNotFoundError(joinURL("/providers", ctx.params.provider), `Provider '${ctx.params.provider}' not found.`);
+		const displayName = models[0].providerDisplayName;
+		return this.buildEntry(joinURL("/providers", ctx.params.provider), {
+			content: {
+				provider: ctx.params.provider,
+				providerDisplayName: displayName,
+				modelCount: models.length,
+				models: models.map((m) => ({
+					model: m.model,
+					type: m.type
+				}))
+			},
+			meta: {
+				childrenCount: models.length,
+				kind: "aignehub:provider",
+				providerDisplayName: displayName
+			}
+		});
+	}
+	async providerMeta(ctx) {
+		const catalog = await this.ensureCatalog();
+		const models = this.getModelsForProvider(catalog, ctx.params.provider);
+		if (models.length === 0) throw new AFSNotFoundError(joinURL("/providers", ctx.params.provider), `Provider '${ctx.params.provider}' not found.`);
+		const displayName = models[0].providerDisplayName;
+		return this.buildEntry(joinURL("/providers", ctx.params.provider, ".meta"), {
+			content: {
+				provider: ctx.params.provider,
+				providerDisplayName: displayName,
+				modelCount: models.length
+			},
+			meta: {
+				childrenCount: models.length,
+				kind: "aignehub:provider",
+				providerDisplayName: displayName
+			}
+		});
+	}
+	async statProvider(ctx) {
+		const catalog = await this.ensureCatalog();
+		const models = this.getModelsForProvider(catalog, ctx.params.provider);
+		if (models.length === 0) throw new AFSNotFoundError(joinURL("/providers", ctx.params.provider), `Provider '${ctx.params.provider}' not found.`);
+		return { data: this.buildEntry(joinURL("/providers", ctx.params.provider), { meta: {
+			childrenCount: models.length,
+			kind: "aignehub:provider"
+		} }) };
+	}
+	async explainProvider(ctx) {
+		const catalog = await this.ensureCatalog();
+		const models = this.getModelsForProvider(catalog, ctx.params.provider);
+		if (models.length === 0) throw new AFSNotFoundError(joinURL("/providers", ctx.params.provider), `Provider '${ctx.params.provider}' not found.`);
+		const displayName = models[0].providerDisplayName;
+		const chatModels = models.filter((m) => m.type === "chat");
+		const imageModels = models.filter((m) => m.type === "image");
+		const videoModels = models.filter((m) => m.type === "video");
+		const parts = [
+			chatModels.length ? `${chatModels.length} chat` : null,
+			imageModels.length ? `${imageModels.length} image` : null,
+			videoModels.length ? `${videoModels.length} video` : null
+		].filter(Boolean);
+		const firstChat = chatModels[0];
+		const lines = [
+			`# ${displayName}`,
+			"",
+			`${parts.join(", ")} models available.`,
+			"",
+			"## Models",
+			"",
+			...models.map((m) => `- **${modelPathSegment(m)}** (${m.type})`),
+			"",
+			"## Example",
+			""
+		];
+		if (firstChat) lines.push(`\`exec /providers/${ctx.params.provider}/${modelPathSegment(firstChat)}/.actions/chat { "prompt": "Hello" }\``);
+		return {
+			content: lines.join("\n"),
+			format: "markdown"
+		};
+	}
+	async listProviderModel(ctx) {
+		await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return { data: [] };
+	}
+	async readProviderModel(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return this.buildModelEntry(joinURL("/providers", ctx.params.provider, ctx.params.model), model);
+	}
+	async providerModelMeta(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return this.buildEntry(joinURL("/providers", ctx.params.provider, ctx.params.model, ".meta"), {
+			content: {
+				model: model.model,
+				provider: model.provider,
+				type: model.type
+			},
+			meta: {
+				childrenCount: 0,
+				kind: `aignehub:${model.type}-model`,
+				type: model.type
+			}
+		});
+	}
+	async statProviderModel(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return { data: this.buildEntry(joinURL("/providers", ctx.params.provider, ctx.params.model), { meta: {
+			childrenCount: 0,
+			kind: `aignehub:${model.type}-model`,
+			type: model.type
+		} }) };
+	}
+	async explainProviderModel(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return this.buildModelExplain(joinURL("/providers", ctx.params.provider, ctx.params.model), model);
+	}
+	async listProviderModelActions(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		const basePath = joinURL("/providers", ctx.params.provider, ctx.params.model);
+		return { data: getActionsForType(model.type).map((action) => this.buildActionEntry(joinURL(basePath, ".actions", action.name), action.name, action.description, action.schema)) };
+	}
+	async execProviderChat(ctx, args) {
+		const model = await this.findModelOfTypeByPath(ctx.params.provider, ctx.params.model, "chat");
+		return this.runChat(model.model, args);
+	}
+	async execProviderGenerateImage(ctx, args) {
+		const model = await this.findModelOfTypeByPath(ctx.params.provider, ctx.params.model, "image");
+		return this.runImage(model.model, args);
+	}
+	async execProviderGenerateVideo(ctx, args) {
+		const model = await this.findModelOfTypeByPath(ctx.params.provider, ctx.params.model, "video");
+		return this.runVideo(model.model, args);
+	}
+	async execProviderSetDefault(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return await this.setDefault(model);
+	}
+	async listTypes(_ctx) {
+		const catalog = await this.ensureCatalog();
+		return { data: MODEL_TYPES.map((type) => this.buildEntry(joinURL("/types", type), { meta: {
+			childrenCount: catalog[type].length,
+			kind: `aignehub:type-${type}`
+		} })) };
+	}
+	async readTypes(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const types = MODEL_TYPES.map((type) => ({
+			type,
+			count: catalog[type].length
+		}));
+		return this.buildEntry("/types", {
+			content: { types },
+			meta: {
+				childrenCount: MODEL_TYPES.length,
+				kind: "aignehub:directory"
+			}
+		});
+	}
+	async typesMeta(_ctx) {
+		const catalog = await this.ensureCatalog();
+		const types = MODEL_TYPES.map((type) => ({
+			type,
+			count: catalog[type].length
+		}));
+		return this.buildEntry("/types/.meta", {
+			content: { types },
+			meta: {
+				childrenCount: MODEL_TYPES.length,
+				kind: "aignehub:directory"
+			}
+		});
+	}
+	async statTypes(_ctx) {
+		return { data: this.buildEntry("/types", { meta: {
+			childrenCount: MODEL_TYPES.length,
+			kind: "aignehub:directory"
+		} }) };
+	}
+	async explainTypes(_ctx) {
+		const catalog = await this.ensureCatalog();
+		return {
+			content: [
+				"# Model Types",
+				"",
+				"Browse models by capability.",
+				"",
+				...MODEL_TYPES.map((type) => `- **${type}**: ${catalog[type].length} models`),
+				"",
+				"## Example",
+				"",
+				"`list /types/chat` — List all chat models",
+				"",
+				"## Navigation",
+				"",
+				"- By provider: `list /providers`"
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async listType(ctx) {
+		const type = this.validateType(ctx.params.type);
+		return { data: (await this.ensureCatalog())[type].map((m) => this.buildEntry(joinURL("/types", type, modelPathSegment(m)), { meta: {
+			childrenCount: 0,
+			kind: `aignehub:${type}-model`,
+			type,
+			provider: m.provider
+		} })) };
+	}
+	async readType(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		return this.buildEntry(joinURL("/types", type), {
+			content: {
+				type,
+				modelCount: catalog[type].length,
+				models: catalog[type].map((m) => ({
+					model: m.model,
+					provider: m.provider
+				}))
+			},
+			meta: {
+				childrenCount: catalog[type].length,
+				kind: `aignehub:type-${type}`
+			}
+		});
+	}
+	async typeMeta(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		return this.buildEntry(joinURL("/types", type, ".meta"), {
+			content: {
+				type,
+				modelCount: catalog[type].length
+			},
+			meta: {
+				childrenCount: catalog[type].length,
+				kind: `aignehub:type-${type}`
+			}
+		});
+	}
+	async statType(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const catalog = await this.ensureCatalog();
+		return { data: this.buildEntry(joinURL("/types", type), { meta: {
+			childrenCount: catalog[type].length,
+			kind: `aignehub:type-${type}`
+		} }) };
+	}
+	async explainType(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const models = (await this.ensureCatalog())[type];
+		const action = primaryActionForType(type);
+		const lines = [
+			`# ${type} models`,
+			"",
+			`${models.length} models available.`,
+			"",
+			"## Models",
+			"",
+			...models.map((m) => `- **${modelPathSegment(m)}** (${m.providerDisplayName})`),
+			"",
+			"## Example",
+			""
+		];
+		if (models.length > 0) {
+			const first = models[0];
+			lines.push(`\`exec /types/${type}/${modelPathSegment(first)}/.actions/${action} { "prompt": "..." }\``);
+		}
+		lines.push("", "## Navigation", "", "- By provider: `list /providers`");
+		return {
+			content: lines.join("\n"),
+			format: "markdown"
+		};
+	}
+	async listTypeModel(ctx) {
+		const type = this.validateType(ctx.params.type);
+		await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return { data: [] };
+	}
+	async readTypeModel(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return this.buildModelEntry(joinURL("/types", type, ctx.params.model), model);
+	}
+	async statTypeModel(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return { data: this.buildEntry(joinURL("/types", type, ctx.params.model), { meta: {
+			childrenCount: 0,
+			kind: `aignehub:${model.type}-model`,
+			type: model.type
+		} }) };
+	}
+	async typeModelMeta(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return this.buildEntry(joinURL("/types", type, ctx.params.model, ".meta"), {
+			content: {
+				model: model.model,
+				provider: model.provider,
+				type: model.type
+			},
+			meta: {
+				childrenCount: 0,
+				kind: `aignehub:${model.type}-model`,
+				type: model.type
+			}
+		});
+	}
+	async explainTypeModel(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return this.buildModelExplain(joinURL("/types", type, ctx.params.model), model);
+	}
+	async listTypeModelActions(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		const basePath = joinURL("/types", type, ctx.params.model);
+		return { data: getActionsForType(model.type).map((action) => this.buildActionEntry(joinURL(basePath, ".actions", action.name), action.name, action.description, action.schema)) };
+	}
+	async execTypeChat(ctx, args) {
+		const type = this.validateType(ctx.params.type);
+		if (type !== "chat") throw new AFSNotFoundError(joinURL("/types", type, ctx.params.model, ".actions/chat"), `Action 'chat' is not available for ${type} models.`);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return this.runChat(model.model, args);
+	}
+	async execTypeGenerateImage(ctx, args) {
+		const type = this.validateType(ctx.params.type);
+		if (type !== "image") throw new AFSNotFoundError(joinURL("/types", type, ctx.params.model, ".actions/generateImage"), `Action 'generateImage' is not available for ${type} models.`);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return this.runImage(model.model, args);
+	}
+	async execTypeGenerateVideo(ctx, args) {
+		const type = this.validateType(ctx.params.type);
+		if (type !== "video") throw new AFSNotFoundError(joinURL("/types", type, ctx.params.model, ".actions/generateVideo"), `Action 'generateVideo' is not available for ${type} models.`);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return this.runVideo(model.model, args);
+	}
+	async execTypeSetDefault(ctx) {
+		const type = this.validateType(ctx.params.type);
+		const model = await this.findModelByTypeAndSegment(type, ctx.params.model);
+		return await this.setDefault(model);
+	}
+	async listRootActions(_ctx) {
+		return { data: [
+			this.buildActionEntry("/.actions/chat", "chat", "Chat inference (prompt shorthand or full messages array)", ROOT_CHAT_SCHEMA),
+			this.buildActionEntry("/.actions/generateImage", "generateImage", "Generate images from a text prompt", ROOT_GENERATE_IMAGE_SCHEMA),
+			this.buildActionEntry("/.actions/generateVideo", "generateVideo", "Generate video from a text prompt", ROOT_GENERATE_VIDEO_SCHEMA),
+			this.buildActionEntry("/.actions/setDefaultModel", "setDefaultModel", "Set the default model for a given type", SET_DEFAULT_MODEL_SCHEMA),
+			this.buildActionEntry("/.actions/refresh", "refresh", "Clear model catalog cache and reload on next access", {
+				type: "object",
+				properties: {}
+			})
+		] };
+	}
+	async execRootChat(_ctx, args) {
+		const modelName = args.model;
+		if (!modelName) return missingParam("model");
+		await this.findModelOfType(modelName, "chat");
+		return this.runChat(modelName, args);
+	}
+	async execRootGenerateImage(_ctx, args) {
+		const modelName = args.model;
+		if (!modelName) return missingParam("model");
+		await this.findModelOfType(modelName, "image");
+		return this.runImage(modelName, args);
+	}
+	async execRootGenerateVideo(_ctx, args) {
+		const modelName = args.model;
+		if (!modelName) return missingParam("model");
+		await this.findModelOfType(modelName, "video");
+		return this.runVideo(modelName, args);
+	}
+	async execRootSetDefaultModel(_ctx, args) {
+		const typeName = args.type;
+		const modelName = args.model;
+		if (!typeName) return missingParam("type");
+		if (!modelName) return missingParam("model");
+		const type = this.validateType(typeName);
+		const model = await this.findModelOfType(modelName, type);
+		return await this.setDefault(model);
+	}
+	async execRefresh(_ctx, _args) {
+		this.catalog = null;
+		return {
+			success: true,
+			data: { message: "Model catalog cache cleared" }
+		};
+	}
+	async setDefault(model) {
+		const type = model.type;
+		this.runtimeDefaults[type] = model.model;
+		if (this.updateConfigFn && this.mountPath) {
+			const key = type === "chat" ? "defaultChat" : type === "image" ? "defaultImage" : "defaultVideo";
+			await this.updateConfigFn(this.mountPath, { [key]: model.model });
+		}
+		return {
+			success: true,
+			data: {
+				message: `Default ${type} model set to ${model.model}`,
+				type,
+				model: model.model,
+				provider: model.provider
+			}
+		};
+	}
+	buildActionsListExplain(basePath, actions) {
+		return {
+			content: [
+				`# Actions for ${basePath || "/"}`,
+				"",
+				"Available actions:",
+				"",
+				...actions.map((a) => `- **${a.name}** — ${a.description}`),
+				"",
+				`Use \`explain ${basePath}/.actions/<name>\` for input schema and usage.`
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	buildActionExplain(basePath, actionName, actions) {
+		const action = actions.find((a) => a.name === actionName);
+		if (!action) throw new AFSNotFoundError(joinURL(basePath, ".actions", actionName));
+		return {
+			content: [
+				`# ${action.name}`,
+				"",
+				action.description,
+				"",
+				"## Input Schema",
+				"",
+				"```json",
+				JSON.stringify(action.schema, null, 2),
+				"```",
+				"",
+				"## Example",
+				"",
+				`\`exec ${basePath}/.actions/${action.name} ${JSON.stringify(Object.fromEntries((Array.isArray(action.schema.required) ? action.schema.required : []).map((k) => [k, `<${k}>`])))}\``
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async explainRootActionsList(_ctx) {
+		return this.buildActionsListExplain("", ROOT_ACTIONS);
+	}
+	async explainRootAction(ctx) {
+		return this.buildActionExplain("", ctx.params.action, ROOT_ACTIONS);
+	}
+	async explainDefaultActionsList(ctx) {
+		const type = this.validateType(ctx.params.type);
+		return this.buildActionsListExplain(joinURL("/defaults", type), getActionsForType(type));
+	}
+	async explainDefaultAction(ctx) {
+		const type = this.validateType(ctx.params.type);
+		return this.buildActionExplain(joinURL("/defaults", type), ctx.params.action, getActionsForType(type));
+	}
+	async explainProviderModelActionsList(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return this.buildActionsListExplain(joinURL("/providers", ctx.params.provider, ctx.params.model), getActionsForType(model.type));
+	}
+	async explainProviderModelAction(ctx) {
+		const model = await this.findModelByPath(ctx.params.provider, ctx.params.model);
+		return this.buildActionExplain(joinURL("/providers", ctx.params.provider, ctx.params.model), ctx.params.action, getActionsForType(model.type));
+	}
+	async explainTypeModelActionsList(ctx) {
+		const type = this.validateType(ctx.params.type);
+		return this.buildActionsListExplain(joinURL("/types", type, ctx.params.model), getActionsForType(type));
+	}
+	async explainTypeModelAction(ctx) {
+		const type = this.validateType(ctx.params.type);
+		return this.buildActionExplain(joinURL("/types", type, ctx.params.model), ctx.params.action, getActionsForType(type));
+	}
+	buildActionEntry(path, name, description, inputSchema) {
+		return this.buildEntry(path, {
+			id: name,
+			content: {
+				name,
+				description,
+				inputSchema
+			},
+			meta: {
+				name,
+				kind: "afs:executable",
+				description,
+				inputSchema
+			}
+		});
+	}
+	buildModelEntry(path, model) {
+		return this.buildEntry(path, {
+			content: {
+				model: model.model,
+				provider: model.provider,
+				providerDisplayName: model.providerDisplayName,
+				type: model.type,
+				inputCreditsPerToken: model.inputCreditsPerToken,
+				outputCreditsPerToken: model.outputCreditsPerToken,
+				available: model.status?.available ?? true
+			},
+			meta: {
+				childrenCount: 0,
+				kind: `aignehub:${model.type}-model`,
+				type: model.type
+			}
+		});
+	}
+	buildModelExplain(modelPath, model) {
+		const actions = getActionsForType(model.type);
+		const action = actions[0];
+		const actionNames = actions.map((a) => a.name).join(", ");
+		const lines = [
+			`# ${model.model}`,
+			"",
+			`- **Type**: ${model.type}`,
+			`- **Provider**: ${model.providerDisplayName} (${model.provider})`,
+			`- **Input Credits**: ${model.inputCreditsPerToken} per token`,
+			`- **Output Credits**: ${model.outputCreditsPerToken} per token`,
+			`- **Available**: ${model.status?.available ?? true ? "Yes" : "No"}`,
+			`- **Actions**: ${actionNames}`,
+			"",
+			"## Example",
+			"",
+			`\`exec ${modelPath}/.actions/${action.name} { "prompt": "..." }\``
+		];
+		for (const a of actions) lines.push("", `## ${a.name} Input Schema`, "", "```json", JSON.stringify(a.schema, null, 2), "```");
+		lines.push("", "## Navigation", "", `- Same type: \`list /types/${model.type}\``, `- Same provider: \`list /providers/${model.provider}\``);
+		return {
+			content: lines.join("\n"),
+			format: "markdown"
+		};
+	}
+	async runChat(modelName, args) {
+		const input = buildChatSDKInput(args);
+		if (!input.messages) return {
+			success: false,
+			error: {
+				code: "MISSING_PARAM",
+				message: "Either 'messages' or 'prompt' is required for chat"
+			}
+		};
+		try {
+			const output = await new AIGNEHubChatModel({
+				baseURL: this.baseURL,
+				apiKey: this.apiKey,
+				model: modelName
+			}).invoke(input);
+			const usage = output.usage;
+			const data = { model: modelName };
+			if (output.text !== void 0 && output.text !== "") data.text = output.text;
+			if (output.json !== void 0) data.json = output.json;
+			if (output.toolCalls !== void 0) data.toolCalls = output.toolCalls;
+			if (output.thoughts !== void 0) data.thoughts = output.thoughts;
+			if (output.files !== void 0) data.files = output.files;
+			if (usage) {
+				data.inputTokens = usage.inputTokens;
+				data.outputTokens = usage.outputTokens;
+			}
+			return {
+				success: true,
+				data
+			};
+		} catch (err) {
+			return inferenceError(modelName, err);
+		}
+	}
+	async runImage(modelName, args) {
+		const prompt = args.prompt;
+		if (prompt === void 0 || prompt === null) return missingParam("prompt");
+		try {
+			const baseOptions = {
+				baseURL: this.baseURL,
+				apiKey: this.apiKey,
+				model: modelName
+			};
+			const modelOptions = {};
+			if (args.size !== void 0) modelOptions.size = args.size;
+			if (args.quality !== void 0) modelOptions.quality = args.quality;
+			if (args.style !== void 0) modelOptions.style = args.style;
+			const input = { prompt: String(prompt) };
+			if (args.n !== void 0) input.n = args.n;
+			input.outputFileType = args.outputFileType ?? "url";
+			if (Object.keys(modelOptions).length > 0) input.modelOptions = modelOptions;
+			const output = await new AIGNEHubImageModel(baseOptions).invoke(input);
+			const data = {
+				images: output.images ?? [],
+				model: modelName
+			};
+			if (output.usage) data.usage = output.usage;
+			return {
+				success: true,
+				data
+			};
+		} catch (err) {
+			return inferenceError(modelName, err);
+		}
+	}
+	async runVideo(modelName, args) {
+		const prompt = args.prompt;
+		if (prompt === void 0 || prompt === null) return missingParam("prompt");
+		try {
+			const baseOptions = {
+				baseURL: this.baseURL,
+				apiKey: this.apiKey,
+				model: modelName
+			};
+			const input = { prompt: String(prompt) };
+			if (args.size !== void 0) input.size = args.size;
+			if (args.seconds !== void 0) input.seconds = args.seconds;
+			input.outputFileType = args.outputFileType ?? "url";
+			const output = await new AIGNEHubVideoModel(baseOptions).invoke(input);
+			const data = {
+				videos: output.videos ?? [],
+				model: modelName
+			};
+			if (output.seconds !== void 0) data.seconds = output.seconds;
+			if (output.usage) data.usage = output.usage;
+			return {
+				success: true,
+				data
+			};
+		} catch (err) {
+			return inferenceError(modelName, err);
+		}
+	}
+	/** Find model by provider + path segment across all types */
+	async findModelByPath(provider, segment) {
+		const catalog = await this.ensureCatalog();
+		for (const type of MODEL_TYPES) {
+			const model = catalog[type].find((m) => m.provider === provider && modelPathSegment(m) === segment);
+			if (model) return model;
+		}
+		const providerModels = this.getModelsForProvider(catalog, provider);
+		if (providerModels.length === 0) throw new AFSNotFoundError(joinURL("/providers", provider, segment), `Provider '${provider}' not found.`);
+		const available = providerModels.map((m) => modelPathSegment(m));
+		throw new AFSNotFoundError(joinURL("/providers", provider, segment), `Model '${segment}' not found under provider '${provider}'. Available: ${available.slice(0, 8).join(", ")}${available.length > 8 ? "..." : ""}`);
+	}
+	/** Find model by provider + path segment in a specific type catalog */
+	async findModelOfTypeByPath(provider, segment, type) {
+		const catalog = await this.ensureCatalog();
+		const model = catalog[type].find((m) => m.provider === provider && modelPathSegment(m) === segment);
+		if (model) return model;
+		for (const otherType of MODEL_TYPES) {
+			if (otherType === type) continue;
+			if (catalog[otherType].find((m) => m.provider === provider && modelPathSegment(m) === segment)) throw new AFSNotFoundError(joinURL("/providers", provider, segment), `Model '${segment}' (${provider}) is not a ${type} model. It is listed under ${otherType} models.`);
+		}
+		throw new AFSNotFoundError(joinURL("/providers", provider, segment), `Model '${segment}' not found in ${type} models for provider '${provider}'.`);
+	}
+	/** Find model by type + path segment (for /types/:type/:model) */
+	async findModelByTypeAndSegment(type, segment) {
+		const catalog = await this.ensureCatalog();
+		const model = catalog[type].find((m) => modelPathSegment(m) === segment);
+		if (model) return model;
+		for (const otherType of MODEL_TYPES) {
+			if (otherType === type) continue;
+			if (catalog[otherType].find((m) => modelPathSegment(m) === segment)) throw new AFSNotFoundError(joinURL("/types", type, segment), `Model '${segment}' is not a ${type} model. It is listed under ${otherType} models.`);
+		}
+		const available = catalog[type].map((m) => modelPathSegment(m));
+		throw new AFSNotFoundError(joinURL("/types", type, segment), `Model '${segment}' not found in ${type} models. Available: ${available.slice(0, 8).join(", ")}${available.length > 8 ? "..." : ""}`);
+	}
+	/** Find model by full model name in a specific type catalog (for root exec) */
+	async findModelOfType(modelName, type) {
+		const catalog = await this.ensureCatalog();
+		const model = catalog[type].find((m) => m.model === modelName);
+		if (model) return model;
+		for (const otherType of MODEL_TYPES) {
+			if (otherType === type) continue;
+			if (catalog[otherType].find((m) => m.model === modelName)) throw new AFSNotFoundError(modelName, `Model '${modelName}' is not a ${type} model. It is listed under ${otherType} models.`);
+		}
+		const available = catalog[type].map((m) => m.model);
+		throw new AFSNotFoundError(modelName, `Model '${modelName}' not found in ${type} models. Available: ${available.slice(0, 8).join(", ")}${available.length > 8 ? "..." : ""}`);
+	}
+};
+__decorate([List("/")], AFSAigneHub.prototype, "listRoot", null);
+__decorate([Read("/")], AFSAigneHub.prototype, "readRoot", null);
+__decorate([Meta("/")], AFSAigneHub.prototype, "rootMeta", null);
+__decorate([Read("/.meta/.capabilities")], AFSAigneHub.prototype, "readCapabilities", null);
+__decorate([Explain("/")], AFSAigneHub.prototype, "explainRoot", null);
+__decorate([Stat("/")], AFSAigneHub.prototype, "statRoot", null);
+__decorate([List("/defaults")], AFSAigneHub.prototype, "listDefaults", null);
+__decorate([Read("/defaults")], AFSAigneHub.prototype, "readDefaults", null);
+__decorate([Meta("/defaults")], AFSAigneHub.prototype, "defaultsMeta", null);
+__decorate([Stat("/defaults")], AFSAigneHub.prototype, "statDefaults", null);
+__decorate([Explain("/defaults")], AFSAigneHub.prototype, "explainDefaults", null);
+__decorate([List("/defaults/:type")], AFSAigneHub.prototype, "listDefault", null);
+__decorate([Read("/defaults/:type")], AFSAigneHub.prototype, "readDefault", null);
+__decorate([Stat("/defaults/:type")], AFSAigneHub.prototype, "statDefault", null);
+__decorate([Meta("/defaults/:type")], AFSAigneHub.prototype, "defaultTypeMeta", null);
+__decorate([Explain("/defaults/:type")], AFSAigneHub.prototype, "explainDefault", null);
+__decorate([Actions("/defaults/:type")], AFSAigneHub.prototype, "listDefaultActions", null);
+__decorate([Actions.Exec("/defaults/:type", "chat")], AFSAigneHub.prototype, "execDefaultChat", null);
+__decorate([Actions.Exec("/defaults/:type", "generateImage")], AFSAigneHub.prototype, "execDefaultGenerateImage", null);
+__decorate([Actions.Exec("/defaults/:type", "generateVideo")], AFSAigneHub.prototype, "execDefaultGenerateVideo", null);
+__decorate([List("/providers")], AFSAigneHub.prototype, "listProviders", null);
+__decorate([Read("/providers")], AFSAigneHub.prototype, "readProviders", null);
+__decorate([Meta("/providers")], AFSAigneHub.prototype, "providersMeta", null);
+__decorate([Stat("/providers")], AFSAigneHub.prototype, "statProviders", null);
+__decorate([Explain("/providers")], AFSAigneHub.prototype, "explainProviders", null);
+__decorate([List("/providers/:provider")], AFSAigneHub.prototype, "listProvider", null);
+__decorate([Read("/providers/:provider")], AFSAigneHub.prototype, "readProvider", null);
+__decorate([Meta("/providers/:provider")], AFSAigneHub.prototype, "providerMeta", null);
+__decorate([Stat("/providers/:provider")], AFSAigneHub.prototype, "statProvider", null);
+__decorate([Explain("/providers/:provider")], AFSAigneHub.prototype, "explainProvider", null);
+__decorate([List("/providers/:provider/:model")], AFSAigneHub.prototype, "listProviderModel", null);
+__decorate([Read("/providers/:provider/:model")], AFSAigneHub.prototype, "readProviderModel", null);
+__decorate([Meta("/providers/:provider/:model")], AFSAigneHub.prototype, "providerModelMeta", null);
+__decorate([Stat("/providers/:provider/:model")], AFSAigneHub.prototype, "statProviderModel", null);
+__decorate([Explain("/providers/:provider/:model")], AFSAigneHub.prototype, "explainProviderModel", null);
+__decorate([Actions("/providers/:provider/:model")], AFSAigneHub.prototype, "listProviderModelActions", null);
+__decorate([Actions.Exec("/providers/:provider/:model", "chat")], AFSAigneHub.prototype, "execProviderChat", null);
+__decorate([Actions.Exec("/providers/:provider/:model", "generateImage")], AFSAigneHub.prototype, "execProviderGenerateImage", null);
+__decorate([Actions.Exec("/providers/:provider/:model", "generateVideo")], AFSAigneHub.prototype, "execProviderGenerateVideo", null);
+__decorate([Actions.Exec("/providers/:provider/:model", "setDefault")], AFSAigneHub.prototype, "execProviderSetDefault", null);
+__decorate([List("/types")], AFSAigneHub.prototype, "listTypes", null);
+__decorate([Read("/types")], AFSAigneHub.prototype, "readTypes", null);
+__decorate([Meta("/types")], AFSAigneHub.prototype, "typesMeta", null);
+__decorate([Stat("/types")], AFSAigneHub.prototype, "statTypes", null);
+__decorate([Explain("/types")], AFSAigneHub.prototype, "explainTypes", null);
+__decorate([List("/types/:type")], AFSAigneHub.prototype, "listType", null);
+__decorate([Read("/types/:type")], AFSAigneHub.prototype, "readType", null);
+__decorate([Meta("/types/:type")], AFSAigneHub.prototype, "typeMeta", null);
+__decorate([Stat("/types/:type")], AFSAigneHub.prototype, "statType", null);
+__decorate([Explain("/types/:type")], AFSAigneHub.prototype, "explainType", null);
+__decorate([List("/types/:type/:model")], AFSAigneHub.prototype, "listTypeModel", null);
+__decorate([Read("/types/:type/:model")], AFSAigneHub.prototype, "readTypeModel", null);
+__decorate([Stat("/types/:type/:model")], AFSAigneHub.prototype, "statTypeModel", null);
+__decorate([Meta("/types/:type/:model")], AFSAigneHub.prototype, "typeModelMeta", null);
+__decorate([Explain("/types/:type/:model")], AFSAigneHub.prototype, "explainTypeModel", null);
+__decorate([Actions("/types/:type/:model")], AFSAigneHub.prototype, "listTypeModelActions", null);
+__decorate([Actions.Exec("/types/:type/:model", "chat")], AFSAigneHub.prototype, "execTypeChat", null);
+__decorate([Actions.Exec("/types/:type/:model", "generateImage")], AFSAigneHub.prototype, "execTypeGenerateImage", null);
+__decorate([Actions.Exec("/types/:type/:model", "generateVideo")], AFSAigneHub.prototype, "execTypeGenerateVideo", null);
+__decorate([Actions.Exec("/types/:type/:model", "setDefault")], AFSAigneHub.prototype, "execTypeSetDefault", null);
+__decorate([Actions("/")], AFSAigneHub.prototype, "listRootActions", null);
+__decorate([Actions.Exec("/", "chat")], AFSAigneHub.prototype, "execRootChat", null);
+__decorate([Actions.Exec("/", "generateImage")], AFSAigneHub.prototype, "execRootGenerateImage", null);
+__decorate([Actions.Exec("/", "generateVideo")], AFSAigneHub.prototype, "execRootGenerateVideo", null);
+__decorate([Actions.Exec("/", "setDefaultModel")], AFSAigneHub.prototype, "execRootSetDefaultModel", null);
+__decorate([Actions.Exec("/", "refresh")], AFSAigneHub.prototype, "execRefresh", null);
+__decorate([Explain("/.actions")], AFSAigneHub.prototype, "explainRootActionsList", null);
+__decorate([Explain("/.actions/:action")], AFSAigneHub.prototype, "explainRootAction", null);
+__decorate([Explain("/defaults/:type/.actions")], AFSAigneHub.prototype, "explainDefaultActionsList", null);
+__decorate([Explain("/defaults/:type/.actions/:action")], AFSAigneHub.prototype, "explainDefaultAction", null);
+__decorate([Explain("/providers/:provider/:model/.actions")], AFSAigneHub.prototype, "explainProviderModelActionsList", null);
+__decorate([Explain("/providers/:provider/:model/.actions/:action")], AFSAigneHub.prototype, "explainProviderModelAction", null);
+__decorate([Explain("/types/:type/:model/.actions")], AFSAigneHub.prototype, "explainTypeModelActionsList", null);
+__decorate([Explain("/types/:type/:model/.actions/:action")], AFSAigneHub.prototype, "explainTypeModelAction", null);
+
+//#endregion
+export { AFSAigneHub };
+//# sourceMappingURL=aignehub.mjs.map