opencandle 0.4.0 → 0.5.0

package/src/routing/slot-resolver.ts

@@ -20,9 +20,34 @@ interface Preferences {
 }
 
 function mapDteHintToTarget(dteHint: string | undefined): string | undefined {
-  switch (dteHint) {
+  const normalized = dteHint?.toLowerCase().trim();
+  if (!normalized) return undefined;
+
+  if (/\bleaps?\b/.test(normalized) || /\blong[\s-]*dated\b/.test(normalized)) {
+    return "180_plus_days";
+  }
+  if (/\b(?:1|one)\s*(?:-|to|or)\s*(?:2|two)\s*weeks?\b/.test(normalized)) {
+    return "7_to_14_days";
+  }
+  if (/\bevent[_\s-]?week\b/.test(normalized)) {
+    return "0_to_7_days";
+  }
+  const explicitDays = normalized.match(/\b(\d+)\s*(?:-|to|or)\s*(\d+)\s*(?:days?|dte)\b/);
+  if (explicitDays) {
+    return `${explicitDays[1]}_to_${explicitDays[2]}_days`;
+  }
+  if (/\b(?:week|weekly|weeks?)\b/.test(normalized)) {
+    return "7_to_14_days";
+  }
+  if (/\b(?:month|monthly|months?)\b/.test(normalized)) {
+    return "25_to_45_days";
+  }
+
+  switch (normalized) {
     case "week":
       return "7_to_14_days";
+    case "event_week":
+      return "0_to_7_days";
     case "month":
       return "25_to_45_days";
     case "leaps":
@@ -68,7 +93,7 @@ export function resolvePortfolioSlots(
   sources.timeHorizon = horizon.source;
   if (horizon.source === "default") defaultsUsed.push("timeHorizon");
 
-  const scope = resolve(undefined, preferences.assetScope, PORTFOLIO_DEFAULTS.assetScope);
+  const scope = resolve(entities.assetScope, preferences.assetScope, PORTFOLIO_DEFAULTS.assetScope);
   sources.assetScope = scope.source;
   if (scope.source === "default") defaultsUsed.push("assetScope");
 
@@ -105,16 +130,20 @@ export function resolveOptionsScreenerSlots(
 
   // Symbol: required, no default
   let symbol = "";
-  if (entities.symbols.length > 0) {
-    symbol = entities.symbols[0];
+  const requestedUnderlying = entities.heldSymbol ?? entities.symbols[0];
+  if (requestedUnderlying) {
+    symbol = requestedUnderlying;
     sources.symbol = "user";
   } else {
     missingRequired.push("symbol");
     sources.symbol = "default";
   }
 
-  // Direction: default to bullish
-  const dir = resolve(entities.direction, undefined, "bullish" as const);
+  // Direction: default to bullish unless the user specified a protective put hedge.
+  const inferredDirection = entities.optionStrategy === "protective_put"
+    ? "bearish"
+    : entities.direction;
+  const dir = resolve(inferredDirection, undefined, "bullish" as const);
   sources.direction = dir.source;
   if (dir.source === "default") defaultsUsed.push("direction");
 
@@ -134,6 +163,11 @@ export function resolveOptionsScreenerSlots(
   sources.liquidityMinimum = liquidity.source;
   if (liquidity.source === "default") defaultsUsed.push("liquidityMinimum");
 
+  if (entities.optionStrategy) sources.optionStrategy = "user";
+  if (entities.costBasis !== undefined) sources.costBasis = "user";
+  if (entities.shareQuantity !== undefined) sources.shareQuantity = "user";
+  if (entities.catalystSymbols !== undefined) sources.catalystSymbols = "user";
+
   return {
     resolved: {
       symbol,
@@ -144,6 +178,10 @@ export function resolveOptionsScreenerSlots(
       liquidityMinimum: liquidity.value,
       budget: entities.budget,
       maxPremium: entities.maxPremium,
+      optionStrategy: entities.optionStrategy,
+      costBasis: entities.costBasis,
+      shareQuantity: entities.shareQuantity,
+      catalystSymbols: entities.catalystSymbols,
     },
     sources,
     defaultsUsed,

package/src/routing/turn-context.ts

@@ -0,0 +1,111 @@
+import type { MemoryCategory, MemoryEntry } from "../memory/types.js";
+import {
+  activeToolsForBundles,
+  memoryScopesForRoute,
+} from "./route-manifest.js";
+import type {
+  RouterInputContext,
+  RouterOutput,
+  RouterRoute,
+  RouterRouteKind,
+  RouterSlot,
+  ToolBundleName,
+  RouterDiagnostic,
+} from "./router-types.js";
+import {
+  buildPlanningEnvelope,
+  type PlanningBuildOptions,
+  type PlanningEnvelope,
+} from "./planning.js";
+import type { ExtractedEntities, WorkflowType } from "./types.js";
+
+export interface MemoryQueryPlan {
+  routeKind: RouterRouteKind;
+  workflow?: Exclude<WorkflowType, "unclassified">;
+  categories: MemoryCategory[];
+  symbols: string[];
+  slotKeys: string[];
+}
+
+export interface MemoryProvenance {
+  category: MemoryCategory;
+  key: string;
+  source?: string;
+  recordedAt: string;
+  confidence?: string;
+  filtered?: boolean;
+  filterReason?: string;
+}
+
+export interface ResolvedTurnContext {
+  userInput: string;
+  priorTurns: RouterInputContext["priorTurns"];
+  routeKind: RouterRouteKind;
+  legacyRoute: RouterRoute;
+  workflow?: Exclude<WorkflowType, "unclassified">;
+  entities: ExtractedEntities;
+  slots: Record<string, RouterSlot>;
+  missingRequired: string[];
+  toolBundles: ToolBundleName[];
+  activeToolNames: string[];
+  memoryQueryPlan: MemoryQueryPlan;
+  memoryProvenance: MemoryProvenance[];
+  promptPlaybook: RouterRouteKind;
+  diagnostics: RouterDiagnostic[];
+  planning: PlanningEnvelope;
+}
+
+export function buildResolvedTurnContext(
+  input: RouterInputContext,
+  output: RouterOutput,
+  options: {
+    availableToolNames?: readonly string[];
+    memoryEntries?: readonly MemoryEntry[];
+    filteredMemory?: readonly MemoryProvenance[];
+    planning?: PlanningBuildOptions;
+  } = {},
+): ResolvedTurnContext {
+  const memoryQueryPlan = buildMemoryQueryPlan(output);
+  const memoryProvenance = [
+    ...(options.memoryEntries ?? []).map(memoryEntryToProvenance),
+    ...(options.filteredMemory ?? []),
+  ];
+
+  return {
+    userInput: input.text,
+    priorTurns: input.priorTurns,
+    routeKind: output.routeKind,
+    legacyRoute: output.route,
+    workflow: output.workflow,
+    entities: output.entities,
+    slots: output.slots,
+    missingRequired: output.missing_required,
+    toolBundles: output.tool_bundles,
+    activeToolNames: activeToolsForBundles(output.tool_bundles, options.availableToolNames),
+    memoryQueryPlan,
+    memoryProvenance,
+    promptPlaybook: output.routeKind,
+    diagnostics: output.diagnostics,
+    planning: buildPlanningEnvelope(input, output, options.planning),
+  };
+}
+
+export function buildMemoryQueryPlan(output: RouterOutput): MemoryQueryPlan {
+  return {
+    routeKind: output.routeKind,
+    workflow: output.workflow,
+    categories: memoryScopesForRoute(output.routeKind, output.workflow),
+    symbols: output.entities.symbols,
+    slotKeys: Object.keys(output.slots),
+  };
+}
+
+function memoryEntryToProvenance(entry: MemoryEntry): MemoryProvenance {
+  return {
+    category: entry.category,
+    key: entry.key,
+    source: entry.source,
+    recordedAt: entry.recordedAt,
+    confidence: entry.confidence,
+  };
+}

package/src/routing/types.ts

@@ -12,9 +12,16 @@ export interface ExtractedEntities {
   budget?: number;
   maxPremium?: number;
   timeHorizon?: string;
+  assetScope?: string;
   riskProfile?: string;
   direction?: "bullish" | "bearish";
   dteHint?: string;
+  optionStrategy?: "covered_call" | "protective_put";
+  heldSymbol?: string;
+  catalystSymbols?: string[];
+  costBasis?: number;
+  shareQuantity?: number;
+  compareMetrics?: string[];
 }
 
 export interface ClassificationResult {
@@ -45,15 +52,20 @@ export interface OptionsScreenerSlots {
   liquidityMinimum: string;
   budget?: number;
   maxPremium?: number;
+  optionStrategy?: "covered_call" | "protective_put";
+  costBasis?: number;
+  shareQuantity?: number;
+  catalystSymbols?: string[];
   ivPreference?: string;
 }
 
 export interface CompareAssetsSlots {
   symbols: string[];
+  timeHorizon?: string;
   metrics?: string[];
 }
 
-export type SlotSource = "user" | "preference" | "default";
+export type SlotSource = "user" | "preference" | "default" | "prior_context" | "memory";
 
 export interface SlotResolution<T> {
   resolved: T;