@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/hosted-eval-cases.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hosted eval cases. The control plane runs each `defineEval` case as its own
+ * architecture v2 session: admission reserves the session's send for the
+ * case, execution runs the case body there with every `t.send` a turn on
+ * that session, and the verdict lands on the session log as
+ * `eval.case.result`, which the control plane reads back.
+ */
+import type { AgentProjectEvalsInfo } from "../types.js";
+import type { HostedSendStart } from "./hosted-delivery.js";
+import type { SessionEngine } from "./session-engine.js";
+type CaseEngine = Pick<SessionEngine, "listEvents" | "interrupt" | "recordEvalCaseResult">;
+export declare function hostedEvalCatalog(projectRoot: string): Promise<AgentProjectEvalsInfo>;
+/** One turn per captured send, or the whole case for an eval-case send. */
+export declare function hostedSendStart(deps: {
+    engine: CaseEngine;
+    projectRoot: string;
+    logger: (line: string) => void;
+    caseDeadlineMs?: number;
+}): HostedSendStart;
+export {};
+//# sourceMappingURL=hosted-eval-cases.d.ts.map

package/dist/internal/hosted-eval-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-eval-cases.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-eval-cases.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EACV,qBAAqB,EAKtB,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,KAAK,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,WAAW,GAAG,sBAAsB,CAAC,CAAC;AAO3F,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAY3F;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,eAAe,CAelB"}

package/dist/internal/hosted-eval-cases.js

