@cursor/july 0.1.1

package/dist/internal/eval-runner.js

@@ -0,0 +1,336 @@
+/**
+ * Discover and run filesystem evals under `<project>/evals/`.
+ *
+ * Case identity: single-`test` files use the path
+ * (`evals/weather/nyc.eval.ts` → `weather/nyc`); multi-`cases` files use
+ * `<fileId>/<case.id>` (`evals/weather.eval.ts` + `nyc` → `weather/nyc`).
+ * Drive with `t.send`, assert with `t.succeeded` / `t.calledTool` /
+ * `t.messageIncludes` / `t.check`.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readdir } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { EVAL_MAX_CONCURRENCY_LIMIT, expandEvalDefinition, matchesEvalIdFilter, normalizeEvalMaxConcurrency, } from "../evals.js";
+import { isDefinitionOfKind } from "./brand.js";
+import { mapPool } from "./map-pool.js";
+import { RunSessionTimeoutError, runSession } from "./run-client.js";
+import { buildTrajectory } from "./trajectory.js";
+function defaultImport(absolutePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield import(pathToFileURL(absolutePath).href));
+    });
+}
+function listEvalFiles(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const out = [];
+        function walk(current) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let entries;
+                try {
+                    entries = yield readdir(current, { withFileTypes: true });
+                }
+                catch (_a) {
+                    return;
+                }
+                for (const entry of entries) {
+                    if (entry.name.startsWith(".")) {
+                        continue;
+                    }
+                    const abs = join(current, entry.name);
+                    if (entry.isDirectory()) {
+                        if (entry.name === "node_modules") {
+                            continue;
+                        }
+                        yield walk(abs);
+                    }
+                    else if (entry.isFile()) {
+                        out.push(abs);
+                    }
+                }
+            });
+        }
+        yield walk(dir);
+        return out.sort();
+    });
+}
+export function discoverEvals(projectRoot_1) {
+    return __awaiter(this, arguments, void 0, function* (projectRoot, importModule = defaultImport) {
+        const root = resolve(projectRoot);
+        const evalsDir = join(root, "evals");
+        const files = yield listEvalFiles(evalsDir);
+        const evals = [];
+        let config = {};
+        for (const abs of files) {
+            const rel = relative(evalsDir, abs).replace(/\\/g, "/");
+            if (rel === "evals.config.ts" || rel === "evals.config.js") {
+                const mod = yield importModule(abs);
+                if (mod.default !== null && typeof mod.default === "object") {
+                    config = mod.default;
+                }
+                continue;
+            }
+            if (!rel.endsWith(".eval.ts") && !rel.endsWith(".eval.js")) {
+                continue;
+            }
+            const mod = yield importModule(abs);
+            const def = mod.default;
+            if (!isDefinitionOfKind(def, "eval")) {
+                throw new Error(`${rel}: default export must be defineEval({ ... })`);
+            }
+            const fileId = rel.replace(/\.eval\.(ts|js)$/, "").replace(/\/index$/, "");
+            try {
+                for (const expanded of expandEvalDefinition(fileId, def)) {
+                    evals.push({
+                        id: expanded.id,
+                        fileId,
+                        path: abs,
+                        definition: expanded.definition,
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`${rel}: ${message}`);
+            }
+        }
+        return { evals, config };
+    });
+}
+/** Apply id/tag filters used by CLI, playground, and `runDiscoveredEvals`. */
+export function filterDiscoveredEvals(evals, options = {}) {
+    let selected = evals;
+    if (options.filterIds !== undefined && options.filterIds.length > 0) {
+        selected = selected.filter((e) => options.filterIds.some((f) => matchesEvalIdFilter(e.id, f)));
+    }
+    if (options.tags !== undefined && options.tags.length > 0) {
+        selected = selected.filter((e) => { var _a; return ((_a = e.definition.tags) !== null && _a !== void 0 ? _a : []).some((t) => options.tags.includes(t)); });
+    }
+    return selected;
+}
+export function runDiscoveredEvals(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        let selected;
+        let config;
+        if (options.discovered !== undefined) {
+            selected = options.discovered.evals;
+            config = options.discovered.config;
+        }
+        else {
+            const importModule = (_a = options.importModule) !== null && _a !== void 0 ? _a : defaultImport;
+            const discovered = yield discoverEvals(options.projectRoot, importModule);
+            config = discovered.config;
+            selected = filterDiscoveredEvals(discovered.evals, {
+                filterIds: options.filterIds,
+                tags: options.tags,
+            });
+        }
+        if (selected.length === 0) {
+            return [];
+        }
+        const maxConcurrency = resolveEvalMaxConcurrency(config);
+        const defaultTimeoutMs = (_c = (_b = options.timeoutMs) !== null && _b !== void 0 ? _b : config.timeoutMs) !== null && _c !== void 0 ? _c : 180000;
+        return mapPool(selected, maxConcurrency, (discovered) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (options.verbose) {
+                process.stderr.write(`  eval ${discovered.id}…\n`);
+            }
+            (_a = options.onCaseStart) === null || _a === void 0 ? void 0 : _a.call(options, discovered.id);
+            const result = yield runOneEval(discovered, {
+                baseUrl: options.baseUrl,
+                defaultTimeoutMs,
+                bearerToken: options.bearerToken,
+                verbose: Boolean(options.verbose),
+                onEvent: (event) => {
+                    var _a, _b;
+                    (_a = options.onCaseEvent) === null || _a === void 0 ? void 0 : _a.call(options, discovered.id, event);
+                    (_b = options.onEvent) === null || _b === void 0 ? void 0 : _b.call(options, event);
+                },
+            });
+            (_b = options.onCaseDone) === null || _b === void 0 ? void 0 : _b.call(options, result);
+            return result;
+        }));
+    });
+}
+function resolveEvalMaxConcurrency(config) {
+    if (config.maxConcurrency === undefined) {
+        throw new Error(`evals/evals.config.ts must define maxConcurrency (1–${EVAL_MAX_CONCURRENCY_LIMIT}; hard limit is due to model provider request limits). Example:\n` +
+            `  import { defineEvalConfig } from "@anysphere/agent-serve/evals";\n` +
+            `  export default defineEvalConfig({ maxConcurrency: 20 });`);
+    }
+    return normalizeEvalMaxConcurrency(config.maxConcurrency);
+}
+function runOneEval(discovered, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const logs = [];
+        const assertions = [];
+        const def = discovered.definition;
+        const timeoutMs = (_a = def.timeoutMs) !== null && _a !== void 0 ? _a : opts.defaultTimeoutMs;
+        const startedAt = Date.now();
+        let sessionId;
+        let continuationToken;
+        const allEvents = [];
+        const inputs = [];
+        let reply = null;
+        const record = (name, passed, detail) => {
+            assertions.push(Object.assign({ name,
+                passed }, (detail === undefined ? {} : { detail })));
+        };
+        const toolsUsed = () => buildTrajectory(allEvents).turns.flatMap((t) => t.toolCalls.map((c) => c.toolName));
+        const toolCallIo = () => buildTrajectory(allEvents).turns.flatMap((turn) => turn.toolCalls.map((c) => (Object.assign(Object.assign(Object.assign({ toolName: c.toolName }, (c.args === undefined ? {} : { args: c.args })), (c.output === undefined ? {} : { output: c.output })), { isError: c.isError }))));
+        const t = {
+            get reply() {
+                return reply;
+            },
+            get sessionId() {
+                return sessionId;
+            },
+            get events() {
+                return allEvents;
+            },
+            send(message_1) {
+                return __awaiter(this, arguments, void 0, function* (message, options = {}) {
+                    inputs.push(message);
+                    const result = yield runSession({
+                        baseUrl: opts.baseUrl,
+                        messages: [message],
+                        sessionId,
+                        continuationToken,
+                        // Keep defineEval traffic out of live defineAB enrollment/metrics.
+                        purpose: "eval",
+                        bearerToken: opts.bearerToken,
+                        workspaceDir: options.workspaceDir,
+                        workspaceFiles: options.workspaceFiles,
+                        timeoutMs,
+                        onEvent: opts.onEvent,
+                    });
+                    sessionId = result.sessionId;
+                    continuationToken = result.continuationToken;
+                    allEvents.push(...result.events);
+                    if (result.trajectory.finalText !== "") {
+                        reply = result.trajectory.finalText;
+                    }
+                    return {
+                        message: result.trajectory.finalText,
+                        sessionId: result.sessionId,
+                        events: result.events,
+                        toolCalls: result.trajectory.turns.flatMap((turn) => turn.toolCalls.map((c) => c.toolName)),
+                        ok: result.ok,
+                    };
+                });
+            },
+            succeeded() {
+                const traj = buildTrajectory(allEvents);
+                record("succeeded", traj.ok && traj.turns.length > 0, traj.ok ? undefined : "turn failed");
+            },
+            calledTool(name) {
+                const tools = toolsUsed();
+                record(`calledTool(${name})`, tools.includes(name), tools.includes(name) ? undefined : `got [${tools.join(", ")}]`);
+            },
+            notCalledTool(name) {
+                const tools = toolsUsed();
+                record(`notCalledTool(${name})`, !tools.includes(name), tools.includes(name) ? "tool was called" : undefined);
+            },
+            messageIncludes(token) {
+                const text = reply !== null && reply !== void 0 ? reply : "";
+                const passed = typeof token === "string" ? text.includes(token) : token.test(text);
+                record(`messageIncludes(${String(token)})`, passed, passed ? undefined : `reply=${JSON.stringify(text.slice(0, 120))}`);
+            },
+            check(value, assertion) {
+                const { passed, detail } = matchExpectation(value, assertion);
+                record(`check(${assertion.kind})`, passed, detail);
+            },
+            log(message) {
+                logs.push(message);
+                if (opts.verbose) {
+                    process.stderr.write(`    ${message}\n`);
+                }
+            },
+        };
+        try {
+            yield def.test(t);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (error instanceof RunSessionTimeoutError && sessionId === undefined) {
+                sessionId = error.sessionId;
+            }
+            return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ id: discovered.id, path: discovered.path }, (def.description === undefined
+                ? {}
+                : { description: def.description })), { ok: false, assertions, error: message, logs,
+                inputs, toolCalls: toolCallIo() }), (sessionId === undefined ? {} : { sessionId })), (reply === null ? {} : { finalText: reply })), { tools: toolsUsed(), durationMs: Date.now() - startedAt });
+        }
+        const traj = buildTrajectory(allEvents);
+        const ok = assertions.length > 0
+            ? assertions.every((a) => a.passed)
+            : traj.ok && traj.turns.length > 0;
+        return Object.assign(Object.assign(Object.assign(Object.assign({ id: discovered.id, path: discovered.path }, (def.description === undefined ? {} : { description: def.description })), { ok,
+            assertions,
+            logs,
+            inputs, toolCalls: toolCallIo() }), (sessionId === undefined ? {} : { sessionId })), { finalText: reply !== null && reply !== void 0 ? reply : traj.finalText, tools: toolsUsed(), durationMs: Date.now() - startedAt });
+    });
+}
+function matchExpectation(value, assertion) {
+    switch (assertion.kind) {
+        case "includes": {
+            const text = value === null || value === undefined ? "" : String(value);
+            const passed = typeof assertion.value === "string"
+                ? text.includes(assertion.value)
+                : assertion.value.test(text);
+            return Object.assign({ passed }, (passed
+                ? {}
+                : {
+                    detail: `value=${JSON.stringify(text.slice(0, 120))}`,
+                }));
+        }
+        case "equals": {
+            const passed = deepEqual(value, assertion.value);
+            return Object.assign({ passed }, (passed ? {} : { detail: `got ${JSON.stringify(value)}` }));
+        }
+        case "satisfies": {
+            const passed = assertion.predicate(value);
+            return Object.assign({ passed }, (passed ? {} : { detail: assertion.label }));
+        }
+    }
+}
+function deepEqual(a, b) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    if (typeof a !== "object" ||
+        typeof b !== "object" ||
+        a === null ||
+        b === null) {
+        return false;
+    }
+    if (Array.isArray(a) !== Array.isArray(b)) {
+        return false;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return a.every((item, i) => deepEqual(item, b[i]));
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys) {
+        if (!deepEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/internal/event-log.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Durable, replayable per-session event log. Events are held in memory for
+ * live fan-out and appended to `events.ndjson` for durability; on process
+ * restart the file is hydrated back so streams can replay from any
+ * `startIndex`.
+ */
+import type { SessionEvent, SessionEventPayload } from "../types.js";
+export type AppendableEvent = SessionEventPayload & {
+    turnId?: string;
+};
+export declare class SessionEventLog {
+    private readonly sessionId;
+    private readonly filePath;
+    private readonly onPersistError;
+    private readonly events;
+    private readonly listeners;
+    private persistChain;
+    private constructor();
+    static open(args: {
+        sessionId: string;
+        filePath: string;
+        onPersistError?: (error: unknown) => void;
+    }): Promise<SessionEventLog>;
+    private hydrate;
+    get count(): number;
+    /**
+     * Assign the next index, record the event, and fan out to live
+     * subscribers. Ordering is synchronous; file persistence is chained in
+     * the background and awaited by {@link flush}.
+     */
+    append(payload: AppendableEvent): SessionEvent;
+    /** Wait for pending file writes (used on close). */
+    flush(): Promise<void>;
+    snapshot(startIndex?: number): SessionEvent[];
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    /**
+     * NDJSON stream: replays recorded events from `startIndex`, then follows
+     * live events until the consumer cancels.
+     */
+    stream(startIndex?: number): ReadableStream<Uint8Array>;
+}
+/** Lazily opens one {@link SessionEventLog} per session. */
+export declare class EventLogStore {
+    private readonly eventFilePathFor;
+    private readonly onPersistError;
+    private readonly logs;
+    constructor(eventFilePathFor: (sessionId: string) => string, onPersistError?: (sessionId: string, error: unknown) => void);
+    get(sessionId: string): Promise<SessionEventLog>;
+    flushAll(): Promise<void>;
+}
+//# sourceMappingURL=event-log.d.ts.map

package/dist/internal/event-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-log.d.ts","sourceRoot":"","sources":["../../src/internal/event-log.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,qBAAa,eAAe;IAMxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAPjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4C;IACtE,OAAO,CAAC,YAAY,CAAoC;IAExD,OAAO,eAIH;IAEJ,OAAa,IAAI,CAAC,IAAI,EAAE;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;KAC3C,GAAG,OAAO,CAAC,eAAe,CAAC,CAQ3B;YAEa,OAAO;IAmBrB,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG,YAAY,CAsB7C;IAED,oDAAoD;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAED,QAAQ,CAAC,UAAU,SAAI,GAAG,YAAY,EAAE,CAEvC;IAED,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,MAAM,IAAI,CAK7D;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,SAAI,GAAG,cAAc,CAAC,UAAU,CAAC,CA0BjD;CACF;AAED,4DAA4D;AAC5D,qBAAa,aAAa;IAItB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAJjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+C;IAEpE,YACmB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,EAC/C,cAAc,GAAE,CAC/B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,KACX,IAAe,EAClB;IAEJ,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAc/C;IAEK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAM9B;CACF"}

package/dist/internal/event-log.js

@@ -0,0 +1,167 @@
+/**
+ * Durable, replayable per-session event log. Events are held in memory for
+ * live fan-out and appended to `events.ndjson` for durability; on process
+ * restart the file is hydrated back so streams can replay from any
+ * `startIndex`.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export class SessionEventLog {
+    constructor(sessionId, filePath, onPersistError) {
+        this.sessionId = sessionId;
+        this.filePath = filePath;
+        this.onPersistError = onPersistError;
+        this.events = [];
+        this.listeners = new Set();
+        this.persistChain = Promise.resolve();
+    }
+    static open(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const log = new SessionEventLog(args.sessionId, args.filePath, (_a = args.onPersistError) !== null && _a !== void 0 ? _a : (() => { }));
+            yield log.hydrate();
+            return log;
+        });
+    }
+    hydrate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let raw;
+            try {
+                raw = yield readFile(this.filePath, "utf8");
+            }
+            catch (_a) {
+                return;
+            }
+            for (const line of raw.split("\n")) {
+                if (line.trim() === "") {
+                    continue;
+                }
+                try {
+                    this.events.push(JSON.parse(line));
+                }
+                catch (_b) {
+                    // Skip torn trailing writes from a crashed process.
+                }
+            }
+        });
+    }
+    get count() {
+        return this.events.length;
+    }
+    /**
+     * Assign the next index, record the event, and fan out to live
+     * subscribers. Ordering is synchronous; file persistence is chained in
+     * the background and awaited by {@link flush}.
+     */
+    append(payload) {
+        const { turnId } = payload, rest = __rest(payload, ["turnId"]);
+        const event = Object.assign(Object.assign(Object.assign({ index: this.events.length, sessionId: this.sessionId }, (turnId === undefined ? {} : { turnId })), { at: new Date().toISOString() }), rest);
+        this.events.push(event);
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(event);
+            }
+            catch (_a) {
+                // Subscriber errors must not break the log.
+            }
+        }
+        const line = `${JSON.stringify(event)}\n`;
+        this.persistChain = this.persistChain
+            .then(() => appendFile(this.filePath, line, "utf8"))
+            .catch((error) => this.onPersistError(error));
+        return event;
+    }
+    /** Wait for pending file writes (used on close). */
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.persistChain;
+        });
+    }
+    snapshot(startIndex = 0) {
+        return startIndex <= 0 ? [...this.events] : this.events.slice(startIndex);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * NDJSON stream: replays recorded events from `startIndex`, then follows
+     * live events until the consumer cancels.
+     */
+    stream(startIndex = 0) {
+        const encoder = new TextEncoder();
+        let unsubscribe;
+        return new ReadableStream({
+            start: (controller) => {
+                const push = (event) => {
+                    try {
+                        controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
+                    }
+                    catch (_a) {
+                        unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+                    }
+                };
+                // Synchronous snapshot + subscribe: no events can interleave.
+                for (const event of this.snapshot(startIndex)) {
+                    push(event);
+                }
+                unsubscribe = this.subscribe((event) => {
+                    if (event.index >= startIndex) {
+                        push(event);
+                    }
+                });
+            },
+            cancel: () => {
+                unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+            },
+        });
+    }
+}
+/** Lazily opens one {@link SessionEventLog} per session. */
+export class EventLogStore {
+    constructor(eventFilePathFor, onPersistError = () => { }) {
+        this.eventFilePathFor = eventFilePathFor;
+        this.onPersistError = onPersistError;
+        this.logs = new Map();
+    }
+    get(sessionId) {
+        let log = this.logs.get(sessionId);
+        if (log === undefined) {
+            const filePath = this.eventFilePathFor(sessionId);
+            log = mkdir(dirname(filePath), { recursive: true }).then(() => SessionEventLog.open({
+                sessionId,
+                filePath,
+                onPersistError: (error) => this.onPersistError(sessionId, error),
+            }));
+            this.logs.set(sessionId, log);
+        }
+        return log;
+    }
+    flushAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([...this.logs.values()].map((logPromise) => logPromise.then((log) => log.flush()).catch(() => { })));
+        });
+    }
+}

