@cursor/bdk 0.2.8 → 0.2.10

package/dist/extensions/cursor-grokbot-agents/lib/conversation.js

@@ -10,15 +10,6 @@
  * a send waits for an in-flight turn to settle first, so a reply always
  * attributes to the message that prompted it.
  */
-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 extension from "../extension.js";
 import { resolveAgentName } from "./agents.js";
 import { grokBotAgentsBackend, } from "./backend.js";
@@ -38,116 +29,107 @@ const MIN_IDLE_POLLS_WITHOUT_BUSY = 4;
  * was created by the call that fetched it; the allowance covers clock skew
  * between this host and the backend.
  */
-const CREATED_WINDOW_MS = 60000;
+const CREATED_WINDOW_MS = 60_000;
 /** The transcript tail of an agent nobody has spoken to. */
 const EMPTY_TRANSCRIPT_TAIL = "-1";
 const agentLocks = new KeyedLock();
-export function ask(ctx, input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const name = resolveAgentName(input.agent, extension.config.agents);
-        const backend = grokBotAgentsBackend();
-        const startedAt = Date.now();
-        const session = yield backend.session(name);
-        return agentLocks.run(session.sessionId, () => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const contact = (yield listContacts(ctx)).find(candidate => candidate.sessionId === session.sessionId);
-            const created = contact === undefined &&
-                session.latestUpdatedSeq === EMPTY_TRANSCRIPT_TAIL &&
-                session.createdAtMs >= startedAt - CREATED_WINDOW_MS;
-            const deadline = Date.now() + input.waitSeconds * 1000;
-            // A turn already in flight, from an earlier message or from the person
-            // in the app, must settle first; otherwise its deliveries would read as
-            // the reply to this message. Nothing is persisted on the way out, so
-            // `check` still returns whatever landed meanwhile.
-            const before = yield collectReplies(backend, session.sessionId, {
-                cursor: (_a = contact === null || contact === void 0 ? void 0 : contact.cursor) !== null && _a !== void 0 ? _a : session.latestUpdatedSeq,
-                deadline,
-                confirmIdle: false,
-            });
-            if (before.status === "running") {
-                throw new Error(`"${session.name}" is still working on an earlier message; nothing was sent. Call check to read that reply, wait, or interrupt it.`);
-            }
-            yield backend.send(session.sessionId, input.message);
-            const replies = yield collectReplies(backend, session.sessionId, {
-                cursor: before.cursor,
-                deadline,
-                confirmIdle: true,
-            });
-            const now = ctx.now().toISOString();
-            yield saveContact(ctx, {
-                name: session.name,
-                sessionId: session.sessionId,
-                cursor: replies.cursor,
-                firstContactAt: (_b = contact === null || contact === void 0 ? void 0 : contact.firstContactAt) !== null && _b !== void 0 ? _b : now,
-                lastContactAt: now,
-            });
-            const notes = [
-                created
-                    ? `No Grok Bot agent named "${session.name}" existed on this account, so an empty one was created. Check the name if that is unexpected.`
-                    : undefined,
-                runningNote(session.name, replies.status),
-            ].filter(note => note !== undefined);
-            return {
-                agent: session.name,
-                sessionId: session.sessionId,
-                status: replies.status,
-                reply: joinReplies(replies.deliveries),
-                earlierReplies: before.deliveries.length === 0 ? undefined : before.deliveries,
-                created: created ? true : undefined,
-                note: notes.length === 0 ? undefined : notes.join(" "),
-            };
-        }));
-    });
-}
-export function check(ctx, input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const contact = yield knownContact(ctx, input.agent);
-        const backend = grokBotAgentsBackend();
-        return agentLocks.run(contact.sessionId, () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Re-read under the lock: a parallel call may have moved the cursor.
-            const current = (_a = (yield listContacts(ctx)).find(candidate => candidate.sessionId === contact.sessionId)) !== null && _a !== void 0 ? _a : contact;
-            const replies = yield collectReplies(backend, current.sessionId, {
-                cursor: current.cursor,
-                deadline: Date.now() + input.waitSeconds * 1000,
-                confirmIdle: true,
-            });
-            yield saveContact(ctx, Object.assign(Object.assign({}, current), { cursor: replies.cursor }));
-            return {
-                agent: current.name,
-                sessionId: current.sessionId,
-                status: replies.status,
-                reply: joinReplies(replies.deliveries),
-                note: runningNote(current.name, replies.status),
-            };
-        }));
+export async function ask(ctx, input) {
+    const name = resolveAgentName(input.agent, extension.config.agents);
+    const backend = grokBotAgentsBackend();
+    const startedAt = Date.now();
+    const session = await backend.session(name);
+    return agentLocks.run(session.sessionId, async () => {
+        const contact = (await listContacts(ctx)).find(candidate => candidate.sessionId === session.sessionId);
+        const created = contact === undefined &&
+            session.latestUpdatedSeq === EMPTY_TRANSCRIPT_TAIL &&
+            session.createdAtMs >= startedAt - CREATED_WINDOW_MS;
+        const deadline = Date.now() + input.waitSeconds * 1000;
+        // A turn already in flight, from an earlier message or from the person
+        // in the app, must settle first; otherwise its deliveries would read as
+        // the reply to this message. Nothing is persisted on the way out, so
+        // `check` still returns whatever landed meanwhile.
+        const before = await collectReplies(backend, session.sessionId, {
+            cursor: contact?.cursor ?? session.latestUpdatedSeq,
+            deadline,
+            confirmIdle: false,
+        });
+        if (before.status === "running") {
+            throw new Error(`"${session.name}" is still working on an earlier message; nothing was sent. Call check to read that reply, wait, or interrupt it.`);
+        }
+        await backend.send(session.sessionId, input.message);
+        const replies = await collectReplies(backend, session.sessionId, {
+            cursor: before.cursor,
+            deadline,
+            confirmIdle: true,
+        });
+        const now = ctx.now().toISOString();
+        await saveContact(ctx, {
+            name: session.name,
+            sessionId: session.sessionId,
+            cursor: replies.cursor,
+            firstContactAt: contact?.firstContactAt ?? now,
+            lastContactAt: now,
+        });
+        const notes = [
+            created
+                ? `No Grok Bot agent named "${session.name}" existed on this account, so an empty one was created. Check the name if that is unexpected.`
+                : undefined,
+            runningNote(session.name, replies.status),
+        ].filter(note => note !== undefined);
+        return {
+            agent: session.name,
+            sessionId: session.sessionId,
+            status: replies.status,
+            reply: joinReplies(replies.deliveries),
+            earlierReplies: before.deliveries.length === 0 ? undefined : before.deliveries,
+            created: created ? true : undefined,
+            note: notes.length === 0 ? undefined : notes.join(" "),
+        };
     });
 }