@@ -0,0 +1,162 @@
+/**
+ * Hosted eval cases. The control plane runs each `defineEval` case as its own
+ * architecture v2 session: admission reserves the session's send for the
+ * case, execution runs the case body there with every `t.send` a turn on
+ * that session, and the verdict lands on the session log as
+ * `eval.case.result`, which the control plane reads back.
+ */
+import { setTimeout as sleep } from "node:timers/promises";
+import { describeError } from "./describe-error.js";
+import { discoverEvals, runEvalCase } from "./eval-runner.js";
+import { evalCaseOf } from "./http-control-plane-session.js";
+import { RunSessionTimeoutError } from "./run-client.js";
+import { buildTrajectory } from "./trajectory.js";
+/** Under the 26-minute limit the host puts on one delivery. */
+const CASE_DEADLINE_MS = 20 * 60_000;
+/** Per tool-call input or output kept on the result; the session log keeps all of it. */
+const MAX_TOOL_IO_CHARS = 8 * 1024;
+export async function hostedEvalCatalog(projectRoot) {
+    const { evals, config } = await discoverEvals(projectRoot);
+    return {
+        protocol: 1,
+        cases: evals.map(e => ({
+            id: e.id,
+            fileId: e.fileId,
+            description: e.definition.description,
+            tags: e.definition.tags,
+        })),
+        config: { maxConcurrency: config.maxConcurrency, timeoutMs: config.timeoutMs },
+    };
+}
+/** One turn per captured send, or the whole case for an eval-case send. */
+export function hostedSendStart(deps) {
+    return async ({ args, message, options, sessionPublicId }) => {
+        const evalCase = evalCaseOf(options);
+        if (evalCase === undefined) {
+            return args.send(message, options);
+        }
+        const done = runHostedEvalCase({
+            ...deps,
+            args,
+            options,
+            sessionId: sessionPublicId,
+            evalCase,
+        });
+        return { id: sessionPublicId, waitForCompletion: () => done };
+    };
+}
+/**
+ * The delivery finishes once the verdict is recorded, whatever the verdict:
+ * a failed case must not look like a failed delivery, which would retry it.
+ */
+async function runHostedEvalCase(input) {
+    const startedAt = Date.now();
+    const deadlineMs = input.caseDeadlineMs ?? CASE_DEADLINE_MS;
+    const deadline = new AbortController();
+    const cancel = new AbortController();
+    const result = await Promise.race([
+        runCase({ ...input, signal: cancel.signal }).catch(error => failedResult(input.evalCase, describeError(error), startedAt)),
+        sleep(deadlineMs, undefined, { signal: deadline.signal }).then(async () => {
+            // The losing case body keeps running; it must not start turns after this verdict.
+            cancel.abort();
+            await input.engine.interrupt(input.sessionId);
+            return failedResult(input.evalCase, `eval case exceeded ${deadlineMs / 60_000} minutes`, startedAt);
+        }),
+    ]).finally(() => deadline.abort());
+    input.logger(`[bdk] eval case ${input.evalCase.caseId} (${input.evalCase.runId}): ${result.verdict ?? "failed"}`);
+    await input.engine.recordEvalCaseResult(input.sessionId, resultEventData(input.evalCase, result));
+    return { status: "finished" };
+}
+async function runCase(input) {
+    const startedAt = Date.now();
+    const { evals, config } = await discoverEvals(input.projectRoot);
+    const discovered = evals.find(e => e.id === input.evalCase.caseId);
+    if (discovered === undefined) {
+        return failedResult(input.evalCase, `No eval case ${JSON.stringify(input.evalCase.caseId)} in this release`, startedAt);
+    }
+    return runEvalCase(discovered, config, sessionTransport(input.engine, input.args, input.options), input.signal);
+}
+/** `t.send` as a turn on the admitted session, read back from its event log. */
+function sessionTransport(engine, args, base) {
+    return {
+        async send(turn) {
+            turn.signal?.throwIfAborted();
+            const session = await args.send(turn.message, {
+                ...base,
+                workspaceDir: turn.options.workspaceDir,
+                workspaceFiles: turn.options.workspaceFiles,
+                cloud: turn.options.cloud,
+            });
+            if (turn.signal?.aborted) {
+                await engine.interrupt(session.id);
+                turn.signal.throwIfAborted();
+            }
+            const timer = new AbortController();
+            const settled = await Promise.race([
+                session.waitForCompletion().then(() => true),
+                sleep(Math.min(turn.timeoutMs, CASE_DEADLINE_MS), false, { signal: timer.signal }),
+            ]).finally(() => timer.abort());
+            if (!settled) {
+                await engine.interrupt(session.id);
+                throw new RunSessionTimeoutError(`eval turn timed out after ${turn.timeoutMs}ms`, session.id, await engine.listEvents(session.id, turn.startIndex));
+            }
+            const events = await engine.listEvents(session.id, turn.startIndex);
+            for (const event of events) {
+                turn.onEvent?.(event);
+            }
+            const trajectory = buildTrajectory(events);
+            return {
+                sessionId: session.id,
+                events,
+                trajectory,
+                ok: trajectory.ok,
+                nextEventIndex: events.length === 0 ? undefined : events[events.length - 1].index + 1,
+            };
+        },
+    };
+}
+function failedResult(ref, error, startedAt) {
+    return {
+        id: ref.caseId,
+        path: "",
+        ok: false,
+        verdict: "failed",
+        assertions: [],
+        inputs: [],
+        error,
+        logs: [],
+        metrics: {},
+        durationMs: Date.now() - startedAt,
+    };
+}
+function boundedIo(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const json = JSON.stringify(value) ?? "";
+    return json.length <= MAX_TOOL_IO_CHARS ? value : `${json.slice(0, MAX_TOOL_IO_CHARS)}…`;
+}
+function resultEventData(ref, result) {
+    return {
+        runId: ref.runId,
+        caseId: ref.caseId,
+        ok: result.ok,
+        verdict: result.verdict ?? (result.ok ? "passed" : "failed"),
+        skipReason: result.skipReason,
+        assertions: result.assertions,
+        durationMs: result.durationMs,
+        error: result.error,
+        logs: result.logs,
+        metrics: result.metrics,
+        metadata: result.metadata,
+        inputs: result.inputs,
+        finalText: result.finalText,
+        tools: result.tools,
+        toolCalls: result.toolCalls?.map(call => ({
+            toolName: call.toolName,
+            args: boundedIo(call.args),
+            output: boundedIo(call.output),
+            isError: call.isError,
+        })),
+    };
+}

package/dist/internal/hosted-execution-diag.js

@@ -2,15 +2,6 @@
  * Local diagnostic record for one hosted execution. Flushed with durable
  * execution history and process output.
  */
