@cursor/july 0.1.1

package/dist/internal/session-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Persisted session registry. Each session lives at
+ * `<stateRoot>/sessions/<sessionId>/` with a `session.json` record, an
+ * `events.ndjson` log, and a `workspace/` directory. Continuation keys are
+ * indexed in memory (hydrated by scanning session records on first use) so
+ * channels can address sessions by their channel-local token.
+ */
+import type { SessionRecord } from "../types.js";
+export declare class SessionStore {
+    private readonly sessionsDir;
+    private readonly cache;
+    private readonly continuationIndex;
+    private hydrated;
+    constructor(sessionsDir: string);
+    sessionDir(sessionId: string): string;
+    workspaceDir(sessionId: string): string;
+    eventFilePath(sessionId: string): string;
+    private recordPath;
+    private continuationKeyOf;
+    private hydrate;
+    private ensureHydrated;
+    private readRecord;
+    private indexRecord;
+    get(sessionId: string): Promise<SessionRecord | undefined>;
+    list(): Promise<SessionRecord[]>;
+    findByContinuation(channelId: string, key: string): Promise<SessionRecord | undefined>;
+    save(record: SessionRecord): Promise<void>;
+}
+//# sourceMappingURL=session-store.d.ts.map

package/dist/internal/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../src/internal/session-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,qBAAa,YAAY;IAKX,OAAO,CAAC,QAAQ,CAAC,WAAW;IAJxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAC/D,OAAO,CAAC,QAAQ,CAA4B;IAE5C,YAA6B,WAAW,EAAE,MAAM,EAAI;IAEpD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKpC;IAED,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtC;IAED,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvC;IAED,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,iBAAiB;YAIX,OAAO;YAmBP,cAAc;YAKd,UAAU;IAcxB,OAAO,CAAC,WAAW;IASb,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAc/D;IAEK,IAAI,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAKrC;IAEK,kBAAkB,CACtB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAMpC;IAEK,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB/C;CACF"}

package/dist/internal/session-store.js

@@ -0,0 +1,140 @@
+/**
+ * Persisted session registry. Each session lives at
+ * `<stateRoot>/sessions/<sessionId>/` with a `session.json` record, an
+ * `events.ndjson` log, and a `workspace/` directory. Continuation keys are
+ * indexed in memory (hydrated by scanning session records on first use) so
+ * channels can address sessions by their channel-local token.
+ */
+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 { randomBytes } from "node:crypto";
+import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isSafeSessionId } from "./auth.js";
+export class SessionStore {
+    constructor(sessionsDir) {
+        this.sessionsDir = sessionsDir;
+        this.cache = new Map();
+        this.continuationIndex = new Map();
+    }
+    sessionDir(sessionId) {
+        if (!isSafeSessionId(sessionId)) {
+            throw new Error(`Invalid session id: ${sessionId}`);
+        }
+        return join(this.sessionsDir, sessionId);
+    }
+    workspaceDir(sessionId) {
+        return join(this.sessionDir(sessionId), "workspace");
+    }
+    eventFilePath(sessionId) {
+        return join(this.sessionDir(sessionId), "events.ndjson");
+    }
+    recordPath(sessionId) {
+        return join(this.sessionDir(sessionId), "session.json");
+    }
+    continuationKeyOf(channelId, key) {
+        return `${channelId}\n${key}`;
+    }
+    hydrate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let entries;
+            try {
+                entries = yield readdir(this.sessionsDir);
+            }
+            catch (_a) {
+                return;
+            }
+            for (const sessionId of entries) {
+                if (!isSafeSessionId(sessionId) || this.cache.has(sessionId)) {
+                    continue;
+                }
+                const record = yield this.readRecord(sessionId);
+                if (record !== undefined) {
+                    this.cache.set(sessionId, record);
+                    this.indexRecord(record);
+                }
+            }
+        });
+    }
+    ensureHydrated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            (_a = this.hydrated) !== null && _a !== void 0 ? _a : (this.hydrated = this.hydrate());
+            yield this.hydrated;
+        });
+    }
+    readRecord(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isSafeSessionId(sessionId)) {
+                return undefined;
+            }
+            try {
+                const raw = yield readFile(this.recordPath(sessionId), "utf8");
+                return JSON.parse(raw);
+            }
+            catch (_a) {
+                return undefined;
+            }
+        });
+    }
+    indexRecord(record) {
+        if (record.continuationKey !== null) {
+            this.continuationIndex.set(this.continuationKeyOf(record.channelId, record.continuationKey), record.sessionId);
+        }
+    }
+    get(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isSafeSessionId(sessionId)) {
+                return undefined;
+            }
+            const cached = this.cache.get(sessionId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const record = yield this.readRecord(sessionId);
+            if (record !== undefined) {
+                this.cache.set(sessionId, record);
+                this.indexRecord(record);
+            }
+            return record;
+        });
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureHydrated();
+            return [...this.cache.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        });
+    }
+    findByContinuation(channelId, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureHydrated();
+            const sessionId = this.continuationIndex.get(this.continuationKeyOf(channelId, key));
+            return sessionId === undefined ? undefined : this.get(sessionId);
+        });
+    }
+    save(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const previous = this.cache.get(record.sessionId);
+            if (previous !== undefined &&
+                previous.continuationKey !== null &&
+                previous.continuationKey !== record.continuationKey) {
+                this.continuationIndex.delete(this.continuationKeyOf(previous.channelId, previous.continuationKey));
+            }
+            this.cache.set(record.sessionId, record);
+            this.indexRecord(record);
+            const dir = this.sessionDir(record.sessionId);
+            yield mkdir(dir, { recursive: true });
+            const finalPath = this.recordPath(record.sessionId);
+            const tmpPath = `${finalPath}.${randomBytes(4).toString("hex")}.tmp`;
+            yield writeFile(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+            yield rename(tmpPath, finalPath);
+        });
+    }
+}

