@code-yeongyu/senpi 2026.9.23-5 → 2026.9.24-2

package/dist/core/agent-session.js

@@ -18,7 +18,7 @@ import { rm } from "node:fs/promises";
 import { dirname } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { ProviderRetryWatchdogAbortError, prepareAgentToolCall, resolveToolNameAlias, } from "@earendil-works/pi-agent-core";
-import { contentText, providerNotConfiguredMessage, SERVER_FALLBACK_ABORTED_DIAGNOSTIC, } from "@earendil-works/pi-ai";
+import { contentText, providerNotConfiguredMessage, SERVER_FALLBACK_ABORTED_DIAGNOSTIC, supportsAllowedToolChoice, supportsConfigurationUpdate, } from "@earendil-works/pi-ai";
 import { cleanupSessionResources, cursorOverflowCompactionSettings, describeProviderFailureForUser, isClassifierRefusal, isContextOverflow, isCursorPayloadResourceExhausted, isCursorQuotaResourceExhausted, isCursorZeroTokenResourceExhausted, isProviderStreamStallError, isProviderTimeoutError, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, shouldRetryOverflowWithoutCompact, streamSimple, stripTurnRetrySuppressionPrefix, } from "@earendil-works/pi-ai/compat";
 import { getCursorContextLimit } from "@earendil-works/pi-ai/utils/cursor-context-limit";
 import { extract429RetryAfterMs, parseRetryAfterMsMarker } from "@earendil-works/pi-ai/utils/retry-hint";
@@ -44,6 +44,7 @@ import { resolveDiscoveredResourcePaths } from "./discovered-resource-scope.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 import { AssistantEditError, assertExpectedLeaf, assistantTextEquals, buildEditedAssistantMessage, SessionStreamingError, } from "./edited-assistant-message.js";
 import { assertExpectedUserLeaf, buildEditedUserMessage, UserEditError, userTextEquals, } from "./edited-user-message.js";
+import { environmentContextMessageIfChanged, resolveEnvironmentContext, } from "./environment-context.js";
 import { areExperimentalFeaturesEnabled } from "./experimental.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -329,6 +330,12 @@ export class AgentSession {
         this._withheldEvalOnlyToolNames = new Set();
         /** Eval-only hint names this session published, so a disarm can withdraw exactly those. */
         this._publishedEvalOnlyHintNames = new Set();
+        /** Every tool that has been active this session, in first-activation order (senpi#2095). */
+        this._declaredToolNames = [];
+        /** Tool names the base system prompt was last built from. */
+        this._promptToolNames = [];
+        /** Whether the last tool declaration used the session-wide declared set. */
+        this._promptDeclaresSessionTools = false;
         this._extensionMode = "print";
         // Tool registry for extension getTools/setTools
         this._toolRegistry = new Map();