-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, randomBytes } from "node:crypto";
 import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -69,9 +60,8 @@ export const HOSTED_ERROR_SNIPPET_MAX_CHARS = 700;
  * `Error.stack` with its message and first frames.
  */
 export function hostedErrorStackSnippet(error) {
-    var _a;
     if (error instanceof Error) {
-        const stack = (_a = error.stack) === null || _a === void 0 ? void 0 : _a.trim();
+        const stack = error.stack?.trim();
         if (stack !== undefined && stack.length > 0) {
             const lines = stack
                 .split("\n")
@@ -132,7 +122,7 @@ export function parseHostedExecutionDiag(raw) {
     try {
         parsed = JSON.parse(raw);
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
@@ -185,27 +175,45 @@ export function parseHostedExecutionDiag(raw) {
     if (body.signalAborted !== undefined && typeof body.signalAborted !== "boolean") {
         return undefined;
     }
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ v: HOSTED_EXECUTION_DIAG_VERSION, executionId: body.executionId, writtenAt: body.writtenAt, sessionPublicId: body.sessionPublicId, sessionId: body.sessionId, turnStatus: body.turnStatus, durationMs: body.durationMs }, (message === undefined ? {} : { message })), (stack === undefined ? {} : { stack })), (body.signalAborted === true ? { signalAborted: true } : {})), (requestId === undefined ? {} : { requestId })), (abortReason === undefined ? {} : { abortReason })), (failureCode === undefined ? {} : { failureCode })), (errorCode === undefined ? {} : { errorCode })), (classification === undefined ? {} : { classification }));
+    return {
+        v: HOSTED_EXECUTION_DIAG_VERSION,
+        executionId: body.executionId,
+        writtenAt: body.writtenAt,
+        sessionPublicId: body.sessionPublicId,
+        sessionId: body.sessionId,
+        turnStatus: body.turnStatus,
+        durationMs: body.durationMs,
+        ...(message === undefined ? {} : { message }),
+        ...(stack === undefined ? {} : { stack }),
+        ...(body.signalAborted === true ? { signalAborted: true } : {}),
+        ...(requestId === undefined ? {} : { requestId }),
+        ...(abortReason === undefined ? {} : { abortReason }),
+        ...(failureCode === undefined ? {} : { failureCode }),
+        ...(errorCode === undefined ? {} : { errorCode }),
+        ...(classification === undefined ? {} : { classification }),
+    };
 }
 /**
  * Overwrite the per-execution diag file. Soft-fail: a write error must not
  * change the hosted-execution HTTP reply.
  */
-export function writeHostedExecutionDiag(stateRoot, diag) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const path = hostedExecutionDiagPath(stateRoot);
-        const tmp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
-        try {
-            yield mkdir(stateRoot, { recursive: true });
-            const serialized = JSON.stringify(diag);
-            const body = serialized.length > HOSTED_EXECUTION_DIAG_MAX_BYTES
-                ? JSON.stringify(Object.assign(Object.assign({}, diag), { stack: undefined, message: boundedOptionalString(diag.message, 256) }))
-                : serialized;
-            yield writeFile(tmp, body, "utf8");
-            yield rename(tmp, path);
-        }
-        catch (_a) {
-            yield unlink(tmp).catch(() => undefined);
-        }
-    });
+export async function writeHostedExecutionDiag(stateRoot, diag) {
+    const path = hostedExecutionDiagPath(stateRoot);
+    const tmp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+        await mkdir(stateRoot, { recursive: true });
+        const serialized = JSON.stringify(diag);
+        const body = serialized.length > HOSTED_EXECUTION_DIAG_MAX_BYTES
+            ? JSON.stringify({
+                ...diag,
+                stack: undefined,
+                message: boundedOptionalString(diag.message, 256),
+            })
+            : serialized;
+        await writeFile(tmp, body, "utf8");
+        await rename(tmp, path);
+    }
+    catch {
+        await unlink(tmp).catch(() => undefined);
+    }
 }

package/dist/internal/hosted-execution-flush.js

@@ -8,15 +8,6 @@
  * Between running and terminal, {@link refreshStartLogWhile} refreshes only
  * process output.
  */
-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 { hostedErrorStackSnippet, writeHostedExecutionDiag, } from "./hosted-execution-diag.js";
 import { serializeSessionRunError, snapshotSessionRunLogs, } from "./session-run-log.js";
 const MAX_ERROR_MESSAGE_LENGTH = 1024;