package/dist/internal/session-urls.d.ts

@@ -0,0 +1,10 @@
+/** Absolute playground deep-link for a session on this agent mount. */
+export declare function playgroundUrlForSession(request: Request, base: string, sessionId: string): string;
+/** Absolute NDJSON event-trace URL for a session on this agent mount. */
+export declare function eventsUrlForSession(requestUrl: string, base: string, sessionId: string): string;
+/** Playground + trace URLs for a custom channel response body. */
+export declare function sessionUrlsForRequest(request: Request, base: string, sessionId: string): {
+    playgroundUrl: string;
+    traceUrl: string;
+};
+//# sourceMappingURL=session-urls.d.ts.map

package/dist/internal/session-urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-urls.d.ts","sourceRoot":"","sources":["../../src/internal/session-urls.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,MAAM,CAIR;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,MAAM,CAIR;AAED,kEAAkE;AAClE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAK7C"}

package/dist/internal/session-urls.js

@@ -0,0 +1,25 @@
+/** Absolute playground deep-link for a session on this agent mount. */
+export function playgroundUrlForSession(request, base, sessionId) {
+    const url = new URL(request.url);
+    const mount = normalizeMountBase(base);
+    return `${url.origin}${mount}/playground?sessionId=${encodeURIComponent(sessionId)}`;
+}
+/** Absolute NDJSON event-trace URL for a session on this agent mount. */
+export function eventsUrlForSession(requestUrl, base, sessionId) {
+    const url = new URL(requestUrl);
+    const mount = normalizeMountBase(base);
+    return `${url.origin}${mount}/v1/session/${encodeURIComponent(sessionId)}/events`;
+}
+/** Playground + trace URLs for a custom channel response body. */
+export function sessionUrlsForRequest(request, base, sessionId) {
+    return {
+        playgroundUrl: playgroundUrlForSession(request, base, sessionId),
+        traceUrl: eventsUrlForSession(request.url, base, sessionId),
+    };
+}
+function normalizeMountBase(base) {
+    if (base === "") {
+        return "";
+    }
+    return base.startsWith("/") ? base : `/${base}`;
+}

package/dist/internal/stream-progress.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Live terminal rendering of session events for `run` / `eval`.
+ * Writes to a caller-provided sink (usually stderr) so stdout can stay JSON.
+ */
+import type { SessionEvent } from "../types.js";
+export interface StreamProgress {
+    onEvent(event: SessionEvent): void;
+    close(): void;
+}
+export declare function createStreamProgress(options?: {
+    write?: (s: string) => void;
+    color?: boolean;
+}): StreamProgress;
+//# sourceMappingURL=stream-progress.d.ts.map

