fengming 0.3.8 → 0.3.10

package/dist/tools-invoke-shared-BH-T9Bcg.js

@@ -0,0 +1,200 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DKw2K5wM.js";
+import { n as defaultSlotIdForKey } from "./slots-DT22cOei.js";
+import { a as isTestDefaultMemorySlotDisabled } from "./config-state-DuITXGx-.js";
+import { a as logWarn } from "./logger-CT4TpBlo.js";
+import { i as resolveMainSessionKey } from "./main-session-BxJmPEXx.js";
+import { t as canonicalizeSessionKeyForAgent } from "./session-store-key-dbCfepNe.js";
+import "./sessions-CtMqsEs2.js";
+import { r as isKnownCoreToolId } from "./tool-catalog-BfQXK2pl.js";
+import { i as getPluginToolMeta } from "./tools-C7700Vu-.js";
+import { E as getChannelAgentToolMeta, m as runBeforeToolCallHook } from "./agent-tools.before-tool-call-CNJrIi9o.js";
+import { n as ToolInputError } from "./common-DSTX6z7j.js";
+import "./agent-tools-CET9usCz.js";
+import { t as resolveToolLoopDetectionConfig } from "./tool-loop-detection-config-CFlU3nvl.js";
+import { t as resolveGatewayScopedTools } from "./tool-resolution-CzsLs-87.js";
+//#region src/gateway/tools-invoke-shared.ts
+const MEMORY_TOOL_NAMES = new Set(["memory_search", "memory_get"]);
+function resolveSessionKey(params) {
+	const rawSessionKey = normalizeOptionalString(params.input.sessionKey);
+	if (rawSessionKey && rawSessionKey !== "main") return rawSessionKey;
+	const agentId = normalizeOptionalString(params.input.agentId);
+	if (agentId) return canonicalizeSessionKeyForAgent(agentId, "main");
+	return resolveMainSessionKey(params.cfg);
+}
+function resolveMemoryToolDisableReasons(cfg) {
+	if (!process.env.VITEST) return [];
+	const reasons = [];
+	const plugins = cfg.plugins;
+	const slotRaw = plugins?.slots?.memory;
+	const slotDisabled = slotRaw === null || normalizeOptionalLowercaseString(slotRaw) === "none";
+	const pluginsDisabled = plugins?.enabled === false;
+	const defaultDisabled = isTestDefaultMemorySlotDisabled(cfg);
+	if (pluginsDisabled) reasons.push("plugins.enabled=false");
+	if (slotDisabled) reasons.push(slotRaw === null ? "plugins.slots.memory=null" : "plugins.slots.memory=\"none\"");
+	if (!pluginsDisabled && !slotDisabled && defaultDisabled) reasons.push("memory plugin disabled by test default");
+	return reasons;
+}
+function mergeActionIntoArgsIfSupported(params) {
+	const { toolSchema, action, args } = params;
+	if (!action || args.action !== void 0) return args;
+	const schemaObj = toolSchema;
+	return Boolean(schemaObj && typeof schemaObj === "object" && schemaObj.properties && "action" in schemaObj.properties) ? {
+		...args,
+		action
+	} : args;
+}
+function getErrorMessage(err) {
+	if (err instanceof Error) return err.message || String(err);
+	if (typeof err === "string") return err;
+	return String(err);
+}
+function resolveToolInputErrorStatus(err) {
+	if (err instanceof ToolInputError) {
+		const status = err.status;
+		return typeof status === "number" ? status : 400;
+	}
+	if (typeof err !== "object" || err === null || !("name" in err)) return null;
+	const name = err.name;
+	if (name !== "ToolInputError" && name !== "ToolAuthorizationError") return null;
+	const status = err.status;
+	if (typeof status === "number") return status;
+	return name === "ToolAuthorizationError" ? 403 : 400;
+}
+function resolveToolSource(tool) {
+	if (getPluginToolMeta(tool)) return "plugin";
+	if (getChannelAgentToolMeta(tool)) return "channel";
+	return "core";
+}
+async function invokeGatewayTool(params) {
+	const toolName = normalizeOptionalString(params.input.name ?? params.input.tool) ?? "";
+	if (!toolName) return {
+		ok: false,
+		status: 400,
+		toolName: "",
+		error: {
+			type: "invalid_request",
+			message: "tools.invoke requires name"
+		}
+	};
+	if (process.env.VITEST && MEMORY_TOOL_NAMES.has(toolName)) {
+		const reasons = resolveMemoryToolDisableReasons(params.cfg);
+		if (reasons.length > 0) return {
+			ok: false,
+			status: 400,
+			toolName,
+			error: {
+				type: "invalid_request",
+				message: `memory tools are disabled in tests${` (${reasons.join(", ")})`}. Enable by setting plugins.slots.memory="${defaultSlotIdForKey("memory")}" (and ensure plugins.enabled is not false).`
+			}
+		};
+	}
+	const knownCoreTool = isKnownCoreToolId(toolName);
+	const gatewayRequestedTools = knownCoreTool ? [] : [toolName];
+	const action = normalizeOptionalString(params.input.action);
+	const argsRaw = params.input.args;
+	const args = argsRaw && typeof argsRaw === "object" && !Array.isArray(argsRaw) ? argsRaw : {};
+	const sessionKey = resolveSessionKey({
+		cfg: params.cfg,
+		input: params.input
+	});
+	const resolveTools = (disablePluginTools) => resolveGatewayScopedTools({
+		cfg: params.cfg,
+		sessionKey,
+		messageProvider: params.messageChannel,
+		accountId: params.accountId,
+		agentTo: params.agentTo,
+		agentThreadId: params.agentThreadId,
+		senderIsOwner: params.senderIsOwner,
+		allowGatewaySubagentBinding: true,
+		allowMediaInvokeCommands: true,
+		surface: "http",
+		disablePluginTools,
+		gatewayRequestedTools
+	});
+	let { agentId, tools } = resolveTools(knownCoreTool);
+	if (knownCoreTool && !tools.some((candidate) => candidate.name === toolName)) ({agentId, tools} = resolveTools(false));
+	const requestedAgentId = normalizeOptionalString(params.input.agentId);
+	if (requestedAgentId && agentId && requestedAgentId !== agentId) return {
+		ok: false,
+		status: 400,
+		toolName,
+		error: {
+			type: "invalid_request",
+			message: `agent id "${requestedAgentId}" does not match session agent "${agentId}"`
+		}
+	};
+	const tool = tools.find((candidate) => candidate.name === toolName);
+	if (!tool) return {
+		ok: false,
+		status: 404,
+		toolName,
+		error: {
+			type: "not_found",
+			message: `Tool not available: ${toolName}`
+		}
+	};
+	try {
+		const gatewayTool = tool;
+		const idempotencyKey = normalizeOptionalString(params.input.idempotencyKey);
+		const toolCallId = idempotencyKey ? `${params.toolCallIdPrefix}-${idempotencyKey}` : `${params.toolCallIdPrefix}-${Date.now()}`;
+		const hookResult = await runBeforeToolCallHook({
+			toolName,
+			params: mergeActionIntoArgsIfSupported({
+				toolSchema: gatewayTool.parameters,
+				action,
+				args
+			}),
+			toolCallId,
+			ctx: {
+				agentId,
+				config: params.cfg,
+				sessionKey,
+				loopDetection: resolveToolLoopDetectionConfig({
+					cfg: params.cfg,
+					agentId
+				})
+			},
+			approvalMode: params.approvalMode
+		});
+		if (hookResult.blocked) return {
+			ok: false,
+			status: 403,
+			toolName,
+			error: {
+				type: "tool_call_blocked",
+				message: hookResult.reason,
+				requiresApproval: hookResult.deniedReason === "plugin-approval"
+			}
+		};
+		return {
+			ok: true,
+			status: 200,
+			toolName,
+			source: resolveToolSource(gatewayTool),
+			result: await gatewayTool.execute?.(toolCallId, hookResult.params)
+		};
+	} catch (err) {
+		const inputStatus = resolveToolInputErrorStatus(err);
+		if (inputStatus !== null) return {
+			ok: false,
+			status: inputStatus === 403 ? 403 : 400,
+			toolName,
+			error: {
+				type: "tool_error",
+				message: getErrorMessage(err) || "invalid tool arguments"
+			}
+		};
+		logWarn(`tools-invoke: tool execution failed: ${String(err)}`);
+		return {
+			ok: false,
+			status: 500,
+			toolName,
+			error: {
+				type: "tool_error",
+				message: "tool execution failed"
+			}
+		};
+	}
+}
+//#endregion
+export { invokeGatewayTool as t };