-export function interrupt(ctx, input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const contact = yield knownContact(ctx, input.agent);
-        yield grokBotAgentsBackend().interrupt(contact.sessionId, "Interrupted from the Agent SDK.");
+export async function check(ctx, input) {
+    const contact = await knownContact(ctx, input.agent);
+    const backend = grokBotAgentsBackend();
+    return agentLocks.run(contact.sessionId, async () => {
+        // Re-read under the lock: a parallel call may have moved the cursor.
+        const current = (await listContacts(ctx)).find(candidate => candidate.sessionId === contact.sessionId) ??
+            contact;
+        const replies = await collectReplies(backend, current.sessionId, {
+            cursor: current.cursor,
+            deadline: Date.now() + input.waitSeconds * 1000,
+            confirmIdle: true,
+        });
+        await saveContact(ctx, { ...current, cursor: replies.cursor });
         return {
-            agent: contact.name,
-            sessionId: contact.sessionId,
-            interrupted: true,
+            agent: current.name,
+            sessionId: current.sessionId,
+            status: replies.status,
+            reply: joinReplies(replies.deliveries),
+            note: runningNote(current.name, replies.status),
         };
     });
 }
+export async function interrupt(ctx, input) {
+    const contact = await knownContact(ctx, input.agent);
+    await grokBotAgentsBackend().interrupt(contact.sessionId, "Interrupted from the Agent SDK.");
+    return {
+        agent: contact.name,
+        sessionId: contact.sessionId,
+        interrupted: true,
+    };
+}
 /**
  * The caller's record of the named agent. Only `ask` resolves a name on the
  * backend, because that creates an agent when none matches; the other tools
  * reach agents the caller has already spoken to.
  */
-function knownContact(ctx, requested) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const name = resolveAgentName(requested, extension.config.agents);
-        const contact = findContact(yield listContacts(ctx), name);
-        if (contact === undefined) {
-            throw new Error(`You have not asked "${name}" anything yet; call ask first.`);
-        }
-        return contact;
-    });
+async function knownContact(ctx, requested) {
+    const name = resolveAgentName(requested, extension.config.agents);
+    const contact = findContact(await listContacts(ctx), name);
+    if (contact === undefined) {
+        throw new Error(`You have not asked "${name}" anything yet; call ask first.`);
+    }
+    return contact;
 }
 /**
  * Read the transcript after `cursor` until the agent's turn settles or the
@@ -157,36 +139,34 @@ function knownContact(ctx, requested) {
  * {@link MIN_IDLE_POLLS_WITHOUT_BUSY} idle polls unless the turn was seen
  * busy; without it, the first idle report settles.
  */