package/dist/internal/stream-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-progress.d.ts","sourceRoot":"","sources":["../../src/internal/stream-progress.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,cAAc,CAmLjB"}

package/dist/internal/stream-progress.js

@@ -0,0 +1,195 @@
+/**
+ * Live terminal rendering of session events for `run` / `eval`.
+ * Writes to a caller-provided sink (usually stderr) so stdout can stay JSON.
+ */
+export function createStreamProgress(options) {
+    var _a, _b;
+    const write = (_a = options === null || options === void 0 ? void 0 : options.write) !== null && _a !== void 0 ? _a : ((s) => process.stderr.write(s));
+    const color = (_b = options === null || options === void 0 ? void 0 : options.color) !== null && _b !== void 0 ? _b : (process.stderr.isTTY === true && process.env.NO_COLOR === undefined);
+    const c = makePalette(color);
+    let assistantOpen = false;
+    let thinkingShown = false;
+    const turnStartedAt = new Map();
+    const toolStartedAt = new Map();
+    let turnClock = 0;
+    const closeAssistant = () => {
+        if (assistantOpen) {
+            write("\n");
+            assistantOpen = false;
+        }
+    };
+    const elapsed = (since) => `${Date.now() - since}ms`;
+    return {
+        onEvent(event) {
+            var _a, _b;
+            switch (event.type) {
+                case "session.started": {
+                    write(c.dim(`session ${event.sessionId}\n`));
+                    break;
+                }
+                case "agent.bound": {
+                    closeAssistant();
+                    write(`  ${c.cyan("agent")} ${c.bold(event.data.sdkAgentId)}\n`);
+                    if (event.data.url !== undefined) {
+                        write(`  ${c.dim(event.data.url)}\n`);
+                    }
+                    break;
+                }
+                case "turn.started": {
+                    turnClock = Date.now();
+                    if (event.turnId !== undefined) {
+                        turnStartedAt.set(event.turnId, turnClock);
+                    }
+                    write(c.dim(`  turn ${(_a = event.turnId) !== null && _a !== void 0 ? _a : "?"} started\n`));
+                    break;
+                }
+                case "message.received": {
+                    thinkingShown = false;
+                    write(`${c.bold("› user")}  ${truncate(event.data.text, 120)}\n`);
+                    break;
+                }
+                case "reasoning.appended": {
+                    if (!thinkingShown) {
+                        thinkingShown = true;
+                        write(c.dim("  · thinking…\n"));
+                    }
+                    break;
+                }
+                case "message.appended": {
+                    if (!assistantOpen) {
+                        write(`${c.green("‹ agent")}  `);
+                        assistantOpen = true;
+                    }
+                    write(event.data.delta);
+                    break;
+                }
+                case "message.completed": {
+                    closeAssistant();
+                    break;
+                }
+                case "step.started": {
+                    write(c.dim(`  · step ${event.data.stepId}\n`));
+                    break;
+                }
+                case "step.completed": {
+                    write(c.dim(`  · step ${event.data.stepId} (${event.data.durationMs}ms)\n`));
+                    break;
+                }
+                case "actions.requested": {
+                    closeAssistant();
+                    const now = Date.now();
+                    for (const call of event.data.calls) {
+                        toolStartedAt.set(call.callId, now);
+                        write(`  ${c.magenta("⚙")} ${c.bold(call.toolName)}${c.dim(formatArgs(call.args))}\n`);
+                    }
+                    break;
+                }
+                case "action.approval_requested": {
+                    closeAssistant();
+                    write(`    ${c.yellow("⏸")} ${c.bold(event.data.toolName)} ${c.dim("awaiting human approval")}\n`);
+                    break;
+                }
+                case "action.approval_resolved": {
+                    const mark = event.data.decision === "approve" ? c.green("✓") : c.red("✗");
+                    write(`    ${mark} ${c.bold(event.data.toolName)} ${c.dim(event.data.decision === "approve" ? "approved" : "denied")}\n`);
+                    break;
+                }
+                case "action.result": {
+                    const started = toolStartedAt.get(event.data.callId);
+                    toolStartedAt.delete(event.data.callId);
+                    const dur = started === undefined ? "" : c.dim(` ${elapsed(started)}`);
+                    const mark = event.data.isError ? c.red("✗") : c.magenta("✓");
+                    write(`    ${mark} ${c.bold(event.data.toolName)}${dur} ${c.dim(truncate(stringify(event.data.output), 90))}\n`);
+                    break;
+                }
+                case "subagent.called": {
+                    closeAssistant();
+                    const detail = event.data.description
+                        ? ` — ${truncate(event.data.description, 60)}`
+                        : "";
+                    write(`  ${c.magenta("task")} ${c.bold((_b = event.data.name) !== null && _b !== void 0 ? _b : "subagent")}${c.dim(detail)}\n`);
+                    break;
+                }
+                case "turn.completed": {
+                    closeAssistant();
+                    const usage = event.data.usage;
+                    const tokens = usage
+                        ? ` · in ${usage.inputTokens} out ${usage.outputTokens} tok`
+                        : "";
+                    const turnStart = event.turnId !== undefined
+                        ? turnStartedAt.get(event.turnId)
+                        : turnClock || undefined;
+                    const wall = turnStart !== undefined && turnStart > 0
+                        ? ` · ${elapsed(turnStart)} wall`
+                        : turnClock > 0
+                            ? ` · ${elapsed(turnClock)} wall`
+                            : "";
+                    write(c.dim(`  ─ turn done${tokens}${wall}\n`));
+                    if (event.turnId !== undefined) {
+                        turnStartedAt.delete(event.turnId);
+                    }
+                    break;
+                }
+                case "turn.failed": {
+                    closeAssistant();
+                    write(`${c.red("  ✗ turn failed")} ${event.data.message}\n`);
+                    break;
+                }
+                case "session.failed": {
+                    closeAssistant();
+                    write(`${c.red("  ✗ session failed")} ${event.data.message}\n`);
+                    break;
+                }
+                case "session.waiting":
+                case "session.completed": {
+                    closeAssistant();
+                    break;
+                }
+                default:
+                    break;
+            }
+        },
+        close: closeAssistant,
+    };
+}
+const IDENTITY = (s) => s;
+function makePalette(enabled) {
+    if (!enabled) {
+        return {
+            dim: IDENTITY,
+            bold: IDENTITY,
+            cyan: IDENTITY,
+            green: IDENTITY,
+            red: IDENTITY,
+            magenta: IDENTITY,
+            yellow: IDENTITY,
+        };
+    }
+    const wrap = (code) => (s) => `\u001b[${code}m${s}\u001b[0m`;
+    return {
+        dim: wrap("2"),
+        bold: wrap("1"),
+        cyan: wrap("36"),
+        green: wrap("32"),
+        red: wrap("31"),
+        magenta: wrap("35"),
+        yellow: wrap("33"),
+    };
+}
+function stringify(value) {
+    if (value === undefined || value === null) {
+        return "(no output)";
+    }
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function formatArgs(args) {
+    if (args === undefined || args === null) {
+        return "";
+    }
+    const text = typeof args === "string" ? args : JSON.stringify(args);
+    return text === "{}" ? "" : `(${truncate(text, 80)})`;
+}
+function truncate(text, max) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+}

