@wix/pathgrade 1.0.9 → 1.0.10

package/dist/agents/{opencode-contract.d.ts → opencode/contract.d.ts}

@@ -1,5 +1,5 @@
-import type { MockMcpServerDescriptor } from '../core/mcp-mock.types.js';
-import type { AgentName, AgentOptions } from '../sdk/types.js';
+import type { MockMcpServerDescriptor } from '../../core/mcp-mock.types.js';
+import type { AgentName, AgentOptions } from '../../sdk/types.js';
 export declare const OPENCODE_MODEL = "anthropic/claude-sonnet-5";
 export declare const OPENCODE_VERSION = "1.18.18";
 export interface OpenCodeRuntimeLockEntry {

package/dist/agents/opencode/process-groups.d.ts

@@ -0,0 +1,3 @@
+export declare function killOpenCodeProcessGroup(pid: number, signal: NodeJS.Signals): void;
+export declare function registerOpenCodeProcessGroup(pid: number): void;
+export declare function unregisterOpenCodeProcessGroup(pid: number): void;

package/dist/agents/opencode/process-groups.js

@@ -0,0 +1,47 @@
+/** Process-wide ownership of detached OpenCode child process groups. */
+const activeProcessGroups = new Set();
+let processCleanupInstalled = false;
+export function killOpenCodeProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        // The process group may already have exited.
+    }
+}
+function killAllProcessGroups() {
+    for (const pid of activeProcessGroups) {
+        killOpenCodeProcessGroup(pid, 'SIGKILL');
+    }
+    activeProcessGroups.clear();
+}
+function uninstallProcessCleanup() {
+    if (!processCleanupInstalled)
+        return;
+    processCleanupInstalled = false;
+    process.removeListener('exit', onProcessExit);
+    process.removeListener('SIGINT', onProcessSignal);
+    process.removeListener('SIGTERM', onProcessSignal);
+}
+function onProcessExit() {
+    killAllProcessGroups();
+}
+function onProcessSignal(signal) {
+    killAllProcessGroups();
+    uninstallProcessCleanup();
+    process.kill(process.pid, signal);
+}
+export function registerOpenCodeProcessGroup(pid) {
+    activeProcessGroups.add(pid);
+    if (processCleanupInstalled)
+        return;
+    processCleanupInstalled = true;
+    process.once('exit', onProcessExit);
+    process.once('SIGINT', onProcessSignal);
+    process.once('SIGTERM', onProcessSignal);
+}
+export function unregisterOpenCodeProcessGroup(pid) {
+    activeProcessGroups.delete(pid);
+    if (activeProcessGroups.size === 0)
+        uninstallProcessCleanup();
+}

package/dist/agents/opencode.js

@@ -7,7 +7,8 @@ import fs from 'fs-extra';
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
 import { buildSummary, enrichSkillEvents } from '../tool-events.js';
 import { readStagedMcpServers } from '../providers/mcp-config.js';
