@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/handleAgentServeTrigger.js

@@ -7,15 +7,6 @@
  * Each agent's `onPullRequest`, `onComment`, and related hooks decide whether
  * to run.
  */
-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 { dispatchGitHubWebhook, getGitHubChannelOptions, } from "../channels/github/github-channel.js";
 import { dispatchOriginWebhook, getOriginChannelOptions, originIngressExtractPayload, parseOriginWebhookEnvelope, } from "../channels/origin/origin-channel.js";
 import { bindLocalIngressSend } from "./local-ingress.js";
@@ -64,133 +55,137 @@ export function collectOriginTriggerTargets(input) {
 /**
  * Dispatch an agent-serve trigger. GitHub and Origin webhook fan-out.
  */
-export function handleAgentServeTrigger(event) {
-    return __awaiter(this, void 0, void 0, function* () {
-        switch (event.type) {
-            case "github":
-                return handleAgentServeGitHubTrigger(event);
-            case "origin":
-                return handleAgentServeOriginTrigger(event);
-            default: {
-                const _ = event;
-                throw new Error(`handleAgentServeTrigger: unknown event type: ${String(_)}`);
-            }
+export async function handleAgentServeTrigger(event) {
+    switch (event.type) {
+        case "github":
+            return handleAgentServeGitHubTrigger(event);
+        case "origin":
+            return handleAgentServeOriginTrigger(event);
+        default: {
+            const _ = event;
+            throw new Error(`handleAgentServeTrigger: unknown event type: ${String(_)}`);
         }
-    });
+    }
 }
-function handleAgentServeGitHubTrigger(event) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (event.eventName === "ping") {
-            return {
-                ok: true,
-                event: "ping",
-                targets: [],
-            };
-        }
-        let payload;
-        try {
-            payload = JSON.parse(event.bodyText);
-        }
-        catch (_a) {
-            return {
-                ok: false,
-                event: event.eventName,
-                targets: [
-                    {
-                        slug: "",
-                        status: 400,
-                        body: { ok: false, error: "invalid_json" },
-                    },
-                ],
-            };
-        }
-        const targets = [];
-        for (const target of event.targets) {
-            const args = event.eventName === null
-                ? target.args
-                : bindLocalIngressSend(target.args, Object.assign({ identity: target.options.continuation, kind: "github", eventType: event.eventName, payload }, (event.routeContinuation === undefined
-                    ? {}
-                    : { routeContinuation: event.routeContinuation })));
-            const response = yield dispatchGitHubWebhook({
-                options: target.options,
-                eventName: event.eventName,
-                payload,
-                deliveryId: event.deliveryId,
-                args,
-            });
-            targets.push(yield triggerTargetResult(target.slug, response));
-        }
+async function handleAgentServeGitHubTrigger(event) {
+    if (event.eventName === "ping") {
         return {
             ok: true,
+            event: "ping",
+            targets: [],
+        };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(event.bodyText);
+    }
+    catch {
+        return {
+            ok: false,
             event: event.eventName,
-            targets,
+            targets: [
+                {
+                    slug: "",
+                    status: 400,
+                    body: { ok: false, error: "invalid_json" },
+                },
+            ],
         };
-    });
-}
-function handleAgentServeOriginTrigger(event) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let payload;
-        try {
-            payload = JSON.parse(event.bodyText);
-        }
-        catch (_a) {
-            return {
-                ok: false,
-                event: null,
-                targets: [
-                    {
-                        slug: "",
-                        status: 400,
-                        body: { ok: false, error: "invalid_json" },
-                    },
-                ],
-            };
-        }
-        const envelope = parseOriginWebhookEnvelope(payload);
-        if (envelope === null) {
-            return {
-                ok: false,
-                event: null,
-                targets: [
-                    {
-                        slug: "",
-                        status: 400,
-                        body: { ok: false, error: "invalid_origin_payload" },
-                    },
-                ],
-            };
-        }
-        const targets = [];
-        for (const target of event.targets) {
-            const response = yield dispatchOriginWebhook({
-                options: target.options,
-                envelope,
-                args: bindLocalIngressSend(target.args, Object.assign({ identity: target.options.continuation, kind: "origin", eventType: envelope.event.type, payload: originIngressExtractPayload(envelope) }, (event.routeContinuation === undefined
+    }
+    const targets = [];
+    for (const target of event.targets) {
+        const args = event.eventName === null
+            ? target.args
+            : bindLocalIngressSend(target.args, {
+                identity: target.options.continuation,
+                kind: "github",
+                eventType: event.eventName,
+                payload,
+                ...(event.routeContinuation === undefined
                     ? {}
-                    : { routeContinuation: event.routeContinuation }))),
+                    : { routeContinuation: event.routeContinuation }),
             });
-            targets.push(yield triggerTargetResult(target.slug, response));
-        }
+        const response = await dispatchGitHubWebhook({
+            options: target.options,
+            eventName: event.eventName,
+            payload,
+            deliveryId: event.deliveryId,
+            args,
+        });
+        targets.push(await triggerTargetResult(target.slug, response));
+    }
+    return {
+        ok: true,
+        event: event.eventName,
+        targets,
+    };
+}
+async function handleAgentServeOriginTrigger(event) {
+    let payload;
+    try {
+        payload = JSON.parse(event.bodyText);
+    }
+    catch {
         return {
-            ok: true,
-            event: envelope.event.type,
-            targets,
+            ok: false,
+            event: null,
+            targets: [
+                {
+                    slug: "",
+                    status: 400,
+                    body: { ok: false, error: "invalid_json" },
+                },
+            ],
         };
-    });
-}
-function triggerTargetResult(slug, response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let body;
-        try {
-            body = yield response.json();
-        }
-        catch (_a) {
-            body = { ok: false, error: "invalid_response_json" };
-        }
+    }
+    const envelope = parseOriginWebhookEnvelope(payload);
+    if (envelope === null) {
         return {
-            slug,
-            status: response.status,
-            body,
+            ok: false,
+            event: null,
+            targets: [
+                {
+                    slug: "",
+                    status: 400,
+                    body: { ok: false, error: "invalid_origin_payload" },
+                },
+            ],
         };
-    });
+    }
+    const targets = [];
+    for (const target of event.targets) {
+        const response = await dispatchOriginWebhook({
+            options: target.options,
+            envelope,
+            args: bindLocalIngressSend(target.args, {
+                identity: target.options.continuation,
+                kind: "origin",
+                eventType: envelope.event.type,
+                payload: originIngressExtractPayload(envelope),
+                ...(event.routeContinuation === undefined
+                    ? {}
+                    : { routeContinuation: event.routeContinuation }),
+            }),
+        });
+        targets.push(await triggerTargetResult(target.slug, response));
+    }
+    return {
+        ok: true,
+        event: envelope.event.type,
+        targets,
+    };
+}
+async function triggerTargetResult(slug, response) {
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = { ok: false, error: "invalid_response_json" };
+    }
+    return {
+        slug,
+        status: response.status,
+        body,
+    };
 }