package/dist/internal/event-mapper.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Maps the Cursor harness's streaming delta vocabulary
+ * (`InteractionUpdate`) onto the framework's channel event vocabulary
+ * (`SessionEvent` payloads). One mapper instance covers one turn.
+ */
+import type { InteractionUpdate, ToolCall } from "@cursor/sdk";
+import type { SessionEventPayload, TurnUsage } from "../types.js";
+export interface ToolCallDescription {
+    toolName: string;
+    args?: unknown;
+    subagent?: {
+        name?: string;
+        description?: string;
+    };
+}
+export interface ToolResultDescription {
+    output?: unknown;
+    isError: boolean;
+}
+export declare class TurnEventMapper {
+    private readonly emit;
+    private textAccumulator;
+    private reasoningAccumulator;
+    private usageTotal;
+    private lastAssistantText;
+    private summaryTitle;
+    constructor(emit: (payload: SessionEventPayload) => void);
+    /** Per-turn token usage summed across model steps. */
+    get usage(): TurnUsage | undefined;
+    /** The final assistant text block of the turn, when one was produced. */
+    get finalText(): string | undefined;
+    /** Conversation summary produced by the harness (used as session title). */
+    get title(): string | undefined;
+    handleUpdate(update: InteractionUpdate): void;
+    /** Close out the turn: finalize any open assistant text block. */
+    finish(): void;
+    private flushAssistantText;
+}
+/**
+ * Human-meaningful tool identity for stream events. In-process tools calls
+ * arrive as MCP calls against the synthetic `custom-user-tools` server; they
+ * surface under the customer's bare tool name.
+ */
+export declare function describeToolCall(toolCall: ToolCall): ToolCallDescription;
+export declare function describeToolResult(toolCall: ToolCall): ToolResultDescription;
+//# sourceMappingURL=event-mapper.d.ts.map

package/dist/internal/event-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-mapper.d.ts","sourceRoot":"","sources":["../../src/internal/event-mapper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIlE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,eAAe;IAOd,OAAO,CAAC,QAAQ,CAAC,IAAI;IANjC,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,oBAAoB,CAAM;IAClC,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,iBAAiB,CAAqB;IAC9C,OAAO,CAAC,YAAY,CAAqB;IAEzC,YAA6B,IAAI,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,EAAI;IAE7E,sDAAsD;IACtD,IAAI,KAAK,IAAI,SAAS,GAAG,SAAS,CAEjC;IAED,yEAAyE;IACzE,IAAI,SAAS,IAAI,MAAM,GAAG,SAAS,CAElC;IAED,4EAA4E;IAC5E,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CA4G5C;IAED,kEAAkE;IAClE,MAAM,IAAI,IAAI,CAEb;IAED,OAAO,CAAC,kBAAkB;CAY3B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,CA0CxE;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,qBAAqB,CA4B5E"}