@code-yeongyu/senpi 2026.10.11 → 2026.10.12

package/dist/core/extensions/builtin/websearch/server-search.js

@@ -0,0 +1,230 @@
+import { isAnthropicWebSearchEnabled, supportsNativeAnthropicWebSearch } from "../anthropic-web-search/index.js";
+import { isOpenaiWebSearchEnabled, supportsNativeOpenAiWebSearch } from "../openai-web-search/index.js";
+import { isServerSearchDisabled, isServerSearchFallback, SERVER_SEARCH_FALLBACK } from "../server-search-fallback.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function additionalServerSearch(model) {
+    if (!model)
+        return undefined;
+    const declared = model.compat && "supportsWebSearch" in model.compat ? model.compat.supportsWebSearch : undefined;
+    if (declared !== true)
+        return undefined;
+    // Google Search grounding uses GenerateContent config.tools, not Messages/Responses.
+    // Gemini 2/3 document this native tool, but search mixed with function tools
+    // remains opt-in until a live endpoint probe succeeds.
+    // https://ai.google.dev/gemini-api/docs/google-search
+    // https://github.com/googleapis/js-genai/blob/main/codegen_instructions.md
+    if ((model.api === "google-generative-ai" || model.api === "google-vertex") &&
+        /^gemini-(?:2[.-]|3[.-]|flash-latest|pro-latest)/.test(model.id) &&
+        !/(image|live|tts|embedding|computer-use)/.test(model.id)) {
+        return "google";
+    }
+    // OpenRouter's own server tool works on Chat Completions and Responses.
+    // Do not translate it into the upstream vendor's tool shape.
+    // https://openrouter.ai/docs/guides/features/server-tools/web-search
+    if (model.provider === "openrouter" && (model.api === "openai-completions" || model.api === "openai-responses")) {
+        return "openrouter";
+    }
+    // PAYG Moonshot executes $web_search and returns its result in generated
+    // arguments; the client echoes those arguments as a tool result, without
+    // making another search request. This is NOT the Kimi coding-plan endpoint.
+    // https://platform.kimi.ai/docs/guide/use-web-search
+    if (model.api === "openai-completions" && (model.provider === "moonshotai" || model.provider === "moonshotai-cn")) {
+        return "moonshot";
+    }
+    // The same provider id can point at PAYG chat or the coding-plan endpoint.
+    // Only an explicit per-route flag enables the PAYG in-chat server tool.
+    // https://docs.z.ai/guides/tools/web-search
+    // https://docs.z.ai/devpack/mcp/search-mcp-server
+    if (model.api === "openai-completions" &&
+        (model.provider === "zai" || model.provider === "z-ai") &&
+        declared === true) {
+        return "zai";
+    }
+    // Sonar searches inside the main completion without a tools[] declaration.
+    // Synchronous Sonar calls are now reformulated as Agent API calls upstream.
+    // https://docs.perplexity.ai/docs/sonar/quickstart
+    if (model.provider === "perplexity" && model.api === "openai-completions" && /^sonar/.test(model.id)) {
+        return "perplexity";
+    }
+    // DeepSeek documents search on /anthropic, not the default Chat Completions API.
+    // An Anthropic-format model opts in through compat.supportsWebSearch, including replay.
+    // https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code
+    // Kimi coding-plan docs do not specify a search/replay contract. Keep the explicit
+    // Messages compat opt-in; do not confuse it with PAYG's deprecated $web_search.
+    // https://www.kimi.com/code/docs/en/third-party-tools/claude-code
+    // https://platform.kimi.ai/docs/guide/use-web-search
+    // GLM coding-plan search is documented as webSearchPrime over remote MCP, not
+    // the PAYG chat tool. Do not inject the PAYG tool on the coding endpoint.
+    // https://docs.z.ai/devpack/mcp/search-mcp-server
+    // https://docs.z.ai/guides/tools/web-search
+    return undefined;
+}
+export function hasServerSearch(model) {
+    if (!model)
+        return false;
+    return ((supportsNativeAnthropicWebSearch(model) && isAnthropicWebSearchEnabled()) ||
+        (supportsNativeOpenAiWebSearch(model) && isOpenaiWebSearchEnabled()) ||
+        additionalServerSearch(model) !== undefined);
+}
+function isMoonshotSearchTool(tool) {
+    return (isRecord(tool) &&
+        (tool.name === "$web_search" || (isRecord(tool.function) && tool.function.name === "$web_search")));
+}
+function isClientSearchTool(tool) {
+    return (isRecord(tool) &&
+        (tool.type === "function" || "input_schema" in tool) &&
+        (tool.name === "web_search" || (isRecord(tool.function) && tool.function.name === "web_search")));
+}
+function withTools(payload, tools) {
+    const result = { ...payload };
+    if (tools.length)
+        result.tools = tools;
+    else
+        delete result.tools;
+    return result;
+}
+function isSearchTool(tool) {
+    if (!isRecord(tool))
+        return false;
+    return (tool.name === "web_search" ||
+        isMoonshotSearchTool(tool) ||
+        (isRecord(tool.function) && tool.function.name === "web_search") ||
+        (typeof tool.type === "string" &&
+            (tool.type === "openrouter:web_search" || tool.type === "web_search" || tool.type.startsWith("web_search_"))));
+}
+function googleTools(tools, retainFunction, disabled) {
+    const result = [];
+    for (const tool of tools) {
+        if (!isRecord(tool) || "googleSearch" in tool || "google_search" in tool)
+            continue;
+        if (!Array.isArray(tool.functionDeclarations)) {
+            result.push(tool);
+            continue;
+        }
+        const declarations = tool.functionDeclarations.filter((declaration) => !isRecord(declaration) || retainFunction || declaration.name !== "web_search");
+        if (declarations.length)
+            result.push({ ...tool, functionDeclarations: declarations });
+    }
+    if (!retainFunction && !disabled)
+        result.push({ googleSearch: {} });
+    return result;
+}
+/** Preserve adapter-built function search on fallback; never reconstruct its normalized schema. */
+export function serverSearchPayload(model, payload, failed = false) {
+    if (!isRecord(payload))
+        return payload;
+    const disabled = isServerSearchDisabled(payload);
+    const fallback = failed || isServerSearchFallback(payload);
+    if (additionalServerSearch(model) !== "moonshot") {
+        if (isMoonshotSearchTool(payload.tool_choice)) {
+            const { tool_choice: _choice, ...rest } = payload;
+            payload = rest;
+        }
+        if (!isRecord(payload))
+            return payload;
+        if (Array.isArray(payload.tools)) {
+            const tools = payload.tools.filter((tool) => !isMoonshotSearchTool(tool));
+            if (tools.length !== payload.tools.length)
+                payload = withTools(payload, tools);
+        }
+        if (isRecord(payload) && isRecord(payload.config) && Array.isArray(payload.config.tools)) {
+            payload = {
+                ...payload,
+                config: withTools(payload.config, payload.config.tools.flatMap((tool) => {
+                    if (!isRecord(tool) || !Array.isArray(tool.functionDeclarations))
+                        return [tool];
+                    const declarations = tool.functionDeclarations.filter((declaration) => !isMoonshotSearchTool(declaration));
+                    return declarations.length ? [{ ...tool, functionDeclarations: declarations }] : [];
+                })),
+            };
+        }
+    }
+    if (!model || !isRecord(payload))
+        return payload;
+    const google = model.api === "google-generative-ai" || model.api === "google-vertex";
+    if (google && (additionalServerSearch(model) === "google" || fallback || disabled)) {
+        const config = isRecord(payload.config) ? payload.config : {};
+        const tools = Array.isArray(config.tools) ? config.tools : [];
+        return {
+            ...payload,
+            config: withTools(config, googleTools(tools, fallback || disabled, disabled)),
+            ...(fallback ? { [SERVER_SEARCH_FALLBACK]: true } : {}),
+        };
+    }
+    const kind = additionalServerSearch(model);
+    if (!fallback && !kind && !disabled)
+        return payload;
+    const tools = (Array.isArray(payload.tools) ? payload.tools : []).filter((tool) => {
+        if (!isSearchTool(tool))
+            return true;
+        if (!disabled && !fallback)
+            return false;
+        // Responses/Completions use type:function; Messages uses input_schema.
+        // These declarations already came through their provider's schema builder.
+        return isClientSearchTool(tool);
+    });
+    if (!fallback && !disabled && kind === "openrouter") {
+        tools.push({ type: "openrouter:web_search" });
+    }
+    else if (!fallback && !disabled && kind === "moonshot") {
+        tools.push({ type: "builtin_function", function: { name: "$web_search" } });
+    }
+    else if (!fallback && !disabled && kind === "zai") {
+        tools.push({ type: "web_search", web_search: { enable: true, search_result: true } });
+    }
+    const result = withTools(payload, tools);
+    if (fallback || disabled) {
+        // An include or tool_choice targeting the removed server tool would reject the retry.
+        if (Array.isArray(result.include)) {
+            result.include = result.include.filter((item) => item !== "web_search_call.action.sources");
+        }
+        if (isRecord(result.tool_choice) &&
+            isSearchTool(result.tool_choice) &&
+            !isClientSearchTool(result.tool_choice) &&
+            !(result.tool_choice.name === "web_search" && tools.some(isClientSearchTool)))
+            delete result.tool_choice;
+    }
+    return fallback ? { ...result, [SERVER_SEARCH_FALLBACK]: true } : result;
+}
+/** Only search-specific errors trigger fallback; cancellation and unrelated provider failures do not. */
+export function serverSearchFailure(message, model) {
+    if (message.stopReason === "aborted")
+        return undefined;
+    // Sonar has inherent retrieval, not an independent server tool declaration or
+    // tool-result error contract. Its model errors stay with core retry; never
+    // turn an arbitrary Sonar error into an unsupported function-tool request.
+    if (model?.provider === "perplexity" && model.api === "openai-completions" && /^sonar/.test(model.id))
+        return undefined;
+    for (const block of message.content) {
+        if (block.type !== "providerNative" || !isRecord(block.raw))
+            continue;
+        const raw = block.raw;
+        if (raw.type === "web_search_call" && raw.status === "failed") {
+            return "server search result: failed";
+        }
+        if (raw.type !== "web_search_tool_result" || !isRecord(raw.content))
+            continue;
+        if (raw.content.type === "web_search_tool_result_error" && typeof raw.content.error_code === "string") {
+            return `server search result: ${raw.content.error_code.replace(/[^a-z_]/g, "").slice(0, 60)}`;
+        }
+    }
+    if (message.stopReason === "error" &&
+        /(\b401\b|invalid[_ -]?(?:api[_ -]?)?key|authentication|unauthorized|quota|billing|insufficient)/i.test(message.errorMessage ?? "")) {
+        return undefined;
+    }
+    if (message.stopReason === "error" &&
+        model !== undefined &&
+        (model.api === "google-generative-ai" || model.api === "google-vertex") &&
+        /(multiple tools|combining.*tools|tools.*combination|tool use with function calling is unsupported)/i.test(message.errorMessage ?? "")) {
+        return "server search request rejected (mixed tools unsupported)";
+    }
+    if (message.stopReason === "error" &&
+        /(web_search_\d{8}|web_search_preview|openrouter:web_search|googleSearch|google_search|(?:tool(?:[_ -]?type)?|type)\s*[:=]?\s*["']?web_search\b)/i.test(message.errorMessage ?? "")) {
+        const status = message.errorMessage?.match(/\b(400|403|429|500|502|503)\b/)?.[1];
+        return `server search request rejected${status ? ` (HTTP ${status})` : ""}`;
+    }
+    return undefined;
+}
+//# sourceMappingURL=server-search.js.map

package/dist/core/extensions/builtin/websearch/websearch/native.d.ts

@@ -1,9 +1,11 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
 import type { SearchProvider, SearchProviderEntry } from "./types.ts";
 export interface NativeModelInfo {
     provider: string;
     id: string;
     baseUrl: string;
     api?: string;
+    compat?: Model<Api>["compat"];
     cost?: {
         input: number;
         output: number;

package/dist/core/extensions/builtin/websearch/websearch/search-model.js

@@ -1,3 +1,4 @@
+import { hasServerSearch } from "../server-search.js";
 import { nativeMapping, nativeRouteKey } from "./native.js";
 export const SESSION_SEARCH_MODEL = "session";
 // Cheaper same-provider models for hosted search, after oh-my-pi's per-provider `web-search-model` catalog axis.
@@ -40,6 +41,20 @@ function defaultChoice(session, candidates) {
 export function resolveNativeSearchModel(session, registry, setting) {
     if (!session || !nativeRouteKey(session))
         return undefined;
+    // Main-request server search is always the active model's job. If that fails,
+    // the standalone retry also keeps that model; only no-server routes default
+    // to the cheaper auxiliary model below. An auxiliary setting cannot preempt
+    // the in-turn tool. See senpi#3122.
+    if (session.api !== undefined &&
+        hasServerSearch({
+            api: session.api,
+            provider: session.provider,
+            id: session.id,
+            baseUrl: session.baseUrl,
+            compat: session.compat,
+        })) {
+        return { model: session.id, source: "session" };
+    }
     if (setting === SESSION_SEARCH_MODEL)
         return { model: session.id, source: "session" };
     const candidates = sameRouteModels(session, registry);

package/dist/core/extensions/runner.d.ts

@@ -14,6 +14,9 @@ import type { SessionManager } from "../session-manager.ts";
 import type { BuildSystemPromptOptions } from "../system-prompt.ts";
 import type { VirtualModelDefinition } from "../virtual-models.ts";
 import type { AgentBeforeSettleEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BoundaryContextPreview, ContextEvent, ContextWithSystemEvent, EntryRenderer, EntryRendererOptions, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionToolContext, ExtensionUIContext, InputEvent, InputEventResult, InputSource, LoadExtensionsResult, MarkdownTransformer, MessageEndEvent, MessageRenderer, ModelSelectEvent, ModelSelectEventResult, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventResult, ProviderConfig, ProviderRequestPreparation, RegisteredMcpServerDeclaration, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, SessionBeforeCompactResult, SessionBeforeForkResult, SessionBeforeReloadResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionBoundaryDraft, SessionShutdownEvent, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, TurnEndEvent, UserBashEvent, UserBashEventResult } from "./types.ts";
+export declare class ExtensionRpcRequestNotFoundError extends Error {
+    constructor(name: string);
+}
 /** Combined result from all before_agent_start handlers */
 interface BeforeAgentStartCombinedResult {
     messages?: NonNullable<BeforeAgentStartEventResult["message"]>[];
@@ -132,6 +135,7 @@ export declare class ExtensionRunner {
     private isCompactingFn;
     private checkReloadVetoFn;
     private getContextUsageFn;
+    private getCompactionModelFn;
     private getCompactionSettingsFn;
     private getPromptCacheSafeWaitSecondsFn;
     private getPromptCacheGoalBackstopMaxSecondsFn;
@@ -151,6 +155,7 @@ export declare class ExtensionRunner {
     private getLoadedHookSourcesFn;
     private getSystemPromptOptionsFn;
     private getPromptCachePrefixRequestFn;
+    private onUserActivityFn;
     private getAgentDirFn;
     private executeToolFn;
     private getCallableToolsFn;
@@ -289,7 +294,9 @@ export declare class ExtensionRunner {
      * handlers then see the full transcript and their output is used as returned.
      */
     emitContext(messages: AgentMessage[], excludeExtensionPath?: string, source?: ContextEvent["source"]): Promise<AgentMessage[]>;
-    prepareProviderRequest(messages: AgentMessage[], excludeExtensionPath?: string): Promise<ProviderRequestPreparation>;
+    prepareProviderRequest(messages: AgentMessage[], excludeExtensionPath?: string, options?: {
+        allowServerSearch?: boolean;
+    }): Promise<ProviderRequestPreparation>;
     emitBeforeProviderRequest(payload: unknown, excludeExtensionPath?: string, request?: {
         model: Model<Api>;
         headers: ProviderHeaders;

package/dist/core/extensions/runner.js

@@ -9,11 +9,18 @@ import { createEventBus, EXTENSION_RPC_EVENT_CHANNEL } from "../event-bus.js";
 import { DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS, DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS, SettingsManager, } from "../settings-manager.js";
 import { goalFilePath } from "./builtin/goal/persistence.js";
 import { goalStoreRef } from "./builtin/goal/store-ref.js";
+import { disableServerSearch } from "./builtin/server-search-fallback.js";
 import { dispatchContextMessages } from "./context-dispatch.js";
 import { kernelToolsStorage } from "./kernel-tools-context.js";
 import { drainPendingProviderRegistrations } from "./loader.js";
 import { SessionStartTurnGate } from "./session-start-turn-gate.js";
 import { RUNTIME_EXTENSION_PATH } from "./types.js";
+export class ExtensionRpcRequestNotFoundError extends Error {
+    constructor(name) {
+        super(`Unknown extension RPC request: ${name}`);
+        this.name = "ExtensionRpcRequestNotFoundError";
+    }
+}
 // Extension shortcuts compete with canonical keybinding ids from keybindings.json.
 // Only editor-global shortcuts are reserved here. Picker-specific bindings are not.
 const RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
@@ -323,6 +330,7 @@ export class ExtensionRunner {
         this.shutdownHandler = contextActions.shutdown;
         this.getContextUsageFn = contextActions.getContextUsage;
         this.getCompactionSettingsFn = contextActions.getCompactionSettings;
+        this.getCompactionModelFn = contextActions.getCompactionModel;
         if (contextActions.getPromptCacheSafeWaitSeconds)
             this.getPromptCacheSafeWaitSecondsFn = contextActions.getPromptCacheSafeWaitSeconds;
         if (contextActions.getPromptCacheGoalBackstopMaxSeconds)
@@ -348,6 +356,7 @@ export class ExtensionRunner {
             this.getAgentDirFn = contextActions.getAgentDir;
         this.getSystemPromptOptionsFn = contextActions.getSystemPromptOptions ?? (() => ({ cwd: this.cwd }));
         this.getPromptCachePrefixRequestFn = contextActions.getPromptCachePrefixRequest;
+        this.onUserActivityFn = contextActions.onUserActivity;
         this.executeToolFn = contextActions.executeTool;
         this.getCallableToolsFn = contextActions.getCallableTools ?? (() => []);
         for (const extension of this.extensions) {
@@ -826,7 +835,7 @@ export class ExtensionRunner {
             return handler === undefined ? [] : [handler];
         });
         if (matches.length === 0) {
-            throw new Error(`Unknown extension RPC request: ${normalizedName}`);
+            throw new ExtensionRpcRequestNotFoundError(normalizedName);
         }
         if (matches.length > 1) {
             throw new Error(`Multiple extension RPC request handlers registered: ${normalizedName}`);
@@ -971,6 +980,15 @@ export class ExtensionRunner {
                 runner.assertActive();
                 return runner.getCompactionSettingsFn();
             },
+            get getCompactionModel() {
+                runner.assertActive();
+                return runner.getCompactionModelFn
+                    ? () => {
+                        runner.assertActive();
+                        return runner.getCompactionModelFn?.();
+                    }
+                    : undefined;
+            },
             getPromptCacheSafeWaitSeconds: () => {
                 runner.assertActive();
                 return runner.getPromptCacheSafeWaitSecondsFn();
@@ -983,6 +1001,22 @@ export class ExtensionRunner {
                 runner.assertActive();
                 return runner.getPromptCacheKeepAliveSettingsFn();
             },
+            onUserActivity: (listener) => {
+                runner.assertActive();
+                const unsubscribe = runner.onUserActivityFn?.((kind) => {
+                    try {
+                        listener(kind);
+                    }
+                    catch (error) {
+                        runner.emitError({
+                            extensionPath: excludeBeforeProviderRequestExtensionPath ?? RUNTIME_EXTENSION_PATH,
+                            event: "user_activity",
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                });
+                return runner.runtime.trackEventBusSubscription(unsubscribe ?? (() => { }));
+            },
             getLookAtSettings: () => {
                 runner.assertActive();
                 return runner.getLookAtSettingsFn();
@@ -1003,9 +1037,9 @@ export class ExtensionRunner {
                 runner.assertActive();
                 runner.compactFn(options);
             },
-            prepareProviderRequest: async (messages) => {
+            prepareProviderRequest: async (messages, options) => {
                 runner.assertActive();
-                return runner.prepareProviderRequest(messages, excludeBeforeProviderRequestExtensionPath);
+                return runner.prepareProviderRequest(messages, excludeBeforeProviderRequestExtensionPath, options);
             },
             getPromptCachePrefixRequest: async (options) => {
                 runner.assertActive();
@@ -1133,9 +1167,24 @@ export class ExtensionRunner {
         const ctx = this.createContext();
         let entries = [];
         let shouldContinue = false;
-        let context = await buildContext(entries);
-        let valid = true;
+        // Reported only when the runner retires before its first preview build completes.
+        let context = {
+            contextEntries: [],
+            contextMessages: [],
+            llmMessages: [],
+            pendingMessages: [],
+            canContinue: false,
+        };
         const retired = () => ({ entries: [], continue: false, context, valid: false });
+        try {
+            context = await buildContext(entries);
+        }
+        catch (err) {
+            if (!this.isActive)
+                return retired();
+            throw err;
+        }
+        let valid = true;
         for (const { ext, handlers } of snapshotEventHandlers(this.extensions, baseEvent.type)) {
             for (const handler of handlers) {
                 if (!this.isActive)
@@ -1546,11 +1595,11 @@ export class ExtensionRunner {
             source,
         });
     }
-    async prepareProviderRequest(messages, excludeExtensionPath) {
+    async prepareProviderRequest(messages, excludeExtensionPath, options) {
         const transformedMessages = await this.emitContext(messages, excludeExtensionPath, "projection");
         return {
             messages: transformedMessages,
-            transformPayload: async (payload) => await this.emitBeforeProviderRequest(payload, excludeExtensionPath),
+            transformPayload: async (payload) => await this.emitBeforeProviderRequest(options?.allowServerSearch ? payload : disableServerSearch(payload), excludeExtensionPath),
             transformHeaders: async (headers) => await this.emitBeforeProviderHeaders(headers),
         };
     }

package/dist/core/extensions/types.d.ts

@@ -40,6 +40,7 @@ import type { McpServerDeclaration } from "./builtin/mcp/config-schema.ts";
 import type { EvalHandleHost } from "./eval-handle-host.ts";
 import type { ExtensionKernelTools } from "./kernel-tools-context.ts";
 import type { SessionControlActions, SessionControlWakeEvent } from "./session-control-types.ts";
+import type { UserActivityKind } from "./user-activity.ts";
 export type { ExecOptions, ExecResult } from "../exec.ts";
 export type { AppKeybinding, KeybindingsManager } from "../keybindings.ts";
 export type { BuildSystemPromptOptions, NormalizedBuildSystemPromptOptions } from "../system-prompt.ts";
@@ -432,6 +433,8 @@ export interface ExtensionContext {
     getContextUsage(): ContextUsage | undefined;
     /** Get resolved compaction settings from global/project/user overrides. */
     getCompactionSettings(): CompactionPreparation["settings"];
+    /** Session-selected usable summarization model; throws when every authenticated account is spent. */
+    getCompactionModel?(): Model<Api> | undefined;
     /**
      * Longest a tool may block in the foreground before the active model's prompt
      * cache expires, or `undefined` when no cache-derived budget applies. Reads the
@@ -440,6 +443,8 @@ export interface ExtensionContext {
     getPromptCacheSafeWaitSeconds?(): number | undefined;
     /** Maximum Goal monitor continuation backstop configured for prompt-cache waits. */
     getPromptCacheGoalBackstopMaxSeconds?(): number;
+    /** Subscribe to host-authenticated activity; extensions cannot publish it. */
+    onUserActivity?(listener: (kind: UserActivityKind) => void): () => void;
     /** Resolved opt-in prompt-cache keep-alive policy. */
     getPromptCacheKeepAliveSettings?(): {
         enabled: boolean;
@@ -468,9 +473,12 @@ export interface ExtensionContext {
     compact(options?: CompactOptions): void;
     /**
      * Prepare a request-local provider context through the normal extension
-     * boundary. Persisted session messages are never modified.
+     * boundary. Persisted session messages are never modified. Server search is
+     * disabled for these auxiliary requests unless preserving a keepalive prefix.
      */
-    prepareProviderRequest?(messages: AgentMessage[]): Promise<ProviderRequestPreparation>;
+    prepareProviderRequest?(messages: AgentMessage[], options?: {
+        allowServerSearch?: boolean;
+    }): Promise<ProviderRequestPreparation>;
     /**
      * The provider request prefix the next user turn will send, with an empty conversation:
      * the system prompt composed through a `before_agent_start` preview pass, the session's
@@ -2379,8 +2387,10 @@ export interface ExtensionContextActions {
     shutdown: () => void;
     getContextUsage: () => ContextUsage | undefined;
     getCompactionSettings: () => CompactionPreparation["settings"];
+    getCompactionModel?: () => Model<Api> | undefined;
     getPromptCacheSafeWaitSeconds?: () => number | undefined;
     getPromptCacheGoalBackstopMaxSeconds?: () => number;
+    onUserActivity?: (listener: (kind: UserActivityKind) => void) => () => void;
     getPromptCacheKeepAliveSettings?: () => {
         enabled: boolean;
         maxRequestsPerSession: number;

package/dist/core/extensions/user-activity.d.ts

@@ -0,0 +1,10 @@
+export type UserActivityKind = "draft" | "prompt";
+/** Only the owning AgentSession receives the emitter; extensions can only subscribe. */
+export declare function createUserActivitySource(): {
+    emit(kind: UserActivityKind): void;
+    subscribe(listener: (kind: UserActivityKind) => void): () => void;
+};
+export declare function emitUserActivity(session: {
+    recordUserActivity?(kind: UserActivityKind): void;
+} | undefined, kind: UserActivityKind): void;
+//# sourceMappingURL=user-activity.d.ts.map

package/dist/core/extensions/user-activity.js

@@ -0,0 +1,20 @@
+/** Only the owning AgentSession receives the emitter; extensions can only subscribe. */
+export function createUserActivitySource() {
+    const listeners = new Set();
+    return {
+        emit(kind) {
+            for (const listener of listeners)
+                listener(kind);
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}
+export function emitUserActivity(session, kind) {
+    session?.recordUserActivity?.(kind);
+}
+//# sourceMappingURL=user-activity.js.map