package/dist/internal/host-files.js

@@ -11,24 +11,18 @@
  * authored sink — including one a customer wrote against their own Dropbox —
  * cannot be steered into another deployment's or another session's files.
  */
-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 { join, normalize, sep } from "node:path";
 import { FilePathRejectedError, FileSessionRequiredError, FileTooLargeError, fileKeys, } from "../files.js";
 import { cursorHostedFiles, isCursorHostedFilesAvailable, } from "../files-backends/cursor-hosted.js";
 import { localFiles } from "../files-backends/local-fs.js";
 /** Build the host file API for one agent process. */
 export function createHostFilesApi(options) {
-    var _a;
-    const sink = (_a = options.sink) !== null && _a !== void 0 ? _a : createDefaultSink(options);
-    return createBoundHostFilesApi(Object.assign({ agentName: options.agentName, sink }, (options.sessionId === undefined ? {} : { sessionId: options.sessionId })));
+    const sink = options.sink ?? createDefaultSink(options);
+    return createBoundHostFilesApi({
+        agentName: options.agentName,
+        sink,
+        ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }),
+    });
 }
 /**
  * Pick the default sink.
@@ -41,8 +35,7 @@ export function createHostFilesApi(options) {
  * their `agent/storage.ts`; resolving it here means authors do not repeat it.
  */
 function createDefaultSink(options) {
-    var _a;
-    if (isCursorHostedFilesAvailable((_a = options.env) !== null && _a !== void 0 ? _a : process.env)) {
+    if (isCursorHostedFilesAvailable(options.env ?? process.env)) {
         return cursorHostedFiles();
     }
     if (options.stateRoot === undefined) {
@@ -58,9 +51,12 @@ function localKeyPrefix(agentName) {
     return fileKeys.deploymentPrefix(agentName).replace(/deployment\/$/, "");
 }
 function createBoundHostFilesApi(state) {
-    var _a;
-    const sinkCaps = (_a = state.sink.capabilities) !== null && _a !== void 0 ? _a : {};
-    const capabilities = Object.assign({ conflictDetection: sinkCaps.etags === true, materialized: sinkCaps.materialized === true && typeof state.sink.materializedPath === "function" }, (sinkCaps.maxBytes === undefined ? {} : { maxBytes: sinkCaps.maxBytes }));
+    const sinkCaps = state.sink.capabilities ?? {};
+    const capabilities = {
+        conflictDetection: sinkCaps.etags === true,
+        materialized: sinkCaps.materialized === true && typeof state.sink.materializedPath === "function",
+        ...(sinkCaps.maxBytes === undefined ? {} : { maxBytes: sinkCaps.maxBytes }),
+    };
     const keyFor = (path, scope) => mintKey(state, path, scope);
     const api = {
         capabilities,
@@ -69,92 +65,82 @@ function createBoundHostFilesApi(state) {
             if (trimmed === "") {
                 throw new FileSessionRequiredError("host.files.forSession requires a non-empty session id");
             }
-            return createBoundHostFilesApi(Object.assign(Object.assign({}, state), { sessionId: trimmed }));
+            return createBoundHostFilesApi({ ...state, sessionId: trimmed });
         },
-        read(path, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const bytes = yield api.readBytes(path, options);
-                return bytes === undefined
-                    ? undefined
-                    : Buffer.from(bytes).toString((_a = options === null || options === void 0 ? void 0 : options.encoding) !== null && _a !== void 0 ? _a : "utf8");
-            });
+        async read(path, options) {
+            const bytes = await api.readBytes(path, options);
+            return bytes === undefined
+                ? undefined
+                : Buffer.from(bytes).toString(options?.encoding ?? "utf8");
         },
-        readBytes(path, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const found = yield state.sink.get(keyFor(path, options === null || options === void 0 ? void 0 : options.scope));
-                if (found === undefined) {
-                    return undefined;
-                }
-                return found instanceof Uint8Array ? found : found.body;
-            });
+        async readBytes(path, options) {
+            const found = await state.sink.get(keyFor(path, options?.scope));
+            if (found === undefined) {
+                return undefined;
+            }
+            return found instanceof Uint8Array ? found : found.body;
         },
-        write(path, data, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const key = keyFor(path, options === null || options === void 0 ? void 0 : options.scope);
-                const body = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
-                const maxBytes = capabilities.maxBytes;
-                if (maxBytes !== undefined && body.byteLength > maxBytes) {
-                    throw new FileTooLargeError(key, body.byteLength, maxBytes);
-                }
-                yield state.sink.put(key, body, (options === null || options === void 0 ? void 0 : options.ifMatch) === undefined ? undefined : { ifMatch: options.ifMatch });
-            });
+        async write(path, data, options) {
+            const key = keyFor(path, options?.scope);
+            const body = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+            const maxBytes = capabilities.maxBytes;
+            if (maxBytes !== undefined && body.byteLength > maxBytes) {
+                throw new FileTooLargeError(key, body.byteLength, maxBytes);
+            }
+            await state.sink.put(key, body, options?.ifMatch === undefined ? undefined : { ifMatch: options.ifMatch });
         },
-        remove(path, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield state.sink.delete(keyFor(path, options === null || options === void 0 ? void 0 : options.scope));
-            });
+        async remove(path, options) {
+            await state.sink.delete(keyFor(path, options?.scope));
         },
-        exists(path, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield api.stat(path, options)) !== undefined;
-            });
+        async exists(path, options) {
+            return (await api.stat(path, options)) !== undefined;
         },
