opencandle 0.4.0 → 0.5.0

package/src/pi/opencandle-extension.ts

@@ -6,18 +6,25 @@ import {
 import { buildComprehensiveAnalysisDefinition } from "../analysts/orchestrator.js";
 import { getConfig } from "../config.js";
 import {
-  classifyIntent,
+  classifyWithLegacyRules,
   createPiAiRouterClient,
   resolveOptionsScreenerSlots,
   resolvePortfolioSlots,
   route as routeLlm,
+  buildResolvedTurnContext,
 } from "../routing/index.js";
 import type {
   RouterInputContext,
   RouterLlmClient,
   RouterOutput,
 } from "../routing/router-types.js";
-import type { CompareAssetsSlots, SlotResolution } from "../routing/types.js";
+import type { ResolvedTurnContext } from "../routing/turn-context.js";
+import type {
+  CompareAssetsSlots,
+  ExtractedEntities,
+  SlotResolution,
+  SlotSource,
+} from "../routing/types.js";
 import { buildAssumptionsBlockFromRouter } from "../prompts/workflow-prompts.js";
 import {
   buildPortfolioWorkflowDefinition,
@@ -76,6 +83,8 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
   const sessionPromptedSet = new Set<ProviderId>();
   let hardPromptFiredInWorkflow = false;
   const degradationAccumulator = createDegradationAccumulator();
+  let activeToolSnapshot: string[] | null = null;
+  let currentRouteToolContext: ResolvedTurnContext | null = null;
 
   // Register tools
   for (const tool of getOpenCandleToolDefinitions()) {
@@ -261,6 +270,7 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
       msg.role === "assistant" && msg.stopReason === "stop";
     if (isFinalAssistantTurn) {
       pi.appendEntry("opencandle-disclaimer", { text: DISCLAIMER_TEXT });
+      restoreRouteToolScope();
     }
 
     if (degradationAccumulator.isEmpty()) return;
@@ -454,6 +464,29 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
     return undefined;
   });
 
+  pi.on("tool_call", async (event) => {
+    if (!currentRouteToolContext) return undefined;
+    const allowed = new Set(currentRouteToolContext.activeToolNames);
+    if (allowed.has(event.toolName)) return undefined;
+
+    const diagnostic = {
+      routeKind: currentRouteToolContext.routeKind,
+      workflow: currentRouteToolContext.workflow,
+      toolName: event.toolName,
+      toolBundles: currentRouteToolContext.toolBundles,
+      activeToolNames: currentRouteToolContext.activeToolNames,
+    };
+    pi.appendEntry("opencandle-tool-scope-violation", diagnostic);
+
+    if (getConfig().toolScopeMode === "enforce") {
+      return {
+        block: true,
+        reason: `Tool ${event.toolName} is outside the route-selected OpenCandle tool bundle.`,
+      };
+    }
+    return undefined;
+  });
+
   // Input handling — branches on OPENCANDLE_ROUTER_MODE.
   pi.on("input", async (event, ctx) => {
     if (event.source === "extension") return;
@@ -462,8 +495,8 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
     const analysis = isAnalysisRequest(event.text);
     if (analysis.match && analysis.symbol) {
       const definition = buildComprehensiveAnalysisDefinition(analysis.symbol, { debate: getConfig().debate });
-      coordinator.executeWorkflow(pi, definition, ctx);
-      return { action: "handled" };
+      const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+      return prompt ? { action: "transform", text: prompt } : { action: "handled" };
     }
 
     const mode = getConfig().routerMode;
@@ -473,25 +506,25 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
       // the workflow's queued prompts; tell Pi not to also forward it.
       // Fallback path (no dispatch) → let Pi pass the user turn through to the
       // main agent, which will run under the router-supplied fallback context.
-      return dispatched ? { action: "handled" } : undefined;
+      return dispatched || undefined;
     }
 
-    // --- rules mode (default) ---
+    // --- explicit legacy rules mode (`OPENCANDLE_ROUTER_MODE=rules`) ---
     // Extract and persist user preferences (legacy regex path)
     coordinator.extractAndStorePreferences(event.text);
     const storage = coordinator.getStorage();
     const workflowPrefs = storage?.getWorkflowPreferences("global") ?? {};
 
     // Classify intent
-    const classification = classifyIntent(event.text);
+    const classification = classifyWithLegacyRules(event.text);
 
     if (classification.workflow === "portfolio_builder") {
       const resolution = resolvePortfolioSlots(classification.entities, workflowPrefs);
       coordinator.recordWorkflowRun("portfolio_builder", classification.entities, resolution.resolved, resolution.defaultsUsed);
       pi.appendEntry("opencandle-workflow", { workflow: "portfolio_builder", entities: classification.entities, resolved: resolution.resolved });
       const definition = buildPortfolioWorkflowDefinition(resolution);
-      coordinator.executeWorkflow(pi, definition, ctx);
-      return { action: "handled" };
+      const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+      return prompt ? { action: "transform", text: prompt } : { action: "handled" };
     }
 
     if (classification.workflow === "options_screener") {
@@ -500,23 +533,31 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
         coordinator.recordWorkflowRun("options_screener", classification.entities, resolution.resolved, resolution.defaultsUsed);
         pi.appendEntry("opencandle-workflow", { workflow: "options_screener", entities: classification.entities, resolved: resolution.resolved });
         const definition = buildOptionsScreenerWorkflowDefinition(resolution);
-        coordinator.executeWorkflow(pi, definition, ctx);
-        return { action: "handled" };
+        const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+        return prompt ? { action: "transform", text: prompt } : { action: "handled" };
       }
     }
 
     if (classification.workflow === "compare_assets" && classification.entities.symbols.length >= 2) {
       const resolution: SlotResolution<CompareAssetsSlots> = {
-        resolved: { symbols: classification.entities.symbols },
-        sources: { symbols: "user" },
+        resolved: {
+          symbols: classification.entities.symbols,
+          metrics: classification.entities.compareMetrics,
+          timeHorizon: classification.entities.timeHorizon,
+        },
+        sources: {
+          symbols: "user",
+          ...(classification.entities.timeHorizon ? { timeHorizon: "user" as const } : {}),
+          ...(classification.entities.compareMetrics ? { metrics: "user" as const } : {}),
+        },
         defaultsUsed: [],
         missingRequired: [],
       };
       coordinator.recordWorkflowRun("compare_assets", classification.entities, resolution.resolved, resolution.defaultsUsed);
       pi.appendEntry("opencandle-workflow", { workflow: "compare_assets", symbols: classification.entities.symbols });
       const definition = buildCompareAssetsWorkflowDefinition(resolution);
-      coordinator.executeWorkflow(pi, definition, ctx);
-      return { action: "handled" };
+      const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+      return prompt ? { action: "transform", text: prompt } : { action: "handled" };
     }
   });
 