-function collectReplies(backend, sessionId, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const deliveries = [];
-        let cursor = options.cursor;
-        let sawBusy = false;
-        let idlePolls = 0;
-        while (true) {
-            const page = yield backend.entries(sessionId, cursor);
-            cursor = page.latestUpdatedSeq;
-            for (const entry of page.entries) {
-                if (entry.kind === "send-message" && entry.text !== undefined) {
-                    deliveries.push(entry.text);
-                }
-            }
-            const busy = isBusy(page.turn);
-            if (busy) {
-                sawBusy = true;
-            }
-            if (page.entries.length === 0 && !busy && page.turn.idle) {
-                idlePolls += 1;
-                if (sawBusy || !options.confirmIdle || idlePolls >= MIN_IDLE_POLLS_WITHOUT_BUSY) {
-                    return { status: "finished", deliveries, cursor };
-                }
+async function collectReplies(backend, sessionId, options) {
+    const deliveries = [];
+    let cursor = options.cursor;
+    let sawBusy = false;
+    let idlePolls = 0;
+    while (true) {
+        const page = await backend.entries(sessionId, cursor);
+        cursor = page.latestUpdatedSeq;
+        for (const entry of page.entries) {
+            if (entry.kind === "send-message" && entry.text !== undefined) {
+                deliveries.push(entry.text);
             }
-            if (Date.now() >= options.deadline) {
-                return { status: "running", deliveries, cursor };
+        }
+        const busy = isBusy(page.turn);
+        if (busy) {
+            sawBusy = true;
+        }
+        if (page.entries.length === 0 && !busy && page.turn.idle) {
+            idlePolls += 1;
+            if (sawBusy || !options.confirmIdle || idlePolls >= MIN_IDLE_POLLS_WITHOUT_BUSY) {
+                return { status: "finished", deliveries, cursor };
             }
-            yield sleep(extension.config.pollIntervalMs);
         }
-    });
+        if (Date.now() >= options.deadline) {
+            return { status: "running", deliveries, cursor };
+        }
+        await sleep(extension.config.pollIntervalMs);
+    }
 }
 function isBusy(turn) {
     return turn.inFlight || turn.queued > 0;

package/dist/extensions/cursor-grokbot-agents/lib/lock.js

@@ -10,8 +10,7 @@ export class KeyedLock {
         this.chains = new Map();
     }
     run(key, task) {
-        var _a;
-        const previous = (_a = this.chains.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        const previous = this.chains.get(key) ?? Promise.resolve();
         const run = previous.then(task, task);
         const settled = run.then(() => undefined, () => undefined);
         this.chains.set(key, settled);

package/dist/extensions/cursor-grokbot-agents/tools/ask.js

@@ -1,12 +1,3 @@
-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 { z } from "zod";
 import { defineTool } from "../../../tools.js";
 import extension from "../extension.js";
@@ -24,13 +15,11 @@ const ask = defineTool({
             .describe("What to tell or ask the agent. Self-contained: who is asking, the facts it needs, and what you want back."),
         wait_seconds: waitSeconds,
     }),
-    execute(input, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return askAgent(ctx, {
-                agent: input.agent,
-                message: input.message,
-                waitSeconds: input.wait_seconds,
-            });
+    async execute(input, ctx) {
+        return askAgent(ctx, {
+            agent: input.agent,
+            message: input.message,
+            waitSeconds: input.wait_seconds,
         });
     },
 });

package/dist/extensions/cursor-grokbot-agents/tools/check.js

@@ -1,12 +1,3 @@
-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 { z } from "zod";
 import { defineTool } from "../../../tools.js";
 import { check as checkAgent } from "../lib/conversation.js";
@@ -20,12 +11,10 @@ const check = defineTool({
         agent: agentName,
         wait_seconds: waitSeconds,
     }),
-    execute(input, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return checkAgent(ctx, {
-                agent: input.agent,
-                waitSeconds: input.wait_seconds,
-            });
+    async execute(input, ctx) {
+        return checkAgent(ctx, {
+            agent: input.agent,
+            waitSeconds: input.wait_seconds,
         });
     },
 });

package/dist/extensions/cursor-grokbot-agents/tools/interrupt.js

@@ -1,12 +1,3 @@
-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 { z } from "zod";
 import { defineTool } from "../../../tools.js";
 import { interrupt as interruptAgent } from "../lib/conversation.js";
@@ -15,10 +6,8 @@ const interrupt = defineTool({
     description: "Stop what a Grok Bot agent you asked is doing right now. It keeps its conversation; ask it again to continue.",
     effect: "write",
     inputSchema: z.object({ agent: agentName }),
-    execute(input, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return interruptAgent(ctx, { agent: input.agent });
-        });
+    async execute(input, ctx) {
+        return interruptAgent(ctx, { agent: input.agent });
     },
 });
 export default interrupt;

package/dist/extensions/cursor-grokbot-agents/tools/list.js

@@ -1,12 +1,3 @@
-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 { z } from "zod";
 import { defineTool } from "../../../tools.js";
 import extension from "../extension.js";
@@ -15,20 +6,17 @@ const list = defineTool({
     description: "List the Grok Bot agents you can talk to: the ones configured for this agent, with what each is for, and the ones you have already asked, most recent first.",
     effect: "read",
     inputSchema: z.object({}),
-    execute(_input, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const contacts = yield listContacts(ctx);
-            return {
-                configured: (_a = extension.config.agents) !== null && _a !== void 0 ? _a : [],
-                contacted: contacts.map(contact => ({
-                    name: contact.name,
-                    sessionId: contact.sessionId,
-                    firstContactAt: contact.firstContactAt,
-                    lastContactAt: contact.lastContactAt,
-                })),
-            };
-        });
+    async execute(_input, ctx) {
+        const contacts = await listContacts(ctx);
+        return {
+            configured: extension.config.agents ?? [],
+            contacted: contacts.map(contact => ({
+                name: contact.name,
+                sessionId: contact.sessionId,
+                firstContactAt: contact.firstContactAt,
+                lastContactAt: contact.lastContactAt,
+            })),
+        };
     },
 });
 export default list;

package/dist/extensions/jev/extension.js

@@ -31,12 +31,12 @@ const config = z
     skills: z.boolean().default(true),
 })
     .default({})
