dsh-web-search-enhanced 0.2.1 → 0.2.2

package/lib/index.js

@@ -14680,7 +14680,8 @@ const SEARCH = {
 	tools: {
 		action: "web_search_enhanced",
 		list: "list_web_search_providers"
-	}
+	},
+	command: "setup-search"
 };
 //#endregion
 //#region ../core/src/shared/route.ts
@@ -14952,8 +14953,6 @@ async function runOnProvider(voice, access, connectionId, request, call, unhinte
 /** The recipient `sendsTo` names for fetch `local`; the text says `fetches from this machine`. */
 const THIS_MACHINE = "this machine";
 const SESSION_MODEL = "the service behind the session model";
-/** Operator data in the listing is one line and bounded; labels and service names share the settings label bound. */
-const LABEL_MAX = 200;
 const HOST_MAX = 253;
 /** Why the session model cannot search, in English; the execution layer's error and the listing share it. */
 const UNSUPPORTED_REASON_TEXT = {
@@ -15084,7 +15083,7 @@ function renderSearchListing(voice, value) {
 }
 function renderLines(voice, value, head, parts) {
 	const entries = value.providers.map((entry) => {
-		const line = [statusText(entry)];
+		const line = [statusText$1(entry)];
 		if (entry.id === value.sessionProvider) line.push("selected for this session");
 		if (entry.use !== void 0) line.push(entry.use);
 		line.push(...parts.marks(entry));
@@ -15100,7 +15099,7 @@ function renderLines(voice, value, head, parts) {
 		...tail
 	].join("\n");
 }
-function statusText(entry) {
+function statusText$1(entry) {
 	switch (entry.status) {
 		case "ready": return "ready";
 		case "needs-key": return "needs an API key (ask the user)";
@@ -15118,7 +15117,7 @@ function listedBase(entry) {
 	const { use, recipient } = entry.facts;
 	return {
 		id: entry.id,
-		name: oneLine(entry.name, LABEL_MAX),
+		name: oneLine(entry.name, 200),
 		...use === void 0 ? {} : { use },
 		sendsTo: recipientText(recipient)
 	};
@@ -15126,8 +15125,8 @@ function listedBase(entry) {
 function recipientText(recipient) {
 	switch (recipient.kind) {
 		case "this-machine": return THIS_MACHINE;
-		case "session-model": return recipient.provider === void 0 ? SESSION_MODEL : `${SESSION_MODEL} (${oneLine(recipient.provider, LABEL_MAX)})`;
-		case "service": return recipient.host === void 0 ? oneLine(recipient.service, LABEL_MAX) : oneLine(recipient.host, HOST_MAX);
+		case "session-model": return recipient.provider === void 0 ? SESSION_MODEL : `${SESSION_MODEL} (${oneLine(recipient.provider, 200)})`;
+		case "service": return recipient.host === void 0 ? oneLine(recipient.service, 200) : oneLine(recipient.host, HOST_MAX);
 	}
 }
 function readiness(entry) {
@@ -15214,8 +15213,8 @@ function nativeAuth(ctx, ref, secrets = /* @__PURE__ */ new Set()) {
 	};
 }
 /** Account readiness uses the next selected model, while request authentication uses its frozen route. */
-async function credentialReadiness(ctx, agent, options) {
-	const account = options.endpoint !== void 0 && nextModel(ctx, agent)?.provider === "deepseek-account" ? ctx.get("deepseekAccount") : void 0;
+async function credentialReadiness(ctx, model, options) {
+	const account = options.endpoint !== void 0 && model?.provider === "deepseek-account" ? ctx.get("deepseekAccount") : void 0;
 	if (account !== void 0 && await account.resolveToken(options.endpoint) !== void 0) return {
 		access: "account",
 		status: "ready"
@@ -15311,10 +15310,32 @@ var Snapshots = class {
 	}
 };
 //#endregion
+//#region ../core/src/host/session-origin.ts
+function sessionOrigin(header) {
+	const { parentSession: parent, isSeeded: seeded, origin } = header;
+	if (origin === "subagent") return {
+		kind: "subagent",
+		parent,
+		seeded
+	};
+	return parent === void 0 ? {
+		kind: "top-level",
+		seeded
+	} : {
+		kind: "fork",
+		parent,
+		seeded
+	};
+}
+function parentOf(origin) {
+	return origin.kind === "top-level" ? void 0 : origin.parent;
+}
+//#endregion
 //#region ../core/src/host/provider-lists.ts
 /** Live setup/created events do not make a new conversation a restored one. */
 function isNewConversation(session) {
-	return session.header.parentSession === void 0 && !session.header.isSeeded && session.firstLiveSeq === 0 && session.firstLifecycleSeq === 0;
+	const origin = sessionOrigin(session.header);
+	return parentOf(origin) === void 0 && !origin.seeded && session.firstLiveSeq === 0 && session.firstLifecycleSeq === 0;
 }
 /** Immutable conversation authorization, sharing the selection queue and storage lifetime. */
 var ProviderLists = class {
@@ -15333,7 +15354,7 @@ var ProviderLists = class {
 			const table = (await this.storage.domain()).table("provider_lists");
 			const stored = table.get(agent.session.id);
 			if (stored !== void 0) return this.nonempty(stored);
-			const parent = agent.session.header.parentSession;
+			const parent = parentOf(sessionOrigin(agent.session.header));
 			let ids;
 			if (parent !== void 0) {
 				await this.storage.settled(parent);
@@ -15356,6 +15377,14 @@ function isSelectable(connection) {
 }
 //#endregion
 //#region ../core/src/host/sessions.ts
+function liveSession(agent) {
+	return {
+		kind: "live",
+		id: agent.session.id,
+		header: agent.session.header,
+		agent
+	};
+}
 var SelectionConflict = class extends Error {
 	constructor() {
 		super("the selection changed since it was read");
@@ -15376,20 +15405,20 @@ var Sessions = class {
 		this.restriction = restriction;
 		this.describe = describe;
 	}
-	current(agent) {
-		return this.exclusive(agent.session.id, async () => this.read(agent, await this.table()));
+	current(target) {
+		return this.exclusive(target.id, async () => this.read(target, await this.table()));
 	}
 	/** Resolve visibility without creating records or materializing inherited/default options. */
-	peek(agent) {
-		return this.exclusive(agent.session.id, async () => this.read(agent, await this.table(), false));
+	peek(target) {
+		return this.exclusive(target.id, async () => this.read(target, await this.table(), false));
 	}
-	change(agent, change, expectedRevision) {
-		return this.exclusive(agent.session.id, async () => {
+	change(target, change, expectedRevision) {
+		return this.exclusive(target.id, async () => {
 			const table = await this.table();
-			await this.read(agent, table);
+			await this.read(target, table);
 			const { connectionId, ...options } = change;
 			const record = this.storage.optionsCodec.toRecord(options);
-			const updated = await table.update(agent.session.id, (current) => {
+			const updated = await table.update(target.id, (current) => {
 				if (current.revision !== expectedRevision) throw new SelectionConflict();
 				return {
 					...current,
@@ -15398,9 +15427,10 @@ var Sessions = class {
 					revision: current.revision + 1
 				};
 			});
-			this.restriction.sync(agent, updated.connectionId);
-			if (connectionId !== void 0) {
-				const model = nextModel(this.ctx, agent);
+			const agent = this.ctx.get("agents")?.get(target.id);
+			if (agent !== void 0) this.restriction.sync(agent, updated.connectionId);
+			if (connectionId !== void 0 && sessionOrigin(target.header).kind !== "subagent") {
+				const model = this.model(target);
 				if (model !== void 0) {
 					const memory = await this.pairings.set(model, updated.connectionId).then(() => ({ kind: "stored" }), (error) => ({
 						kind: "failed",
@@ -15415,29 +15445,33 @@ var Sessions = class {
 			};
 		});
 	}
-	connections(agent) {
-		return this.describe(this.settings(), agent);
+	connections(target) {
+		return this.describe(this.settings(), this.model(target));
 	}
 	selectable(connectionId) {
 		return isSelectable(this.settings().connections.get(connectionId));
 	}
+	model(target) {
+		return target.kind === "live" ? nextModel(this.ctx, target.agent) : void 0;
+	}
 	async table() {
 		return (await this.storage.domain()).table("selections");
 	}
 	exclusive(id, work) {
 		return this.storage.exclusive(id, work);
 	}
-	async read(agent, table, persist = true) {
+	async read(target, table, persist = true) {
 		const settings = this.settings();
 		const codec = this.storage.optionsCodec;
-		const id = agent.session.id;
+		const id = target.id;
 		let stored = table.get(id);
-		const { parentSession, isSeeded } = agent.session.header;
-		const seeded = parentSession !== void 0 && isSeeded;
+		const origin = sessionOrigin(target.header);
+		const parentSession = parentOf(origin);
+		const seeded = parentSession !== void 0 && origin.seeded;
 		let inherited = stored !== void 0 && seeded && (stored.inherited ?? table.get(parentSession) !== void 0);
 		if (stored === void 0 && seeded) {
 			const parentAgent = this.ctx.get("agents")?.get(parentSession);
-			if (parentAgent !== void 0 && persist) await this.current(parentAgent);
+			if (parentAgent !== void 0 && persist) await this.current(liveSession(parentAgent));
 			else await this.storage.settled(parentSession);
 			const parent = table.get(parentSession);
 			if (parent !== void 0) {
@@ -15461,7 +15495,7 @@ var Sessions = class {
 				source: next.revision > 0 ? "session" : "inherited"
 			};
 		}
-		const fallback = await this.defaultFor(agent, settings);
+		const fallback = await this.defaultFor(target, settings);
 		const options = stored === void 0 ? codec.initial(settings) : codec.fromRecord(stored, settings);
 		const next = {
 			...codec.toRecord(options),
@@ -15475,8 +15509,8 @@ var Sessions = class {
 			source: fallback.source
 		};
 	}
-	async defaultFor(agent, settings) {
-		const model = nextModel(this.ctx, agent);
+	async defaultFor(target, settings) {
+		const model = this.model(target);
 		const paired = model === void 0 ? void 0 : await this.pairings.get(model);
 		if (paired === null) return {
 			connectionId: null,
@@ -15503,6 +15537,24 @@ function sameRecord(left, right) {
 	return left !== void 0 && JSON.stringify(left) === JSON.stringify(right);
 }
 //#endregion
+//#region ../core/src/host/selection-write.ts
+/** The shared eligibility check and revisioned write for commands and Remote set. */
+async function writeSelection(sessions, target, change, expectedRevision) {
+	if (typeof change.connectionId === "string" && !sessions.selectable(change.connectionId)) return {
+		kind: "unavailable",
+		connectionId: change.connectionId
+	};
+	try {
+		return {
+			kind: "written",
+			current: await sessions.change(target, change, expectedRevision)
+		};
+	} catch (error) {
+		if (error instanceof SelectionConflict) return { kind: "conflict" };
+		throw error;
+	}
+}
+//#endregion
 //#region ../core/src/host/remote.ts
 var __runInitializers = function(thisArg, initializers, value) {
 	var useValue = arguments.length > 2;
@@ -15650,27 +15702,22 @@ function createConnectionsService(ctx, spec) {
 			async get(request) {
 				return boundary("get", async () => {
 					const { sessionId } = parse(selectionRequest, request);
-					const agent = await this.agent(sessionId);
-					return this.view(agent, await spec.sessions.current(agent));
+					const target = await this.target(sessionId);
+					return this.view(target, await spec.sessions.current(target));
 				});
 			}
 			async set(request) {
 				return boundary("set", async () => {
 					const { sessionId, connectionId, options, expectedRevision } = parse(spec.contract.selectionChange, request);
-					const agent = await this.agent(sessionId);
-					if (typeof connectionId === "string" && !spec.sessions.selectable(connectionId)) throw new RemoteError(spec.namespace + "/unavailable", "the connection is missing, disabled or unsupported", { connectionId });
-					let current;
-					try {
-						const change = {
-							...options,
-							...connectionId === void 0 ? {} : { connectionId }
-						};
-						current = await spec.sessions.change(agent, change, expectedRevision);
-					} catch (error) {
-						if (error instanceof SelectionConflict) throw new RemoteError(spec.namespace + "/conflict", "the selection changed elsewhere; re-read it and retry", {});
-						throw error;
-					}
-					return this.view(agent, current);
+					const target = await this.target(sessionId);
+					const change = {
+						...options,
+						...connectionId === void 0 ? {} : { connectionId }
+					};
+					const result = await writeSelection(spec.sessions, target, change, expectedRevision);
+					if (result.kind === "unavailable") throw new RemoteError(spec.namespace + "/unavailable", "the connection is missing, disabled or unsupported", { connectionId: result.connectionId });
+					if (result.kind === "conflict") throw new RemoteError(spec.namespace + "/conflict", "the selection changed elsewhere; re-read it and retry", {});
+					return this.view(target, result.current);
 				});
 			}
 			async provider(request) {
@@ -15692,15 +15739,27 @@ function createConnectionsService(ctx, spec) {
 					return { pairings: await spec.pairings.list() };
 				});
 			}
-			async agent(sessionId) {
-				const found = await this.ctx.sessionController.resolveAgent(sessionId);
+			async target(sessionId) {
+				const id = sessionId;
+				const agent = this.ctx.agents.get(id);
+				if (agent !== void 0) return liveSession(agent);
+				const persistence = this.ctx.get("sessionPersistence");
+				if (persistence !== void 0) {
+					const stored = await persistence.stat(id);
+					if (stored !== void 0 && sessionOrigin(stored.header).kind === "subagent") return {
+						kind: "cold",
+						id,
+						header: stored.header
+					};
+				}
+				const found = await this.ctx.sessionController.resolveAgent(id);
 				if ("error" in found) throw found.error;
-				return found.agent;
+				return liveSession(found.agent);
 			}
-			async view(agent, current) {
+			async view(target, current) {
 				return {
 					...current,
-					connections: await spec.sessions.connections(agent)
+					connections: await spec.sessions.connections(target)
 				};
 			}
 		};
@@ -16014,7 +16073,7 @@ function explicitAccess(ctx, capability, runtime, errors, unavailable) {
 			const described = await errors.abortable(capability.describe({
 				...prepared.settings,
 				connections
-			}, call.agent), call.signal);
+			}, nextModel(ctx, call.agent)), call.signal);
 			errors.throwIfAborted(call.signal);
 			return new Map(described.map((view) => [view.id, view]));
 		} catch {
@@ -16211,6 +16270,188 @@ var SessionStorage = class {
 	}
 };
 //#endregion
+//#region ../core/src/host/command.ts
+var SelectionOperationError = class extends Error {};
+const SOURCES = {
+	session: "chosen in this session",
+	inherited: "copied from the parent session",
+	model: "remembered for this model",
+	default: "the default connection"
+};
+function registerCommand(ctx, capability, sessions) {
+	const { command, providerId, rowId } = capability.identity;
+	const noun = capability.tool === "web_search" ? "web search" : "web fetch";
+	const capital = capability.tool === "web_search" ? "Web search" : "Web fetch";
+	const options = capability.commandOptions;
+	const hint = options === void 0 ? "[off | <connection id>]" : "[off | <connection id> | freshness auto|fresh|realtime]";
+	const failure = "The " + noun + " selection could not be read or saved; retry, or check the Host logs.";
+	const error = (text) => ({
+		kind: "error",
+		text
+	});
+	const selectionOperation = async (work) => {
+		try {
+			return await work();
+		} catch (cause) {
+			if (cause instanceof InvalidSettingsError) throw cause;
+			ctx.logger.warn("%s command selection read or write failed: %s", rowId, cause);
+			throw new SelectionOperationError("selection read or write failed");
+		}
+	};
+	const route = () => routeFacts(ctx, capability.field, providerId);
+	const routing = () => routingText(route(), capability.tool, providerId);
+	const unavailable = (id) => error(id + " is missing or turned off in the settings. Run /" + command + " to list the connections.");
+	const success = (text) => ({
+		kind: "success",
+		text: text + (route().kind === "this" ? "" : "\n" + routing())
+	});
+	const run = async (invocation) => {
+		const raw = invocation.rawInput.trim();
+		const args = raw === "" ? [] : raw.split(/\s+/u);
+		const usage = () => error("Unknown argument \"" + oneLine(raw, 64) + "\". Usage: /" + command + " " + hint);
+		const keyword = args.length === 0 ? "" : args[0].toLowerCase();
+		const freshnessValue = args.length === 2 ? args[1].toLowerCase() : "";
+		const freshness = options !== void 0 && args.length === 2 && keyword === "freshness";
+		if (args.length > 0 && !freshness && !(args.length === 1 && (keyword === "off" || isConnectionId(args[0])))) return usage();
+		if (freshness && !FRESHNESS.some((value) => value === freshnessValue)) return error("Unknown freshness \"" + oneLine(args[1], 64) + "\". Use auto, fresh or realtime.");
+		const target = liveSession(invocation.agent);
+		const settings = capability.settings();
+		const current = await selectionOperation(() => sessions.current(target));
+		if (args.length === 0) {
+			const views = await sessions.connections(target);
+			const id = current.selection.connectionId;
+			const selected = id === null ? void 0 : views.find((view) => view.id === id);
+			let summary = id === null ? "Off" : selected === void 0 || !sessions.selectable(id) ? id : oneLine(selected.label, 200) + " (" + id + ")";
+			summary += " · " + SOURCES[current.source];
+			if (id !== null && !sessions.selectable(id)) summary += " · missing or turned off in the settings; " + capability.tool + " fails until another connection is chosen";
+			if (options !== void 0) summary += " · freshness: " + options.freshness(current.selection.options);
+			const entries = [];
+			for (const view of views) {
+				const connection = settings.connections.get(view.id);
+				if (!isSelectable(connection)) continue;
+				const name = oneLine(view.label, 200);
+				const parts = [statusText(view)];
+				if (view.id === id) parts.push("current");
+				if (view.freshness === true) parts.push("applies freshness");
+				const recipient = recipientText(capability.enhanced.listing(connection, {
+					agent: invocation.agent,
+					signal: invocation.signal
+				}).recipient);
+				if (recipient === "this machine") parts.push("fetches from this machine");
+				else if (recipient !== name) parts.push((capability.tool === "web_search" ? "queries" : "URLs") + " go to " + recipient);
+				entries.push("- " + view.id + " — " + name + " · " + parts.join(" · "));
+			}
+			if (entries.length === 0) entries.push("- (none; turn connections on in the row settings)");
+			const tail = "Turn off: /" + command + " off" + (options === void 0 ? "" : " · Freshness: /" + command + " freshness auto|fresh|realtime (connections marked \"applies freshness\")");
+			return {
+				kind: "success",
+				text: [
+					summary,
+					routing(),
+					"Connections (/" + command + " <id> chooses one):",
+					...entries,
+					tail
+				].join("\n")
+			};
+		}
+		let change;
+		let message;
+		if (freshness && options !== void 0) {
+			const selected = (await sessions.connections(target)).find((view) => view.id === current.selection.connectionId);
+			if (selected === void 0 || selected.freshness !== true || !sessions.selectable(selected.id)) return error("The current connection does not apply freshness. Choose one marked \"applies freshness\" first.");
+			const value = FRESHNESS.find((mode) => mode === freshnessValue);
+			change = options.changeFreshness(value);
+			message = "Freshness is " + value + " from the next model request.";
+		} else if (keyword === "off") {
+			change = { connectionId: null };
+			message = capital + " is off for this session from the next model request.";
+		} else {
+			const id = args[0];
+			if (!sessions.selectable(id)) return unavailable(id);
+			const selected = (await sessions.connections(target)).find((view) => view.id === id);
+			change = { connectionId: id };
+			message = "Now using " + oneLine(selected.label, 200) + " (" + id + ") for " + noun + " from the next model request.";
+		}
+		const result = await selectionOperation(() => writeSelection(sessions, target, change, current.selection.revision));
+		if (result.kind === "unavailable") return unavailable(result.connectionId);
+		if (result.kind === "conflict") return error("The selection changed while this command ran. Run /" + command + " to see it, then try again.");
+		return success(message);
+	};
+	ctx.effect(() => ctx.commands.register({
+		name: command,
+		description: "Show or change this session's " + noun + " connection",
+		input: { hint },
+		async handler(invocation) {
+			try {
+				return await run(invocation);
+			} catch (cause) {
+				if (cause instanceof SelectionOperationError) return error(failure);
+				ctx.logger.warn("%s command failed: %s", rowId, cause);
+				if (cause instanceof InvalidSettingsError) return error("The " + noun + " settings are invalid; fix them in the Enhanced " + noun + " row settings.");
+				throw new Error("The " + noun + " command failed; retry, or check the Host logs.");
+			}
+		}
+	}));
+}
+function routingText(route, tool, providerId) {
+	switch (route.kind) {
+		case "this": return "Routing: " + tool + " goes to this plugin.";
+		case "other": return "Routing: " + tool + " goes to " + oneLine(route.provider, 200) + ", so this selection has no effect until the web row routes it to " + providerId + ".";
+		case "auto": return "Routing: the web row pins no " + tool + " provider, so this selection has no effect until it routes " + tool + " to " + providerId + ".";
+		case "unknown": return "Routing: the web row could not be read, so this selection may have no effect.";
+	}
+}
+function statusText(view) {
+	switch (view.status) {
+		case "ready": return "ready";
+		case "needs-credential": return view.access === "account" ? "needs DeepSeek sign-in" : "needs an API key";
+		case "unsupported": return "unavailable: " + UNSUPPORTED_REASON_TEXT[view.reason];
+		case "disabled": return "missing or turned off in the settings";
+	}
+}
+//#endregion
+//#region ../core/src/host/terminal.ts
+function registerTerminal(ctx, root, noun, settings, freshness) {
+	ctx.effect(() => ctx.tuiCommandTrees.register({
+		root,
+		children(path) {
+			if (path[0] !== root) return [];
+			if (freshness && path.length === 2 && path[1] === "freshness") return [
+				{
+					name: "auto",
+					description: "Auto"
+				},
+				{
+					name: "fresh",
+					description: "Within 24 hours"
+				},
+				{
+					name: "realtime",
+					description: "Live"
+				}
+			];
+			if (path.length !== 1) return [];
+			const nodes = [{
+				name: "off",
+				description: "Turn " + noun + " off for this session"
+			}];
+			try {
+				for (const connection of settings().connections.values()) if (isSelectable(connection)) nodes.push({
+					name: connection.id,
+					description: oneLine(connection.label, 200)
+				});
+			} catch (error) {
+				if (!(error instanceof InvalidSettingsError)) throw error;
+			}
+			if (freshness) nodes.push({
+				name: "freshness",
+				description: "Content freshness, for connections that apply it"
+			});
+			return nodes;
+		}
+	}));
+}
+//#endregion
 //#region ../core/src/host/runtime.ts
 /** Install the sole Seat, session lifecycle, route-guarded restrictions and Remote service. */
 function installCapability(ctx, capability) {
@@ -16231,7 +16472,7 @@ function installCapability(ctx, capability) {
 	const restriction = new ToolRestriction(ctx, {
 		tool: capability.tool,
 		routed: () => routeFacts(ctx, capability.field, capability.identity.providerId).kind === "this",
-		selection: async (agent) => (await sessions.peek(agent)).selection.connectionId,
+		selection: async (agent) => (await sessions.peek(liveSession(agent))).selection.connectionId,
 		enhanced: {
 			rowId: capability.identity.rowId,
 			names: capability.enhanced.names,
@@ -16247,11 +16488,11 @@ function installCapability(ctx, capability) {
 			providers: (agent) => lists.read(agent)
 		}
 	});
-	const sessions = new Sessions(ctx, () => capability.settings(), storage, pairings, restriction, (settings, agent) => capability.describe(settings, agent));
+	const sessions = new Sessions(ctx, () => capability.settings(), storage, pairings, restriction, (settings, model) => capability.describe(settings, model));
 	const capture = async (agent, signal) => {
 		const operation = restriction.begin(agent);
 		try {
-			const read = sessions.current(agent);
+			const read = sessions.current(liveSession(agent));
 			const { selection } = signal === void 0 ? await read : await errors.abortable(read, signal);
 			if (!restriction.active) return {
 				kind: "failed",
@@ -16298,7 +16539,17 @@ function installCapability(ctx, capability) {
 		snapshots.forget(agent);
 		restriction.forget(agent);
 	});
-	ctx.inject(["sessionController", "typert"], (scope) => {
+	ctx.inject(["commands"], (scope) => {
+		registerCommand(scope, capability, sessions);
+	});
+	ctx.inject(["tuiCommandTrees"], (scope) => {
+		registerTerminal(scope, capability.identity.command, "web " + kind, () => capability.settings(), capability.commandOptions !== void 0);
+	});
+	ctx.inject([
+		"sessionController",
+		"typert",
+		"agents"
+	], (scope) => {
 		createConnectionsService(scope, {
 			namespace: capability.remoteNamespace,
 			contract: capability.contract,
@@ -17180,7 +17431,7 @@ const { withDeadline, readJson, requestJson, invalidResponse } = transport;
 const mcp = createMcpClient(transport, searchErrors, {
 	clientInfo: {
 		name: SEARCH.packageName,
-		version: "0.2.1"
+		version: "0.2.2"
 	},
 	messages: {
 		toolFailed: (label, detail) => label + " could not complete the search; retry later or choose another search connection" + upstreamSuffix(label, detail),
@@ -18258,14 +18509,14 @@ function searchEnhanced(ctx) {
 }
 //#endregion
 //#region src/host/connections.ts
-async function describeConnections(ctx, settings, agent) {
+async function describeConnections(ctx, settings, model) {
 	return Promise.all([...settings.connections.values()].map(async (connection) => {
 		const base = baseOf(connection);
 		if (connection.kind === "model") {
 			const target = connection.route.kind === "fixed" ? {
 				kind: "route",
 				route: fixedRoute(connection.route)
-			} : sessionRoute(ctx, nextModel(ctx, agent));
+			} : sessionRoute(ctx, model);
 			const access = target.kind === "route" ? target.route.auth.kind : "api-key";
 			if (connection.disabled) return {
 				...base,
@@ -18298,7 +18549,7 @@ async function describeConnections(ctx, settings, agent) {
 		const endpoint = connection.kind === "native" ? typeof connection.options.baseURL === "string" ? connection.options.baseURL : CATALOG[connection.native].endpoint : void 0;
 		return {
 			...base,
-			...await credentialReadiness(ctx, agent, {
+			...await credentialReadiness(ctx, model, {
 				endpoint,
 				credentialRef: connection.credentialRef
 			})
@@ -18343,7 +18594,11 @@ function searchCapability(ctx, settings) {
 		contract,
 		optionsCodec,
 		settings,
-		describe: (current, agent) => describeConnections(ctx, current, agent),
+		commandOptions: {
+			freshness: (options) => options.freshness,
+			changeFreshness: (freshness) => ({ freshness })
+		},
+		describe: (current, model) => describeConnections(ctx, current, model),
 		target: (connection, options, call) => {
 			switch (connection.kind) {
 				case "adapter": return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-web-search-enhanced",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "web_search provider for DeepSeek Harness with switchable search backends; installed through dsh-tool-web-enhanced-profile",
   "keywords": [
     "deepseek-harness",