@@ -29,79 +20,97 @@ function boundedMessage(text) {
  * Write local diagnostics and durable output together. Soft-fail per sink so
  * a storage outage does not change the hosted response.
  */
-export function flushHostedExecutionRecord(sinks, fields) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        var _b;
-        const writtenAt = new Date().toISOString();
-        const message = fields.message === undefined ? undefined : boundedMessage(fields.message);
-        const stack = fields.error === undefined ? undefined : hostedErrorStackSnippet(fields.error);
-        if (sinks.stateRoot !== undefined) {
-            yield writeHostedExecutionDiag(sinks.stateRoot, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ v: 1, executionId: fields.executionId, writtenAt, sessionPublicId: fields.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: fields.durationMs }, (message === undefined ? {} : { message })), (stack === undefined || stack.length === 0 ? {} : { stack })), { signalAborted: fields.abortReason === "signal_abort" ? true : undefined }), (fields.abortReason === undefined ? {} : { abortReason: fields.abortReason })), { failureCode: fields.failureCode }), (fields.errorCode === undefined ? {} : { errorCode: fields.errorCode })), { classification: fields.classification }));
+export async function flushHostedExecutionRecord(sinks, fields) {
+    const writtenAt = new Date().toISOString();
+    const message = fields.message === undefined ? undefined : boundedMessage(fields.message);
+    const stack = fields.error === undefined ? undefined : hostedErrorStackSnippet(fields.error);
+    if (sinks.stateRoot !== undefined) {
+        await writeHostedExecutionDiag(sinks.stateRoot, {
+            v: 1,
+            executionId: fields.executionId,
+            writtenAt,
+            sessionPublicId: fields.sessionPublicId,
+            sessionId: fields.sessionId,
+            turnStatus: fields.turnStatus,
+            durationMs: fields.durationMs,
+            ...(message === undefined ? {} : { message }),
+            ...(stack === undefined || stack.length === 0 ? {} : { stack }),
+            signalAborted: fields.abortReason === "signal_abort" ? true : undefined,
+            ...(fields.abortReason === undefined ? {} : { abortReason: fields.abortReason }),
+            failureCode: fields.failureCode,
+            ...(fields.errorCode === undefined ? {} : { errorCode: fields.errorCode }),
+            classification: fields.classification,
+        });
+    }
+    if (sinks.persistSessionRun !== undefined) {
+        const error = fields.error === undefined ? undefined : serializeSessionRunError(fields.error);
+        try {
+            await sinks.persistSessionRun({
+                executionId: fields.executionId,
+                writtenAt,
+                sessionPublicId: fields.sessionPublicId,
+                sessionId: fields.sessionId,
+                turnStatus: fields.turnStatus,
+                durationMs: fields.durationMs,
+                ...(fields.abortReason === undefined ? {} : { abortReason: fields.abortReason }),
+                ...(message === undefined ? {} : { message }),
+                ...(error === undefined ? {} : { error }),
+                logs: snapshotSessionRunLogs(sinks.snapshotLogs?.() ?? []),
+            });
+        }
+        catch {
+            // Soft-fail: a store outage must not change the HTTP reply.
         }
-        if (sinks.persistSessionRun !== undefined) {
-            const error = fields.error === undefined ? undefined : serializeSessionRunError(fields.error);
-            try {
-                yield sinks.persistSessionRun(Object.assign(Object.assign(Object.assign(Object.assign({ executionId: fields.executionId, writtenAt, sessionPublicId: fields.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: fields.durationMs }, (fields.abortReason === undefined ? {} : { abortReason: fields.abortReason })), (message === undefined ? {} : { message })), (error === undefined ? {} : { error })), { logs: snapshotSessionRunLogs((_b = (_a = sinks.snapshotLogs) === null || _a === void 0 ? void 0 : _a.call(sinks)) !== null && _b !== void 0 ? _b : []) }));
-            }
-            catch (_c) {
-                // Soft-fail: a store outage must not change the HTTP reply.
-            }
+    }
+    if (sinks.flushStartLog !== undefined) {
+        try {
+            await sinks.flushStartLog(fields.sessionPublicId);
         }
-        if (sinks.flushStartLog !== undefined) {
-            try {
-                yield sinks.flushStartLog(fields.sessionPublicId);
-            }
-            catch (_d) {
-                // Soft-fail: same posture as the session-run persist.
-            }
+        catch {
+            // Soft-fail: same posture as the session-run persist.
         }
-    });
+    }
 }
 /**
  * Each refresh is a store write on the deployment's shared write budget, so
  * keep it coarse. An unchanged tee costs nothing (the store skips the put).
  */