-    .transform(options => { var _a; return ({
+    .transform(options => ({
     apiKey: options.apiKey,
-    model: (_a = options.model) !== null && _a !== void 0 ? _a : DEFAULT_EVALUATION_MODEL,
+    model: options.model ?? DEFAULT_EVALUATION_MODEL,
     harnessTools: options.harnessTools,
     skills: options.skills,
-}); });
+}));
 const jev = defineExtension({
     root: import.meta.dirname,
     description: "Ask Jev for typed choice, score, and boolean answers.",

package/dist/extensions/jev/lib/evaluate.js

@@ -36,15 +36,6 @@
  * Auth is `TYPESAFE_API_KEY`. `model` is a TypeSafe id (`jev-latest` by
  * default).
  */
-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());
-    });
-};
 /** TypeSafe model used when {@link EvaluateArgs.model} is omitted. */
 export const DEFAULT_EVALUATION_MODEL = "jev-latest";
 /** Default bar for {@link needsHuman} when the caller does not pass one. */
@@ -55,8 +46,7 @@ export const DEFAULT_TYPESAFE_HOST = new URL(DEFAULT_BASE_URL).hostname;
 /** Environment variable holding the TypeSafe key when a call passes no `apiKey`. */
 export const TYPESAFE_API_KEY_ENV = "TYPESAFE_API_KEY";
 function resolveApiKey(explicit) {
-    var _a;
-    const key = (_a = (explicit !== null && explicit !== void 0 ? explicit : process.env[TYPESAFE_API_KEY_ENV])) === null || _a === void 0 ? void 0 : _a.trim();
+    const key = (explicit ?? process.env[TYPESAFE_API_KEY_ENV])?.trim();
     if (key === undefined || key === "") {
         throw new Error(`evaluate requires ${TYPESAFE_API_KEY_ENV}`);
     }
@@ -101,61 +91,54 @@ function decodeAnswer(question, raw) {
         probabilities: asRecord(value.probabilities, "score probabilities are missing"),
     };
 }