@@ -530,7 +571,7 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
   async function handleLlmRouterTurn(
     text: string,
     ctx: Parameters<Parameters<ExtensionAPI["on"]>[1]>[1],
-  ): Promise<boolean> {
+  ): Promise<{ action: "transform"; text: string } | false> {
     const storage = coordinator.getStorage();
     const { profileSnapshot, recentWorkflowRuns, priorTurns } =
       coordinator.buildRouterContextBase(ctx.sessionManager);
@@ -563,7 +604,33 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
       return false;
     }
 
+    const availableToolNames = safeGetAllToolNames();
+    const memory = coordinator.retrieveMemoryForRoute(
+      output.routeKind,
+      output.workflow,
+      Object.keys(output.slots),
+    );
+    const resolvedTurnContext = buildResolvedTurnContext(input, output, {
+      availableToolNames,
+      memoryEntries: memory.entries,
+      filteredMemory: memory.filtered.map(({ entry, reason }) => ({
+        category: entry.category,
+        key: entry.key,
+        source: entry.source,
+        recordedAt: entry.recordedAt,
+        confidence: entry.confidence,
+        filtered: true,
+        filterReason: reason,
+      })),
+      planning: {
+        migrationStatuses: getConfig().planningMigrationStatuses,
+      },
+    });
+
     pi.appendEntry("opencandle-router", { output });
+    pi.appendEntry("opencandle-route-context", resolvedTurnContext);
+    coordinator.setPendingResolvedTurnContext(resolvedTurnContext);
+    applyRouteToolScope(resolvedTurnContext);
 
     // Preference writes: HIGH-confidence only. Medium/low are logged for
     // observability even when no storage is available.
