poe-code 3.0.269 → 3.0.271

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.269",
+  "version": "3.0.271",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/agent-eval/dist/check/check.js

@@ -7,6 +7,7 @@ import { loadEval } from "../source/registry.js";
 import { cloneTarget } from "../run/clone.js";
 import { runScorer } from "../run/scorer.js";
 import { assertCanonicalContainedPath, assertCanonicalDestinationPath, resolveContainedPath } from "../path-boundary.js";
+import { assertNoSymlinksInDirectoryTree } from "../run/fixture-copy.js";
 export async function evalCheck(opts) {
     const startedAt = Date.now();
     const source = await openSource(opts.sourceDir);
@@ -66,6 +67,7 @@ async function copyDirectoryIfPresent(sourceDir, destDir) {
         }
         throw error;
     }
+    await assertNoSymlinksInDirectoryTree(sourceDir, "starter");
     await cp(sourceDir, destDir, {
         recursive: true,
         force: true
@@ -75,6 +77,7 @@ async function copyOracleSolution(input) {
     const destDir = resolveCloneRelativePath(input.cloneDir, input.solutionDest);
     await assertCanonicalDestinationPath(input.cloneDir, destDir, "oracle.solution_dest");
     await mkdir(destDir, { recursive: true });
+    await assertNoSymlinksInDirectoryTree(input.solutionDir, "oracle.solution");
     await cp(input.solutionDir, destDir, {
         recursive: true,
         force: true

package/packages/agent-eval/dist/report/load.js

@@ -80,7 +80,7 @@ async function enrichAggregatedCell(cell, outDir) {
     }
 }
 async function enrichMatchedRunResult(runId, resultPath) {
-    const result = parseJson(await readFile(resultPath, "utf8"), resultPath);
+    const result = validateRunResult(parseJson(await readFile(resultPath, "utf8"), resultPath), resultPath);
     if (result.runId !== runId) {
         throw new Error(`Run result "${runId}" embeds mismatched runId "${result.runId}"`);
     }
@@ -158,7 +158,7 @@ async function enrichRunResult(result, runDir) {
 async function loadTraceSummary(tracePath, outDir) {
     try {
         await assertCanonicalOutputFile(outDir, tracePath);
-        const trace = parseJson(await readFile(tracePath, "utf8"), tracePath);
+        const trace = validateTrace(parseJson(await readFile(tracePath, "utf8"), tracePath), tracePath);
         return {
             available: true,
             eventCount: trace.events.length,
@@ -173,6 +173,120 @@ async function loadTraceSummary(tracePath, outDir) {
         throw error;
     }
 }
+function validateRunResult(value, filePath) {
+    const result = requireRecord(value, filePath, "result.json", []);
+    requireString(result.runId, filePath, "result.json", ["runId"]);
+    requireString(result.eval, filePath, "result.json", ["eval"]);
+    requireString(result.agent, filePath, "result.json", ["agent"]);
+    requireString(result.model, filePath, "result.json", ["model"]);
+    requireString(result.planKind, filePath, "result.json", ["planKind"]);
+    requireString(result.verdict, filePath, "result.json", ["verdict"]);
+    requireNonNegativeInteger(result.iterations, filePath, "result.json", ["iterations"]);
+    requireNonNegativeNumber(result.durationMs, filePath, "result.json", ["durationMs"]);
+    requireRange(result.correctness, 0, 1, filePath, "result.json", ["correctness"]);
+    const usage = requireRecord(result.usage, filePath, "result.json", ["usage"]);
+    requireNonNegativeInteger(usage.inputTokens, filePath, "result.json", ["usage", "inputTokens"]);
+    requireNonNegativeInteger(usage.outputTokens, filePath, "result.json", ["usage", "outputTokens"]);
+    if (usage.cachedTokens !== undefined) {
+        requireNonNegativeInteger(usage.cachedTokens, filePath, "result.json", [
+            "usage",
+            "cachedTokens"
+        ]);
+    }
+    if (usage.costUsd !== undefined) {
+        requireNonNegativeNumber(usage.costUsd, filePath, "result.json", ["usage", "costUsd"]);
+    }
+    const tests = requireRecord(result.tests, filePath, "result.json", ["tests"]);
+    const passed = requireNonNegativeInteger(tests.passed, filePath, "result.json", [
+        "tests",
+        "passed"
+    ]);
+    const total = requireNonNegativeInteger(tests.total, filePath, "result.json", ["tests", "total"]);
+    if (passed > total) {
+        throw invalidArtifactField(filePath, "result.json", ["tests", "passed"], "integer less than or equal to tests.total", passed);
+    }
+    requireRange(tests.pass_rate, 0, 1, filePath, "result.json", ["tests", "pass_rate"]);
+    if (!Array.isArray(tests.cases)) {
+        throw invalidArtifactField(filePath, "result.json", ["tests", "cases"], "array", tests.cases);
+    }
+    const scoring = requireRecord(result.scoring, filePath, "result.json", ["scoring"]);
+    validateScoringComponent(scoring.tests, filePath, ["scoring", "tests"]);
+    validateScoringComponent(scoring.judge, filePath, ["scoring", "judge"]);
+    requireBoolean(result.cheated, filePath, "result.json", ["cheated"]);
+    requireRecord(result.cheatReport, filePath, "result.json", ["cheatReport"]);
+    return result;
+}
+function validateScoringComponent(value, filePath, path) {
+    const component = requireRecord(value, filePath, "result.json", path);
+    requireBoolean(component.configured, filePath, "result.json", [...path, "configured"]);
+    requireBoolean(component.required, filePath, "result.json", [...path, "required"]);
+    requireRange(component.configuredWeight, 0, 1, filePath, "result.json", [
+        ...path,
+        "configuredWeight"
+    ]);
+    requireRange(component.effectiveWeight, 0, 1, filePath, "result.json", [
+        ...path,
+        "effectiveWeight"
+    ]);
+    requireString(component.status, filePath, "result.json", [...path, "status"]);
+}
+function validateTrace(value, filePath) {
+    const trace = requireRecord(value, filePath, "trace.json", []);
+    if (!Array.isArray(trace.events)) {
+        throw invalidArtifactField(filePath, "trace.json", ["events"], "array", trace.events);
+    }
+    return trace;
+}
+function requireRecord(value, filePath, artifact, path) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "object", value);
+}
+function requireString(value, filePath, artifact, path) {
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "non-empty string", value);
+}
+function requireBoolean(value, filePath, artifact, path) {
+    if (typeof value !== "boolean") {
+        throw invalidArtifactField(filePath, artifact, path, "boolean", value);
+    }
+}
+function requireNonNegativeInteger(value, filePath, artifact, path) {
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "non-negative integer", value);
+}
+function requireNonNegativeNumber(value, filePath, artifact, path) {
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "non-negative number", value);
+}
+function requireRange(value, min, max, filePath, artifact, path) {
+    if (typeof value === "number" && Number.isFinite(value) && value >= min && value <= max) {
+        return;
+    }
+    throw invalidArtifactField(filePath, artifact, path, `number from ${min} through ${max}`, value);
+}
+function invalidArtifactField(filePath, artifact, path, expected, received) {
+    return new Error(`Invalid ${artifact} in ${filePath} (${formatIssuePath(path)}): expected ${expected}, received ${formatReceived(received)}.`);
+}
+function formatIssuePath(path) {
+    return path.join(".") || "value";
+}
+function formatReceived(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "object" && value !== null) {
+        return Array.isArray(value) ? "array" : "object";
+    }
+    return String(value);
+}
 async function assertCanonicalOutputFile(outDir, filePath) {
     const canonicalOutDir = await realpath(path.resolve(outDir));
     const canonicalFilePath = await realpath(filePath);

package/packages/agent-eval/dist/run/fixture-copy.d.ts

@@ -0,0 +1 @@
+export declare function assertNoSymlinksInDirectoryTree(rootDir: string, label: string): Promise<void>;

package/packages/agent-eval/dist/run/fixture-copy.js

@@ -0,0 +1,24 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+export async function assertNoSymlinksInDirectoryTree(rootDir, label) {
+    await walkDirectoryTree(rootDir, label);
+}
+async function walkDirectoryTree(targetPath, label) {
+    const targetStat = await lstat(targetPath);
+    if (targetStat.isSymbolicLink()) {
+        throw new Error(`${label} must not contain symbolic links: ${targetPath}`);
+    }
+    if (!targetStat.isDirectory()) {
+        return;
+    }
+    const entries = await readdir(targetPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(targetPath, entry.name);
+        if (entry.isSymbolicLink()) {
+            throw new Error(`${label} must not contain symbolic links: ${entryPath}`);
+        }
+        if (entry.isDirectory()) {
+            await walkDirectoryTree(entryPath, label);
+        }
+    }
+}

package/packages/agent-eval/dist/run/run.js

@@ -19,6 +19,7 @@ import { verifyOracle } from "./oracle.js";
 import { runScorer } from "./scorer.js";
 import { createTraceNormalizer } from "./trace/normalize.js";
 import { writeRunCompletion, writeRunEvidence, writeRunResult } from "./result-writer.js";
+import { assertNoSymlinksInDirectoryTree } from "./fixture-copy.js";
 export class EvalFrameworkError extends Error {
     constructor(message) {
         super(message);
@@ -258,6 +259,7 @@ async function copyStarterIfPresent(starterDir, cloneDir) {
         }
         throw error;
     }
+    await assertNoSymlinksInDirectoryTree(starterDir, "starter");
     await cp(starterDir, cloneDir, {
         recursive: true,
         force: true

package/packages/agent-eval/dist/schema.js

@@ -1,5 +1,9 @@
 import { S, validate } from "toolcraft-schema";
 import path from "node:path";
+const nonEmptyString = S.String({ minLength: 1 });
+const positiveInteger = S.Number({ jsonType: "integer", minimum: 1 });
+const nonNegativeInteger = S.Number({ jsonType: "integer", minimum: 0 });
+const scoringWeight = S.Number({ minimum: 0, maximum: 1 });
 const metricEvaluatorSchema = S.OneOf({
     discriminator: "kind",
     branches: {
@@ -38,41 +42,41 @@ const metricSchema = S.Object({
  * oracle.solution_dest to copy it under a clone-root-relative subdirectory.
  */
 export const evalYamlSchema = S.Object({
-    id: S.String(),
-    title: S.String(),
+    id: nonEmptyString,
+    title: nonEmptyString,
     target: S.Object({
-        repo: S.String(),
-        ref: S.String(),
-        plan_dest: S.Optional(S.String({ default: "docs/plans/eval-task.md" }))
+        repo: nonEmptyString,
+        ref: nonEmptyString,
+        plan_dest: S.Optional(S.String({ default: "docs/plans/eval-task.md", minLength: 1 }))
     }),
     scorer: S.Optional(S.Object({
-        command: S.String(),
+        command: nonEmptyString,
         cwd: S.Optional(S.String({ default: "" })),
-        result_path: S.String(),
-        timeout_ms: S.Number()
+        result_path: nonEmptyString,
+        timeout_ms: nonNegativeInteger
     })),
     oracle: S.Object({
-        path: S.Optional(S.String({ default: "oracle" })),
-        solution_dest: S.Optional(S.String({ default: "." }))
+        path: S.Optional(S.String({ default: "oracle", minLength: 1 })),
+        solution_dest: S.Optional(S.String({ default: ".", minLength: 1 }))
     }),
     budget: S.Object({
-        max_iterations: S.Number(),
-        max_tokens: S.Number(),
-        wall_clock_ms: S.Number()
+        max_iterations: positiveInteger,
+        max_tokens: positiveInteger,
+        wall_clock_ms: positiveInteger
     }),
     judge: S.Object({
-        agent: S.String(),
-        model: S.String(),
-        rubric: S.Array(S.String())
+        agent: nonEmptyString,
+        model: nonEmptyString,
+        rubric: S.Array(nonEmptyString, { minItems: 1 })
     }),
     weights: S.Object({
-        tests: S.Number(),
-        judge: S.Number()
+        tests: scoringWeight,
+        judge: scoringWeight
     }),
     metrics: S.Optional(S.Array(metricSchema)),
     verify: S.Optional(S.Object({
-        command: S.String(),
-        timeout_ms: S.Number()
+        command: nonEmptyString,
+        timeout_ms: nonNegativeInteger
     }))
 });
 Object.freeze(evalYamlSchema.shape);
@@ -89,6 +93,7 @@ export function validateEvalYaml(value, filePath = "eval.yaml") {
     const result = validate(evalYamlSchema, value);
     if (result.ok) {
         const issues = [
+            ...validateNonBlankStrings(result.value),
             ...validateTarget(result.value.target),
             ...validateMetrics(result.value.metrics)
         ];
@@ -99,6 +104,42 @@ export function validateEvalYaml(value, filePath = "eval.yaml") {
     }
     throw new EvalYamlValidationError(formatIssues(filePath, result.issues), result.issues);
 }
+function validateNonBlankStrings(value) {
+    const issues = [];
+    const fields = [
+        [["id"], value.id],
+        [["title"], value.title],
+        [["target", "repo"], value.target.repo],
+        [["target", "ref"], value.target.ref],
+        [["target", "plan_dest"], value.target.plan_dest],
+        [["scorer", "command"], value.scorer?.command],
+        [["scorer", "result_path"], value.scorer?.result_path],
+        [["oracle", "path"], value.oracle.path],
+        [["oracle", "solution_dest"], value.oracle.solution_dest],
+        [["judge", "agent"], value.judge.agent],
+        [["judge", "model"], value.judge.model],
+        [["verify", "command"], value.verify?.command]
+    ];
+    for (const [fieldPath, fieldValue] of fields) {
+        if (fieldValue !== undefined && fieldValue.trim().length === 0) {
+            issues.push(blankStringIssue(fieldPath, fieldValue));
+        }
+    }
+    for (const [index, rubricLine] of value.judge.rubric.entries()) {
+        if (rubricLine.trim().length === 0) {
+            issues.push(blankStringIssue(["judge", "rubric", String(index)], rubricLine));
+        }
+    }
+    return issues;
+}
+function blankStringIssue(path, value) {
+    return {
+        path,
+        expected: "non-blank string",
+        received: JSON.stringify(value),
+        message: `${path.join(".")} must not be blank.`
+    };
+}
 function validateTarget(target) {
     const destination = target.plan_dest ?? "docs/plans/eval-task.md";
     if (path.isAbsolute(destination)) {

package/packages/agent-eval/dist/source/config.js

@@ -39,7 +39,9 @@ export async function loadSourceConfig(source, fs = nodeFs) {
     if (!isRecord(parsed)) {
         throw new Error(`${configPath} must contain a JSON object.`);
     }
-    return deepMerge(cloneDefaultConfig(), parsed);
+    const merged = deepMerge(cloneDefaultConfig(), parsed);
+    validateSourceConfig(merged, configPath);
+    return merged;
 }
 function cloneDefaultConfig() {
     return {
@@ -74,6 +76,46 @@ function deepMerge(base, patch) {
     }
     return result;
 }
+function validateSourceConfig(config, configPath) {
+    const judge = requireRecord(config.judge, configPath, "judge");
+    requireNonBlankString(judge.agent, configPath, "judge.agent");
+    requireNonBlankString(judge.model, configPath, "judge.model");
+    requireNonBlankString(config.out, configPath, "out");
+    const weights = requireRecord(config.weights, configPath, "weights");
+    requireWeight(weights.tests, configPath, "weights.tests");
+    requireWeight(weights.judge, configPath, "weights.judge");
+    if (config.clone_cache_dir !== null) {
+        requireNonBlankString(config.clone_cache_dir, configPath, "clone_cache_dir");
+    }
+}
+function requireRecord(value, configPath, fieldPath) {
+    if (isRecord(value)) {
+        return value;
+    }
+    throw invalidConfigField(configPath, fieldPath, "object", value);
+}
+function requireNonBlankString(value, configPath, fieldPath) {
+    if (typeof value !== "string") {
+        throw invalidConfigField(configPath, fieldPath, "string", value);
+    }
+    if (value.trim().length === 0) {
+        throw invalidConfigField(configPath, fieldPath, "non-blank string", value);
+    }
+}
+function requireWeight(value, configPath, fieldPath) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+        throw invalidConfigField(configPath, fieldPath, "number from 0 through 1", value);
+    }
+}
+function invalidConfigField(configPath, fieldPath, expected, received) {
+    return new Error(`${configPath} (${fieldPath}): expected ${expected}, received ${formatReceived(received)}.`);
+}
+function formatReceived(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/packages/agent-eval/dist/source/registry.js

@@ -34,6 +34,9 @@ export async function loadEval(source, id, fs = nodeFs) {
     await assertFsCanonicalContainedPath(fs, source.rootDir, evalYamlPath, "eval.yaml");
     await assertFsCanonicalContainedPath(fs, source.rootDir, planPath, "plan.md");
     const evalYaml = validateEvalYaml(parseYamlFile(await fs.readFile(evalYamlPath, "utf8"), evalYamlPath), evalYamlPath);
+    if (evalYaml.id !== id) {
+        throw new Error(`Eval id mismatch in ${evalYamlPath}: expected "${id}", found "${evalYaml.id}".`);
+    }
     const plan = parsePlanMarkdown(await fs.readFile(planPath, "utf8"), planPath);
     return {
         id: evalYaml.id,

package/packages/agent-spawn/dist/acp/session-update-converter.d.ts

@@ -1,10 +1,13 @@
-import type { SessionUpdate, ToolKind } from "../../../poe-acp-client/dist/index.js";
-import type { AcpEvent } from "./types.js";
+import type { SessionUpdate as AcpClientSessionUpdate, ToolKind as AcpClientToolKind } from "../../../poe-acp-client/dist/index.js";
+import type { AcpEvent, SessionUpdate as LegacySessionUpdate, ToolKind as LegacyToolKind } from "./types.js";
+type ConvertibleSessionUpdate = AcpClientSessionUpdate | LegacySessionUpdate;
+type ConvertibleToolKind = AcpClientToolKind | LegacyToolKind;
 export interface ToolRenderState {
     startedToolCalls: Set<string>;
     toolCallKinds: Map<string, string>;
     toolCallTitles: Map<string, string>;
 }
 export declare function createToolRenderState(): ToolRenderState;
-export declare function toRenderKind(kind: ToolKind | undefined | null): string;
-export declare function sessionUpdateToEvents(update: SessionUpdate, state: ToolRenderState): AcpEvent[];
+export declare function toRenderKind(kind: ConvertibleToolKind | undefined | null): string;
+export declare function sessionUpdateToEvents(update: ConvertibleSessionUpdate, state: ToolRenderState): AcpEvent[];
+export {};

package/packages/agent-spawn/dist/acp/session-update-converter.js

@@ -2,13 +2,13 @@ export function createToolRenderState() {
     return {
         startedToolCalls: new Set(),
         toolCallKinds: new Map(),
-        toolCallTitles: new Map(),
+        toolCallTitles: new Map()
     };
 }
 export function toRenderKind(kind) {
     if (kind === "execute")
         return "exec";
-    if (kind === "write")
+    if (kind === "write" || kind === "edit")
         return "edit";
     if (kind === "read")
         return "read";
@@ -60,7 +60,7 @@ export function sessionUpdateToEvents(update, state) {
         const usage = {
             event: "usage",
             inputTokens,
-            outputTokens,
+            outputTokens
         };
         if (cachedTokens > 0) {
             usage.cachedTokens = cachedTokens;
@@ -79,31 +79,33 @@ export function sessionUpdateToEvents(update, state) {
             return [];
         }
         state.startedToolCalls.add(update.toolCallId);
-        return [{
+        return [
+            {
                 event: "tool_start",
                 kind: renderKind,
                 title,
-                id: update.toolCallId,
-            }];
+                id: update.toolCallId
+            }
+        ];
     }
     if (update.sessionUpdate === "tool_call_update") {
-        const renderKind = toRenderKind(update.kind ?? undefined)
-            || state.toolCallKinds.get(update.toolCallId)
-            || "other";
+        const renderKind = (update.kind == null ? undefined : toRenderKind(update.kind)) ||
+            state.toolCallKinds.get(update.toolCallId) ||
+            "other";
         state.toolCallKinds.set(update.toolCallId, renderKind);
         const events = [];
         const toolTitle = toToolTitle(state.toolCallTitles.get(update.toolCallId) ?? update.toolCallId, update.locations);
         state.toolCallTitles.set(update.toolCallId, toolTitle);
         const status = update.status;
-        const shouldStart = !state.startedToolCalls.has(update.toolCallId)
-            && (status === "pending" || status === "in_progress");
+        const shouldStart = !state.startedToolCalls.has(update.toolCallId) &&
+            (status === "pending" || status === "in_progress");
         if (shouldStart) {
             state.startedToolCalls.add(update.toolCallId);
             events.push({
                 event: "tool_start",
                 kind: renderKind,
                 title: toolTitle,
-                id: update.toolCallId,
+                id: update.toolCallId
             });
         }
         if (status === "completed" || status === "failed" || status === "cancelled") {
@@ -113,14 +115,14 @@ export function sessionUpdateToEvents(update, state) {
                     event: "tool_start",
                     kind: renderKind,
                     title: toolTitle,
-                    id: update.toolCallId,
+                    id: update.toolCallId
                 });
             }
             events.push({
                 event: "tool_complete",
                 kind: renderKind,
                 path: extractToolOutputText(update),
-                id: update.toolCallId,
+                id: update.toolCallId
             });
         }
         return events;

package/packages/agent-spawn/dist/acp/types.d.ts

@@ -18,7 +18,7 @@
  */
 export type ToolKind = "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
 /** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */
-export type ToolCallStatus = "pending" | "in_progress" | "completed" | "failed";
+export type ToolCallStatus = "pending" | "in_progress" | "completed" | "failed" | "cancelled";
 /** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */
 export interface ContentChunk {
     type: "text";
@@ -39,9 +39,12 @@ export interface ToolCall {
     sessionUpdate: "tool_call";
     toolCallId: string;
     title: string;
+    content?: ToolCallContent[];
     kind?: ToolKind;
+    locations?: ToolCallLocation[];
     status?: ToolCallStatus;
     rawInput?: unknown;
+    rawOutput?: unknown;
     _meta?: Record<string, unknown>;
 }
 /** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */
@@ -54,13 +57,22 @@ export type ToolCallContent = {
     data: string;
 };
 /** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */
+export interface ToolCallLocation {
+    path: string;
+    lineNumber?: number | null;
+    _meta?: Record<string, unknown>;
+}
+/** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */
 export interface ToolCallUpdate {
     sessionUpdate: "tool_call_update";
     toolCallId: string;
     kind?: ToolKind;
-    status?: ToolCallStatus;
+    status?: ToolCallStatus | null;
     rawOutput?: unknown;
-    content?: ToolCallContent[];
+    rawInput?: unknown;
+    content?: ToolCallContent[] | null;
+    locations?: ToolCallLocation[] | null;
+    title?: string | null;
     _meta?: Record<string, unknown>;
 }
 /** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */

package/packages/agent-spawn/dist/index.d.ts

@@ -17,6 +17,8 @@ export { spawnInteractive } from "./spawn-interactive.js";
 export { spawnAutonomous } from "./autonomous.js";
 export type { AutonomousOptions, StreamingSpawnFn, StreamingSpawnReturn } from "./autonomous.js";
 export { renderAcpEvent, renderAcpStream, renderSessionUpdateStream } from "./acp/renderer.js";
+export { createToolRenderState, sessionUpdateToEvents } from "./acp/session-update-converter.js";
+export type { ToolRenderState } from "./acp/session-update-converter.js";
 export type { LogEntry, MalformedSpawnLogRecord, ReadSpawnLogOptions } from "./acp/replay.js";
 export { findLatestLog, listSpawnLogs, pickRandomLog, readSpawnLog, replaySpawnLog } from "./acp/replay.js";
 export type { SpawnStreamingOptions, SpawnStreamingResult } from "./acp/spawn.js";

package/packages/agent-spawn/dist/index.js

@@ -14,6 +14,7 @@ export { createSpawnParallel, SpawnParallelError } from "./parallel.js";
 export { spawnInteractive } from "./spawn-interactive.js";
 export { spawnAutonomous } from "./autonomous.js";
 export { renderAcpEvent, renderAcpStream, renderSessionUpdateStream } from "./acp/renderer.js";
+export { createToolRenderState, sessionUpdateToEvents } from "./acp/session-update-converter.js";
 export { findLatestLog, listSpawnLogs, pickRandomLog, readSpawnLog, replaySpawnLog } from "./acp/replay.js";
 export { spawnStreaming } from "./acp/spawn.js";
 export { spawnAcp } from "./acp/spawn-acp.js";