@cursor/bdk 0.2.9 → 0.2.10

package/dist/storage-backends/file-kv.js

@@ -24,32 +24,22 @@
  *   real failure (anything else throws) — on the lazy-restore path a
  *   throw correctly fails the follow-up instead of forking the session.
  */
-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 { createHash, randomUUID } from "node:crypto";
 import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
 /** File-backed `defineStorage` methods, ready to spread into `defineStorage({...})`. */
 export function fileKv(options) {
     const resolveDir = (ctx) => {
-        var _a;
-        const dir = (_a = options === null || options === void 0 ? void 0 : options.dir) !== null && _a !== void 0 ? _a : ".agent-serve/kv";
+        const dir = options?.dir ?? ".agent-serve/kv";
         return isAbsolute(dir) ? dir : join(ctx.projectRoot, dir);
     };
     // The evals table is scoped per agent (KV keys already carry the agent
     // name via the framework key scheme).
     const evalRunsDir = (ctx) => join(resolveDir(ctx), "eval-runs", encodeURIComponent(ctx.agentName));
     const filePath = (ctx, key) => join(resolveDir(ctx), `${encodeURIComponent(key)}.json`);
-    const readRaw = (ctx, key) => __awaiter(this, void 0, void 0, function* () {
+    const readRaw = async (ctx, key) => {
         try {
-            return yield readFile(filePath(ctx, key), "utf8");
+            return await readFile(filePath(ctx, key), "utf8");
         }
         catch (error) {
             if (error.code === "ENOENT") {
@@ -57,18 +47,18 @@ export function fileKv(options) {
             }
             throw error; // real failure: let lazy restore fail the follow-up
         }
-    });
-    const readKey = (ctx, key) => __awaiter(this, void 0, void 0, function* () {
-        const text = yield readRaw(ctx, key);
+    };
+    const readKey = async (ctx, key) => {
+        const text = await readRaw(ctx, key);
         return text === undefined ? undefined : JSON.parse(text);
-    });
-    const readVersioned = (ctx, key) => __awaiter(this, void 0, void 0, function* () {
-        const text = yield readRaw(ctx, key);
+    };
+    const readVersioned = async (ctx, key) => {
+        const text = await readRaw(ctx, key);
         if (text === undefined) {
             return undefined;
         }
         return { value: JSON.parse(text), version: versionOf(text) };
-    });
+    };
     // In-process mutex: CAS check-then-write pairs queue on one promise
     // chain so they cannot interleave with each other. Plain `put` stays
     // outside the chain on purpose — it is unconditional LWW and always
@@ -80,49 +70,43 @@ export function fileKv(options) {
         return result;
     };
     return {
-        put(key, value, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield writeJsonAtomic({
-                    dir: resolveDir(ctx),
-                    fileName: `${encodeURIComponent(key)}.json`,
-                    value,
-                });
+        async put(key, value, ctx) {
+            await writeJsonAtomic({
+                dir: resolveDir(ctx),
+                fileName: `${encodeURIComponent(key)}.json`,
+                value,
             });
         },
         get(key, ctx) {
             return readKey(ctx, key);
         },
-        delete(key, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield rm(filePath(ctx, key), { force: true });
-            });
+        async delete(key, ctx) {
+            await rm(filePath(ctx, key), { force: true });
         },
-        list(prefix, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let names;
-                try {
-                    names = yield readdir(resolveDir(ctx));
-                }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        return []; // nothing stored yet
-                    }
-                    throw error;
+        async list(prefix, ctx) {
+            let names;
+            try {
+                names = await readdir(resolveDir(ctx));
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return []; // nothing stored yet
                 }
-                const keys = names
-                    .filter(name => name.endsWith(".json"))
-                    .map(name => decodeURIComponent(name.slice(0, -".json".length)))
-                    .filter(key => key.startsWith(prefix))
-                    .sort();
-                const entries = [];
-                for (const key of keys) {
-                    const value = yield readKey(ctx, key);
-                    if (value !== undefined) {
-                        entries.push({ key, value });
-                    }
+                throw error;
+            }
+            const keys = names
+                .filter(name => name.endsWith(".json"))
+                .map(name => decodeURIComponent(name.slice(0, -".json".length)))
+                .filter(key => key.startsWith(prefix))
+                .sort();
+            const entries = [];
+            for (const key of keys) {
+                const value = await readKey(ctx, key);
+                if (value !== undefined) {
+                    entries.push({ key, value });
                 }
-                return entries;
-            });
+            }
+            return entries;
         },
         // Conditional writes over the same raw value files — no on-disk format
         // change, so data written before the CAS group existed stays readable
@@ -137,94 +121,86 @@ export function fileKv(options) {
         // only safe for single-instance deployments.
         cas: {
             getWithVersion: (key, ctx) => readVersioned(ctx, key),
-            putIfAbsent: (key, value, ctx) => locked(() => __awaiter(this, void 0, void 0, function* () {
-                const current = yield readVersioned(ctx, key);
+            putIfAbsent: (key, value, ctx) => locked(async () => {
+                const current = await readVersioned(ctx, key);
                 if (current !== undefined) {
                     return { ok: false, current };
                 }
                 const text = JSON.stringify(value);
-                yield writeTextAtomic({
+                await writeTextAtomic({
                     dir: resolveDir(ctx),
                     fileName: `${encodeURIComponent(key)}.json`,
                     text,
                 });
                 return { ok: true, version: versionOf(text) };
-            })),
-            putIfVersion: (key, value, expectedVersion, ctx) => locked(() => __awaiter(this, void 0, void 0, function* () {
-                const current = yield readVersioned(ctx, key);
+            }),
+            putIfVersion: (key, value, expectedVersion, ctx) => locked(async () => {
+                const current = await readVersioned(ctx, key);
                 if (current === undefined || current.version !== expectedVersion) {
                     return { ok: false, current };
                 }
                 const text = JSON.stringify(value);
-                yield writeTextAtomic({
+                await writeTextAtomic({
                     dir: resolveDir(ctx),
                     fileName: `${encodeURIComponent(key)}.json`,
                     text,
                 });
                 return { ok: true, version: versionOf(text) };
-            })),
-            listKeys(prefix, ctx) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    let names;
-                    try {
-                        names = yield readdir(resolveDir(ctx));
-                    }
-                    catch (error) {
-                        if (error.code === "ENOENT") {
-                            return [];
-                        }
-                        throw error;
+            }),
+            async listKeys(prefix, ctx) {
+                let names;
+                try {
+                    names = await readdir(resolveDir(ctx));
+                }
+                catch (error) {
+                    if (error.code === "ENOENT") {
+                        return [];
                     }
-                    return names
-                        .filter(name => name.endsWith(".json"))
-                        .map(name => decodeURIComponent(name.slice(0, -".json".length)))
-                        .filter(key => key.startsWith(prefix))
-                        .sort();
-                });
+                    throw error;
+                }
+                return names
+                    .filter(name => name.endsWith(".json"))
+                    .map(name => decodeURIComponent(name.slice(0, -".json".length)))
+                    .filter(key => key.startsWith(prefix))
+                    .sort();
             },
         },
         // Playground eval batches: one JSON file per run under eval-runs/<agent>/.
         evals: {
-            put(run, ctx) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    yield writeJsonAtomic({
-                        dir: evalRunsDir(ctx),
-                        fileName: `${encodeURIComponent(run.runId)}.json`,
-                        value: run,
-                    });
+            async put(run, ctx) {
+                await writeJsonAtomic({
+                    dir: evalRunsDir(ctx),
+                    fileName: `${encodeURIComponent(run.runId)}.json`,
+                    value: run,
                 });
             },
-            delete(runId, ctx) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    yield rm(join(evalRunsDir(ctx), `${encodeURIComponent(runId)}.json`), {
-                        force: true,
-                    });
+            async delete(runId, ctx) {
+                await rm(join(evalRunsDir(ctx), `${encodeURIComponent(runId)}.json`), {
+                    force: true,
                 });
             },
-            list(ctx) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const dir = evalRunsDir(ctx);
-                    let names;
-                    try {
-                        names = yield readdir(dir);
-                    }
-                    catch (error) {
-                        if (error.code === "ENOENT") {
-                            return [];
-                        }
-                        throw error;
+            async list(ctx) {
+                const dir = evalRunsDir(ctx);
+                let names;
+                try {
+                    names = await readdir(dir);
+                }
+                catch (error) {
+                    if (error.code === "ENOENT") {
+                        return [];
                     }
-                    const runs = [];
-                    for (const name of names.filter(n => n.endsWith(".json")).sort()) {
-                        // One unreadable/corrupt file must not wipe the whole history:
-                        // hydrate treats a throwing list() as "nothing saved".
-                        try {
-                            runs.push(JSON.parse(yield readFile(join(dir, name), "utf8")));
-                        }
-                        catch (_a) { }
+                    throw error;
+                }
+                const runs = [];
+                for (const name of names.filter(n => n.endsWith(".json")).sort()) {
+                    // One unreadable/corrupt file must not wipe the whole history:
+                    // hydrate treats a throwing list() as "nothing saved".
+                    try {
+                        runs.push(JSON.parse(await readFile(join(dir, name), "utf8")));
                     }
-                    return runs;
-                });
+                    catch { }
+                }
+                return runs;
             },
         },
     };
@@ -234,21 +210,17 @@ function versionOf(text) {
     return `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
 }
 /** tmp + rename write so concurrent readers never see a torn file. */
-function writeJsonAtomic(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield writeTextAtomic({
-            dir: args.dir,
-            fileName: args.fileName,
-            text: JSON.stringify(args.value),
-        });
+async function writeJsonAtomic(args) {
+    await writeTextAtomic({
+        dir: args.dir,
+        fileName: args.fileName,
+        text: JSON.stringify(args.value),
     });
 }
 /** tmp + rename write of exact text (CAS hashes the same bytes it wrote). */
-function writeTextAtomic(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield mkdir(args.dir, { recursive: true });
-        const tmp = join(args.dir, `.tmp-${randomUUID()}`);
-        yield writeFile(tmp, args.text, "utf8");
-        yield rename(tmp, join(args.dir, args.fileName));
-    });
+async function writeTextAtomic(args) {
+    await mkdir(args.dir, { recursive: true });
+    const tmp = join(args.dir, `.tmp-${randomUUID()}`);
+    await writeFile(tmp, args.text, "utf8");
+    await rename(tmp, join(args.dir, args.fileName));
 }

package/dist/storage-protocol.js

@@ -70,17 +70,15 @@ export const MAX_KEY_SEGMENT_BYTES = 256;
  * session writes no log.
  */
 export function frameworkStartLogId(args) {
-    var _a, _b, _c;
-    var _d, _e, _f;
-    const sessionPublicId = (_d = (_a = args.sessionPublicId) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _d !== void 0 ? _d : "";
+    const sessionPublicId = args.sessionPublicId?.trim() ?? "";
     if (sessionPublicId.length > 0) {
         return sessionPublicId;
     }
-    const workflowId = (_e = (_b = args.workflowId) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _e !== void 0 ? _e : "";
+    const workflowId = args.workflowId?.trim() ?? "";
     if (workflowId.length === 0) {
         return undefined;
     }
-    const runId = (_f = (_c = args.runId) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _f !== void 0 ? _f : "";
+    const runId = args.runId?.trim() ?? "";
     return runId.length > 0 ? `wf:${workflowId}/${runId}` : `wf:${workflowId}`;
 }
 /**

package/dist/storage.js

@@ -48,15 +48,6 @@
  * event log under `--state-root` remains the live source of truth; this
  * interface is the durable mirror.
  */
-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 { brandDefinition } from "./internal/brand.js";
 import { storageKeys } from "./storage-protocol.js";
 export { AGENTSDK_STORAGE_KEY_ROOT, agentSdkStorageKeys, frameworkStartLogId, GOLDEN_DURABLE_SESSION_RECORD, isDurableSessionRecordKey, keySegment, MAX_KEY_SEGMENT_BYTES, parseDurableSessionRecord, STORAGE_KEY_ROOT, storageKeys, storageKeysForArchitecture, summarizeDurableSessionRecord, } from "./storage-protocol.js";
@@ -100,7 +91,10 @@ export function defineStorage(config) {
     // the dedicated table is a backend-native optimization, derived over
     // the core when absent. An authored group always wins.
     const derivedEvals = config.evals === undefined ? deriveEvalsTable(config) : undefined;
-    return brandDefinition("storage", Object.assign(Object.assign({}, config), (derivedEvals === undefined ? {} : { evals: derivedEvals })));
+    return brandDefinition("storage", {
+        ...config,
+        ...(derivedEvals === undefined ? {} : { evals: derivedEvals }),
+    });
 }
 /**
  * Eval-runs table over the KV core: one key per run under
@@ -115,34 +109,31 @@ function deriveEvalsTable(config) {
     }
     return {
         put: (run, ctx) => config.put(storageKeys.evalRun(ctx.agentName, run.runId), run, ctx),
-        delete: (runId, ctx) => { var _a; return (_a = config.delete) === null || _a === void 0 ? void 0 : _a.call(config, storageKeys.evalRun(ctx.agentName, runId), ctx); },
-        list: (ctx) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            var _b;
-            const entries = (_b = (yield (_a = config.list) === null || _a === void 0 ? void 0 : _a.call(config, storageKeys.evalRunsPrefix(ctx.agentName), ctx))) !== null && _b !== void 0 ? _b : [];
+        delete: (runId, ctx) => config.delete?.(storageKeys.evalRun(ctx.agentName, runId), ctx),
+        list: async (ctx) => {
+            const entries = (await config.list?.(storageKeys.evalRunsPrefix(ctx.agentName), ctx)) ?? [];
             return entries.map(entry => entry.value);
-        }),
+        },
     };
 }
 // ============================================================================
 // Policy resolution
 // ============================================================================
-export const STORAGE_DEFAULT_RESTORE_MAX_SESSIONS = 1000;
-export const STORAGE_DEFAULT_RESTORE_MAX_AGE_MS = 30 * 24 * 60 * 60000;
-export const STORAGE_DEFAULT_RESTORE_MAX_TOTAL_BYTES = 1073741824; // 1 GiB
+export const STORAGE_DEFAULT_RESTORE_MAX_SESSIONS = 1_000;
+export const STORAGE_DEFAULT_RESTORE_MAX_AGE_MS = 30 * 24 * 60 * 60_000;
+export const STORAGE_DEFAULT_RESTORE_MAX_TOTAL_BYTES = 1_073_741_824; // 1 GiB
 /** Apply {@link StoragePolicy} defaults (exposed for tooling/tests). */
 export function resolveStoragePolicy(policy) {
-    var _a, _b, _c;
     return {
-        events: (policy === null || policy === void 0 ? void 0 : policy.debounceMs) === undefined
+        events: policy?.debounceMs === undefined
             ? "turnEnd"
-            : { debounceMs: clampInt(policy.debounceMs, 2000, 0, 60000) },
-        restore: (policy === null || policy === void 0 ? void 0 : policy.restore) === "off"
+            : { debounceMs: clampInt(policy.debounceMs, 2_000, 0, 60_000) },
+        restore: policy?.restore === "off"
             ? "off"
             : {
-                maxSessions: clampInt((_a = policy === null || policy === void 0 ? void 0 : policy.restore) === null || _a === void 0 ? void 0 : _a.maxSessions, STORAGE_DEFAULT_RESTORE_MAX_SESSIONS, 0, 1000000),
-                maxAgeMs: clampInt((_b = policy === null || policy === void 0 ? void 0 : policy.restore) === null || _b === void 0 ? void 0 : _b.maxAgeMs, STORAGE_DEFAULT_RESTORE_MAX_AGE_MS, 0, 10 * 365 * 24 * 60 * 60000),
-                maxTotalBytes: clampInt((_c = policy === null || policy === void 0 ? void 0 : policy.restore) === null || _c === void 0 ? void 0 : _c.maxTotalBytes, STORAGE_DEFAULT_RESTORE_MAX_TOTAL_BYTES, 0, 1099511627776),
+                maxSessions: clampInt(policy?.restore?.maxSessions, STORAGE_DEFAULT_RESTORE_MAX_SESSIONS, 0, 1_000_000),
+                maxAgeMs: clampInt(policy?.restore?.maxAgeMs, STORAGE_DEFAULT_RESTORE_MAX_AGE_MS, 0, 10 * 365 * 24 * 60 * 60_000),
+                maxTotalBytes: clampInt(policy?.restore?.maxTotalBytes, STORAGE_DEFAULT_RESTORE_MAX_TOTAL_BYTES, 0, 1_099_511_627_776),
             },
     };
 }

package/dist/types.d.ts

@@ -1286,6 +1286,20 @@ export interface AuthRequestInfo {
  * with 401 when every policy in the chain returns null.
  */
 export type AuthPolicy = (request: Request, info: AuthRequestInfo) => AuthContext | null | Promise<AuthContext | null>;
+/**
+ * A secret named rather than read. Locally the value is
+ * `process.env[secretName]`; on Cursor hosting it is the deployment secret
+ * of that name (`secrets set <slug> <NAME>`).
+ *
+ * Prefer this over a `() => process.env.X` getter for webhook secrets: the
+ * name is what `deploy` writes into the manifest, so the control plane can
+ * verify a provider signature at ingestion — before any compute starts —
+ * and answer the sender with a 401 instead of a 202.
+ */
+export interface SecretRef {
+    secretName: string;
+}
+export declare function isSecretRef(value: unknown): value is SecretRef;
 export interface SessionEventEnvelope {
     /** Monotonic per-session event index; reconnect with `?startIndex=`. */
     index: number;
@@ -1579,7 +1593,42 @@ export type SessionEventPayload = {
     data: {
         message: string;
     };
+} | {
+    /** A hosted eval case finished on this session, after its last turn. */
+    type: "eval.case.result";
+    data: EvalCaseResultEventData;
 };
+/** Verdict of one hosted eval case, as recorded on its session. */
+export interface EvalCaseResultEventData {
+    runId: string;
+    caseId: string;
+    ok: boolean;
+    verdict: "passed" | "failed" | "scored" | "skipped";
+    skipReason?: string;
+    assertions: Array<{
+        name: string;
+        passed: boolean;
+        detail?: string;
+        severity?: "gate" | "soft";
+        score?: number;
+        threshold?: number;
+        scope?: string;
+    }>;
+    durationMs: number;
+    error?: string;
+    logs: string[];
+    metrics: Record<string, string | number>;
+    metadata?: Record<string, unknown>;
+    inputs: string[];
+    finalText?: string;
+    tools?: string[];
+    toolCalls?: Array<{
+        toolName: string;
+        args?: unknown;
+        output?: unknown;
+        isError: boolean;
+    }>;
+}
 export type SessionEvent = SessionEventEnvelope & SessionEventPayload;
 export type SessionEventType = SessionEventPayload["type"];
 export interface TurnUsage {
@@ -3137,8 +3186,27 @@ export interface AgentProjectInfo {
         agentTool: boolean;
         max: number;
     };
+    /**
+     * Eval cases a hosted architecture v2 release runs as its own sessions.
+     * Set only in that release's deploy manifest.
+     */
+    evals?: AgentProjectEvalsInfo;
     diagnostics: Diagnostic[];
 }
+export interface AgentProjectEvalsInfo {
+    /** Hosted eval-case protocol this release speaks. */
+    protocol: 1;
+    cases: Array<{
+        id: string;
+        fileId: string;
+        description?: string;
+        tags?: string[];
+    }>;
+    config: {
+        maxConcurrency?: number;
+        timeoutMs?: number;
+    };
+}
 /**
  * A streaming update from the harness, re-exported from the Cursor SDK's
  * delta vocabulary.