package/dist/tts-runtime-C1wu3o15.d.ts

@@ -0,0 +1,230 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { G as TtsModelOverrideConfig, H as TtsAutoMode, V as ResolvedTtsPersona, Y as TtsProvider } from "./types.slack-BO--YUFl.js";
+import { Oo as SpeechVoiceOption, ao as ResolvedTtsModelOverrides, io as ResolvedTtsConfig, ko as TtsDirectiveOverrides, mo as SpeechProviderConfig, oo as TtsConfigResolutionContext } from "./types-BQw1qXGl.js";
+import { r as ReplyPayload } from "./reply-payload-mCw4ZND6.js";
+import { n as summarizeText } from "./speech-core-wWkTZPpQ.js";
+import { o as parseTtsDirectives } from "./provider-registry-i--H79Ao.js";
+
+//#region packages/speech-core/src/tts.d.ts
+type TtsAttemptReasonCode = "success" | "no_provider_registered" | "not_configured" | "unsupported_for_streaming" | "unsupported_for_telephony" | "timeout" | "provider_error";
+type TtsProviderAttempt = {
+  provider: string;
+  outcome: "success" | "skipped" | "failed";
+  reasonCode: TtsAttemptReasonCode;
+  persona?: string;
+  personaBinding?: "applied" | "missing" | "none";
+  latencyMs?: number;
+  error?: string;
+};
+type TtsResult = {
+  success: boolean;
+  audioPath?: string;
+  error?: string;
+  latencyMs?: number;
+  provider?: string;
+  persona?: string;
+  fallbackFrom?: string;
+  attemptedProviders?: string[];
+  attempts?: TtsProviderAttempt[];
+  outputFormat?: string;
+  voiceCompatible?: boolean;
+  audioAsVoice?: boolean;
+  target?: "audio-file" | "voice-note";
+};
+type TtsSynthesisResult = {
+  success: boolean;
+  audioBuffer?: Buffer;
+  error?: string;
+  latencyMs?: number;
+  provider?: string;
+  providerModel?: string;
+  providerVoice?: string;
+  persona?: string;
+  fallbackFrom?: string;
+  attemptedProviders?: string[];
+  attempts?: TtsProviderAttempt[];
+  outputFormat?: string;
+  voiceCompatible?: boolean;
+  fileExtension?: string;
+  target?: "audio-file" | "voice-note";
+};
+type TtsStreamResult = {
+  success: boolean;
+  audioStream?: ReadableStream<Uint8Array>;
+  error?: string;
+  latencyMs?: number;
+  provider?: string;
+  providerModel?: string;
+  providerVoice?: string;
+  persona?: string;
+  fallbackFrom?: string;
+  attemptedProviders?: string[];
+  attempts?: TtsProviderAttempt[];
+  outputFormat?: string;
+  voiceCompatible?: boolean;
+  fileExtension?: string;
+  target?: "audio-file" | "voice-note";
+  release?: () => Promise<void>;
+};
+type TtsSynthesisStreamResult = TtsStreamResult;
+type TtsTelephonyResult = {
+  success: boolean;
+  audioBuffer?: Buffer;
+  error?: string;
+  latencyMs?: number;
+  provider?: string;
+  providerModel?: string;
+  providerVoice?: string;
+  persona?: string;
+  fallbackFrom?: string;
+  attemptedProviders?: string[];
+  attempts?: TtsProviderAttempt[];
+  outputFormat?: string;
+  sampleRate?: number;
+};
+type TtsStatusEntry = {
+  timestamp: number;
+  success: boolean;
+  textLength: number;
+  summarized: boolean;
+  provider?: string;
+  persona?: string;
+  fallbackFrom?: string;
+  attemptedProviders?: string[];
+  attempts?: TtsProviderAttempt[];
+  latencyMs?: number;
+  error?: string;
+};
+declare function resolveModelOverridePolicy(overrides: TtsModelOverrideConfig | undefined): ResolvedTtsModelOverrides;
+declare function getResolvedSpeechProviderConfig(config: ResolvedTtsConfig, providerId: string, cfg?: FengMingConfig): SpeechProviderConfig;
+declare function resolveTtsConfig(cfg: FengMingConfig, contextOrAgentId?: string | TtsConfigResolutionContext): ResolvedTtsConfig;
+declare function resolveTtsPrefsPath(config: ResolvedTtsConfig): string;
+declare function resolveTtsAutoMode(params: {
+  config: ResolvedTtsConfig;
+  prefsPath: string;
+  sessionAuto?: string;
+}): TtsAutoMode;
+declare function buildTtsSystemPromptHint(cfg: FengMingConfig, agentId?: string): string | undefined;
+declare function isTtsEnabled(config: ResolvedTtsConfig, prefsPath: string, sessionAuto?: string): boolean;
+declare function setTtsAutoMode(prefsPath: string, mode: TtsAutoMode): void;
+declare function setTtsEnabled(prefsPath: string, enabled: boolean): void;
+declare function getTtsProvider(config: ResolvedTtsConfig, prefsPath: string): TtsProvider;
+declare function getTtsPersona(config: ResolvedTtsConfig, prefsPath: string): ResolvedTtsPersona | undefined;
+declare function listTtsPersonas(config: ResolvedTtsConfig): ResolvedTtsPersona[];
+declare function setTtsPersona(prefsPath: string, persona: string | null | undefined): void;
+declare function setTtsProvider(prefsPath: string, provider: TtsProvider): void;
+declare function resolveExplicitTtsOverrides(params: {
+  cfg: FengMingConfig;
+  prefsPath?: string;
+  provider?: string;
+  modelId?: string;
+  voiceId?: string;
+  agentId?: string;
+  channelId?: string;
+  accountId?: string;
+}): TtsDirectiveOverrides;
+declare function getTtsMaxLength(prefsPath: string): number;
+declare function setTtsMaxLength(prefsPath: string, maxLength: number): void;
+declare function isSummarizationEnabled(prefsPath: string): boolean;
+declare function setSummarizationEnabled(prefsPath: string, enabled: boolean): void;
+declare function getLastTtsAttempt(): TtsStatusEntry | undefined;
+declare function setLastTtsAttempt(entry: TtsStatusEntry | undefined): void;
+declare function supportsNativeVoiceNoteTts(channel: string | undefined): boolean;
+declare function supportsTranscodedVoiceNoteTts(channel: string | undefined): boolean;
+declare function resolveTtsSynthesisTarget(channel: string | undefined): "audio-file" | "voice-note";
+declare function shouldDeliverTtsAsVoice(params: {
+  channel: string | undefined;
+  target: "audio-file" | "voice-note" | undefined;
+  voiceCompatible: boolean | undefined;
+  fileExtension?: string;
+  outputFormat?: string;
+}): boolean;
+declare function resolveTtsProviderOrder(primary: TtsProvider, cfg?: FengMingConfig): TtsProvider[];
+declare function isTtsProviderConfigured(config: ResolvedTtsConfig, provider: TtsProvider, cfg?: FengMingConfig): boolean;
+declare function formatTtsProviderError(provider: TtsProvider, err: unknown): string;
+declare function sanitizeTtsErrorForLog(err: unknown): string;
+declare function textToSpeech(params: {
+  text: string;
+  cfg: FengMingConfig;
+  prefsPath?: string;
+  channel?: string;
+  overrides?: TtsDirectiveOverrides;
+  disableFallback?: boolean;
+  timeoutMs?: number;
+  agentId?: string;
+  accountId?: string;
+}): Promise<TtsResult>;
+declare function synthesizeSpeech(params: {
+  text: string;
+  cfg: FengMingConfig;
+  prefsPath?: string;
+  channel?: string;
+  overrides?: TtsDirectiveOverrides;
+  disableFallback?: boolean;
+  timeoutMs?: number;
+  agentId?: string;
+  accountId?: string;
+}): Promise<TtsSynthesisResult>;
+declare function streamSpeech(params: {
+  text: string;
+  cfg: FengMingConfig;
+  prefsPath?: string;
+  channel?: string;
+  overrides?: TtsDirectiveOverrides;
+  disableFallback?: boolean;
+  timeoutMs?: number;
+  agentId?: string;
+  accountId?: string;
+}): Promise<TtsSynthesisStreamResult>;
+declare function textToSpeechStream(params: {
+  text: string;
+  cfg: FengMingConfig;
+  prefsPath?: string;
+  channel?: string;
+  overrides?: TtsDirectiveOverrides;
+  disableFallback?: boolean;
+  timeoutMs?: number;
+  agentId?: string;
+  accountId?: string;
+}): Promise<TtsStreamResult>;
+declare function textToSpeechTelephony(params: {
+  text: string;
+  cfg: FengMingConfig;
+  prefsPath?: string;
+  overrides?: TtsDirectiveOverrides;
+  timeoutMs?: number;
+}): Promise<TtsTelephonyResult>;
+declare function listSpeechVoices(params: {
+  provider: string;
+  cfg?: FengMingConfig;
+  config?: ResolvedTtsConfig;
+  apiKey?: string;
+  baseUrl?: string;
+}): Promise<SpeechVoiceOption[]>;
+declare function maybeApplyTtsToPayload(params: {
+  payload: ReplyPayload;
+  cfg: FengMingConfig;
+  channel?: string;
+  kind?: "tool" | "block" | "final";
+  inboundAudio?: boolean;
+  ttsAuto?: string;
+  agentId?: string;
+  accountId?: string;
+}): Promise<ReplyPayload>;
+declare const testApi: {
+  parseTtsDirectives: typeof parseTtsDirectives;
+  resolveModelOverridePolicy: typeof resolveModelOverridePolicy;
+  supportsNativeVoiceNoteTts: typeof supportsNativeVoiceNoteTts;
+  supportsTranscodedVoiceNoteTts: typeof supportsTranscodedVoiceNoteTts;
+  resolveTtsSynthesisTarget: typeof resolveTtsSynthesisTarget;
+  shouldDeliverTtsAsVoice: typeof shouldDeliverTtsAsVoice;
+  summarizeText: typeof summarizeText;
+  getResolvedSpeechProviderConfig: typeof getResolvedSpeechProviderConfig;
+  formatTtsProviderError: typeof formatTtsProviderError;
+  sanitizeTtsErrorForLog: typeof sanitizeTtsErrorForLog;
+};
+//#endregion
+//#region src/plugin-sdk/tts-runtime.d.ts
+declare function prewarmTtsRuntimeFacade(): void;
+//#endregion
+export { setTtsProvider as A, resolveTtsProviderOrder as C, setTtsEnabled as D, setTtsAutoMode as E, textToSpeechStream as F, textToSpeechTelephony as I, synthesizeSpeech as M, testApi as N, setTtsMaxLength as O, textToSpeech as P, resolveTtsPrefsPath as S, setSummarizationEnabled as T, listTtsPersonas as _, TtsSynthesisStreamResult as a, resolveTtsAutoMode as b, getLastTtsAttempt as c, getTtsPersona as d, getTtsProvider as f, listSpeechVoices as g, isTtsProviderConfigured as h, TtsSynthesisResult as i, streamSpeech as j, setTtsPersona as k, getResolvedSpeechProviderConfig as l, isTtsEnabled as m, TtsResult as n, TtsTelephonyResult as o, isSummarizationEnabled as p, TtsStreamResult as r, buildTtsSystemPromptHint as s, prewarmTtsRuntimeFacade as t, getTtsMaxLength as u, maybeApplyTtsToPayload as v, setLastTtsAttempt as w, resolveTtsConfig as x, resolveExplicitTtsOverrides as y };