-function postSystemOne(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield args.fetch(args.url, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${args.apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(args.body),
-        });
-        const text = yield response.text();
-        let parsed;
-        try {
-            parsed = text.length === 0 ? {} : JSON.parse(text);
-        }
-        catch (_a) {
-            throw new Error(`evaluate returned non-JSON (${response.status})`);
-        }
-        if (!response.ok) {
-            throw new Error(`evaluate failed (${response.status}): ${text.slice(0, 240)}`);
-        }
-        return asRecord(asRecord(parsed, "response is not an object").answers, "response is missing answers");
+async function postSystemOne(args) {
+    const response = await args.fetch(args.url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${args.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(args.body),
     });
+    const text = await response.text();
+    let parsed;
+    try {
+        parsed = text.length === 0 ? {} : JSON.parse(text);
+    }
+    catch {
+        throw new Error(`evaluate returned non-JSON (${response.status})`);
+    }
+    if (!response.ok) {
+        throw new Error(`evaluate failed (${response.status}): ${text.slice(0, 240)}`);
+    }
+    return asRecord(asRecord(parsed, "response is not an object").answers, "response is missing answers");
 }
 /** Ask Jev for typed answers over one state. */
-export function evaluate(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const questions = {};
-        for (const [id, question] of Object.entries(args.questions)) {
-            questions[id] = toWireQuestion(question);
-        }
-        const raw = yield postSystemOne({
-            url: `${((_a = args.baseUrl) !== null && _a !== void 0 ? _a : DEFAULT_BASE_URL).replace(/\/$/u, "")}/systemone`,
-            apiKey: resolveApiKey(args.apiKey),
-            fetch: (_b = args.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch,
-            body: {
-                model: (_c = args.model) !== null && _c !== void 0 ? _c : DEFAULT_EVALUATION_MODEL,
-                state: args.state,
-                questions,
-            },
-        });
-        const answers = {};
-        for (const id of Object.keys(args.questions)) {
-            answers[id] = decodeAnswer(args.questions[id], raw[id]);
-        }
-        return { answers };
+export async function evaluate(args) {
+    const questions = {};
+    for (const [id, question] of Object.entries(args.questions)) {
+        questions[id] = toWireQuestion(question);
+    }
+    const raw = await postSystemOne({
+        url: `${(args.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/u, "")}/systemone`,
+        apiKey: resolveApiKey(args.apiKey),
+        fetch: args.fetch ?? globalThis.fetch,
+        body: {
+            model: args.model ?? DEFAULT_EVALUATION_MODEL,
+            state: args.state,
+            questions,
+        },
     });
+    const answers = {};
+    for (const id of Object.keys(args.questions)) {
+        answers[id] = decodeAnswer(args.questions[id], raw[id]);
+    }
+    return { answers };
 }
 /** Same as {@link evaluate}, returning only `answers`. */
-export function decide(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = yield evaluate(args);
-        return result.answers;
-    });
+export async function decide(args) {
+    const result = await evaluate(args);
+    return result.answers;
 }
 export function above(answer, threshold) {
     if (answer.type === "boolean") {

package/dist/extensions/jev/tools/evaluate.js

@@ -1,12 +1,3 @@
-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 { z } from "zod";
 import { defineTool } from "../../../tools.js";
 import extension from "../extension.js";
@@ -69,14 +60,12 @@ const evaluateTool = defineTool({
             .describe("One or more typed questions over the same state."),
     })
         .refine(input => new Set(input.questions.map(item => item.id)).size === input.questions.length, "questions must not repeat an id"),
-    execute(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return evaluate({
-                state: input.state,
-                questions: toQuestionMap(input.questions),
-                apiKey: extension.config.apiKey,
-                model: extension.config.model,
-            });
+    async execute(input) {
+        return evaluate({
+            state: input.state,
+            questions: toQuestionMap(input.questions),
+            apiKey: extension.config.apiKey,
+            model: extension.config.model,
         });
     },
 });

package/dist/extensions/slack-communication/tools/post-file.js

@@ -47,7 +47,7 @@ const postFile = defineTool({
         try {
             realPath = realpathSync(path);
         }
-        catch (_a) {
+        catch {
             return `No such file: ${path}`;
         }
         const workspaceRoot = realpathSync(ctx.workspaceDir);