@duetso/agent 0.2.6 → 0.3.1

package/dist/src/turn-runner/turn-runner.js

@@ -1,6 +1,13 @@
+import { resolve } from "node:path";
 import { Agent, } from "@earendil-works/pi-agent-core";
 import { isContextOverflow } from "@earendil-works/pi-ai";
 import { resolveProviderApiKey } from "../model-resolution/duet-gateway.js";
+import { ensureFreshConnectedTokens, markConnectedProviderReconnectNeeded, } from "../connected-providers/tokens.js";
+import { isConnectedProviderId } from "../connected-providers/store.js";
+import { connectedFallbackCause, isPostOutputConnectedFailure, nextTransportAfterConnectedFailure, } from "../connected-providers/fallback.js";
+import { transportFallbackNotice } from "../connected-providers/fallback-notice.js";
+import { usageForTransport } from "../connected-providers/billing.js";
+import { connectedTransportSnapshot, demoteConnectedTransport } from "../cli/shared.js";
 import dedent from "dedent";
 import { stripSystemReminders, systemReminder } from "../lib/system-reminder.js";
 import { assistantText } from "../core/serializer.js";
@@ -8,20 +15,22 @@ import { classifyRoute } from "../model-routing/classifier.js";
 import { loadRoutingTable } from "../model-routing/loader.js";
 import { AdvisorTurnLifecycle } from "../model-routing/advisor-lifecycle.js";
 import { ADVISOR_COMPLETION_REVIEW_REMINDER, ADVISOR_EXECUTOR_GUIDANCE_LAYER, ADVISOR_ORIENTATION_REMINDER, } from "../model-routing/prompts.js";
-import { captureAdvisorExecutorContext } from "../model-routing/advisor-context.js";
+import { ADVISOR_RECENT_MESSAGE_TARGET_TOKENS, buildAdvisorContext, captureAdvisorExecutorContext, } from "../model-routing/advisor-context.js";
+import { ADVISOR_MAX_OUTPUT_TOKENS } from "../model-routing/advisor.js";
 import { resolveTierDefault } from "../model-routing/resolve.js";
 import { ModelRouter, } from "../model-routing/router.js";
 import { BUILT_IN_ROUTING_TABLE, isVirtualModel, } from "../model-routing/table.js";
 import { toXML } from "../lib/xml.js";
-import { createObservationalContextTransform, DEFAULT_EFFECTIVE_CONTEXT, estimateTokens, resolveObservationalMemorySettings, stripObservationalContextMessages, updateObservationalMemory, } from "../memory/observational.js";
-import { rebuildMemoryContextPack } from "../memory/context-pack.js";
+import { compactObservationalContext, createObservationalContextTransform, DEFAULT_EFFECTIVE_CONTEXT, estimateTokens, resolveObservationalMemorySettings, stripObservationalContextMessages, updateObservationalMemory, } from "../memory/observational.js";
+import { rebuildMemoryContextPack, rebuildPinnedStoreContextPack } from "../memory/context-pack.js";
 import { createEmbeddingClient } from "../memory/embedding.js";
 import { loadStoredMemory, replaceSessionObservations, } from "../memory/storage.js";
 import { MemoryContextCache } from "../memory/store.js";
-import { DEFAULT_CLI_MEMORY_MODEL, DEFAULT_CLI_MODEL, resolveModelName, routingCatalogAdapter, } from "../model-resolution/resolver.js";
+import { discoverMemoryStores } from "../memory/store/discovery.js";
+import { DEFAULT_CLI_MEMORY_MODEL, DEFAULT_CLI_MODEL, resolveMeteredModelName, resolveModelName, routingCatalogAdapter, } from "../model-resolution/resolver.js";
 import { DEFAULT_TASK_WAIT_BUDGET_MS } from "../types/config.js";
 import { COMPACT_MESSAGE_TOKENS_RATIO, compactTurnState, } from "./state-compaction.js";
