@agentconnect.md/daemon 1.0.0-rc.96 → 1.0.0-rc.98

package/dist/index.js

@@ -7688,6 +7688,7 @@ const AgentSchema = object({
 	description: string().optional(),
 	reasoningEffort: string().optional(),
 	executionMode: string().optional(),
+	fastMode: boolean().optional(),
 	runtimeOverrides: object({
 		model: string().optional(),
 		env: array(object({
@@ -13030,6 +13031,12 @@ const AgentSpec = object({
 	model: string().optional(),
 	reasoningEffort: string().optional(),
 	executionMode: string().optional(),
+	outputMode: _enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	fastMode: boolean().optional(),
 	workspace: AgentWorkspace.optional(),
 	env: record(string(), string()).optional()
 });
@@ -18055,21 +18062,32 @@ function planConfigSelection(configOptions, category, desired) {
 		value: desired
 	};
 }
-/** The claude-acp session `_meta` that turns ultracode on, or undefined when the
-*  desired effort isn't ultracode or the runtime isn't Claude. ultracode is a
-*  session-scoped flag setting the wrapper reads from
-*  `_meta.claudeCode.options.settings` (spread into the SDK `query()` flag-settings
-*  layer) on session/new and session/load — the effort select can't reach it.
-*  `enableWorkflows` rides along so the "pro" plan default (workflows off) doesn't
-*  silently drop the orchestration half. Best-effort: on a non-xhigh-capable model
-*  or with workflows unavailable the runtime reports `applied.ultracode=false` and
-*  the session still runs on its default effort — nothing to fail on our side. */
-function ultracodeMeta(reasoningEffort, isClaudeRuntime) {
-	if (!isClaudeRuntime || reasoningEffort !== "ultracode") return void 0;
-	return { claudeCode: { options: { settings: {
-		ultracode: true,
-		enableWorkflows: true
-	} } } };
+/** The session `_meta` sent to a Claude runtime on session/new and session/load
+*  (`_meta.claudeCode.options` is spread into the SDK `query()` options layer), or
+*  undefined off Claude runtimes. Two things ride on it:
+*
+*  - `thinking`: recent models default `thinking.display` to "omitted" — thinking
+*    blocks stream signature-only with empty text, so the ACP wrapper never emits
+*    `agent_thought_chunk` and the transcript loses its reasoning rows. Request
+*    "summarized" (the fullest display the API offers) so thoughts reach the stream.
+*  - `settings.ultracode` (effort "ultracode" only): a session-scoped flag setting
+*    the effort select can't reach — the runtime rejects effort="ultracode".
+*    `enableWorkflows` rides along so the "pro" plan default (workflows off) doesn't
+*    silently drop the orchestration half. Best-effort: on a non-xhigh-capable model
+*    or with workflows unavailable the runtime reports `applied.ultracode=false` and
+*    the session still runs on its default effort — nothing to fail on our side. */
+function claudeSessionMeta(reasoningEffort, isClaudeRuntime) {
+	if (!isClaudeRuntime) return void 0;
+	return { claudeCode: { options: {
+		thinking: {
+			type: "adaptive",
+			display: "summarized"
+		},
+		...reasoningEffort === "ultracode" ? { settings: {
+			ultracode: true,
+			enableWorkflows: true
+		} } : {}
+	} } };
 }
 /**
 * Extract the model selector from a session's `configOptions`. ACP models are an
@@ -18160,7 +18178,7 @@ var AcpHost = class {
 		return Boolean(this.promptCaps[kind]);
 	}
 	async newSession(cwd, mcpServers = []) {
-		const _meta = ultracodeMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
+		const _meta = claudeSessionMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
 		const res = await this.conn.agent.request(methods.agent.session.new, {
 			cwd,
 			mcpServers,
@@ -18172,17 +18190,23 @@ var AcpHost = class {
 		return res.sessionId;
 	}
 	/**
-	* Apply the desired model / reasoning effort to a fresh session via ACP
-	* `session/set_config_option`. Model first — the effort vocabulary depends on
-	* the selected model, and each response returns the reconciled option set the
-	* next step plans against. Best-effort by design: a runtime without the
-	* selector, an unoffered value, or a failed request logs and moves on — the
-	* session still runs on the runtime's defaults. Returns the final option set.
+	* Apply the desired model / reasoning effort / fast mode to a fresh session
+	* via ACP `session/set_config_option`. Model first — the effort and fast-mode
+	* vocabularies depend on the selected model, and each response returns the
+	* reconciled option set the next step plans against. Best-effort by design: a
+	* runtime without the selector, an unoffered value, or a failed request logs
+	* and moves on — the session still runs on the runtime's defaults. Returns the
+	* final option set.
 	*/
 	async applySessionConfig(sessionId, initial) {
 		let options = initial;
-		const ultracode = ultracodeMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime()) !== void 0;
-		const prefs = [["model", this.opts.configPrefs?.model], ["thought_level", ultracode ? void 0 : this.opts.configPrefs?.reasoningEffort]];
+		const ultracode = this.isClaudeRuntime() && this.opts.configPrefs?.reasoningEffort === "ultracode";
+		const fastMode = this.opts.configPrefs?.fastMode;
+		const prefs = [
+			["model", this.opts.configPrefs?.model],
+			["thought_level", ultracode ? void 0 : this.opts.configPrefs?.reasoningEffort],
+			["model_config", fastMode === void 0 ? void 0 : fastMode ? "on" : "off"]
+		];
 		for (const [category, desired] of prefs) {
 			if (!desired) continue;
 			const plan = planConfigSelection(options, category, desired);
@@ -18228,7 +18252,7 @@ var AcpHost = class {
 	async loadSession(sessionId, cwd) {
 		this.loadingSessions.add(sessionId);
 		try {
-			const _meta = ultracodeMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
+			const _meta = claudeSessionMeta(this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime());
 			const res = await this.conn.agent.request(methods.agent.session.load, {
 				sessionId,
 				cwd,
@@ -18321,7 +18345,8 @@ async function runChat(opts) {
 		env: agentChildEnv(agent),
 		configPrefs: {
 			model: agent.runtimeOverrides?.model,
-			reasoningEffort: agent.reasoningEffort
+			reasoningEffort: agent.reasoningEffort,
+			fastMode: agent.fastMode
 		}
 	});
 	await host.start();
@@ -23924,7 +23949,7 @@ function signature(a) {
 /** Sub-signature over the dimensions that determine the ACP host subprocess —
 *  the spawn binary (`runtime`) and the knobs baked into the host at construction:
 *  child env / system-prompt seed (agentChildEnv + cpRuntimeEnv) and the session
-*  config prefs (model / reasoningEffort, applied per session via ACP
+*  config prefs (model / reasoningEffort / fastMode, applied per session via ACP
 *  set_config_option). A change here means the cached host must be evicted so
 *  the next session respawns it fresh. */
 function hostSpawnSig(a) {
@@ -23934,6 +23959,7 @@ function hostSpawnSig(a) {
 		description: a.description,
 		reasoningEffort: a.reasoningEffort,
 		executionMode: a.executionMode,
+		fastMode: a.fastMode,
 		env: a.runtimeOverrides?.env
 	});
 }
@@ -23995,7 +24021,7 @@ var LocalStore = class {
       CREATE TABLE IF NOT EXISTS sessions (
         key TEXT PRIMARY KEY, agentId TEXT, platform TEXT, channel TEXT, thread TEXT,
         acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER,
-        usage TEXT, muted INTEGER, triggeredBy TEXT
+        usage TEXT, muted INTEGER, triggeredBy TEXT, title TEXT
       );
       -- Platform id → human display name (Slack channel/user names, daemon-resolved
       -- and cached here so session read-back can label ids without a Slack call).
@@ -24041,14 +24067,16 @@ var LocalStore = class {
          ON transcript (channel, thread, tool_call_id) WHERE tool_call_id IS NOT NULL`);
 	}
 	/** Add the `sessions.usage` (JSON token accounting), `sessions.muted` (`!stop`
-	*  thread mute) and `sessions.triggeredBy` columns to a pre-existing DB. CREATE
-	*  TABLE IF NOT EXISTS above adds them for fresh DBs but never alters an existing
-	*  table, so upgrade in place. No-op once the columns are present. */
+	*  thread mute), `sessions.triggeredBy` and `sessions.title` columns to a
+	*  pre-existing DB. CREATE TABLE IF NOT EXISTS above adds them for fresh DBs but
+	*  never alters an existing table, so upgrade in place. No-op once the columns
+	*  are present. */
 	migrateSessionUsage() {
 		const cols = this.db.prepare("PRAGMA table_info(sessions)").all();
 		if (!cols.some((c) => c.name === "usage")) this.db.exec("ALTER TABLE sessions ADD COLUMN usage TEXT");
 		if (!cols.some((c) => c.name === "muted")) this.db.exec("ALTER TABLE sessions ADD COLUMN muted INTEGER");
 		if (!cols.some((c) => c.name === "triggeredBy")) this.db.exec("ALTER TABLE sessions ADD COLUMN triggeredBy TEXT");
+		if (!cols.some((c) => c.name === "title")) this.db.exec("ALTER TABLE sessions ADD COLUMN title TEXT");
 	}
 	/**
 	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
@@ -24128,6 +24156,11 @@ var LocalStore = class {
 	setSessionMuted(key, muted) {
 		this.db.prepare("UPDATE sessions SET muted = ? WHERE key = ?").run(muted ? 1 : 0, key);
 	}
+	/** Human-facing session title from the runtime's `session_info_update` (latest
+	*  wins; null clears per ACP semantics). No-op on an unknown key. */
+	setSessionTitle(key, title) {
+		this.db.prepare("UPDATE sessions SET title = ? WHERE key = ?").run(title, key);
+	}
 	isSessionMuted(key) {
 		return this.db.prepare("SELECT muted FROM sessions WHERE key = ?").get(key)?.muted === 1;
 	}
@@ -83276,6 +83309,7 @@ function createSessionReader(store) {
 					status: r.state,
 					lastActivityAt: new Date(r.updatedAt).toISOString(),
 					...usage ? { usage } : {},
+					...r.title ? { title: r.title } : {},
 					...r.triggeredBy ? { triggeredBy: r.triggeredBy } : {},
 					...channelName ? { channelName } : {},
 					...triggeredByName ? { triggeredByName } : {}
@@ -83527,8 +83561,10 @@ async function fetchHeadMtime(root) {
 * `workspace.path` rewritten to an absolute path. Editing the raw file preserves
 * `${VAR}` templates and the original relative `workspace.path`.
 *
-* Locally-owned keys (id, status, runtime, integrations, output, permissions,
-* crons, workspace.path / pullOnNewSession / skills) are preserved untouched.
+* Locally-owned keys (id, status, runtime, integrations, permissions, crons,
+* workspace.path / pullOnNewSession / skills) are preserved untouched.
+* `output.mode` is CP-owned when the spec carries `outputMode` (a spec without
+* it leaves the local value alone — hand-authored agent.json keeps working).
 */
 /** Map a CP workspace mode onto the daemon's AgentSchema workspace mode. */
 function mapWorkspaceMode(mode) {
@@ -83556,6 +83592,12 @@ function applySpecFields(raw, spec, opts) {
 	if (spec.description !== void 0) raw.description = spec.description;
 	if (spec.reasoningEffort !== void 0) raw.reasoningEffort = spec.reasoningEffort;
 	if (spec.executionMode !== void 0) raw.executionMode = spec.executionMode;
+	if (spec.fastMode !== void 0) raw.fastMode = spec.fastMode;
+	if (spec.outputMode !== void 0) {
+		const out = typeof raw.output === "object" && raw.output !== null ? raw.output : {};
+		out.mode = spec.outputMode;
+		raw.output = out;
+	}
 	if (spec.model !== void 0 || spec.env !== void 0) {
 		const ro = typeof raw.runtimeOverrides === "object" && raw.runtimeOverrides !== null ? raw.runtimeOverrides : {};
 		if (spec.model !== void 0) ro.model = spec.model;
@@ -84414,7 +84456,8 @@ var Daemon = class Daemon {
 				},
 				configPrefs: {
 					model: agent.runtimeOverrides?.model,
-					reasoningEffort: agent.reasoningEffort
+					reasoningEffort: agent.reasoningEffort,
+					fastMode: agent.fastMode
 				},
 				log: this.log
 			});
@@ -84781,6 +84824,7 @@ var Daemon = class Daemon {
 			costAmount: update.cost?.amount ?? void 0,
 			costCurrency: update.cost?.currency ?? void 0
 		});
+		if (update?.sessionUpdate === "session_info_update" && update.title !== void 0) this.store.setSessionTitle(p.sessionKey, update.title);
 		for (const action of p.conv.onUpdate(update)) this.enqueueApply(p, action);
 		this.armIdle(p);
 		for (const ev of p.rec.onUpdate(update)) this.recordEvent(p.agentId, p.channel, p.statusThread, ev);