-export const HOSTED_START_LOG_REFRESH_INTERVAL_MS = 30000;
+export const HOSTED_START_LOG_REFRESH_INTERVAL_MS = 30_000;
 /**
  * Refresh the tee while `run` (the turn) settles: v2 has no engine to tail,
  * so this snapshot is the only view of a running turn. A tick is skipped
  * while a refresh is still in flight, and the last one settles before this
  * returns so it cannot land after the terminal flush.
  */
-export function refreshStartLogWhile(sinks, startLogId, run) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const flush = sinks.flushStartLog;
-        if (flush === undefined) {
-            return yield run();
-        }
-        let refresh;
-        const timer = setInterval(() => {
-            // Soft-fail like the other flushes. A rejection left unhandled here would
-            // trip the process-death flush.
-            refresh !== null && refresh !== void 0 ? refresh : (refresh = flush(startLogId)
-                .catch(() => undefined)
-                .finally(() => {
-                refresh = undefined;
-            }));
-        }, HOSTED_START_LOG_REFRESH_INTERVAL_MS);
-        try {
-            return yield run();
-        }
-        finally {
-            clearInterval(timer);
-            yield refresh;
-        }
-    });
+export async function refreshStartLogWhile(sinks, startLogId, run) {
+    const flush = sinks.flushStartLog;
+    if (flush === undefined) {
+        return await run();
+    }
+    let refresh;
+    const timer = setInterval(() => {
+        // Soft-fail like the other flushes. A rejection left unhandled here would
+        // trip the process-death flush.
+        refresh ??= flush(startLogId)
+            .catch(() => undefined)
+            .finally(() => {
+            refresh = undefined;
+        });
+    }, HOSTED_START_LOG_REFRESH_INTERVAL_MS);
+    try {
+        return await run();
+    }
+    finally {
+        clearInterval(timer);
+        await refresh;
+    }
 }
 /**
  * Durable-only crash flush. Leaves `hosted-execution.json` at `running`.
  */
-export function flushHostedExecutionProcessDeath(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield args.flushProcessDeath(args.reason, args.error);
-        if (args.startLogId !== undefined && args.flushStartLog !== undefined) {
-            yield args.flushStartLog(args.startLogId);
-        }
-    });
+export async function flushHostedExecutionProcessDeath(args) {
+    await args.flushProcessDeath(args.reason, args.error);
+    if (args.startLogId !== undefined && args.flushStartLog !== undefined) {
+        await args.flushStartLog(args.startLogId);
+    }
 }

package/dist/internal/hosted-execution-latency.js

