opencandle 0.10.0 → 0.11.1

package/src/runtime/planning-evidence.ts

@@ -1,3 +1,9 @@
+import {
+  classifyMarketStatus,
+  KNOWN_US_MARKET_HOLIDAYS,
+  lastTradingDay,
+  localDateTimeParts,
+} from "../infra/market-calendar.js";
 import type { ParsedTag } from "../onboarding/tool-tags.js";
 import { parseToolTag } from "../onboarding/tool-tags.js";
 import type { CapabilityGapId, EvidencePlanId, TaskFamily } from "../routing/planning.js";
@@ -202,19 +208,6 @@ export const EVIDENCE_PLAN_REGISTRY: Record<EvidencePlanId, EvidencePlanDefiniti
   ),
 };
 
-const KNOWN_US_MARKET_HOLIDAYS: Record<string, string> = {
-  "2026-01-01": "New Year's Day",
-  "2026-01-19": "Martin Luther King Jr. Day",
-  "2026-02-16": "Washington's Birthday",
-  "2026-04-03": "Good Friday",
-  "2026-05-25": "Memorial Day",
-  "2026-06-19": "Juneteenth",
-  "2026-07-03": "Independence Day observed",
-  "2026-09-07": "Labor Day",
-  "2026-11-26": "Thanksgiving Day",
-  "2026-12-25": "Christmas Day",
-};
-
 function placeholderPlan(
   id: EvidencePlanId,
   taskFamilies: TaskFamily[],
@@ -591,20 +584,6 @@ function temporalReferencesFor(text: string): string[] {
   return refs;
 }
 
-function classifyMarketStatus(
-  local: LocalDateTimeParts,
-  isWeekend: boolean,
-  isMarketHoliday: boolean,
-  temporalReferences: string[],
-): string {
-  if (isWeekend) return "closed_weekend";
-  if (isMarketHoliday) return "closed_holiday";
-  if (local.minutesSinceMidnight < 9 * 60 + 30) return "pre_market";
-  if (local.minutesSinceMidnight < 16 * 60) return "open";
-  if (temporalReferences.includes("after_close")) return "after_close";
-  return "closed_after_hours";
-}
-
 function quoteAsOfCaveat(marketStatus: string): string {
   if (marketStatus === "open")
     return "Quote evidence may be intraday or delayed depending on provider.";
@@ -613,70 +592,6 @@ function quoteAsOfCaveat(marketStatus: string): string {
   return "Quote evidence should distinguish the current calendar date from the most recent trading session.";
 }
 
-interface LocalDateTimeParts {
-  date: string;
-  time: string;
-  weekday: string;
-  minutesSinceMidnight: number;
-}
-
-function localDateTimeParts(date: Date, timezone: string): LocalDateTimeParts {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
-    weekday: "short",
-  });
-  const parts = formatter.formatToParts(date).reduce<Record<string, string>>((acc, part) => {
-    acc[part.type] = part.value;
-    return acc;
-  }, {});
-  const hour = Number(parts.hour);
-  const minute = Number(parts.minute);
-  return {
-    date: `${parts.year}-${parts.month}-${parts.day}`,
-    time: `${parts.hour}:${parts.minute}`,
-    weekday: parts.weekday ?? "",
-    minutesSinceMidnight: hour * 60 + minute,
-  };
-}
-
-function lastTradingDay(localDate: string): string {
-  let cursor = dateFromKey(localDate);
-  do {
-    cursor = addDays(cursor, -1);
-  } while (isWeekendOrKnownHoliday(dateKey(cursor)));
-  return dateKey(cursor);
-}
-
-function isWeekendOrKnownHoliday(key: string): boolean {
-  const date = dateFromKey(key);
-  const day = date.getUTCDay();
-  return day === 0 || day === 6 || KNOWN_US_MARKET_HOLIDAYS[key] !== undefined;
-}
-
-function dateFromKey(key: string): Date {
-  const [year, month, day] = key.split("-").map(Number);
-  return new Date(Date.UTC(year, month - 1, day));
-}
-
-function addDays(date: Date, days: number): Date {
-  const next = new Date(date);
-  next.setUTCDate(next.getUTCDate() + days);
-  return next;
-}
-
-function dateKey(date: Date): string {
-  const year = date.getUTCFullYear();
-  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date.getUTCDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/runtime/prompt-step.ts

@@ -1,3 +1,6 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { FreshnessStamp } from "../infra/freshness.js";
+import type { EvidenceRecord } from "./evidence.js";
 import type { StepOutput, WorkflowStep } from "./workflow-types.js";
 
 /**
@@ -43,14 +46,98 @@ export function promptStep(
  * Create a StepOutput for a prompt-based step (no structured evidence yet).
  * Evidence will be captured separately via tool call hooks.
  */
-export function promptStepOutput(stepIndex: number, stepType: string): StepOutput {
+export function promptStepOutput(
+  stepIndex: number,
+  stepType: string,
+  options: { evidence?: EvidenceRecord[]; rawText?: string } = {},
+): StepOutput {
   return {
     stepIndex,
     stepType,
-    evidence: [],
+    evidence: options.evidence ?? [],
+    ...(options.rawText ? { rawText: options.rawText } : {}),
   };
 }
 
+/** Capture compact evidence records from session entries produced by one step. */
+export function captureToolEvidence(entries: SessionEntry[]): EvidenceRecord[] {
+  const calls = new Map<string, { tool: string; args: unknown; startedAt: string }>();
+  const evidence: EvidenceRecord[] = [];
+
+  for (const entry of entries) {
+    if (entry.type !== "message") continue;
+    const message = entry.message as unknown as Record<string, unknown>;
+
+    if (message.role === "assistant") {
+      for (const part of Array.isArray(message.content) ? message.content : []) {
+        const record = asRecord(part);
+        if (record.type !== "toolCall") continue;
+        const id = stringValue(record.id);
+        const tool = stringValue(record.name);
+        if (!id || !tool) continue;
+        calls.set(id, {
+          tool,
+          args: record.arguments ?? record.args ?? {},
+          startedAt: entry.timestamp,
+        });
+      }
+      continue;
+    }
+
+    if (message.role !== "toolResult") continue;
+    const toolCallId = stringValue(message.toolCallId);
+    const pending = toolCallId ? calls.get(toolCallId) : undefined;
+    const tool = pending?.tool ?? stringValue(message.toolName);
+    if (!tool) continue;
+    const resultValue = message.details ?? message.content ?? "";
+    const freshness = extractFreshness(resultValue);
+    const serializedResult = serialize(resultValue);
+    evidence.push({
+      label: `tool:${tool}`,
+      value: {
+        tool,
+        args: truncate(serialize(pending?.args ?? {}), 500),
+        ...(freshness ? { freshness } : {}),
+        resultDigest: {
+          preview: truncate(serializedResult, 500),
+          totalLength: serializedResult.length,
+        },
+        startedAt: pending?.startedAt ?? entry.timestamp,
+        completedAt: entry.timestamp,
+      },
+      provenance: {
+        source: "computed",
+        timestamp: freshness?.providerDataAt ?? freshness?.fetchedAt ?? entry.timestamp,
+        provider: tool,
+        confidence: message.isError === true ? 0.5 : undefined,
+      },
+    });
+  }
+
+  return evidence;
+}
+
+/** Extract assistant text emitted during a step, preserving final response order. */
+export function extractAssistantText(entries: SessionEntry[]): string {
+  return entries
+    .filter((entry) => entry.type === "message")
+    .flatMap((entry) => {
+      const message = (entry as Extract<SessionEntry, { type: "message" }>)
+        .message as unknown as Record<string, unknown>;
+      if (message.role !== "assistant") return [];
+      const content = message.content;
+      if (typeof content === "string") return [content];
+      if (!Array.isArray(content)) return [];
+      return content
+        .map((part) => asRecord(part))
+        .filter((part) => part.type === "text")
+        .map((part) => stringValue(part.text) ?? "")
+        .filter(Boolean);
+    })
+    .join("\n")
+    .trim();
+}
+
 /**
  * Extract just the WorkflowStep metadata from PromptStep definitions
  * (dropping the prompt field) for passing to WorkflowRunner.
@@ -58,3 +145,41 @@ export function promptStepOutput(stepIndex: number, stepType: string): StepOutpu
 export function toStepDefinitions(steps: PromptStep[]): Omit<WorkflowStep, "status">[] {
   return steps.map(({ prompt: _prompt, ...step }) => step);
 }
+
+function serialize(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function truncate(value: string, maxLength: number): string {
+  return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function extractFreshness(value: unknown): FreshnessStamp | undefined {
+  const record = asRecord(value);
+  return isFreshnessStamp(record.freshness) ? record.freshness : undefined;
+}
+
+function isFreshnessStamp(value: unknown): value is FreshnessStamp {
+  const record = asRecord(value);
+  return (
+    typeof record.fetchedAt === "string" &&
+    typeof record.cacheStatus === "string" &&
+    typeof record.marketSession === "string" &&
+    typeof record.isStaleForSession === "boolean"
+  );
+}