pi-sage 0.2.13 → 0.2.15

package/.pi/extensions/sage/caller-context.ts

@@ -0,0 +1,50 @@
+import type { CallerContext } from "./types.js";
+
+export type InputSource = "interactive" | "rpc" | "extension";
+export type InteractiveOrRpcSource = "interactive" | "rpc";
+
+export function isKnownInputSource(value: string): value is InputSource {
+  return value === "interactive" || value === "rpc" || value === "extension";
+}
+
+export function updateLastInteractiveOrRpcSource(
+  previous: InteractiveOrRpcSource | undefined,
+  source: string
+): InteractiveOrRpcSource | undefined {
+  if (source === "interactive" || source === "rpc") {
+    return source;
+  }
+  return previous;
+}
+
+export function buildCallerContextFromSignals(input: {
+  lastInteractiveOrRpcSource: InteractiveOrRpcSource | undefined;
+  unknownSourceSeen: boolean;
+  hasUI: boolean;
+  roleHint?: string;
+  isCI?: boolean;
+  isSubagent?: boolean;
+}): CallerContext | null {
+  const { lastInteractiveOrRpcSource, unknownSourceSeen, hasUI, roleHint, isCI, isSubagent } = input;
+  if (unknownSourceSeen) return null;
+  if (!lastInteractiveOrRpcSource) return null;
+
+  const normalizedRole = roleHint?.trim().toLowerCase();
+  const isRpcSource = lastInteractiveOrRpcSource === "rpc";
+  const interactive = hasUI && lastInteractiveOrRpcSource === "interactive";
+  const isInteractiveSupervisor = interactive && normalizedRole === "supervisor";
+
+  return {
+    session: {
+      interactive
+    },
+    agent: {
+      role: normalizedRole ?? "primary",
+      isSubagent: Boolean(isSubagent),
+      isRpcOrchestrated: isRpcSource || Boolean(normalizedRole && normalizedRole !== "primary" && !isInteractiveSupervisor)
+    },
+    runtime: {
+      mode: isCI ? "ci" : hasUI ? (isRpcSource ? "rpc" : "interactive") : "non-interactive"
+    }
+  };
+}

package/.pi/extensions/sage/index.ts

@@ -7,14 +7,26 @@ import {
   isHardCostCapExceeded,
   makeBlockedResult
 } from "./policy.js";
