@pixelzx/genesis 2026.5.3-2 → 2026.5.3-3

package/dist/message-action-runner-VdRgHq0O.js

@@ -0,0 +1,2 @@
+import { n as runMessageAction, t as getToolResult } from "./message-action-runner-PKW742hU.js";
+export { getToolResult, runMessageAction };

package/dist/message-actions-C6yR-dy_.js

@@ -0,0 +1,143 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-C1IzJjqi.js";
+import { a as createActionGate, g as readStringParam, l as jsonResult } from "./common-8-i2T_X8.js";
+import { t as resolveReactionLevel } from "./text-runtime-BGtvBT2C.js";
+import { r as resolveReactionMessageId } from "./channel-actions-CdTr01WN.js";
+import { i as resolveSignalAccount, t as listEnabledSignalAccounts } from "./accounts-B9DSBt2S.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BNJMHeSk.js";
+//#region extensions/signal/src/reaction-level.ts
+/**
+* Resolve the effective reaction level and its implications for Signal.
+*
+* Levels:
+* - "off": No reactions at all
+* - "ack": Only automatic ack reactions (👀 when processing), no agent reactions
+* - "minimal": Agent can react, but sparingly (default)
+* - "extensive": Agent can react liberally
+*/
+function resolveSignalReactionLevel(params) {
+	return resolveReactionLevel({
+		value: resolveSignalAccount({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}).config.reactionLevel,
+		defaultLevel: "minimal",
+		invalidFallback: "minimal"
+	});
+}
+//#endregion
+//#region extensions/signal/src/message-actions.ts
+const providerId = "signal";
+const GROUP_PREFIX = "group:";
+function normalizeSignalReactionRecipient(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return trimmed;
+	const withoutSignal = trimmed.replace(/^signal:/i, "").trim();
+	if (!withoutSignal) return withoutSignal;
+	if (normalizeLowercaseStringOrEmpty(withoutSignal).startsWith("uuid:")) return withoutSignal.slice(5).trim();
+	return withoutSignal;
+}
+function resolveSignalReactionTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const withoutSignal = trimmed.replace(/^signal:/i, "").trim();
+	if (!withoutSignal) return {};
+	if (normalizeLowercaseStringOrEmpty(withoutSignal).startsWith(GROUP_PREFIX)) {
+		const groupId = withoutSignal.slice(6).trim();
+		return groupId ? { groupId } : {};
+	}
+	return { recipient: normalizeSignalReactionRecipient(withoutSignal) };
+}
+async function mutateSignalReaction(params) {
+	const options = {
+		cfg: params.cfg,
+		accountId: params.accountId,
+		groupId: params.target.groupId,
+		targetAuthor: params.targetAuthor,
+		targetAuthorUuid: params.targetAuthorUuid
+	};
+	if (params.remove) {
+		await removeReactionSignal(params.target.recipient ?? "", params.timestamp, params.emoji, options);
+		return jsonResult({
+			ok: true,
+			removed: params.emoji
+		});
+	}
+	await sendReactionSignal(params.target.recipient ?? "", params.timestamp, params.emoji, options);
+	return jsonResult({
+		ok: true,
+		added: params.emoji
+	});
+}
+const signalMessageActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		const configuredAccounts = accountId ? [resolveSignalAccount({
+			cfg,
+			accountId
+		})].filter((account) => account.enabled && account.configured) : listEnabledSignalAccounts(cfg).filter((account) => account.configured);
+		if (configuredAccounts.length === 0) return null;
+		const actions = new Set(["send"]);
+		if (configuredAccounts.some((account) => createActionGate(account.config.actions)("reactions"))) actions.add("react");
+		return { actions: Array.from(actions) };
+	},
+	supportsAction: ({ action }) => action !== "send",
+	handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
+		if (action === "send") throw new Error("Send should be handled by outbound, not actions handler.");
+		if (action === "react") {
+			const reactionLevelInfo = resolveSignalReactionLevel({
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`Signal agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.signal.reactionLevel to "minimal" or "extensive" to enable.`);
+			const actionConfig = resolveSignalAccount({
+				cfg,
+				accountId
+			}).config.actions;
+			if (!createActionGate(actionConfig)("reactions")) throw new Error("Signal reactions are disabled via actions.reactions.");
+			const target = resolveSignalReactionTarget(readStringParam(params, "recipient") ?? readStringParam(params, "to", {
+				required: true,
+				label: "recipient (UUID, phone number, or group)"
+			}));
+			if (!target.recipient && !target.groupId) throw new Error("recipient or group required");
+			const messageIdRaw = resolveReactionMessageId({
+				args: params,
+				toolContext
+			});
+			const messageId = messageIdRaw != null ? String(messageIdRaw) : void 0;
+			if (!messageId) throw new Error("messageId (timestamp) required. Provide messageId explicitly or react to the current inbound message.");
+			const targetAuthor = readStringParam(params, "targetAuthor");
+			const targetAuthorUuid = readStringParam(params, "targetAuthorUuid");
+			if (target.groupId && !targetAuthor && !targetAuthorUuid) throw new Error("targetAuthor or targetAuthorUuid required for group reactions.");
+			const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+			const remove = typeof params.remove === "boolean" ? params.remove : void 0;
+			const timestamp = Number.parseInt(messageId, 10);
+			if (!Number.isFinite(timestamp)) throw new Error(`Invalid messageId: ${messageId}. Expected numeric timestamp.`);
+			if (remove) {
+				if (!emoji) throw new Error("Emoji required to remove reaction.");
+				return await mutateSignalReaction({
+					cfg,
+					accountId: accountId ?? void 0,
+					target,
+					timestamp,
+					emoji,
+					remove: true,
+					targetAuthor,
+					targetAuthorUuid
+				});
+			}
+			if (!emoji) throw new Error("Emoji required to add reaction.");
+			return await mutateSignalReaction({
+				cfg,
+				accountId: accountId ?? void 0,
+				target,
+				timestamp,
+				emoji,
+				remove: false,
+				targetAuthor,
+				targetAuthorUuid
+			});
+		}
+		throw new Error(`Action ${action} not supported for ${providerId}.`);
+	}
+};
+//#endregion
+export { resolveSignalReactionLevel as n, signalMessageActions as t };