package/dist/internal/tool-result.d.ts

@@ -0,0 +1,20 @@
+import type { SDKCustomToolResult } from "@cursor/sdk";
+import type { ToolExecuteResult } from "../types.js";
+/**
+ * Normalize a custom tool's return value for the SDK.
+ *
+ * Plain objects are round-tripped through JSON so fields whose value is
+ * `undefined` are dropped (JSON semantics). Without this, a return like
+ * `{ action: undefined }` reaches the SDK's protobuf `Struct.fromJson`,
+ * which throws `cannot decode google.protobuf.Value from JSON undefined` —
+ * the tool has already executed, but the model only sees an opaque encode
+ * error and typically retries the call.
+ */
+export declare function normalizeToolResult(result: ToolExecuteResult | undefined): SDKCustomToolResult;
+/**
+ * Pull a channel-friendly error string out of a normalized tool result
+ * (error envelopes with `{ content: [{ type: "text", text }] }`, or a
+ * bare string). Used for {@link import("../types.js").ToolCallOutcome.errorMessage}.
+ */
+export declare function toolCallErrorMessage(result: unknown): string | undefined;
+//# sourceMappingURL=tool-result.d.ts.map

package/dist/internal/tool-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result.d.ts","sourceRoot":"","sources":["../../src/internal/tool-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,GACpC,mBAAmB,CAYrB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAmBxE"}