@@ -51,7 +51,7 @@ export function resetHostedExecutionLatencyForTests() {
     nowOverride = undefined;
 }
 function resolveMeter() {
-    return meterOverride !== null && meterOverride !== void 0 ? meterOverride : metrics.getMeter(INSTRUMENTATION);
+    return meterOverride ?? metrics.getMeter(INSTRUMENTATION);
 }
 function durationInstrument() {
     if (durationHistogram === undefined) {
@@ -110,17 +110,19 @@ export function isDuringHostedExecutionLatency() {
  * progress updates and final fallback posts are ignored.
  */
 export function markHostedFirstVisibleReply(args) {
-    var _a;
     const store = latencyAls.getStore();
     if (store === undefined || store.firstVisibleAt !== undefined) {
         return false;
     }
     store.firstVisibleAt = hostedExecutionNow();
     store.firstVisibleOutcome = args.outcome;
-    store.deliverySurface = (_a = args.deliverySurface) !== null && _a !== void 0 ? _a : "slack";
+    store.deliverySurface = args.deliverySurface ?? "slack";
     if (!store.visibleCounterEmitted) {
         store.visibleCounterEmitted = true;
-        visibleInstrument().add(1, Object.assign(Object.assign({}, baseAttrs(store)), { outcome: args.outcome }));
+        visibleInstrument().add(1, {
+            ...baseAttrs(store),
+            outcome: args.outcome,
+        });
     }
     return true;
 }
@@ -134,7 +136,7 @@ export function noteHostedVisibleReplyError(args) {
         return;
     }
     store.errorEmitted = true;
-    if ((args === null || args === void 0 ? void 0 : args.deliverySurface) !== undefined) {
+    if (args?.deliverySurface !== undefined) {
         store.deliverySurface = args.deliverySurface;
     }
     else if (store.deliverySurface === "none") {
@@ -142,7 +144,10 @@ export function noteHostedVisibleReplyError(args) {
     }
     if (!store.visibleCounterEmitted) {
         store.visibleCounterEmitted = true;
-        visibleInstrument().add(1, Object.assign(Object.assign({}, baseAttrs(store)), { outcome: "error" }));
+        visibleInstrument().add(1, {
+            ...baseAttrs(store),
+            outcome: "error",
+        });
     }
 }
 function resolveOutcome(store) {
@@ -171,7 +176,10 @@ export function finalizeHostedExecutionLatency(marks) {
     const outcome = resolveOutcome(store);
     if (!store.visibleCounterEmitted) {
         store.visibleCounterEmitted = true;
-        visibleInstrument().add(1, Object.assign(Object.assign({}, baseAttrs(store)), { outcome: "none" }));
+        visibleInstrument().add(1, {
+            ...baseAttrs(store),
+            outcome: "none",
+        });
     }
     const phases = {
         durability_drain: Math.max(0, marks.drainAt - marks.completionAt),
@@ -189,7 +197,7 @@ export function finalizeHostedExecutionLatency(marks) {
     };
     const histogram = durationInstrument();
     for (const [phase, value] of Object.entries(phases)) {
-        histogram.record(value, Object.assign(Object.assign({}, attrs), { phase }));
+        histogram.record(value, { ...attrs, phase });
     }
     return {
         channelKind: store.channelKind,

package/dist/internal/hosted-managed-automation.js

@@ -33,8 +33,8 @@ function managedAutomationTable() {
     return table;
 }
 /** Long enough to outlive a slow review run kicked off by the delivery. */
-const MANAGED_AUTOMATION_TTL_MS = 60 * 60000;
-const MANAGED_AUTOMATION_MAX_ENTRIES = 10000;
+const MANAGED_AUTOMATION_TTL_MS = 60 * 60_000;
+const MANAGED_AUTOMATION_MAX_ENTRIES = 10_000;
 export function recordHostedManagedAutomation(delivery) {
     if (delivery.managedAutomation === undefined) {
         console.info(`[bdk] hosted managedAutomation not recorded deliveryId=${delivery.deliveryId}: admission envelope carried no managedAutomation slice (non-managed delivery, or the control plane resolved no MCP servers and no Slack channels)`);

package/dist/internal/hosting.js

@@ -78,15 +78,14 @@ export function isReservedSecretName(name) {
  * secret names, each prefixed with its field (`egressDomains: …`).
  */
 export function hostingEntryErrors(declared) {
-    var _a, _b;
     const errors = [];
-    for (const domain of (_a = declared.egressDomains) !== null && _a !== void 0 ? _a : []) {
+    for (const domain of declared.egressDomains ?? []) {
         const domainError = validateEgressDomain(domain);
         if (domainError !== undefined) {
             errors.push(`egressDomains: ${domainError}`);
         }
     }
-    for (const name of (_b = declared.secretNames) !== null && _b !== void 0 ? _b : []) {
+    for (const name of declared.secretNames ?? []) {
         const nameError = validateSecretName(name);
         if (nameError !== undefined) {
             errors.push(`secretNames: ${nameError}`);

package/dist/internal/http-channel-define.js

@@ -11,7 +11,10 @@ import { attachHttpControlPlaneAdmission } from "./http-control-plane-session.js
  */
 export function httpChannel(config = {}) {
     const definition = config.continuation !== undefined
-        ? brandDefinition("http-channel", Object.assign(Object.assign({}, config), { continuation: normalizeIdentity(config.continuation, "http") }))
+        ? brandDefinition("http-channel", {
+            ...config,
+            continuation: normalizeIdentity(config.continuation, "http"),
+        })
         : brandDefinition("http-channel", config);
     attachHttpControlPlaneAdmission(definition);
     return definition;