package/dist/message.gateway.runtime-CXGM9Aaa.js

@@ -0,0 +1,2 @@
+import { a as callGatewayLeastPrivilege, c as randomIdempotencyKey } from "./call-45FewBaL.js";
+export { callGatewayLeastPrivilege, randomIdempotencyKey };

package/dist/message.gateway.runtime.js

@@ -1 +1 @@
-export * from "./message.gateway.runtime-x9oPkfCV.js";
+export * from "./message.gateway.runtime-CXGM9Aaa.js";

package/dist/method-scopes-Dut0EB9J.js

@@ -0,0 +1,209 @@
+import { r as getPluginRegistryState } from "./runtime-state-DX95lWv5.js";
+import { n as resolveReservedGatewayMethodScope } from "./gateway-method-policy-CCV7oDGt.js";
+//#region src/gateway/operator-scopes.ts
+const ADMIN_SCOPE = "operator.admin";
+const READ_SCOPE = "operator.read";
+const WRITE_SCOPE = "operator.write";
+const APPROVALS_SCOPE = "operator.approvals";
+const PAIRING_SCOPE = "operator.pairing";
+const TALK_SECRETS_SCOPE = "operator.talk.secrets";
+//#endregion
+//#region src/gateway/method-scopes.ts
+const CLI_DEFAULT_OPERATOR_SCOPES = [
+	ADMIN_SCOPE,
+	READ_SCOPE,
+	WRITE_SCOPE,
+	APPROVALS_SCOPE,
+	PAIRING_SCOPE,
+	TALK_SECRETS_SCOPE
+];
+const NODE_ROLE_METHODS = new Set([
+	"node.invoke.result",
+	"node.event",
+	"node.pending.drain",
+	"node.canvas.capability.refresh",
+	"node.pending.pull",
+	"node.pending.ack",
+	"skills.bins"
+]);
+const METHOD_SCOPE_BY_NAME = new Map(Object.entries({
+	[APPROVALS_SCOPE]: [
+		"exec.approval.get",
+		"exec.approval.list",
+		"exec.approval.request",
+		"exec.approval.waitDecision",
+		"exec.approval.resolve",
+		"plugin.approval.list",
+		"plugin.approval.request",
+		"plugin.approval.waitDecision",
+		"plugin.approval.resolve"
+	],
+	[PAIRING_SCOPE]: [
+		"node.pair.request",
+		"node.pair.list",
+		"node.pair.reject",
+		"node.pair.verify",
+		"node.pair.approve",
+		"device.pair.list",
+		"device.pair.approve",
+		"device.pair.reject",
+		"device.pair.remove",
+		"device.token.rotate",
+		"device.token.revoke",
+		"node.rename"
+	],
+	[READ_SCOPE]: [
+		"assistant.media.get",
+		"health",
+		"diagnostics.stability",
+		"doctor.memory.status",
+		"doctor.memory.dreamDiary",
+		"logs.tail",
+		"channels.status",
+		"status",
+		"usage.status",
+		"usage.cost",
+		"tts.status",
+		"tts.providers",
+		"commands.list",
+		"models.list",
+		"models.authStatus",
+		"tools.catalog",
+		"tools.effective",
+		"agents.list",
+		"agent.identity.get",
+		"skills.status",
+		"skills.search",
+		"skills.detail",
+		"voicewake.get",
+		"sessions.list",
+		"sessions.get",
+		"sessions.preview",
+		"sessions.resolve",
+		"sessions.compaction.list",
+		"sessions.compaction.get",
+		"sessions.subscribe",
+		"sessions.unsubscribe",
+		"sessions.messages.subscribe",
+		"sessions.messages.unsubscribe",
+		"sessions.usage",
+		"sessions.usage.timeseries",
+		"sessions.usage.logs",
+		"cron.list",
+		"cron.status",
+		"cron.runs",
+		"gateway.identity.get",
+		"system-presence",
+		"last-heartbeat",
+		"node.list",
+		"node.describe",
+		"chat.history",
+		"config.get",
+		"config.schema.lookup",
+		"wallet.summary",
+		"talk.config",
+		"agents.files.list",
+		"agents.files.get"
+	],
+	[WRITE_SCOPE]: [
+		"message.action",
+		"send",
+		"poll",
+		"agent",
+		"agent.wait",
+		"wake",
+		"talk.mode",
+		"talk.realtime.session",
+		"talk.speak",
+		"tts.enable",
+		"tts.disable",
+		"tts.convert",
+		"tts.setProvider",
+		"voicewake.set",
+		"node.invoke",
+		"chat.send",
+		"chat.abort",
+		"sessions.create",
+		"sessions.send",
+		"sessions.steer",
+		"sessions.abort",
+		"sessions.compaction.branch",
+		"doctor.memory.backfillDreamDiary",
+		"doctor.memory.resetDreamDiary",
+		"doctor.memory.resetGroundedShortTerm",
+		"doctor.memory.repairDreamingArtifacts",
+		"doctor.memory.dedupeDreamDiary",
+		"push.test",
+		"node.pending.enqueue"
+	],
+	[ADMIN_SCOPE]: [
+		"channels.start",
+		"channels.logout",
+		"agents.create",
+		"agents.update",
+		"agents.delete",
+		"skills.install",
+		"skills.update",
+		"secrets.reload",
+		"secrets.resolve",
+		"cron.add",
+		"cron.update",
+		"cron.remove",
+		"cron.run",
+		"sessions.patch",
+		"sessions.reset",
+		"sessions.delete",
+		"sessions.compact",
+		"sessions.compaction.restore",
+		"wallet.recoveryPhrase.set",
+		"connect",
+		"chat.inject",
+		"nativeHook.invoke",
+		"web.login.start",
+		"web.login.wait",
+		"set-heartbeats",
+		"system-event",
+		"agents.files.set"
+	],
+	[TALK_SECRETS_SCOPE]: []
+}).flatMap(([scope, methods]) => methods.map((method) => [method, scope])));
+function resolveScopedMethod(method) {
+	const explicitScope = METHOD_SCOPE_BY_NAME.get(method);
+	if (explicitScope) return explicitScope;
+	const reservedScope = resolveReservedGatewayMethodScope(method);
+	if (reservedScope) return reservedScope;
+	const pluginScope = getPluginRegistryState()?.activeRegistry?.gatewayMethodScopes?.[method];
+	if (pluginScope) return pluginScope;
+}
+function isNodeRoleMethod(method) {
+	return NODE_ROLE_METHODS.has(method);
+}
+function isAdminOnlyMethod(method) {
+	return resolveScopedMethod(method) === ADMIN_SCOPE;
+}
+function resolveRequiredOperatorScopeForMethod(method) {
+	return resolveScopedMethod(method);
+}
+function resolveLeastPrivilegeOperatorScopesForMethod(method) {
+	const requiredScope = resolveRequiredOperatorScopeForMethod(method);
+	if (requiredScope) return [requiredScope];
+	return [];
+}
+function authorizeOperatorScopesForMethod(method, scopes) {
+	if (scopes.includes("operator.admin")) return { allowed: true };
+	const requiredScope = resolveRequiredOperatorScopeForMethod(method) ?? "operator.admin";
+	if (requiredScope === "operator.read") {
+		if (scopes.includes("operator.read") || scopes.includes("operator.write")) return { allowed: true };
+		return {
+			allowed: false,
+			missingScope: READ_SCOPE
+		};
+	}
+	if (scopes.includes(requiredScope)) return { allowed: true };
+	return {
+		allowed: false,
+		missingScope: requiredScope
+	};
+}
+//#endregion
+export { resolveLeastPrivilegeOperatorScopesForMethod as a, PAIRING_SCOPE as c, WRITE_SCOPE as d, isNodeRoleMethod as i, READ_SCOPE as l, authorizeOperatorScopesForMethod as n, ADMIN_SCOPE as o, isAdminOnlyMethod as r, APPROVALS_SCOPE as s, CLI_DEFAULT_OPERATOR_SCOPES as t, TALK_SECRETS_SCOPE as u };