-import { createAgentEventTranslator, agentMessageText } from "./agent-events.js";
+import { createAgentEventTranslator, agentMessageText, isExternallyVisibleAgentEvent, } from "./agent-events.js";
 import { createRecallMemorySystemPromptLayer, createSourceOfTruthSystemPromptLayer, createStateMachineSystemPromptLayer, withheldAskReminder, parkNudge, } from "./prompts.js";
 import { applyEvictionHorizon, calculateWireTokens, createInitialHorizon, findEvictionHorizon, } from "./wire-shaping.js";
 import { createDefaultTurnRunnerTools, createTurnRunnerTools, resolveStateCwd, formatCarriedTodosReminder, formatStateMachineTerminalAcknowledgmentPrompt, isTurnRunnerControlResult, MINIMUM_STATE_MACHINE_DELAY_MS, } from "./tools.js";
@@ -284,8 +293,9 @@ export class TurnRunner {
                 }
                 : undefined),
             retryTransientServerErrors: (agent) => this.retryTransientServerErrors(agent),
+            retryConnectedTransportFallback: (agent, visibleOutput) => this.retryConnectedTransportFallback(agent, visibleOutput),
             emitAgentEvent: (event, origin) => this.emitAgentEvent(event, origin),
-            recordUsage: (usage, modelId) => this.recordUsage(usage, modelId),
+            recordUsage: (usage, modelId, provider) => this.recordUsage(usage, modelId, provider),
             emitTurnUsage: (origin) => this.emitTurnUsage(origin),
         });
     }