-import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode-contract.js';
+import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode/contract.js';
+import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
 const FIXED_OPENCODE_ENV = {
     OPENCODE_CLIENT: 'pathgrade',
@@ -68,6 +69,7 @@ export function spawnOpenCode(executable, args, options) {
         let aborted = false;
         let killTimer;
         let settled = false;
+        let terminating = false;
         const child = spawn(executable, args, {
             cwd: options.cwd,
             env: options.env,
@@ -75,22 +77,22 @@ export function spawnOpenCode(executable, args, options) {
             detached: true,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        if (child.pid)
+            registerOpenCodeProcessGroup(child.pid);
         const killGroup = (signal) => {
             if (!child.pid)
                 return;
-            try {
-                process.kill(-child.pid, signal);
-            }
-            catch {
-                // The process may have exited between the state check and kill.
-            }
+            killOpenCodeProcessGroup(child.pid, signal);
         };
         const terminate = () => {
+            terminating = true;
             killGroup('SIGTERM');
             killTimer ??= setTimeout(() => killGroup('SIGKILL'), 250);
             killTimer.unref();
         };
         const onAbort = () => {
+            if (aborted)
+                return;
             aborted = true;
             terminate();
         };
@@ -98,9 +100,6 @@ export function spawnOpenCode(executable, args, options) {
             overflow = true;
             terminate();
         };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
-        if (options.signal?.aborted)
-            onAbort();
         child.stdout.on('data', (chunk) => {
             stdoutBytes += chunk.length;
             if (stdoutBytes <= cap)
@@ -114,16 +113,23 @@ export function spawnOpenCode(executable, args, options) {
                 onOverflow();
         });
         child.stdin.on('error', () => undefined);
+        child.once('error', (error) => finish(undefined, undefined, error));
+        child.once('close', (code, signal) => finish(code, signal));
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
         if (!aborted)
             child.stdin.end(options.stdin);
         else
             child.stdin.destroy();
-        child.once('error', (error) => finish(undefined, undefined, error));
-        child.once('close', (code, signal) => finish(code, signal));
         function finish(code, signal, error) {
             if (settled)
                 return;
             settled = true;
+            if (child.pid && terminating)
+                killOpenCodeProcessGroup(child.pid, 'SIGKILL');
+            if (child.pid)
+                unregisterOpenCodeProcessGroup(child.pid);
             options.signal?.removeEventListener('abort', onAbort);
             if (killTimer)
                 clearTimeout(killTimer);
@@ -377,6 +383,7 @@ class OpenCodeSession {
     disposed = false;
     sessionId;
     inFlight;
+    disposeController = new AbortController();
     constructor(runtime, options) {
         this.workspacePath = getWorkspacePath(runtime);
         this.runtimeEnv = getRuntimeEnv(runtime);
@@ -432,11 +439,15 @@ class OpenCodeSession {
                 '--model', OPENCODE_MODEL, '--agent', 'build',
                 ...(this.sessionId ? ['--session', this.sessionId] : []),
             ];
+            const turnSignal = this.getAbortSignal();
+            const signal = turnSignal
+                ? AbortSignal.any([turnSignal, this.disposeController.signal])
+                : this.disposeController.signal;
             const processResult = await spawnOpenCode(this.resolvedExecutable, args, {
                 cwd: this.workspacePath,
                 env,
                 stdin: message,
-                signal: this.getAbortSignal(),
+                signal,
             });
             const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames);
             if (this.sessionId && parsed.sessionId !== this.sessionId) {
@@ -494,6 +505,7 @@ class OpenCodeSession {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.disposeController.abort();
         await this.inFlight?.catch(() => undefined);
         await this.cleanupState();
     }

package/dist/sdk/agent.js

@@ -15,7 +15,7 @@ import { createVerboseEmitter } from '../reporters/verbose-emitter.js';
 import fs from 'fs-extra';
 import * as path from 'path';
 import { cleanDebugRuns, DEFAULT_DEBUG_RETAIN_RUNS, prepareManagedDebugRun, } from '../providers/debug-runs.js';
-import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode-contract.js';
+import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode/contract.js';
 /**
  * Test-only injection point: override the sink used by the next emitter
  * built inside `createAgent`. Pass `null` to restore the default (stderr).

package/dist/sdk/judge-tool-session.js

@@ -35,13 +35,14 @@ export async function runJudgeSession(input, options = {}) {
         { role: 'user', content: user },
     ];
     let rounds = 0;
+    let scoreRepairAttempted = false;
     while (rounds < maxRounds) {
         rounds++;
         let response;
         try {
             response = await llm.callWithTools(messages, {
                 system,
-                tools: toolSchemas,
+                tools: scoreRepairAttempted ? [] : toolSchemas,
                 model: scorer.model,
                 cacheControl: scorer.cacheControl,
             });
@@ -63,6 +64,22 @@ export async function runJudgeSession(input, options = {}) {
             }
             const parsed = parseFinalScore(response.text);
             if (!parsed.ok) {
+                if (parsed.message.startsWith('JSON parse failed:')
+                    && !scoreRepairAttempted
+                    && rounds < maxRounds) {
+                    scoreRepairAttempted = true;
+                    messages.push({ role: 'assistant', content: response.text });
+                    messages.push({
+                        role: 'user',
+                        content: [
+                            `Your final answer was not valid JSON: ${parsed.message}.`,
+                            'Return ONLY a valid JSON object with double-quoted keys in this exact shape:',
+                            '{"score": <number 0..1>, "details": "<brief explanation>"}',
+                            'Do not call more tools or include Markdown fences.',
+                        ].join('\n'),
+                    });
+                    continue;
+                }
                 return makeOutcome(tokenUsage, toolCalls, logEntries, rounds, {
                     code: 'invalid_score',
                     details: parsed.message,

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

@@ -11,6 +11,11 @@ function resolveBaseUrl(env) {
         || process.env.APP_ANTHROPIC_BASE_URL
         || 'https://api.anthropic.com';
 }
+function resolveMessagesUrl(env) {
+    const baseUrl = resolveBaseUrl(env).replace(/\/+$/, '');
+    const apiRoot = baseUrl.endsWith('/v1') ? baseUrl : `${baseUrl}/v1`;
+    return `${apiRoot}/messages`;
+}
 function buildHeaders(apiKey, useCache) {
     const headers = {
         'Content-Type': 'application/json',
@@ -57,7 +62,7 @@ function resolveTemperature(model, config, temperature) {
     return temperature ?? 0;
 }
 async function postAnthropic(apiKey, useCache, body, env) {
-    const response = await fetch(`${resolveBaseUrl(env)}/v1/messages`, {
+    const response = await fetch(resolveMessagesUrl(env), {
         method: 'POST',
         headers: buildHeaders(apiKey, useCache),
         body: JSON.stringify(body),

package/dist/utils/llm.js

@@ -199,6 +199,7 @@ export function createAgentLLM(agentName, agentEnv) {
     const adapters = agentEnv && Object.keys(agentEnv).length > 0
         ? baseAdapters.map((a) => ({
             ...a,
+            isAvailable: (env) => a.isAvailable({ ...agentEnv, ...env }),
             call: (prompt, opts) => a.call(prompt, { ...opts, env: { ...agentEnv, ...opts.env } }),
             ...(a.callWithTools
                 ? { callWithTools: (messages, opts) => a.callWithTools(messages, { ...opts, env: { ...agentEnv, ...opts.env } }) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "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": "130e5449f0131fe2bba40bf0237a7620315714dfe492f7e5e9d7cc14"
+  "falconPackageHash": "be877aa61dfb2cd1b58c716b704cffee9592428675a660382e86e358"
 }