-import { isSageRunnerPolicyError, runSageSingleShot } from "./runner.js";
+import {
+  buildCallerContextFromSignals,
+  isKnownInputSource,
+  updateLastInteractiveOrRpcSource,
+  type InteractiveOrRpcSource
+} from "./caller-context.js";
+import {
+  isSageRunnerPolicyError,
+  runSageSingleShot,
+  type SageRunnerInput,
+  type SageRunnerOutput
+} from "./runner.js";
 import {
   getSettingsPathForScope,
   loadSettings,
   mergeSettings,
   saveSettings,
   type SageSettings,
-  type SettingsScope
+  type SettingsScope,
+  type ToolPolicySettings
 } from "./settings.js";
 import { checkVolumeCaps, getDisallowedCustomTools, resolveToolPolicy } from "./tool-policy.js";
 import type {
@@ -28,8 +40,6 @@ import type {
   ToolProfile
 } from "./types.js";
 
-type InputSource = "interactive" | "rpc" | "extension";
-
 type ModelLike = {
   provider: string;
   id: string;
@@ -68,12 +78,22 @@ export default function registerSageExtension(pi: ExtensionAPI): void {
     sessionCostTotal: 0
   };
 
-  let lastInputSource: InputSource | undefined;
+  let lastInteractiveOrRpcSource: InteractiveOrRpcSource | undefined;
+  let unknownInputSourceSeen = false;
 
   pi.on("input", (event) => {
-    if (event.source === "interactive" || event.source === "rpc" || event.source === "extension") {
-      lastInputSource = event.source;
+    const source = String(event.source ?? "");
+
+    if (!isKnownInputSource(source)) {
+      unknownInputSourceSeen = true;
+      return { action: "continue" };
+    }
+
+    lastInteractiveOrRpcSource = updateLastInteractiveOrRpcSource(lastInteractiveOrRpcSource, source);
+    if (source === "interactive" || source === "rpc") {
+      unknownInputSourceSeen = false;
     }
+
     return { action: "continue" };
   });
 
@@ -160,7 +180,7 @@ export default function registerSageExtension(pi: ExtensionAPI): void {
         });
       }
 
-      const callerContext = buildCallerContext(lastInputSource, ctx.hasUI);
+      const callerContext = buildCallerContext(lastInteractiveOrRpcSource, unknownInputSourceSeen, ctx.hasUI);
       const eligibility = isEligibleCaller(callerContext);
       if (!eligibility.ok) {
         return makeBlockedResult({
@@ -232,10 +252,8 @@ export default function registerSageExtension(pi: ExtensionAPI): void {
         });
       }
 
-      const toolPolicy = resolveToolPolicy(settings.toolPolicy);
-
       try {
-        const runnerResult = await runSageSingleShot({
+        const runnerInput: Omit<SageRunnerInput, "toolPolicy"> = {
           cwd: ctx.cwd,
           model: resolvedModel,
           reasoningLevel: settings.reasoningLevel,
@@ -246,11 +264,13 @@ export default function registerSageExtension(pi: ExtensionAPI): void {
           evidence: input.evidence,
           objective: input.objective,
           urgency: input.urgency,
-          toolPolicy: settings.toolPolicy,
           signal
-        });
+        };
 
-        const volume = checkVolumeCaps(runnerResult.toolUsage, toolPolicy);
+        const invocation = await runSageWithFallback(runnerInput, settings.toolPolicy);
+        const toolPolicy = resolveToolPolicy(invocation.toolPolicyUsed);
+
+        const volume = checkVolumeCaps(invocation.result.toolUsage, toolPolicy);
         if (!volume.ok) {
           return makeBlockedResult({
             mode,
@@ -266,21 +286,25 @@ export default function registerSageExtension(pi: ExtensionAPI): void {
         budgetState.callsThisTurn += 1;
         budgetState.sessionCalls += 1;
         if (mode === "autonomous") budgetState.lastAutoTurn = budgetState.currentTurn;
-        if (runnerResult.usage?.costTotal) budgetState.sessionCostTotal += runnerResult.usage.costTotal;
+        if (invocation.result.usage?.costTotal) budgetState.sessionCostTotal += invocation.result.usage.costTotal;
+
+        const contextReason = invocation.fallbackReason
+          ? "eligible; fallback to read-only-lite after blocked bash command"
+          : "eligible";
 
         return {
-          content: [{ type: "text", text: runnerResult.text }],
+          content: [{ type: "text", text: invocation.result.text }],
           details: {
             model: resolvedModel,
             reasoningLevel: settings.reasoningLevel,
-            latencyMs: runnerResult.latencyMs,
-            stopReason: runnerResult.stopReason,
-            usage: runnerResult.usage,
-            toolUsage: runnerResult.toolUsage,
+            latencyMs: invocation.result.latencyMs,
+            stopReason: invocation.result.stopReason,
+            usage: invocation.result.usage,
+            toolUsage: invocation.result.toolUsage,
             policy: {
               mode,
               allowedByContext: true,
-              contextReason: "eligible",
+              contextReason,
               allowedByBudget: true,
               budgetReason: softBudget.reason
             }
@@ -353,28 +377,45 @@ function formatRunnerPolicyReason(blockCode: BlockCode, reason: string): string
   return reason;
 }
 
-function buildCallerContext(lastInputSource: InputSource | undefined, hasUI: boolean): CallerContext | null {
-  if (!lastInputSource) return null;
-
-  const roleHint = getRoleHint();
-  const isRpcSource = lastInputSource === "rpc";
-  const isSubagent = process.env.PI_SAGE_SUBAGENT === "1";
-  const interactive = hasUI && lastInputSource === "interactive";
-  const isInteractiveSupervisor = interactive && roleHint === "supervisor";
+async function runSageWithFallback(
+  runnerInput: Omit<SageRunnerInput, "toolPolicy">,
+  toolPolicy: ToolPolicySettings
+): Promise<{ result: SageRunnerOutput; toolPolicyUsed: ToolPolicySettings; fallbackReason?: string }> {
+  try {
+    const result = await runSageSingleShot({ ...runnerInput, toolPolicy });
+    return { result, toolPolicyUsed: toolPolicy };
+  } catch (error) {
+    if (
+      isSageRunnerPolicyError(error) &&
+      error.blockCode === "tool-disallowed" &&
+      toolPolicy.profile === "git-review-readonly"
+    ) {
+      const fallbackPolicy: ToolPolicySettings = {
+        ...toolPolicy,
+        profile: "read-only-lite"
+      };
+
+      const result = await runSageSingleShot({ ...runnerInput, toolPolicy: fallbackPolicy });
+      return { result, toolPolicyUsed: fallbackPolicy, fallbackReason: error.message };
+    }
+
+    throw error;
+  }
+}
 
-  return {
-    session: {
-      interactive
-    },
-    agent: {
-      role: roleHint ?? "primary",
-      isSubagent,
-      isRpcOrchestrated: isRpcSource || Boolean(roleHint && roleHint !== "primary" && !isInteractiveSupervisor)
-    },
-    runtime: {
-      mode: process.env.CI ? "ci" : hasUI ? (isRpcSource ? "rpc" : "interactive") : "non-interactive"
-    }
-  };
+function buildCallerContext(
+  lastInteractiveOrRpcSource: InteractiveOrRpcSource | undefined,
+  unknownInputSourceSeen: boolean,
+  hasUI: boolean
+): CallerContext | null {
+  return buildCallerContextFromSignals({
+    lastInteractiveOrRpcSource,
+    unknownSourceSeen: unknownInputSourceSeen,
+    hasUI,
+    roleHint: getRoleHint(),
+    isCI: Boolean(process.env.CI),
+    isSubagent: process.env.PI_SAGE_SUBAGENT === "1"
+  });
 }
 
 function getRoleHint(): string | undefined {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sage",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "private": false,
   "type": "module",
   "description": "Interactive-only advisory Sage extension for Pi",