package/dist/models-cli-CZt8Jsll.js

@@ -0,0 +1,219 @@
+import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
+import { t as formatDocsLink } from "./links-DmsJCU7L.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { n as runCommandWithRuntime, t as resolveOptionFromCommand } from "./cli-utils-CsLPn__A.js";
+import { n as modelsListCommand, t as modelsStatusCommand } from "./list-Bx1ShIyl.js";
+//#region src/cli/models-cli.ts
+function runModelsCommand(action) {
+	return runCommandWithRuntime(defaultRuntime, action);
+}
+function registerModelsCli(program) {
+	const models = program.command("models").description("Model discovery, scanning, and configuration").option("--status-json", "Output JSON (alias for `models status --json`)", false).option("--status-plain", "Plain output (alias for `models status --plain`)", false).option("--agent <id>", "Agent id to inspect (overrides GENESIS_AGENT_DIR/PI_CODING_AGENT_DIR)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/models", "docs.genesis.ai/cli/models")}\n`);
+	models.command("list").description("List models (configured by default)").option("--all", "Show full model catalog", false).option("--local", "Filter to local models", false).option("--provider <id>", "Filter by provider id").option("--json", "Output JSON", false).option("--plain", "Plain line output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsListCommand(opts, defaultRuntime);
+		});
+	});
+	models.command("status").description("Show configured model state").option("--json", "Output JSON", false).option("--plain", "Plain output", false).option("--check", "Exit non-zero if auth is expiring/expired (1=expired/missing, 2=expiring)", false).option("--probe", "Probe configured provider auth (live)", false).option("--probe-provider <name>", "Only probe a single provider").option("--probe-profile <id>", "Only probe specific auth profile ids (repeat or comma-separated)", (value, previous) => {
+		const next = Array.isArray(previous) ? previous : previous ? [previous] : [];
+		next.push(value);
+		return next;
+	}).option("--probe-timeout <ms>", "Per-probe timeout in ms").option("--probe-concurrency <n>", "Concurrent probes").option("--probe-max-tokens <n>", "Probe max tokens (best-effort)").option("--agent <id>", "Agent id to inspect (overrides GENESIS_AGENT_DIR/PI_CODING_AGENT_DIR)").action(async (opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			await modelsStatusCommand({
+				json: Boolean(opts.json),
+				plain: Boolean(opts.plain),
+				check: Boolean(opts.check),
+				probe: Boolean(opts.probe),
+				probeProvider: opts.probeProvider,
+				probeProfile: opts.probeProfile,
+				probeTimeout: opts.probeTimeout,
+				probeConcurrency: opts.probeConcurrency,
+				probeMaxTokens: opts.probeMaxTokens,
+				agent
+			}, defaultRuntime);
+		});
+	});
+	models.command("set").description("Set the default model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			const { modelsSetCommand } = await import("./set-B96_W3ei.js");
+			await modelsSetCommand(model, defaultRuntime);
+		});
+	});
+	models.command("set-image").description("Set the image model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			const { modelsSetImageCommand } = await import("./set-image-D5DHMNQD.js");
+			await modelsSetImageCommand(model, defaultRuntime);
+		});
+	});
+	const aliases = models.command("aliases").description("Manage model aliases");
+	aliases.command("list").description("List model aliases").option("--json", "Output JSON", false).option("--plain", "Plain output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsAliasesListCommand } = await import("./aliases-8yRNckmx.js");
+			await modelsAliasesListCommand(opts, defaultRuntime);
+		});
+	});
+	aliases.command("add").description("Add or update a model alias").argument("<alias>", "Alias name").argument("<model>", "Model id or alias").action(async (alias, model) => {
+		await runModelsCommand(async () => {
+			const { modelsAliasesAddCommand } = await import("./aliases-8yRNckmx.js");
+			await modelsAliasesAddCommand(alias, model, defaultRuntime);
+		});
+	});
+	aliases.command("remove").description("Remove a model alias").argument("<alias>", "Alias name").action(async (alias) => {
+		await runModelsCommand(async () => {
+			const { modelsAliasesRemoveCommand } = await import("./aliases-8yRNckmx.js");
+			await modelsAliasesRemoveCommand(alias, defaultRuntime);
+		});
+	});
+	const fallbacks = models.command("fallbacks").description("Manage model fallback list");
+	fallbacks.command("list").description("List fallback models").option("--json", "Output JSON", false).option("--plain", "Plain output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsFallbacksListCommand } = await import("./fallbacks-Dln-Fm7a.js");
+			await modelsFallbacksListCommand(opts, defaultRuntime);
+		});
+	});
+	fallbacks.command("add").description("Add a fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			const { modelsFallbacksAddCommand } = await import("./fallbacks-Dln-Fm7a.js");
+			await modelsFallbacksAddCommand(model, defaultRuntime);
+		});
+	});
+	fallbacks.command("remove").description("Remove a fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			const { modelsFallbacksRemoveCommand } = await import("./fallbacks-Dln-Fm7a.js");
+			await modelsFallbacksRemoveCommand(model, defaultRuntime);
+		});
+	});
+	fallbacks.command("clear").description("Clear all fallback models").action(async () => {
+		await runModelsCommand(async () => {
+			const { modelsFallbacksClearCommand } = await import("./fallbacks-Dln-Fm7a.js");
+			await modelsFallbacksClearCommand(defaultRuntime);
+		});
+	});
+	const imageFallbacks = models.command("image-fallbacks").description("Manage image model fallback list");
+	imageFallbacks.command("list").description("List image fallback models").option("--json", "Output JSON", false).option("--plain", "Plain output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsImageFallbacksListCommand } = await import("./image-fallbacks-Dz8AR8dy.js");
+			await modelsImageFallbacksListCommand(opts, defaultRuntime);
+		});
+	});
+	imageFallbacks.command("add").description("Add an image fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			const { modelsImageFallbacksAddCommand } = await import("./image-fallbacks-Dz8AR8dy.js");
+			await modelsImageFallbacksAddCommand(model, defaultRuntime);
+		});
+	});
+	imageFallbacks.command("remove").description("Remove an image fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			const { modelsImageFallbacksRemoveCommand } = await import("./image-fallbacks-Dz8AR8dy.js");
+			await modelsImageFallbacksRemoveCommand(model, defaultRuntime);
+		});
+	});
+	imageFallbacks.command("clear").description("Clear all image fallback models").action(async () => {
+		await runModelsCommand(async () => {
+			const { modelsImageFallbacksClearCommand } = await import("./image-fallbacks-Dz8AR8dy.js");
+			await modelsImageFallbacksClearCommand(defaultRuntime);
+		});
+	});
+	models.command("scan").description("Scan OpenRouter free models for tools + images").option("--min-params <b>", "Minimum parameter size (billions)").option("--max-age-days <days>", "Skip models older than N days").option("--provider <name>", "Filter by provider prefix").option("--max-candidates <n>", "Max fallback candidates", "6").option("--timeout <ms>", "Per-probe timeout in ms").option("--concurrency <n>", "Probe concurrency").option("--no-probe", "Skip live probes; list free candidates only").option("--yes", "Accept defaults without prompting", false).option("--no-input", "Disable prompts (use defaults)").option("--set-default", "Set agents.defaults.model to the first selection", false).option("--set-image", "Set agents.defaults.imageModel to the first image selection", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsScanCommand } = await import("./scan-DaCjqwXa.js");
+			await modelsScanCommand(opts, defaultRuntime);
+		});
+	});
+	models.action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsStatusCommand({
+				json: Boolean(opts?.statusJson),
+				plain: Boolean(opts?.statusPlain),
+				agent: opts?.agent
+			}, defaultRuntime);
+		});
+	});
+	const auth = models.command("auth").description("Manage model auth profiles");
+	auth.option("--agent <id>", "Agent id for auth order get/set/clear");
+	auth.action(() => {
+		auth.help();
+	});
+	auth.command("add").description("Interactive auth helper (provider auth or paste token)").action(async () => {
+		await runModelsCommand(async () => {
+			const { modelsAuthAddCommand } = await import("./auth-DQKEcU2i.js");
+			await modelsAuthAddCommand({}, defaultRuntime);
+		});
+	});
+	auth.command("login").description("Run a provider plugin auth flow (OAuth/API key)").option("--provider <id>", "Provider id registered by a plugin").option("--method <id>", "Provider auth method id").option("--set-default", "Apply the provider's default model recommendation", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsAuthLoginCommand } = await import("./auth-DQKEcU2i.js");
+			await modelsAuthLoginCommand({
+				provider: opts.provider,
+				method: opts.method,
+				setDefault: Boolean(opts.setDefault)
+			}, defaultRuntime);
+		});
+	});
+	auth.command("setup-token").description("Run a provider CLI to create/sync a token (TTY required)").option("--provider <name>", "Provider id").option("--yes", "Skip confirmation", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsAuthSetupTokenCommand } = await import("./auth-DQKEcU2i.js");
+			await modelsAuthSetupTokenCommand({
+				provider: opts.provider,
+				yes: Boolean(opts.yes)
+			}, defaultRuntime);
+		});
+	});
+	auth.command("paste-token").description("Paste a token into auth-profiles.json and update config").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--profile-id <id>", "Auth profile id (default: <provider>:manual)").option("--expires-in <duration>", "Optional expiry duration (e.g. 365d, 12h). Stored as absolute expiresAt.").action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsAuthPasteTokenCommand } = await import("./auth-DQKEcU2i.js");
+			await modelsAuthPasteTokenCommand({
+				provider: opts.provider,
+				profileId: opts.profileId,
+				expiresIn: opts.expiresIn
+			}, defaultRuntime);
+		});
+	});
+	auth.command("login-github-copilot").description("Login to GitHub Copilot via GitHub device flow (TTY required)").option("--yes", "Overwrite existing profile without prompting", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			const { modelsAuthLoginCommand } = await import("./auth-DQKEcU2i.js");
+			await modelsAuthLoginCommand({
+				provider: "github-copilot",
+				method: "device",
+				yes: Boolean(opts.yes)
+			}, defaultRuntime);
+		});
+	});
+	const order = auth.command("order").description("Manage per-agent auth profile order overrides");
+	order.command("get").description("Show per-agent auth order override (from auth-state.json)").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--agent <id>", "Agent id (default: configured default agent)").option("--json", "Output JSON", false).action(async (opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			const { modelsAuthOrderGetCommand } = await import("./auth-order-DCT4hb8Z.js");
+			await modelsAuthOrderGetCommand({
+				provider: opts.provider,
+				agent,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	order.command("set").description("Set per-agent auth order override (writes auth-state.json)").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--agent <id>", "Agent id (default: configured default agent)").argument("<profileIds...>", "Auth profile ids (e.g. anthropic:default)").action(async (profileIds, opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			const { modelsAuthOrderSetCommand } = await import("./auth-order-DCT4hb8Z.js");
+			await modelsAuthOrderSetCommand({
+				provider: opts.provider,
+				agent,
+				order: profileIds
+			}, defaultRuntime);
+		});
+	});
+	order.command("clear").description("Clear per-agent auth order override (fall back to config/round-robin)").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--agent <id>", "Agent id (default: configured default agent)").action(async (opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			const { modelsAuthOrderClearCommand } = await import("./auth-order-DCT4hb8Z.js");
+			await modelsAuthOrderClearCommand({
+				provider: opts.provider,
+				agent
+			}, defaultRuntime);
+		});
+	});
+}
+//#endregion
+export { registerModelsCli };

package/dist/models-http-Dcpveulc.js

@@ -0,0 +1,92 @@
+import { a as loadConfig } from "./io-CRPT2IUI.js";
+import { g as listAgentIds, x as resolveDefaultAgentId } from "./agent-scope-CDjZLqNk.js";
+import "./config-DcheqK7J.js";
+import { n as authorizeOperatorScopesForMethod } from "./method-scopes-Dut0EB9J.js";
+import { S as sendMethodNotAllowed, b as sendInvalidRequest, l as resolveAgentIdFromModel, n as GENESIS_MODEL_ID, p as resolveOpenAiCompatibleHttpOperatorScopes, r as authorizeGatewayHttpRequestOrReply, t as GENESIS_DEFAULT_MODEL_ID, x as sendJson } from "./http-utils-Dwz38Ezf.js";
+//#region src/gateway/models-http.ts
+function toOpenAiModel(id) {
+	return {
+		id,
+		object: "model",
+		created: 0,
+		owned_by: "genesis",
+		permission: []
+	};
+}
+async function authorizeRequest(req, res, opts) {
+	return await authorizeGatewayHttpRequestOrReply({
+		req,
+		res,
+		auth: opts.auth,
+		trustedProxies: opts.trustedProxies,
+		allowRealIpFallback: opts.allowRealIpFallback,
+		rateLimiter: opts.rateLimiter
+	});
+}
+function loadAgentModelIds() {
+	const cfg = loadConfig();
+	const defaultAgentId = resolveDefaultAgentId(cfg);
+	const ids = new Set([GENESIS_MODEL_ID, GENESIS_DEFAULT_MODEL_ID]);
+	ids.add(`genesis/${defaultAgentId}`);
+	for (const agentId of listAgentIds(cfg)) ids.add(`genesis/${agentId}`);
+	return Array.from(ids);
+}
+function resolveRequestPath(req) {
+	return new URL(req.url ?? "/", `http://${req.headers.host || "localhost"}`).pathname;
+}
+async function handleOpenAiModelsHttpRequest(req, res, opts) {
+	const requestPath = resolveRequestPath(req);
+	if (requestPath !== "/v1/models" && !requestPath.startsWith("/v1/models/")) return false;
+	if (req.method !== "GET") {
+		sendMethodNotAllowed(res, "GET");
+		return true;
+	}
+	const requestAuth = await authorizeRequest(req, res, opts);
+	if (!requestAuth) return true;
+	const scopeAuth = authorizeOperatorScopesForMethod("models.list", resolveOpenAiCompatibleHttpOperatorScopes(req, requestAuth));
+	if (!scopeAuth.allowed) {
+		sendJson(res, 403, {
+			ok: false,
+			error: {
+				type: "forbidden",
+				message: `missing scope: ${scopeAuth.missingScope}`
+			}
+		});
+		return true;
+	}
+	const ids = loadAgentModelIds();
+	if (requestPath === "/v1/models") {
+		sendJson(res, 200, {
+			object: "list",
+			data: ids.map(toOpenAiModel)
+		});
+		return true;
+	}
+	const encodedId = requestPath.slice(11);
+	if (!encodedId) {
+		sendInvalidRequest(res, "Missing model id.");
+		return true;
+	}
+	let decodedId;
+	try {
+		decodedId = decodeURIComponent(encodedId);
+	} catch {
+		sendInvalidRequest(res, "Invalid model id encoding.");
+		return true;
+	}
+	if (decodedId !== "genesis" && !resolveAgentIdFromModel(decodedId)) {
+		sendInvalidRequest(res, "Invalid model id.");
+		return true;
+	}
+	if (!ids.includes(decodedId)) {
+		sendJson(res, 404, { error: {
+			message: `Model '${decodedId}' not found.`,
+			type: "invalid_request_error"
+		} });
+		return true;
+	}
+	sendJson(res, 200, toOpenAiModel(decodedId));
+	return true;
+}
+//#endregion
+export { handleOpenAiModelsHttpRequest };