@wix/pathgrade 1.0.10 → 1.0.12

package/dist/sdk/judge-tools.js

@@ -206,7 +206,28 @@ export async function getToolEvents(events, actionFilter) {
     const filtered = actionFilter
         ? events.filter((e) => e.action.includes(actionFilter))
         : events;
-    return JSON.stringify(filtered);
+    const serialized = JSON.stringify(filtered);
+    const maxChars = 200 * 1024;
+    if (serialized.length <= maxChars)
+        return serialized;
+    const included = [];
+    for (const event of filtered) {
+        const candidate = JSON.stringify({
+            events: [...included, event],
+            truncated: true,
+            totalEvents: filtered.length,
+            includedEvents: included.length + 1,
+        });
+        if (candidate.length > maxChars)
+            break;
+        included.push(event);
+    }
+    return JSON.stringify({
+        events: included,
+        truncated: true,
+        totalEvents: filtered.length,
+        includedEvents: included.length,
+    });
 }
 export const DEFAULT_TOOL_REGISTRY = new Map([
     ['readFile', {
@@ -269,7 +290,7 @@ export const DEFAULT_TOOL_REGISTRY = new Map([
     ['getToolEvents', {
             schema: {
                 name: 'getToolEvents',
-                description: 'Retrieve the agent session tool events as JSON. Optional actionFilter substring-matches against event.action.',
+                description: 'Retrieve the agent session tool events as JSON. Optional actionFilter substring-matches against event.action. Oversized responses use a valid { events, truncated, totalEvents, includedEvents } JSON envelope.',
                 input_schema: {
                     type: 'object',
                     properties: { actionFilter: { type: 'string' } },

package/dist/sdk/managed-session.js

@@ -2,6 +2,7 @@ import { createAgentSession } from '../types.js';
 import { createAgentEnvironment } from '../agents/registry.js';
 import { withAbortTimeout } from '../utils/timeout.js';
 import { buildModelAgentResultLogEntry } from './agent-result-log.js';
+import { buildToolEventLogEntry } from './tool-event-log.js';
 import { planRuntimePolicies } from './runtime-policy.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
 import { createAskBus } from './ask-bus/bus.js';
@@ -27,6 +28,7 @@ export function createManagedSession(deps) {
         ...(deps.opencodeExecutable !== undefined ? { opencodeExecutable: deps.opencodeExecutable } : {}),
         ...(deps.opencodeMcpToolNames !== undefined ? { opencodeMcpToolNames: deps.opencodeMcpToolNames } : {}),
         getAbortSignal: () => currentSignal,
+        getRemainingMs: () => Math.max(0, deadlineMs - Date.now()),
     };
     let session = null;
     let setupDone = false;
@@ -84,14 +86,15 @@ export function createManagedSession(deps) {
             messages.push({ role: 'user', content: message });
             const turnResult = await executeTurn(message);
             const response = getVisibleAssistantMessage(turnResult);
+            const turnCompletedAt = new Date().toISOString();
+            for (const toolEvent of turnResult.toolEvents) {
+                log.push(buildToolEventLogEntry(toolEvent, turnCompletedAt));
+            }
             log.push(buildModelAgentResultLogEntry({
-                timestamp: new Date().toISOString(),
+                timestamp: turnCompletedAt,
                 turnResult,
                 assistantMessage: response,
             }));
-            for (const toolEvent of turnResult.toolEvents) {
-                log.push({ type: 'tool_event', timestamp: new Date().toISOString(), tool_event: toolEvent });
-            }
             messages.push({ role: 'agent', content: response });
             if (turnResult.exitCode !== 0) {
                 if (turnResult.timedOut)

package/dist/sdk/persona.d.ts

@@ -2,4 +2,5 @@ import type { LLMPort } from '../utils/llm-types.js';
 import type { Persona, PersonaConfig } from './types.js';
 export declare function createPersona(config: PersonaConfig & {
     llm: LLMPort;
+    defaultSummaryModel?: string;
 }): Persona;

package/dist/sdk/persona.js

@@ -1,8 +1,12 @@
 import { createConversationWindow } from './conversation-window.js';
 export function createPersona(config) {
     const llm = config.llm;
+    const configuredWindowModel = config.conversationWindow === false
+        ? undefined
+        : config.conversationWindow?.model;
+    const summaryModel = config.model ?? configuredWindowModel ?? config.defaultSummaryModel;
     const window = config.conversationWindow !== false
-        ? createConversationWindow({ ...config.conversationWindow, model: config.model, llm })
+        ? createConversationWindow({ ...config.conversationWindow, model: summaryModel, llm })
         : null;
     return {
         async reply(chat) {

package/dist/sdk/tool-event-log.d.ts

@@ -0,0 +1,3 @@
+import type { ToolEvent } from '../tool-events.js';
+import type { LogEntry } from '../types.js';
+export declare function buildToolEventLogEntry(toolEvent: ToolEvent, fallbackTimestamp: string): LogEntry;

package/dist/sdk/tool-event-log.js

@@ -0,0 +1,7 @@
+export function buildToolEventLogEntry(toolEvent, fallbackTimestamp) {
+    return {
+        type: 'tool_event',
+        timestamp: toolEvent.startedAt ?? fallbackTimestamp,
+        tool_event: toolEvent,
+    };
+}

package/dist/tool-events.d.ts

@@ -3,13 +3,32 @@ export interface ToolEvent {
     action: ToolAction;
     provider: 'claude' | 'codex' | 'cursor' | 'opencode';
     providerToolName: string;
+    /** Provider correlation identifier joining a tool invocation to its result. */
+    toolUseId?: string;
     turnNumber?: number;
     arguments?: Record<string, unknown>;
+    /** Lifecycle state observed by PathGrade. Absent on legacy provider events. */
+    status?: 'completed' | 'error' | 'incomplete';
+    /** Local wall-clock receive time for the invocation boundary. */
+    startedAt?: string;
+    /** Local wall-clock receive time for the matching result boundary. */
+    completedAt?: string;
+    /** Monotonic receive-time delta between invocation and result. */
+    durationMs?: number;
+    /** Bounded provider result data. Fields remain absent when unavailable. */
+    result?: ToolEventResult;
     summary: string;
     confidence: 'high' | 'medium' | 'low';
     rawSnippet: string;
     skillName?: string;
 }
+export interface ToolEventResult {
+    content?: string;
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+    truncated?: boolean;
+}
 export declare function summarizeToolEvents(events: ToolEvent[]): string;
 /**
  * Map from provider-specific tool names to normalized Pathgrade actions.

package/dist/types.d.ts

@@ -379,6 +379,8 @@ export interface AgentSessionOptions {
     abortSignal?: AbortSignal;
     /** Supplies the current timeout/cancellation signal for reused sessions. */
     getAbortSignal?: () => AbortSignal | undefined;
+    /** Supplies the remaining managed-session deadline for credential validity checks. */
+    getRemainingMs?: () => number;
     /** Absolute pinned runtime path for the OpenCode adapter. */
     opencodeExecutable?: string;
     /** Exact generated MCP tool names accepted by the OpenCode event normalizer. */

package/dist/utils/llm-providers/anthropic.js

@@ -1,16 +1,20 @@
 function getApiKey(env) {
-    return env?.ANTHROPIC_API_KEY
-        || env?.APP_ANTHROPIC_API_KEY
-        || process.env.ANTHROPIC_API_KEY
-        || process.env.APP_ANTHROPIC_API_KEY;
+    return env === undefined
+        ? process.env.ANTHROPIC_API_KEY || process.env.APP_ANTHROPIC_API_KEY
+        : env.ANTHROPIC_API_KEY || env.APP_ANTHROPIC_API_KEY;
 }
 function resolveBaseUrl(env) {
-    return env?.ANTHROPIC_BASE_URL
-        || env?.APP_ANTHROPIC_BASE_URL
-        || process.env.ANTHROPIC_BASE_URL
-        || process.env.APP_ANTHROPIC_BASE_URL
+    return (env === undefined
+        ? process.env.ANTHROPIC_BASE_URL || process.env.APP_ANTHROPIC_BASE_URL
+        : env.ANTHROPIC_BASE_URL || env.APP_ANTHROPIC_BASE_URL)
         || 'https://api.anthropic.com';
 }
+function normalizeModel(model) {
+    const normalized = model.trim();
+    return normalized.toLowerCase().startsWith('anthropic/')
+        ? normalized.slice('anthropic/'.length)
+        : normalized;
+}
 function resolveMessagesUrl(env) {
     const baseUrl = resolveBaseUrl(env).replace(/\/+$/, '');
     const apiRoot = baseUrl.endsWith('/v1') ? baseUrl : `${baseUrl}/v1`;
@@ -79,14 +83,14 @@ export const anthropicProvider = {
         return !!getApiKey(env);
     },
     supportsModel(model) {
-        return model.trim().toLowerCase().startsWith('claude');
+        return normalizeModel(model).toLowerCase().startsWith('claude');
     },
     async call(prompt, opts) {
         const apiKey = getApiKey(opts.env);
         if (!apiKey) {
             throw new Error('No ANTHROPIC_API_KEY available');
         }
-        const model = opts.model || DEFAULT_ANTHROPIC_MODEL;
+        const model = normalizeModel(opts.model || DEFAULT_ANTHROPIC_MODEL);
         const modelConfig = getAnthropicModelConfig(model);
         assertRawAnthropicModel(model, modelConfig);
         const temperature = resolveTemperature(model, modelConfig, opts.temperature);
@@ -120,7 +124,7 @@ export const anthropicProvider = {
         if (!apiKey) {
             throw new Error('No ANTHROPIC_API_KEY available');
         }
-        const model = opts.model || DEFAULT_ANTHROPIC_MODEL;
+        const model = normalizeModel(opts.model || DEFAULT_ANTHROPIC_MODEL);
         const modelConfig = getAnthropicModelConfig(model);
         assertRawAnthropicModel(model, modelConfig);
         const temperature = resolveTemperature(model, modelConfig, opts.temperature);

package/dist/utils/llm-providers/openai.js

@@ -1,5 +1,11 @@
 function getApiKey(env) {
-    return env?.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+    return env === undefined ? process.env.OPENAI_API_KEY : env.OPENAI_API_KEY;
+}
+function normalizeModel(model) {
+    const normalized = model.trim();
+    return normalized.toLowerCase().startsWith('openai/')
+        ? normalized.slice('openai/'.length)
+        : normalized;
 }
 export const openaiProvider = {
     name: 'openai',
@@ -7,7 +13,7 @@ export const openaiProvider = {
         return !!getApiKey(env);
     },
     supportsModel(model) {
-        const normalized = model.trim().toLowerCase();
+        const normalized = normalizeModel(model).toLowerCase();
         return (normalized.startsWith('gpt-')
             || normalized.startsWith('chatgpt-')
             || normalized.startsWith('o1')
@@ -19,9 +25,12 @@ export const openaiProvider = {
         if (!apiKey) {
             throw new Error('No OPENAI_API_KEY available');
         }
-        const model = opts.model || 'gpt-4o';
+        const model = normalizeModel(opts.model || 'gpt-4o');
         const temperature = opts.temperature ?? 0;
-        const baseUrl = (opts.env?.OPENAI_BASE_URL || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1').replace(/\/$/, '');
+        const configuredBaseUrl = opts.env === undefined
+            ? process.env.OPENAI_BASE_URL
+            : opts.env.OPENAI_BASE_URL;
+        const baseUrl = (configuredBaseUrl || 'https://api.openai.com/v1').replace(/\/$/, '');
         try {
             const response = await fetch(`${baseUrl}/chat/completions`, {
                 method: 'POST',

package/dist/utils/llm.d.ts

@@ -25,7 +25,7 @@ export declare function createLLMClient(opts: CreateLLMClientOptions): LLMPort;
 export declare function createLLMClient(providers: LLMProviderAdapter[], agentName?: string): LLMPort;
 export declare function callLLM(prompt: string, opts?: LLMCallOptions): Promise<LLMCallResult>;
 /**
- * Create an LLM client scoped to the providers that match the given agent.
+ * Create an LLM client scoped to the providers that match the given agent and model.
  *
  * - claude → CLI + Anthropic API (no OpenAI fallthrough)
  * - codex  → OpenAI API
@@ -33,4 +33,4 @@ export declare function callLLM(prompt: string, opts?: LLMCallOptions): Promise<
  * If `agentEnv` is provided, it is merged into every LLM call so that
  * the agent's env propagates to persona/judge/summarization calls.
  */
-export declare function createAgentLLM(agentName: string, agentEnv?: Record<string, string>): LLMPort;
+export declare function createAgentLLM(agentName: string, agentEnv?: Record<string, string>, agentModel?: string): LLMPort;

package/dist/utils/llm.js

@@ -17,6 +17,10 @@ function inferProviderFromModel(model) {
     const normalized = model?.trim().toLowerCase();
     if (!normalized)
         return undefined;
+    if (normalized.startsWith('anthropic/'))
+        return 'anthropic';
+    if (normalized.startsWith('openai/'))
+        return 'openai';
     if (normalized.startsWith('claude'))
         return 'anthropic';
     if (normalized.startsWith('gpt-')
@@ -178,7 +182,7 @@ export async function callLLM(prompt, opts = {}) {
     return defaultClient.call(prompt, opts);
 }
 /**
- * Create an LLM client scoped to the providers that match the given agent.
+ * Create an LLM client scoped to the providers that match the given agent and model.
  *
  * - claude → CLI + Anthropic API (no OpenAI fallthrough)
  * - codex  → OpenAI API
@@ -186,17 +190,18 @@ export async function callLLM(prompt, opts = {}) {
  * If `agentEnv` is provided, it is merged into every LLM call so that
  * the agent's env propagates to persona/judge/summarization calls.
  */
-export function createAgentLLM(agentName, agentEnv) {
+export function createAgentLLM(agentName, agentEnv, agentModel) {
     // Tool-using judges need a provider that implements callWithTools.
     // For claude, anthropicProvider is added as a tool-use-capable fallback
     // alongside the CLI. The CLI still wins for plain call() when available.
     // Cursor inherits the Claude chain by design (judge consistency across
     // harnesses — see PRD §"LLM-backend routing"). Cursor evals therefore
     // depend on Claude CLI or ANTHROPIC_API_KEY being available at judge time.
-    const baseAdapters = agentName === 'codex'
+    const openCodeUsesOpenAI = agentName === 'opencode' && agentModel === 'openai/gpt-5.4';
+    const baseAdapters = agentName === 'codex' || openCodeUsesOpenAI
         ? [openaiProvider]
         : [cliProvider, anthropicProvider];
-    const adapters = agentEnv && Object.keys(agentEnv).length > 0
+    const adapters = agentEnv !== undefined
         ? baseAdapters.map((a) => ({
             ...a,
             isAvailable: (env) => a.isAvailable({ ...agentEnv, ...env }),

package/dist/viewer.html

@@ -1127,10 +1127,10 @@
             + (e.value?.toFixed(2) || '0.00') + '</span>'
             + (e.output ? '<div class="scorer-details" style="margin-top:0.25rem">' + esc(e.output) + '</div>' : '');
           break;
-        case 'tool_event':
-          body = '<span class="badge badge-type">' + esc(e.tool_event?.action || 'unknown') + '</span> '
-            + '<span class="scorer-details">' + esc(e.tool_event?.summary || '') + '</span>';
-          break;
+        case 'tool_event': {
+          const tool = e.tool_event || {}; const toolResult = tool.result || {}; const resultText = toolResult.content || toolResult.stdout || ''; const stderrText = toolResult.stderr || ''; const duration = typeof tool.durationMs === 'number' ? `${Math.round(tool.durationMs)}ms` : ''; const exit = typeof toolResult.exitCode === 'number' ? `exit ${toolResult.exitCode}` : ''; const meta = [tool.status || 'unknown', duration, exit].filter(Boolean).join(' · '); const output = resultText || stderrText ? '<div class="log-command-output"><pre class="code-block">' + esc(resultText) + (stderrText ? '<span class="stderr-text">' + esc(stderrText) + '</span>' : '') + '</pre></div>' : '';
+          body = '<details class="log-command-details"><summary class="log-command-summary"><span class="badge badge-type">' + esc(tool.action || 'unknown') + '</span> <span class="scorer-details">' + esc(tool.summary || '') + '</span><span class="log-command-meta">' + esc(meta) + '</span></summary>' + output + '</details>'; break;
+        }
         case 'judge_tool_call': {
           const tc = e.judge_tool_call || {};
           const okBadge = tc.ok

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "packageManager": "yarn@4.12.0",
   "description": "Evaluate whether AI agents discover and use your skills correctly",
   "exports": {
@@ -132,5 +132,5 @@
     "typescript": "^5.9.3",
     "zod": "4.3.6"
   },
-  "falconPackageHash": "be877aa61dfb2cd1b58c716b704cffee9592428675a660382e86e358"
+  "falconPackageHash": "48e95ba80576ede589f0a5e47d60b9c94fd53c1ef435d8ca9af35392"
 }