@@ -429,6 +436,7 @@ export class AgentSession {
         this._selectorCooldowns = new SelectorCooldowns(config.fallbackNow ?? (() => Date.now()));
         this._fallbackNow = config.fallbackNow ?? (() => Date.now());
         this._retryRandom = config.retryRandom ?? Math.random;
+        this._environmentContextEnabled = config.environmentContext ?? true;
         this._retryFallback = new RetryFallbackController({
             getSettings: () => this.settingsManager.getRetryFallbackSettings(),
             registry: this._modelRegistry,
@@ -821,6 +829,7 @@ export class AgentSession {
                 };
                 previousContext = previousSnapshot.context ?? postLateCompactionTurn.context;
             }
+            this._refreshToolDeclarationsForModel();
             return {
                 ...previousSnapshot,
                 context: {
@@ -828,6 +837,7 @@ export class AgentSession {
                     messages: previousContext.messages,
                     systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
                     tools: this.agent.state.tools.slice(),
+                    declaredTools: this.agent.state.declaredTools?.slice(),
                 },
                 model: this.agent.state.model,
                 thinkingLevel: this.agent.state.thinkingLevel,
@@ -2424,9 +2434,12 @@ export class AgentSession {
         const activeToolNamesChanged = validToolNames.length !== this.agent.state.tools.length ||
             validToolNames.some((name, index) => name !== this.agent.state.tools[index]?.name);
         this.agent.state.tools = tools;
+        for (const name of validToolNames) {
+            if (!this._declaredToolNames.includes(name))
+                this._declaredToolNames.push(name);
+        }
         // Rebuild base system prompt with new tool set
-        this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
-        this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
+        this._applyToolDeclarations(validToolNames);
         if (activeToolNamesChanged) {
             // A tool change emitted while extensions are still binding belongs to the
             // binding itself, not to a mid-session change. The session was already
@@ -2438,6 +2451,45 @@ export class AgentSession {
             }
         }
     }
+    /**
+     * senpi#2095: a model that accepts `allowed_tools` is declared every tool this session has
+     * activated, and the prompt's tool section lists that same set, so the active set shrinking or
+     * re-growing restricts callability through `tool_choice` instead of rewriting the cached prefix.
+     * Any other model is declared exactly the active tools.
+     */
+    _declaresSessionTools() {
+        const model = this.model;
+        return model !== undefined && supportsAllowedToolChoice(model);
+    }
+    _toolDeclarationNames(activeToolNames) {
+        if (!this._declaresSessionTools())
+            return [...activeToolNames];
+        return this._declaredToolNames.filter((name) => this._toolRegistry.has(name));
+    }
+    _applyToolDeclarations(activeToolNames) {
+        this._promptDeclaresSessionTools = this._declaresSessionTools();
+        const declaredNames = this._toolDeclarationNames(activeToolNames);
+        const declaresInactiveTools = declaredNames.length !== activeToolNames.length ||
+            declaredNames.some((name, index) => name !== activeToolNames[index]);
+        this.agent.state.declaredTools = declaresInactiveTools
+            ? declaredNames.flatMap((name) => this._toolRegistry.get(name) ?? [])
+            : undefined;
+        this._baseSystemPrompt = this._rebuildSystemPrompt(declaredNames);
+        this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
+    }
+    /**
+     * Re-derive the declaration after a model change. Only a switch into or out of a model that declares
+     * the session set can move it, and the prompt is rebuilt only when its tool list actually moves.
+     */
+    _refreshToolDeclarationsForModel() {
+        if (!this._declaresSessionTools() && !this._promptDeclaresSessionTools)
+            return;
+        const declaredNames = this._toolDeclarationNames(this.getActiveToolNames());
+        const unchanged = declaredNames.length === this._promptToolNames.length &&
+            declaredNames.every((name, index) => name === this._promptToolNames[index]);
+        if (!unchanged)
+            this._applyToolDeclarations(this.getActiveToolNames());
+    }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
         return (this._compactionLifecycle.state.status === "running" ||
@@ -2550,6 +2602,7 @@ export class AgentSession {
     }
     _rebuildSystemPrompt(toolNames) {
         const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
+        this._promptToolNames = validToolNames;
         // An eval-only tool is hidden from the model but still callable as `tool.<name>(...)`,
         // so its own snippet and guidelines still apply and must survive the withholding.
         // `selectedTools` stays the model-visible list; only the contributions are widened.
@@ -2956,8 +3009,11 @@ export class AgentSession {
             }
             // The user's new prompt is sent below, so do not call agent.continue() here.
             await this._enforceCompactionBeforeProvider(this._findLastAssistantMessage(), false, "pre_prompt");
-            // Build messages array (custom message if any, then user message)
+            // Build messages array (environment context if it changed, user message, then custom messages)
             messages = [];
+            const environmentContext = this._pendingEnvironmentContextMessage();
+            if (environmentContext)
+                messages.push(environmentContext);
             // Add user message
             const userContent = [{ type: "text", text: expandedText }];
             if (currentImages) {
@@ -2977,6 +3033,7 @@ export class AgentSession {
                 messages.push(msg);
             }
             // Emit before_agent_start extension event
+            this._refreshToolDeclarationsForModel();
             const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPrompt, this._baseSystemPromptOptions);
             this._applyBeforeAgentStartResult(messages, result);
             // The preflight above only sees persisted session context. These prompt,
@@ -3429,7 +3486,8 @@ export class AgentSession {
             }
             else if (options?.triggerTurn) {
                 finishSessionWork ??= this._sessionWorkBarrier.begin();
-                const messages = [appMessage];
+                const environmentContext = this._pendingEnvironmentContextMessage();
+                const messages = environmentContext ? [environmentContext, appMessage] : [appMessage];
                 const queueTriggerForLater = () => {
                     if (options.deliverAs === "followUp") {
                         this.agent.followUp(appMessage);
@@ -3441,6 +3499,7 @@ export class AgentSession {
                 this._triggerTurnAdmissionAbortGeneration = userAbortGeneration;
                 try {
                     await this._enforceCompactionBeforeProvider(this._findLastAssistantMessage(), false, "pre_prompt");
+                    this._refreshToolDeclarationsForModel();
                     const result = await this._extensionRunner.emitBeforeAgentStart(contentText(appMessage.content, ""), undefined, this._baseSystemPrompt, this._baseSystemPromptOptions);
                     if (userAbortGeneration !== this._userAbortGeneration) {
                         queueTriggerForLater();
@@ -3478,6 +3537,12 @@ export class AgentSession {
             finishSessionWork?.();
         }
     }
+    /** Environment context a new turn must carry: set when cwd or date differs from the latest one visible (senpi#2093). */
+    _pendingEnvironmentContextMessage() {
+        if (!this._environmentContextEnabled)
+            return undefined;
+        return environmentContextMessageIfChanged(this.agent.state.messages, resolveEnvironmentContext(this._cwd));
+    }
     _appendCustomMessage(appMessage) {
         this.agent.state.messages.push(appMessage);
         this._emitEntryAppended(this.sessionManager.appendCustomMessageEntry(appMessage.customType, appMessage.content, appMessage.display, appMessage.details));
@@ -4050,7 +4115,7 @@ export class AgentSession {
         const previousReasoningBaseline = this.agent.state.reasoningBaseline;
         const previousAbortServerSideFallback = this.agent.abortServerSideFallback;
         this.agent.state.model = model;
-        if (!(model.id === "gpt-6-astra" && (model.provider === "openai" || model.provider === "chatgpt-subscription"))) {
+        if (!supportsConfigurationUpdate(model)) {
             this.agent.state.reasoningBaseline = undefined;
         }
         const scopedMatch = this._scopedModels.find((sm) => modelsAreEqual(sm.model, model));
@@ -4345,9 +4410,7 @@ export class AgentSession {
         if (isChanging || selectionChanged) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel, effectiveSelection);
             const model = this.model;
-            if (isChanging &&
-                model?.id === "gpt-6-astra" &&
-                (model.provider === "openai" || model.provider === "chatgpt-subscription")) {
+            if (isChanging && model !== undefined && supportsConfigurationUpdate(model)) {
                 this.agent.state.reasoningBaseline ??= previousLevel;
                 this.sessionManager.appendConfigurationUpdate(effectiveLevel);
                 this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
@@ -4995,8 +5058,8 @@ export class AgentSession {
             }
             const modelAfterCompaction = this.model;
             if (latestConfigurationEffort !== undefined &&
-                modelAfterCompaction?.id === "gpt-6-astra" &&
-                (modelAfterCompaction.provider === "openai" || modelAfterCompaction.provider === "chatgpt-subscription")) {
+                modelAfterCompaction !== undefined &&
+                supportsConfigurationUpdate(modelAfterCompaction)) {
                 this.sessionManager.appendConfigurationUpdate(latestConfigurationEffort);
             }
             const sessionContext = this.sessionManager.buildSessionContext();
@@ -5977,7 +6040,7 @@ export class AgentSession {
         };
         this._resourceLoader.extendResources(extensionPaths);
         if (skillPaths.length > 0 || promptPaths.length > 0 || themePaths.length > 0) {
-            this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
+            this._baseSystemPrompt = this._rebuildSystemPrompt(this._toolDeclarationNames(this.getActiveToolNames()));
             this.agent.state.systemPrompt = this._baseSystemPrompt;
         }
     }