@@ -585,10 +652,14 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
     }
 
     // Workflow dispatch for recognised workflows.
-    if (output.route === "workflow" && output.workflow) {
+    if (output.routeKind === "workflow_dispatch" && output.workflow) {
       return dispatchRouterWorkflow(output, ctx);
     }
 
+    if (output.routeKind === "pass_through") {
+      return false;
+    }
+
     // Fallback: record the turn and stash the fallback context for the
     // upcoming `before_agent_start` hook to render into the system prompt.
     coordinator.recordWorkflowRun(
@@ -596,7 +667,7 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
       output.entities,
       Object.fromEntries(Object.entries(output.slots).map(([k, v]) => [k, v.value])),
       [],
-      "fallback",
+      output.routeKind,
     );
 
     const assumptionsBlock = buildAssumptionsBlockFromRouter(output.slots);
@@ -605,6 +676,7 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
       missingRequired: output.missing_required,
       extraContext: output.entities.symbols.length > 0
         ? `Router-extracted symbols: ${output.entities.symbols.join(", ")}.`
+          + ` Route kind: ${output.routeKind}. Tool bundles: ${output.tool_bundles.join(", ") || "(none)"}.`
         : undefined,
     });
     return false;
@@ -613,73 +685,88 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
   function dispatchRouterWorkflow(
     output: RouterOutput,
     ctx: Parameters<Parameters<ExtensionAPI["on"]>[1]>[1],
-  ): boolean {
+  ): { action: "transform"; text: string } | false {
     const workflow = output.workflow!;
     const storage = coordinator.getStorage();
     const workflowPrefs = storage?.getWorkflowPreferences("global") ?? {};
+    const entities = mergeRouterSlotsIntoEntities(output);
 
     if (workflow === "portfolio_builder") {
-      const resolution = resolvePortfolioSlots(output.entities, workflowPrefs);
+      const resolution = withRouterSlotSources(
+        resolvePortfolioSlots(entities, workflowPrefs),
+        output,
+      );
       coordinator.recordWorkflowRun(
         "portfolio_builder",
-        output.entities,
+        entities,
         resolution.resolved,
         resolution.defaultsUsed,
-        "workflow",
+        output.routeKind,
       );
       pi.appendEntry("opencandle-workflow", {
         workflow: "portfolio_builder",
-        entities: output.entities,
+        entities,
         resolved: resolution.resolved,
       });
       const definition = buildPortfolioWorkflowDefinition(resolution);
-      coordinator.executeWorkflow(pi, definition, ctx);
-      return true;
+      const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+      return prompt ? { action: "transform", text: prompt } : false;
     }
     if (workflow === "options_screener") {
-      const resolution = resolveOptionsScreenerSlots(output.entities, workflowPrefs);
+      const resolution = withRouterSlotSources(
+        resolveOptionsScreenerSlots(entities, workflowPrefs),
+        output,
+      );
       // Router may emit missing_required; main agent handles via ask_user.
       // Still dispatch the workflow when symbol is present.
       if (resolution.missingRequired.length === 0) {
         coordinator.recordWorkflowRun(
           "options_screener",
-          output.entities,
+          entities,
           resolution.resolved,
           resolution.defaultsUsed,
-          "workflow",
+          output.routeKind,
         );
         pi.appendEntry("opencandle-workflow", {
           workflow: "options_screener",
-          entities: output.entities,
+          entities,
           resolved: resolution.resolved,
         });
         const definition = buildOptionsScreenerWorkflowDefinition(resolution);
-        coordinator.executeWorkflow(pi, definition, ctx);
-        return true;
+        const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+        return prompt ? { action: "transform", text: prompt } : false;
       }
       // Missing required symbol — treat as fallback with ask_user directive.
     }
-    if (workflow === "compare_assets" && output.entities.symbols.length >= 2) {
+    if (workflow === "compare_assets" && entities.symbols.length >= 2) {
       const resolution: SlotResolution<CompareAssetsSlots> = {
-        resolved: { symbols: output.entities.symbols },
-        sources: { symbols: "user" },
+        resolved: {
+          symbols: entities.symbols,
+          metrics: entities.compareMetrics,
+          timeHorizon: entities.timeHorizon,
+        },
+        sources: {
+          symbols: sourceForRouterSlot(output, "symbols", "user"),
+          ...(entities.timeHorizon ? { timeHorizon: "user" as const } : {}),
+          ...(entities.compareMetrics ? { metrics: "user" as const } : {}),
+        },
         defaultsUsed: [],
         missingRequired: [],
       };
       coordinator.recordWorkflowRun(
         "compare_assets",
-        output.entities,
+        entities,
         resolution.resolved,
         [],
-        "workflow",
+        output.routeKind,
       );
       pi.appendEntry("opencandle-workflow", {
         workflow: "compare_assets",
-        symbols: output.entities.symbols,
+        symbols: entities.symbols,
       });
       const definition = buildCompareAssetsWorkflowDefinition(resolution);
-      coordinator.executeWorkflow(pi, definition, ctx);
-      return true;
+      const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+      return prompt ? { action: "transform", text: prompt } : false;
     }
 
     // single_asset_analysis / watchlist / general_qa + any workflow with
@@ -690,17 +777,155 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
       output.entities,
       Object.fromEntries(Object.entries(output.slots).map(([k, v]) => [k, v.value])),
       [],
-      "fallback",
+      output.routeKind,
     );
     const assumptionsBlock = buildAssumptionsBlockFromRouter(output.slots);
     coordinator.setPendingFallbackContext({
       assumptionsBlock,
       missingRequired: output.missing_required,
-      extraContext: `Router classified as ${workflow} but declined to dispatch. Symbols: ${output.entities.symbols.join(", ") || "(none)"}.`,
+      extraContext: `Router classified as ${workflow} but declined to dispatch. Symbols: ${entities.symbols.join(", ") || "(none)"}.`,
     });
     return false;
   }
 