@@ -442,6 +452,7 @@ export class TurnRunner {
      * sees available skills before typing the first prompt.
      */
     async start(command) {
+        await ensureFreshConnectedTokens();
         await this.ensureMemoryLoaded();
         await this.ensureSkillsLoaded();
         await this.ensureMcpServersConnected(command.mcpServers);
@@ -508,6 +519,7 @@ export class TurnRunner {
      */
     async turn(command, onAccepted) {
         this.requireStarted();
+        await ensureFreshConnectedTokens();
         await this.ensureMemoryLoaded();
         await this.ensureSkillsLoaded();
         // Serialize behind an in-flight compact. Compact advances the wire
@@ -1881,12 +1893,9 @@ export class TurnRunner {
         });
     }
     createAskAdvisorStorage(router, policy) {
-        const resolveAdvisorModel = () => resolveModelName(policy.target.modelName);
+        const resolveAdvisorModel = () => resolveMeteredModelName(policy.target.modelName);
         return {
-            getContext: async () => {
-                const agent = this.requireParentAgent();
-                return await captureAdvisorExecutorContext(agent);
-            },
+            getContext: async (contextWindowTokens) => await this.captureContextForAdvisor(contextWindowTokens),
             resolveModel: () => {
                 const model = resolveAdvisorModel();
                 return {
@@ -1905,7 +1914,7 @@ export class TurnRunner {
             },
             recordUsage: (usage) => {
                 const model = resolveAdvisorModel();
-                this.recordAndEmitUsage(usageFromAiSdk(usage, model), model.id);
+                this.recordAndEmitUsage(usageFromAiSdk(usage, model), model.id, model.provider);
             },
             onUsageError: (error) => {
                 const reason = error instanceof Error ? error.message : String(error);
@@ -1925,6 +1934,55 @@ export class TurnRunner {
             },
         };
     }
+    /**
+     * Keep ordinary advisor calls raw when already efficient. Above the soft
+     * target, drain older work through the normal memory observer and project it
+     * with an advisor-owned horizon so the executor's next request is unchanged.
+     */
+    async captureContextForAdvisor(contextWindowTokens, options = {}) {
+        const agent = this.requireParentAgent();
+        const rawContext = await captureAdvisorExecutorContext(agent);
+        const rawRequest = buildAdvisorContext({
+            context: rawContext,
+            contextWindowTokens,
+            reservedOutputTokens: ADVISOR_MAX_OUTPUT_TOKENS,
+        });
+        const inputTargetTokens = rawRequest.metadata.inputTargetTokens;
+        if (!rawRequest.metadata.truncated &&
+            rawRequest.metadata.estimatedInputTokens <= inputTargetTokens) {
+            return rawContext;
+        }
+        if (!this.memoryPersistence?.session)
+            return rawContext;
+        let recentMessageTarget = Math.min(ADVISOR_RECENT_MESSAGE_TARGET_TOKENS, Math.floor(inputTargetTokens / 2));
+        let projectedContext = rawContext;
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            projectedContext = await captureAdvisorExecutorContext(agent, {
+                transformMessages: async (messages) => await compactObservationalContext({
+                    messages,
+                    memory: this.memory,
+                    horizon: this.advisorWireGuardHorizon,
+                    targetMessageTokens: recentMessageTarget,
+                    protectRecentToolInteraction: true,
+                    ...(options.drainObservations === false
+                        ? {}
+                        : {
+                            onCompaction: async (observable) => await this.ensureMemoryCoverageForCompaction(observable),
+                        }),
+                }),
+            });
+            const projectedRequest = buildAdvisorContext({
+                context: projectedContext,
+                contextWindowTokens,
+                reservedOutputTokens: ADVISOR_MAX_OUTPUT_TOKENS,
+            });
+            const excess = projectedRequest.metadata.estimatedInputTokens - inputTargetTokens;
+            if (excess <= 0)
+                return projectedContext;
+            recentMessageTarget = Math.max(1, recentMessageTarget - excess);
+        }
+        return projectedContext;
+    }
     /**
      * Pass-prep applied to EVERY parent pass, including harness overrides of
      * `runAgentWorker` (they must call this first). One-shot reminders that must
@@ -1947,7 +2005,12 @@ export class TurnRunner {
         agent.state.tools = this.turnTools ?? this.createTools(input.state.mode).tools;
         this.parentControlResults.length = 0;
         this.setParentAgentRunning(true);
-        const unsubscribe = agent.subscribe((event) => this.emitParentAgentEvent(event));
+        let visibleOutput = false;
+        const unsubscribe = agent.subscribe((event) => {
+            if (isExternallyVisibleAgentEvent(event))
+                visibleOutput = true;
+            this.emitParentAgentEvent(event);
+        });
         this.parentAgentInterrupted = false;
         try {
             if (!input.continuation) {
@@ -1960,6 +2023,7 @@ export class TurnRunner {
             if (switched)
                 await this.applyRouterSwitch(agent, switched);
             await agent.prompt(input.prompt, input.images);
+            await this.retryConnectedTransportFallback(agent, () => visibleOutput);
             // Single-shot recovery: if the provider rejected the first attempt
             // with a context-overflow error, advance the sticky wire-shaping
             // horizon so the next send carries roughly the newer half of
@@ -1971,7 +2035,9 @@ export class TurnRunner {
             if (await this.tryRecoverFromContextOverflow(agent)) {
                 await agent.continue();
             }
-            await this.retryTransientServerErrors(agent);
+            if (!isPostOutputConnectedFailure(agent.state.model.provider, agent.state.messages.at(-1), visibleOutput)) {
+                await this.retryTransientServerErrors(agent);
+            }
         }
         catch (error) {
             if (!this.parentAgentInterrupted) {
@@ -2152,6 +2218,37 @@ export class TurnRunner {
             attempt = messagesAppended > 1 ? 1 : attempt + 1;
         }
     }
+    /** Retry a connected-provider refusal on the next transport before any visible effect. */
+    async retryConnectedTransportFallback(agent, visibleOutput) {
+        while (agent.state.errorMessage) {
+            const provider = agent.state.model.provider;
+            if (!isConnectedProviderId(provider))
+                return;
+            const cause = connectedFallbackCause(agent.state.messages.at(-1));
+            if (!cause || visibleOutput())
+                return;
+            const fallback = nextTransportAfterConnectedFailure(provider, agent.state.model.id, connectedTransportSnapshot());
+            if (!fallback || fallback.transport === provider)
+                return;
+            const failedModelName = agent.state.model.id;
+            demoteConnectedTransport(provider);
+            if (cause === "auth_failed")
+                await markConnectedProviderReconnectNeeded(provider);
+            agent.state.messages.pop();
+            agent.state.model = resolveModelName(`${fallback.transport}:${fallback.modelId}`);
+            this.emit({
+                type: "system",
+                level: "info",
+                message: transportFallbackNotice({
+                    provider,
+                    modelName: failedModelName,
+                    fallbackTransport: fallback.transport,
+                    cause,
+                }),
+            });
+            await agent.continue();
+        }
+    }
     async updateMemoryAfterAgentRun(messages, options, sessionId = this.config.sessionId, refreshReflections = true) {
         if (this.config.memoryDbPath === undefined) {
             return;
@@ -2164,13 +2261,14 @@ export class TurnRunner {
         // state-agent entries in `usageByModel` (e.g. `openai/gpt-5.4-mini`) rather
         // than mixing a shorthand in among resolved ids.
         const memoryModel = this.resolveMemoryActorModel(options);
-        const memoryModelId = resolveModelName(memoryModel).id;
+        const resolvedMemoryModel = resolveMeteredModelName(memoryModel);
+        const memoryModelId = resolvedMemoryModel.id;
         const result = await updateObservationalMemory({
             session,
             memory: this.memory,
             sessionId,
             effectiveContext: this.resolveEffectiveContext(this.parentAgent?.state.model.contextWindow),
-            actorModel: memoryModel,
+            actorModel: `${resolvedMemoryModel.provider}:${resolvedMemoryModel.id}`,
             settings: this.config.memory,
             messages,
             cwd: this.config.cwd ?? process.cwd(),
@@ -2180,7 +2278,7 @@ export class TurnRunner {
             // the terminal aggregate even though memory runs after the parent's
             // final `message_end`.
             onUsage: (usage) => {
-                this.recordUsage(usage, memoryModelId);
+                this.recordUsage(usage, memoryModelId, resolvedMemoryModel.provider);
                 this.emitTurnUsage();
             },
             onActivity: (event) => this.emit({ type: "memory", ...event }),
@@ -2333,18 +2431,21 @@ export class TurnRunner {
     // `runAgentWorker` on a provider context-overflow error so the retry
     // sends the newer half of history.
     wireGuardHorizon = createInitialHorizon();
+    /** Sticky only for repeated advisor projections; never persisted into executor state. */
+    advisorWireGuardHorizon = createInitialHorizon();
     async getSkills() {
         await this.ensureSkillsLoaded();
         return this.skillContext.getSkills();
     }
     /**
-     * Re-discover installed skills from disk. Surfaces newly added skills
-     * (e.g. installed in this session) without restarting the runner.
+     * Re-discover installed skills and curated memory stores from disk. Surfaces
+     * newly added skills or edited memory files without restarting the runner.
      * Callers typically pair this with `getSkills()` to refresh their
      * autocomplete catalog.
      */
     async reloadSkills() {
         await this.skillContext.reload();
+        await this.refreshPinnedStoreContextPack();
         return this.skillContext.getSkills();
     }
     /** System-prompt files (AGENTS.md by default) that resolved on disk for this session. */
@@ -2383,10 +2484,11 @@ export class TurnRunner {
         // call so a `duet login` mid-session lights up retrieval without
         // a runner restart.
         //
-        // Initial context pack build runs synchronously inside
-        // loadStoredMemory so the very first dispatched turn already sees
-        // a frozen memory prefix. Subsequent compaction triggers (reflector
-        // completion, wire-shaping eviction) refresh it.
+        // The file-backed pack loads alongside the database-backed pack so the
+        // first dispatched turn sees both frozen layers. Later database compaction
+        // triggers refresh only observations; explicit skills reload refreshes the
+        // file-backed layer.
+        const pinnedStoreLoad = this.refreshPinnedStoreContextPack();
         this.memoryPersistence = await loadStoredMemory(this.config.memoryDbPath, this.config.cwd ?? process.cwd(), {
             embed: createEmbeddingClient(),
             contextPack: {
@@ -2415,6 +2517,27 @@ export class TurnRunner {
                 });
             },
         });
+        await pinnedStoreLoad;
+    }
+    /** Reload the frozen file-backed layer without touching database memory. */
+    async refreshPinnedStoreContextPack() {
+        if (this.config.memoryStores === false) {
+            this.memory.setStoredContextPack([]);
+            return;
+        }
+        try {
+            const base = this.config.cwd ?? process.cwd();
+            // Explicit entries may be relative; resolve them against the configured
+            // cwd like relative db and system-prompt paths, not the process cwd.
+            const stores = this.config.memoryStores
+                ? this.config.memoryStores.map((store) => resolve(base, store))
+                : await discoverMemoryStores(base);
+            await rebuildPinnedStoreContextPack({ stores, cache: this.memory });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            console.warn(`[duet-agent] failed to load pinned memory stores: ${reason}`);
+        }
     }
     createBaseSystemPromptWithAppendedLayers(input) {
         return this.skillContext.createSystemPromptWithAppendedLayers(input);
@@ -2433,15 +2556,21 @@ export class TurnRunner {
             thinkingLevel: options?.thinkingLevel ?? base?.thinkingLevel ?? this.config.thinkingLevel,
         };
     }
-    recordUsage(usage, modelId) {
-        this.turnUsage = addUsage(this.turnUsage, usage);
-        if (usage && modelId) {
-            this.turnUsageByModel = addUsageByModel(this.turnUsageByModel, modelId, usage);
+    recordUsage(usage, modelId, provider) {
+        const transport = provider ?? this.parentAgent?.state.model.provider;
+        if (usage && (!modelId || !transport)) {
+            throw new Error("Usage accounting requires both model id and transport provider.");
+        }
+        const accounted = usage && transport ? usageForTransport(usage, transport) : usage;
+        this.turnUsage = addUsage(this.turnUsage, accounted);
+        if (accounted && modelId && transport) {
+            this.turnUsageByModel = addUsageByModel(this.turnUsageByModel, modelId, transport, accounted);
+            this.turnUsage.cost.total = this.turnUsageByModel.reduce((total, entry) => total + entry.usage.cost.total, 0);
         }
     }
     /** Attribute a non-parent model call and publish it once a flat context snapshot exists. */
-    recordAndEmitUsage(usage, modelId) {
-        this.recordUsage(usage, modelId);
+    recordAndEmitUsage(usage, modelId, provider) {
+        this.recordUsage(usage, modelId, provider);
         this.emitTurnUsage();
     }
     emitAgentEvent(event, origin) {
@@ -2475,7 +2604,7 @@ export class TurnRunner {
         // consumed tokens, so a rejected attempt (e.g. a provider context-overflow
         // error the turn then recovers from) carries no usage and would otherwise
         // emit a degenerate all-zero bar.
-        this.recordUsage(event.message.usage, event.message.model);
+        this.recordUsage(event.message.usage, event.message.model, event.message.provider);
         if (event.message.usage.totalTokens > 0)
             this.emitTurnUsage();
     }
@@ -2593,7 +2722,7 @@ export class TurnRunner {
             systemPrompt: estimateTokens(agent.state.systemPrompt),
             messages: messageWireTokens,
             localMemory: pack.local.reduce((total, row) => total + estimateTokens(row.content), 0),
-            globalMemory: pack.global.reduce((total, row) => total + estimateTokens(row.content), 0),
+            globalMemory: [...pack.stored, ...pack.global].reduce((total, row) => total + estimateTokens(row.content), 0),
         };
     }
     /**
@@ -2646,11 +2775,11 @@ export class TurnRunner {
     }
     /** One metered classifier contract shared by parent routing and spawned children. */
     classifierOptions(table) {
-        const model = resolveModelName(table.classifier.target.modelName);
+        const model = resolveMeteredModelName(table.classifier.target.modelName);
         return {
             model: `${model.provider}:${model.id}`,
             thinkingLevel: table.classifier.target.thinkingLevel,
-            onUsage: (usage) => this.recordAndEmitUsage(usage, model.id),
+            onUsage: (usage) => this.recordAndEmitUsage(usage, model.id, model.provider),
         };
     }
     /** True when a model name is owned by the validated project table. */