-        stat(path, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const key = keyFor(path, options === null || options === void 0 ? void 0 : options.scope);
-                const entry = yield statKey(state.sink, key);
-                if (entry === undefined) {
-                    return undefined;
-                }
-                return Object.assign(Object.assign({ size: entry.size }, (entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs })), (entry.etag === undefined ? {} : { etag: entry.etag }));
-            });
+        async stat(path, options) {
+            const key = keyFor(path, options?.scope);
+            const entry = await statKey(state.sink, key);
+            if (entry === undefined) {
+                return undefined;
+            }
+            return {
+                size: entry.size,
+                ...(entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs }),
+                ...(entry.etag === undefined ? {} : { etag: entry.etag }),
+            };
         },
-        list(prefix, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const scopePrefix = mintPrefix(state, options === null || options === void 0 ? void 0 : options.scope);
-                const rel = prefix === undefined ? "" : normalizeRelPath(prefix, true);
-                const entries = yield state.sink.list(`${scopePrefix}${rel}`);
-                const out = [];
-                for (const entry of entries) {
-                    if (!entry.key.startsWith(scopePrefix)) {
-                        // A sink that widens the prefix must not leak keys from another
-                        // scope through a listing.
-                        continue;
-                    }
-                    out.push(Object.assign({ path: entry.key.slice(scopePrefix.length), size: entry.size }, (entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs })));
+        async list(prefix, options) {
+            const scopePrefix = mintPrefix(state, options?.scope);
+            const rel = prefix === undefined ? "" : normalizeRelPath(prefix, true);
+            const entries = await state.sink.list(`${scopePrefix}${rel}`);
+            const out = [];
+            for (const entry of entries) {
+                if (!entry.key.startsWith(scopePrefix)) {
+                    // A sink that widens the prefix must not leak keys from another
+                    // scope through a listing.
+                    continue;
                 }
-                return out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-            });
+                out.push({
+                    path: entry.key.slice(scopePrefix.length),
+                    size: entry.size,
+                    ...(entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs }),
+                });
+            }
+            return out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
         },
         materializedPath(path, options) {
-            var _a, _b;
             if (!capabilities.materialized) {
                 return undefined;
             }
-            return (_b = (_a = state.sink).materializedPath) === null || _b === void 0 ? void 0 : _b.call(_a, keyFor(path, options === null || options === void 0 ? void 0 : options.scope));
+            return state.sink.materializedPath?.(keyFor(path, options?.scope));
         },
     };
     return api;
 }
