@caupulican/pi-adaptative 0.81.26 → 0.81.27

package/dist/core/agent-session.d.ts

@@ -1,4 +1,4 @@
-import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, StreamIdleOptions, ThinkingLevel } from "@caupulican/pi-agent-core";
+import type { Agent, AgentEvent, AgentLoopConfig, AgentMessage, AgentState, AgentTool, StreamIdleOptions, ThinkingLevel } from "@caupulican/pi-agent-core";
 import { type CustomMessage } from "@caupulican/pi-agent-core";
 import { type BranchSummaryEntry, type CompactionResult, type SessionManager } from "@caupulican/pi-agent-core/node";
 import type { CacheRetention, ImageContent, Message, Model, StopReason, TextContent, TextToolProtocolVariant, Usage } from "@caupulican/pi-ai";
@@ -12,6 +12,7 @@ import { type ContextCompositionReport } from "./context/context-composition.ts"
 import type { PromptEnforcementReport } from "./context/context-prompt-enforcement.ts";
 import type { PromptPolicyGcCorrelationReport, PromptPolicyShadowReport } from "./context/context-prompt-policy.ts";
 import type { MemoryPromptInclusionReport } from "./context/memory-diagnostics.ts";
+import type { MemoryProvider as ContextMemoryProvider } from "./context/memory-provider-contract.ts";
 import type { MemoryRetrievalReport } from "./context/memory-retrieval.ts";
 import type { ContextGcReport } from "./context-gc.ts";
 import type { SessionCostSummary } from "./cost/cost-summary.ts";
@@ -274,8 +275,8 @@ export interface SpawnedUsageTotals {
     reports: number;
 }
 /**
- * Options for {@link AgentSession.runIsolatedCompletion} — a one-shot LLM call fully isolated from
- * the main session (used by the native reflection engine, R2). See the adaptive-agent design §6c/§7.
+ * Options for {@link AgentSession.runIsolatedCompletion} — an LLM call fully isolated from the main
+ * session. With no tools it is one-shot (reflection); lane callers may supply a bounded child loop.
  */
 export interface IsolatedCompletionOptions {
     /** System prompt for the isolated call. */
@@ -288,6 +289,14 @@ export interface IsolatedCompletionOptions {
     thinkingLevel?: ThinkingLevel;
     /** Output token cap. */
     maxTokens?: number;
+    /** Fresh tools owned by the isolated child. Omitted/empty preserves one-shot behavior. */
+    tools?: AgentTool[];
+    /** Maximum assistant turns for a tool-enabled child loop. Ignored by one-shot calls. */
+    maxTurns?: number;
+    /** Child-only capability/path gate. Never inherited from the foreground session. */
+    beforeToolCall?: AgentLoopConfig["beforeToolCall"];
+    /** Child-only result observer (for example, successful scoped-write accounting). */
+    afterToolCall?: AgentLoopConfig["afterToolCall"];
     /** Abort signal. */
     signal?: AbortSignal;
     /**
@@ -418,7 +427,6 @@ export declare class AgentSession {
     private readonly _analytics;
     private readonly _treeNavigator;
     private _lastCostGuardDecision?;
-    private _costGuardDowngraded;
     /** Per-turn model-router subsystem (see model-router-controller.ts); owns the transient route/intent,
      * the cheap-turn session buffer, the escalation/retry flags, and the sticky last-decision/skip-reason
      * used by the status report. Its parallel routed drive path delegates every turn back to
@@ -488,13 +496,12 @@ export declare class AgentSession {
      */
     private _installAgentContextTransform;
     /**
-     * Proactive per-turn cost guard (#34): estimate the USD cost of the about-to-be-submitted turn and,
-     * when it exceeds the user's ceiling, record a warning decision (for the host UI to surface) and —
-     * if configured to `downgrade` — step reasoning effort down ONCE per over-threshold episode to curb a
-     * runaway billing spike. Disabled by default (`maxTurnUsd<=0`), so it never alters behavior unless the
-     * user opts in. Best-effort: never throws into the turn.
+     * Resolve the foreground request's cost policy after routing/context conversion, when the actual
+     * model, full system prompt, converted messages, and tool schemas are known. The guard is a
+     * projection threshold rather than a hard output cap: warning mode never reduces capability, while
+     * opt-in downgrade changes only this request's reasoning effort. Best-effort: never throws.
      */
-    private _applyCostGuard;
+    private _resolveCostGuardRequestReasoning;
     /** Latest cost-guard decision (for the host footer/UI to surface a warning). Undefined if disabled. */
     getLastCostGuardDecision(): CostGuardDecision | undefined;
     private get _skillCurator();
@@ -773,6 +780,7 @@ export declare class AgentSession {
     private _normalizePromptSnippet;
     private _normalizePromptGuidelines;
     private _rebuildSystemPrompt;
+    private _refreshBaseSystemPrompt;
     /**
      * Build a system prompt for a specific tool surface WITHOUT touching the session's base prompt
      * state (G4 router-swap; see {@link SystemPromptBuilder.buildSystemPromptForToolNames}).
@@ -897,6 +905,8 @@ export declare class AgentSession {
     setModel(model: Model<any>, options?: {
         persistSettings?: boolean;
     }): Promise<void>;
+    /** Re-resolve startup profile model/thinking after allowed extension providers are bound. */
+    reapplyActiveProfileModelSettings(): Promise<void>;
     cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
     setThinkingLevel(level: ThinkingLevel, options?: {
         persistSettings?: boolean;
@@ -960,6 +970,7 @@ export declare class AgentSession {
     private _bindExtensionCore;
     /** Register a memory provider contributed by an extension; applied on the next memory (re)init. */
     registerMemoryProvider(provider: MemoryProvider): void;
+    registerContextMemoryProvider(provider: ContextMemoryProvider): void;
     /** R8: the gateway/scheduler registry. A deployment runner registers providers and drives start/stop. */
     get gateways(): GatewayRegistry;
     /** R8: register a deployment-supplied transport channel (gateway). */