package/dist/tui-C733Qov0.js

@@ -0,0 +1,2 @@
+import "./tui-ink-run-ChXEGj1h.js";
+export {};

package/dist/tui-DqbscVN5.js

@@ -0,0 +1,3 @@
+import { g as runTuiInk } from "./tui-ink-run-ChXEGj1h.js";
+import "./tui-C733Qov0.js";
+export { runTuiInk as runTui };

package/dist/tui-backend-_Pn3Byj-.js

@@ -0,0 +1,257 @@
+import { r as buildAgentMainSessionKey } from "./session-key-CJf5_zWs.js";
+import { i as isPersistentCrestodianOperation, n as executeCrestodianOperation } from "./operations-Z85LFqsT.js";
+import { n as formatCrestodianStartupMessage, r as loadCrestodianOverview } from "./overview-6BeqbKXR.js";
+import { n as isYes, r as resolveCrestodianOperation, t as approvalQuestion } from "./dialogue-No0NvYX7.js";
+import { g as runTuiInk } from "./tui-ink-run-ChXEGj1h.js";
+import "./tui-C733Qov0.js";
+import { randomUUID } from "node:crypto";
+//#region src/crestodian/tui-backend.ts
+const CRESTODIAN_AGENT_ID = "crestodian";
+const CRESTODIAN_SESSION_KEY = buildAgentMainSessionKey({ agentId: CRESTODIAN_AGENT_ID });
+function createCaptureRuntime() {
+	const lines = [];
+	return {
+		log: (...args) => lines.push(args.join(" ")),
+		error: (...args) => lines.push(args.join(" ")),
+		exit: (code) => {
+			throw new Error(`Crestodian operation exited with code ${String(code)}`);
+		},
+		read: () => lines.join("\n").trim()
+	};
+}
+async function loadOverviewForTui(opts) {
+	if (opts.deps?.loadOverview) return await opts.deps.loadOverview();
+	return await loadCrestodianOverview();
+}
+function message(role, text) {
+	return {
+		role,
+		content: [{
+			type: "text",
+			text
+		}],
+		timestamp: Date.now()
+	};
+}
+function splitModelRef(ref) {
+	const trimmed = ref?.trim();
+	if (!trimmed) return {};
+	const slash = trimmed.indexOf("/");
+	if (slash <= 0 || slash >= trimmed.length - 1) return { model: trimmed };
+	return {
+		provider: trimmed.slice(0, slash),
+		model: trimmed.slice(slash + 1)
+	};
+}
+var CrestodianTuiBackend = class {
+	constructor(opts, welcome) {
+		this.opts = opts;
+		this.connection = { url: "crestodian local" };
+		this.seq = 0;
+		this.pending = null;
+		this.handoff = null;
+		this.requestExit = null;
+		this.messages = [];
+		this.messages.push(message("assistant", welcome));
+	}
+	setRequestExitHandler(handler) {
+		this.requestExit = handler;
+	}
+	consumeHandoff() {
+		const handoff = this.handoff;
+		this.handoff = null;
+		return handoff;
+	}
+	start() {
+		queueMicrotask(() => {
+			this.onConnected?.();
+		});
+	}
+	stop() {}
+	async sendChat(opts) {
+		const runId = opts.runId ?? randomUUID();
+		const text = opts.message.trim();
+		this.messages.push(message("user", opts.message));
+		this.respond(runId, opts.sessionKey, text);
+		return { runId };
+	}
+	async abortChat() {
+		return {
+			ok: true,
+			aborted: false
+		};
+	}
+	async loadHistory() {
+		return {
+			sessionId: "crestodian",
+			messages: this.messages,
+			thinkingLevel: "off",
+			verboseLevel: "off"
+		};
+	}
+	async listSessions() {
+		const model = splitModelRef((await loadOverviewForTui(this.opts)).defaultModel);
+		return {
+			ts: Date.now(),
+			path: "crestodian",
+			count: 1,
+			defaults: {
+				model: model.model ?? null,
+				modelProvider: model.provider ?? null,
+				contextTokens: null
+			},
+			sessions: [{
+				key: CRESTODIAN_SESSION_KEY,
+				sessionId: "crestodian",
+				displayName: "Crestodian",
+				updatedAt: Date.now(),
+				thinkingLevel: "off",
+				verboseLevel: "off",
+				model: model.model,
+				modelProvider: model.provider
+			}]
+		};
+	}
+	async listAgents() {
+		return {
+			defaultId: CRESTODIAN_AGENT_ID,
+			mainKey: "main",
+			scope: "per-sender",
+			agents: [{
+				id: CRESTODIAN_AGENT_ID,
+				name: "Crestodian"
+			}]
+		};
+	}
+	async patchSession(opts) {
+		const model = splitModelRef(typeof opts.model === "string" ? opts.model : void 0);
+		return {
+			ok: true,
+			path: "crestodian",
+			key: CRESTODIAN_SESSION_KEY,
+			entry: {
+				sessionId: "crestodian",
+				displayName: "Crestodian",
+				updatedAt: Date.now(),
+				...model.model ? { model: model.model } : {},
+				...model.provider ? { modelProvider: model.provider } : {}
+			},
+			resolved: {
+				modelProvider: model.provider,
+				model: model.model
+			}
+		};
+	}
+	async resetSession() {
+		this.pending = null;
+		const overview = await loadOverviewForTui(this.opts);
+		this.messages.splice(0, this.messages.length, message("assistant", formatCrestodianStartupMessage(overview)));
+		return { ok: true };
+	}
+	async getGatewayStatus() {
+		return (await loadOverviewForTui(this.opts)).gateway.reachable ? "Gateway reachable" : "Gateway unreachable";
+	}
+	async listModels() {
+		return [];
+	}
+	nextSeq() {
+		this.seq += 1;
+		return this.seq;
+	}
+	emit(event, payload) {
+		this.onEvent?.({
+			event,
+			payload,
+			seq: this.nextSeq()
+		});
+	}
+	emitFinal(runId, sessionKey, text) {
+		const assistant = message("assistant", text || "Crestodian listened and found nothing to change.");
+		this.messages.push(assistant);
+		this.emit("chat", {
+			runId,
+			sessionKey,
+			state: "final",
+			message: assistant
+		});
+	}
+	emitError(runId, sessionKey, error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		this.emit("chat", {
+			runId,
+			sessionKey,
+			state: "error",
+			errorMessage
+		});
+	}
+	async respond(runId, sessionKey, text) {
+		try {
+			const reply = await this.resolveReply(text);
+			this.emitFinal(runId, sessionKey, reply);
+		} catch (error) {
+			this.emitError(runId, sessionKey, error);
+		}
+	}
+	async resolveReply(text) {
+		if (this.pending) {
+			if (isYes(text)) {
+				const pending = this.pending;
+				this.pending = null;
+				const capture = createCaptureRuntime();
+				await executeCrestodianOperation(pending, capture, {
+					approved: true,
+					deps: this.opts.deps
+				});
+				return capture.read() || "Applied. Audit entry written.";
+			}
+			this.pending = null;
+			return "Skipped. No barnacles on config today.";
+		}
+		const capture = createCaptureRuntime();
+		const operation = await resolveCrestodianOperation(text, capture, this.opts);
+		if (operation.kind === "open-tui") {
+			this.handoff = operation;
+			queueMicrotask(() => this.requestExit?.());
+			return "Opening your normal agent TUI. Use /crestodian there to come back.";
+		}
+		if (isPersistentCrestodianOperation(operation) && !this.opts.yes) {
+			this.pending = operation;
+			await executeCrestodianOperation(operation, capture, {
+				approved: false,
+				deps: this.opts.deps
+			});
+			return [capture.read(), approvalQuestion(operation)].filter(Boolean).join("\n\n");
+		}
+		await executeCrestodianOperation(operation, capture, {
+			approved: this.opts.yes === true || !isPersistentCrestodianOperation(operation),
+			deps: this.opts.deps
+		});
+		const reply = capture.read();
+		if (operation.kind === "none" && reply.includes("Bye.")) queueMicrotask(() => this.requestExit?.());
+		return reply;
+	}
+};
+async function runCrestodianTui(opts, runtime) {
+	let nextInput;
+	for (;;) {
+		const backend = new CrestodianTuiBackend(opts, formatCrestodianStartupMessage(await loadOverviewForTui(opts)));
+		await (opts.runTui ?? runTuiInk)({
+			local: true,
+			session: CRESTODIAN_SESSION_KEY,
+			historyLimit: 200,
+			backend,
+			config: {},
+			title: "fengming crestodian",
+			...nextInput ? { message: nextInput } : {}
+		});
+		const handoff = backend.consumeHandoff();
+		if (!handoff) return;
+		nextInput = (await executeCrestodianOperation(handoff, runtime, {
+			approved: true,
+			deps: opts.deps
+		})).nextInput;
+		if (!nextInput?.trim()) return;
+	}
+}
+//#endregion
+export { runCrestodianTui };