-function statKey(sink, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof sink.stat === "function") {
-            return yield sink.stat(key);
-        }
-        const entries = yield sink.list(key);
-        return entries.find(entry => entry.key === key);
-    });
+async function statKey(sink, key) {
+    if (typeof sink.stat === "function") {
+        return await sink.stat(key);
+    }
+    const entries = await sink.list(key);
+    return entries.find(entry => entry.key === key);
 }
 // ============================================================================
 // Key minting
@@ -178,7 +164,6 @@ function mintPrefix(state, scope) {
     return resolved.partition === undefined ? base : `${base}${resolved.partition}/`;
 }
 function resolveScope(state, scope) {
-    var _a;
     if (scope === "deployment") {
         return { kind: "deployment" };
     }
@@ -188,7 +173,7 @@ function resolveScope(state, scope) {
                 ? { kind: "deployment" }
                 : { kind: "deployment", partition: segment(scope.partition) };
         }
-        const explicit = (_a = scope.sessionId) !== null && _a !== void 0 ? _a : state.sessionId;
+        const explicit = scope.sessionId ?? state.sessionId;
         return { kind: "session", sessionId: requireSession(explicit) };
     }
     // Default and explicit `"session"` both bind to the caller's own session, so

package/dist/internal/host-kv.js

@@ -5,15 +5,6 @@
  * sink under {@link storageKeys.kv}. Otherwise they land as one JSON file
  * per key under `--state-root/kv` (local dogfood / no durable plug-in).
  */
-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 { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -21,7 +12,7 @@ import { storageKeys } from "../storage.js";
 /** Build the host KV API for one agent process. */
 export function createHostKvApi(options) {
     const storage = options.storage;
-    if ((storage === null || storage === void 0 ? void 0 : storage.supportsAuthorKv) === true) {
+    if (storage?.supportsAuthorKv === true) {
         return {
             get: key => storage.kvGet(normalizeAuthorKey(key)),
             put: (key, value) => storage.kvPut(normalizeAuthorKey(key), value),
@@ -37,35 +28,29 @@ function createFilesystemKvApi(options) {
     const dir = join(options.stateRoot, "kv");
     const filePath = (authorKey) => join(dir, `${encodeURIComponent(storageKeys.kv(options.agentName, authorKey))}.json`);
     return {
-        get(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const authorKey = normalizeAuthorKey(key);
-                try {
-                    return JSON.parse(yield readFile(filePath(authorKey), "utf8"));
-                }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        return undefined;
-                    }
-                    throw error;
+        async get(key) {
+            const authorKey = normalizeAuthorKey(key);
+            try {
+                return JSON.parse(await readFile(filePath(authorKey), "utf8"));
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return undefined;
                 }
-            });
+                throw error;
+            }
         },
-        put(key, value) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const authorKey = normalizeAuthorKey(key);
-                yield mkdir(dir, { recursive: true });
-                const target = filePath(authorKey);
-                const tmp = join(dir, `.tmp-${randomUUID()}`);
-                yield writeFile(tmp, JSON.stringify(value), "utf8");
-                yield rename(tmp, target);
-            });
+        async put(key, value) {
+            const authorKey = normalizeAuthorKey(key);
+            await mkdir(dir, { recursive: true });
+            const target = filePath(authorKey);
+            const tmp = join(dir, `.tmp-${randomUUID()}`);
+            await writeFile(tmp, JSON.stringify(value), "utf8");
+            await rename(tmp, target);
         },
-        delete(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const authorKey = normalizeAuthorKey(key);
-                yield rm(filePath(authorKey), { force: true });
-            });
+        async delete(key) {
+            const authorKey = normalizeAuthorKey(key);
+            await rm(filePath(authorKey), { force: true });
         },
     };
 }