package/dist/internal/tool-result.js

@@ -0,0 +1,45 @@
+/**
+ * Normalize a custom tool's return value for the SDK.
+ *
+ * Plain objects are round-tripped through JSON so fields whose value is
+ * `undefined` are dropped (JSON semantics). Without this, a return like
+ * `{ action: undefined }` reaches the SDK's protobuf `Struct.fromJson`,
+ * which throws `cannot decode google.protobuf.Value from JSON undefined` —
+ * the tool has already executed, but the model only sees an opaque encode
+ * error and typically retries the call.
+ */
+export function normalizeToolResult(result) {
+    if (result === undefined) {
+        return "";
+    }
+    if (typeof result === "string") {
+        return result;
+    }
+    try {
+        return JSON.parse(JSON.stringify(result));
+    }
+    catch (_a) {
+        return result;
+    }
+}
+/**
+ * Pull a channel-friendly error string out of a normalized tool result
+ * (error envelopes with `{ content: [{ type: "text", text }] }`, or a
+ * bare string). Used for {@link import("../types.js").ToolCallOutcome.errorMessage}.
+ */
+export function toolCallErrorMessage(result) {
+    if (typeof result === "string" && result.trim() !== "") {
+        return result;
+    }
+    if (result === null ||
+        typeof result !== "object" ||
+        !("content" in result) ||
+        !Array.isArray(result.content)) {
+        return undefined;
+    }
+    const texts = result.content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text.trim())
+        .filter((text) => text !== "");
+    return texts.length === 0 ? undefined : texts.join("\n");
+}

package/dist/internal/trajectory.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Compact, agent-friendly views of a session's NDJSON event stream.
+ *
+ * Coding agents (and eval harnesses) want a stable JSON shape: user
+ * messages, assistant text, tool calls with args/results, and
+ * success/failure — not a firehose of streaming deltas.
+ */
+import type { SessionEvent, TurnUsage } from "../types.js";
+export interface TrajectoryToolCall {
+    callId: string;
+    toolName: string;
+    args?: unknown;
+    output?: unknown;
+    isError: boolean;
+    /** Present when the tool required human approval before execute. */
+    approvalDecision?: "approve" | "deny";
+}
+export interface TrajectoryTurn {
+    turnId: string;
+    userMessage?: string;
+    assistantText: string;
+    reasoningText?: string;
+    toolCalls: TrajectoryToolCall[];
+    subagents: Array<{
+        callId: string;
+        name?: string;
+        description?: string;
+    }>;
+    usage?: TurnUsage;
+    result?: string;
+    failed: boolean;
+    error?: string;
+}
+export interface Trajectory {
+    sessionId: string;
+    sdkAgentId?: string;
+    agentUrl?: string;
+    channelId?: string;
+    ok: boolean;
+    finalText: string;
+    turnsFailed: number;
+    toolCallCount: number;
+    turns: TrajectoryTurn[];
+}
+/**
+ * Collapse a session event list into a trajectory. Streaming deltas are
+ * folded into final assistant / reasoning text per turn.
+ */
+export declare function buildTrajectory(events: SessionEvent[]): Trajectory;
+/** Parse an `events.ndjson` file (or any NDJSON blob of SessionEvents). */
+export declare function parseEventsNdjson(text: string): SessionEvent[];
+/** Load and summarize a durable session event log. */
+export declare function loadTrajectoryFromEventsFile(path: string): Promise<Trajectory>;
+/** Human-readable one-line-per-turn dump (for non-JSON CLI output). */
+export declare function formatTrajectoryText(trajectory: Trajectory): string;
+//# sourceMappingURL=trajectory.d.ts.map

package/dist/internal/trajectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trajectory.d.ts","sourceRoot":"","sources":["../../src/internal/trajectory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,oEAAoE;IACpE,gBAAgB,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,SAAS,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,UAAU,CAuKlE;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CAc9D;AAED,sDAAsD;AACtD,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED,uEAAuE;AACvE,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAwCnE"}