+  function mergeRouterSlotsIntoEntities(output: RouterOutput): ExtractedEntities {
+    const entities: ExtractedEntities = {
+      ...output.entities,
+      symbols: output.entities.symbols,
+    };
+
+    if (entities.budget === undefined && typeof output.slots.budget?.value === "number") {
+      entities.budget = output.slots.budget.value;
+    }
+
+    const slotSymbols = symbolsFromRouterSlots(output);
+    if (slotSymbols.length > 0 && slotSymbols.length > entities.symbols.length) {
+      entities.symbols = mergeSymbols(slotSymbols, entities.symbols);
+    }
+
+    return entities;
+  }
+
+  function withRouterSlotSources<T extends object>(
+    resolution: SlotResolution<T>,
+    output: RouterOutput,
+  ): SlotResolution<T> {
+    const sources: Record<string, SlotSource | undefined> = { ...resolution.sources };
+    if (output.entities.budget === undefined && output.slots.budget) {
+      sources.budget = output.slots.budget.source;
+    }
+    if (output.entities.symbols.length === 0 && output.slots.symbol) {
+      sources.symbol = output.slots.symbol.source;
+    }
+    if (output.entities.symbols.length < 2 && output.slots.symbols) {
+      sources.symbols = output.slots.symbols.source;
+    }
+    return { ...resolution, sources: sources as SlotResolution<T>["sources"] };
+  }
+
+  function sourceForRouterSlot(
+    output: RouterOutput,
+    slotName: "symbol" | "symbols" | "budget",
+    fallback: SlotSource,
+  ): SlotSource {
+    return output.slots[slotName]?.source ?? fallback;
+  }
+
+  function symbolsFromRouterSlots(output: RouterOutput): string[] {
+    const symbols: string[] = [];
+    const symbol = output.slots.symbol?.value;
+    if (typeof symbol === "string" && symbol.trim() !== "") {
+      symbols.push(symbol.toUpperCase());
+    }
+    const symbolList = output.slots.symbols?.value;
+    if (Array.isArray(symbolList)) {
+      for (const value of symbolList) {
+        if (typeof value === "string" && value.trim() !== "") {
+          symbols.push(value.toUpperCase());
+        }
+      }
+    }
+    return symbols;
+  }
+
+  function mergeSymbols(primary: string[], secondary: string[]): string[] {
+    const merged: string[] = [];
+    for (const symbol of [...primary, ...secondary]) {
+      if (!merged.includes(symbol)) merged.push(symbol);
+    }
+    return merged;
+  }
+
+  function safeGetAllToolNames(): string[] {
+    try {
+      return pi.getAllTools().map((tool) => tool.name);
+    } catch {
+      return [];
+    }
+  }
+
+  function applyRouteToolScope(context: ResolvedTurnContext): void {
+    const mode = getConfig().toolScopeMode;
+    currentRouteToolContext = context;
+    pi.appendEntry("opencandle-tool-scope", {
+      mode,
+      routeKind: context.routeKind,
+      workflow: context.workflow,
+      toolBundles: context.toolBundles,
+      activeToolNames: context.activeToolNames,
+      enforced: false,
+    });
+
+    if (mode !== "enforce") return;
+    if (context.activeToolNames.length === 0) return;
+
+    try {
+      if (activeToolSnapshot === null) {
+        activeToolSnapshot = pi.getActiveTools();
+      }
+      pi.setActiveTools(context.activeToolNames);
+      pi.appendEntry("opencandle-tool-scope", {
+        mode,
+        routeKind: context.routeKind,
+        workflow: context.workflow,
+        toolBundles: context.toolBundles,
+        activeToolNames: context.activeToolNames,
+        enforced: true,
+      });
+    } catch (err) {
+      pi.appendEntry("opencandle-tool-scope", {
+        mode,
+        routeKind: context.routeKind,
+        workflow: context.workflow,
+        toolBundles: context.toolBundles,
+        activeToolNames: context.activeToolNames,
+        enforced: false,
+        diagnostic: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  function restoreRouteToolScope(): void {
+    currentRouteToolContext = null;
+    if (activeToolSnapshot === null) return;
+    try {
+      pi.setActiveTools(activeToolSnapshot);
+      pi.appendEntry("opencandle-tool-scope", {
+        mode: getConfig().toolScopeMode,
+        restored: true,
+        activeToolNames: activeToolSnapshot,
+      });
+    } catch (err) {
+      pi.appendEntry("opencandle-tool-scope", {
+        mode: getConfig().toolScopeMode,
+        restored: false,
+        diagnostic: err instanceof Error ? err.message : String(err),
+      });
+    } finally {
+      activeToolSnapshot = null;
+    }
+  }
+
   function resolveRouterLlmClient(
     ctx: Parameters<Parameters<ExtensionAPI["on"]>[1]>[1],
   ): RouterLlmClient | null {
@@ -717,8 +942,14 @@ export default function openCandleExtension(pi: ExtensionAPI, options?: OpenCand
   // is pending (router-mode fallback turns), inject it into the prompt.
   pi.on("before_agent_start", async (event) => {
     const fallbackContext = coordinator.consumePendingFallbackContext() ?? undefined;
+    const resolvedTurnContext = coordinator.consumePendingResolvedTurnContext() ?? undefined;
     return {
-      systemPrompt: coordinator.buildSystemPrompt(event.systemPrompt, undefined, fallbackContext),
+      systemPrompt: coordinator.buildSystemPrompt(
+        event.systemPrompt,
+        undefined,
+        fallbackContext,
+        resolvedTurnContext,
+      ),
     };
   });
 }

package/src/pi/setup.ts

@@ -158,8 +158,18 @@ async function runLoginDialog(ctx: ExtensionContext, providerId: string): Promis
           dialog.showWaiting("Waiting for browser authentication...");
         }
       },
+      onDeviceCode: (info) => {
+        dialog.showDeviceCode(info);
+        dialog.showWaiting("Waiting for authentication...");
+      },
       onPrompt: async (prompt) => dialog.showPrompt(prompt.message, prompt.placeholder),
       onProgress: (message) => dialog.showProgress(message),
+      onSelect: async (prompt) => {
+        const options = prompt.options.map((option, index) => `${index + 1}. ${option.label}`).join("\n");
+        const answer = await dialog.showPrompt(`${prompt.message}\n\n${options}`, "Enter a number");
+        const selectedIndex = Number.parseInt(answer.trim(), 10) - 1;
+        return prompt.options[selectedIndex]?.id;
+      },
       onManualCodeInput: () => manualCodePromise,
       signal: dialog.signal,
     })