package/dist/internal/host-otel.js

@@ -44,24 +44,21 @@ function createBoundHostOtelApi(state) {
             return state.shared.meter !== undefined;
         },
         setAttributes(attributes) {
-            var _a;
             const cleaned = validateAttributes(attributes);
             if (state.sessionId === undefined) {
                 Object.assign(state.localTags, cleaned);
                 return;
             }
             mergeSessionTags(state, state.sessionId, cleaned);
-            (_a = state.shared.collector) === null || _a === void 0 ? void 0 : _a.setSessionAttributes(state.sessionId, cleaned);
+            state.shared.collector?.setSessionAttributes(state.sessionId, cleaned);
         },
         increment(name, valueOrAttributes, maybeAttributes) {
-            var _a;
             const value = typeof valueOrAttributes === "number" ? valueOrAttributes : 1;
             const attributes = typeof valueOrAttributes === "number" ? maybeAttributes : valueOrAttributes;
-            (_a = counter(state.shared, name)) === null || _a === void 0 ? void 0 : _a.add(value, emitAttributes(state, attributes));
+            counter(state.shared, name)?.add(value, emitAttributes(state, attributes));
         },
         record(name, value, attributes) {
-            var _a;
-            (_a = histogram(state.shared, name)) === null || _a === void 0 ? void 0 : _a.record(value, emitAttributes(state, attributes));
+            histogram(state.shared, name)?.record(value, emitAttributes(state, attributes));
         },
         forSession(sessionId) {
             const trimmed = sessionId.trim();
@@ -78,28 +75,34 @@ function createBoundHostOtelApi(state) {
     return api;
 }
 function mergeSessionTags(state, sessionId, incoming) {
-    var _a;
-    const bag = (_a = state.shared.sessionTags.get(sessionId)) !== null && _a !== void 0 ? _a : {};
+    const bag = state.shared.sessionTags.get(sessionId) ?? {};
     Object.assign(bag, incoming);
     state.shared.sessionTags.set(sessionId, bag);
 }
 function emitAttributes(state, callSite) {
-    return attrs(Object.assign(Object.assign(Object.assign(Object.assign({}, sessionBag(state)), validateAttributes(callSite)), { "agent_sdk.agent": state.shared.agentName }), (state.sessionId === undefined
-        ? {}
-        : {
-            "cursor.conversation.id": state.sessionId,
-            "agent_sdk.session_id": state.sessionId,
-        })));
+    return attrs({
+        ...sessionBag(state),
+        ...validateAttributes(callSite),
+        "agent_sdk.agent": state.shared.agentName,
+        ...(state.sessionId === undefined
+            ? {}
+            : {
+                "cursor.conversation.id": state.sessionId,
+                "agent_sdk.session_id": state.sessionId,
+            }),
+    });
 }
 function sessionBag(state) {
-    var _a;
-    var _b;
     if (state.sessionId === undefined) {
         return state.localTags;
     }
-    const fromCollector = (_a = state.shared.collector) === null || _a === void 0 ? void 0 : _a.getSessionAttributes(state.sessionId);
-    const fromShared = (_b = state.shared.sessionTags.get(state.sessionId)) !== null && _b !== void 0 ? _b : {};
-    return Object.assign(Object.assign(Object.assign({}, fromShared), (fromCollector !== null && fromCollector !== void 0 ? fromCollector : {})), state.localTags);
+    const fromCollector = state.shared.collector?.getSessionAttributes(state.sessionId);
+    const fromShared = state.shared.sessionTags.get(state.sessionId) ?? {};
+    return {
+        ...fromShared,
+        ...(fromCollector ?? {}),
+        ...state.localTags,
+    };
 }
 function counter(shared, name) {
     validateMetricName(name);