@cursor/bdk 0.2.1 → 0.2.3

package/dist/extensions/cursor-grokbot-agents/lib/conversation.d.ts

@@ -0,0 +1,53 @@
+/**
+ * One exchange with a hosted Grok Bot agent, the way the grokbot runtime
+ * drives a turn: send a user message, then read the transcript until the
+ * agent's turn settles. Only `send-message` entries (what the agent delivers
+ * through SendToUser) are the reply; its internal work never appears in the
+ * transcript. Waits are bounded, so a long turn comes back as `running` and
+ * `check` picks it up from the caller's cursor.
+ *
+ * Sends and reads on one hosted agent are chained within this process, and
+ * a send waits for an in-flight turn to settle first, so a reply always
+ * attributes to the message that prompted it.
+ */
+import type { ToolContext } from "../../../types.js";
+export declare const DEFAULT_WAIT_SECONDS = 120;
+export declare const MAX_WAIT_SECONDS = 600;
+export type ReplyStatus = "finished" | "running";
+export type AskResult = {
+    agent: string;
+    sessionId: string;
+    status: ReplyStatus;
+    /** What the agent sent back, in order; absent when it sent nothing (yet). */
+    reply?: string;
+    /** Replies to earlier messages that this caller had not read yet. */
+    earlierReplies?: string[];
+    /** The account had no agent of that name; this call created an empty one. */
+    created?: true;
+    note?: string;
+};
+export type CheckResult = {
+    agent: string;
+    sessionId: string;
+    status: ReplyStatus;
+    reply?: string;
+    note?: string;
+};
+export type InterruptResult = {
+    agent: string;
+    sessionId: string;
+    interrupted: true;
+};
+export declare function ask(ctx: ToolContext, input: {
+    agent?: string;
+    message: string;
+    waitSeconds: number;
+}): Promise<AskResult>;
+export declare function check(ctx: ToolContext, input: {
+    agent?: string;
+    waitSeconds: number;
+}): Promise<CheckResult>;
+export declare function interrupt(ctx: ToolContext, input: {
+    agent?: string;
+}): Promise<InterruptResult>;
+//# sourceMappingURL=conversation.d.ts.map

package/dist/extensions/cursor-grokbot-agents/lib/conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/lib/conversation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAWrD,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAkBpC,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AAGjD,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,6EAA6E;IAC7E,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,IAAI,CAAC;CACnB,CAAC;AAWF,wBAAsB,GAAG,CACvB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC9D,OAAO,CAAC,SAAS,CAAC,CA0DpB;AAED,wBAAsB,KAAK,CACzB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,WAAW,CAAC,CAsBtB;AAED,wBAAsB,SAAS,CAC7B,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACxB,OAAO,CAAC,eAAe,CAAC,CAQ1B"}

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

@@ -0,0 +1,206 @@
+/**
+ * One exchange with a hosted Grok Bot agent, the way the grokbot runtime
+ * drives a turn: send a user message, then read the transcript until the
+ * agent's turn settles. Only `send-message` entries (what the agent delivers
+ * through SendToUser) are the reply; its internal work never appears in the
+ * transcript. Waits are bounded, so a long turn comes back as `running` and
+ * `check` picks it up from the caller's cursor.
+ *
+ * Sends and reads on one hosted agent are chained within this process, and
+ * 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";
+import { findContact, listContacts, saveContact } from "./contacts.js";
+import { KeyedLock } from "./lock.js";
+export const DEFAULT_WAIT_SECONDS = 120;
+export const MAX_WAIT_SECONDS = 600;
+/**
+ * Idle polls required before a turn counts as settled when the workflow
+ * never reported busy: covers the window between an accepted send and the
+ * workflow picking the signal up, which a `check` right after a short `ask`
+ * can still be inside.
+ */
+const MIN_IDLE_POLLS_WITHOUT_BUSY = 4;
+/**
+ * A session whose row is this young, and whose transcript is still empty,
+ * was created by the call that fetched it; the allowance covers clock skew
+ * between this host and the backend.
+ */
+const CREATED_WINDOW_MS = 60000;
+/** 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 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.");
+        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;
+    });
+}
+/**
+ * Read the transcript after `cursor` until the agent's turn settles or the
+ * deadline passes. Only an empty page can settle the turn, so a backlog
+ * drains page by page first. With `confirmIdle`, an idle report may predate
+ * the workflow picking a message up, so settling takes
+ * {@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 };
+                }
+            }
+            if (Date.now() >= options.deadline) {
+                return { status: "running", deliveries, cursor };
+            }
+            yield sleep(extension.config.pollIntervalMs);
+        }
+    });
+}
+function isBusy(turn) {
+    return turn.inFlight || turn.queued > 0;
+}
+function joinReplies(deliveries) {
+    return deliveries.length === 0 ? undefined : deliveries.join("\n\n");
+}
+function runningNote(name, status) {
+    return status === "running"
+        ? `"${name}" is still replying. Call check with the same agent to keep waiting; a reply so far, if any, is above.`
+        : undefined;
+}
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/extensions/cursor-grokbot-agents/lib/inputs.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const agentName: z.ZodOptional<z.ZodString>;
+export declare const waitSeconds: z.ZodDefault<z.ZodNumber>;
+//# sourceMappingURL=inputs.d.ts.map

package/dist/extensions/cursor-grokbot-agents/lib/inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/lib/inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAM9C,CAAC;AAEJ,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAQ/C,CAAC"}

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { AGENT_NAME_MAX_LENGTH } from "../extension.js";
+import { DEFAULT_WAIT_SECONDS, MAX_WAIT_SECONDS } from "./conversation.js";
+export const agentName = z
+    .string()
+    .max(AGENT_NAME_MAX_LENGTH)
+    .optional()
+    .describe("The Grok Bot agent's name, as shown in the Grok Bot app. With agents configured, one of those; optional when exactly one is configured.");
+export const waitSeconds = z
+    .number()
+    .int()
+    .min(0)
+    .max(MAX_WAIT_SECONDS)
+    .default(DEFAULT_WAIT_SECONDS)
+    .describe(`How long to wait for the reply before returning status "running" (default ${DEFAULT_WAIT_SECONDS}, max ${MAX_WAIT_SECONDS}). 0 returns after one look.`);

package/dist/extensions/cursor-grokbot-agents/lib/lock.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Per-key chaining of async work. `host.kv` has no compare-and-swap, and a
+ * model that talks to two agents in one turn calls these tools in parallel,
+ * so read-modify-writes of one principal's records queue up here. The same
+ * chain keeps one hosted agent's sends and reads from interleaving within
+ * this process, so a reply attributes to the message that prompted it.
+ */
+export declare class KeyedLock {
+    private readonly chains;
+    run<T>(key: string, task: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=lock.d.ts.map

package/dist/extensions/cursor-grokbot-agents/lib/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/lib/lock.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;IAE3D,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CActD;CACF"}

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

@@ -0,0 +1,25 @@
+/**
+ * Per-key chaining of async work. `host.kv` has no compare-and-swap, and a
+ * model that talks to two agents in one turn calls these tools in parallel,
+ * so read-modify-writes of one principal's records queue up here. The same
+ * chain keeps one hosted agent's sends and reads from interleaving within
+ * this process, so a reply attributes to the message that prompted it.
+ */
+export class KeyedLock {
+    constructor() {
+        this.chains = new Map();
+    }
+    run(key, task) {
+        var _a;
+        const previous = (_a = this.chains.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        const run = previous.then(task, task);
+        const settled = run.then(() => undefined, () => undefined);
+        this.chains.set(key, settled);
+        void settled.then(() => {
+            if (this.chains.get(key) === settled) {
+                this.chains.delete(key);
+            }
+        });
+        return run;
+    }
+}

package/dist/extensions/cursor-grokbot-agents/skills/consult.md

@@ -0,0 +1,40 @@
+---
+description: "Talk to your Grok Bot agents: when to bring one in, how to write a message it can act on alone, and how to wait for, read, and interrupt its reply."
+---
+
+# Consulting a Grok Bot agent
+
+Bring a Grok Bot agent in when the person set one up for the job: a specialist with its own instructions, memory, and tools, such as one that decides whether an outdoor plan survives a forecast or one that keeps a household's calendar. Answer questions you can answer yourself.
+
+The tools below are this extension's; they appear under its mount namespace, as `<namespace>__ask` and so on. Every agent is addressed by its `agent` name, as it appears in the Grok Bot app. When exactly one agent is configured, `agent` can be omitted.
+
+## Write for a stranger
+
+Your message lands in the person's own conversation with that agent, the same one they see in the app. The agent does not see this conversation, your tools, or your earlier results. Say who is asking and why, paste the facts it needs rather than referring to them, and say what you want back and in what shape. One complete message beats a back-and-forth.
+
+## Ask
+
+Call `ask` with the `agent` and the `message`. It sends the message and waits up to `wait_seconds` for the agent's turn to finish. The result carries `status`, the `reply` (everything the agent sent back during that turn, in order), and `sessionId`.
+
+- `status: "finished"`: the turn is over; `reply` is the whole answer. No `reply` means the agent finished without sending anything.
+- `status: "running"`: the agent is still working. Call `check` with the same `agent` to keep waiting; whatever it had sent so far is already in `reply`.
+
+If `earlierReplies` is present, the agent had answered earlier messages that nobody read yet; pass them on when they matter, and do not mistake them for the reply to this message.
+
+If `created` is true, no agent of that name existed on the account and an empty one was created. Tell the person and check the spelling before asking it anything else.
+
+If `ask` fails because an agent of that name already exists in the Grok Bot app, nothing was created and nothing was sent. Tell the person. Do not invent a different name to get around it.
+
+If `ask` refuses because the agent is still working on an earlier message, nothing was sent. If you have already asked that agent, call `check` to read the reply, then ask again; use `interrupt` when the earlier work should stop. On first contact, `check` and `interrupt` cannot address the agent yet, so tell the person it is busy, wait for the existing turn to finish in the Grok Bot app, and retry `ask`.
+
+## Wait for a long reply
+
+Call `check` with the `agent`. It returns what the agent has sent since you last read, and `status: "running"` while the turn is still going. Pass `wait_seconds: 0` for a single look. Check when you need the answer, not in a tight loop; a long task can take minutes.
+
+## Interrupt
+
+Call `interrupt` with the `agent` to stop its current turn. The agent keeps its conversation, so a later `ask` continues from there.
+
+## Which agents
+
+`list` returns the agents configured for you, with what each is for, and the ones you have already asked. Names outside the configured set are refused; with no set configured, any name works, and an unknown name creates an agent.

package/dist/extensions/cursor-grokbot-agents/tools/ask.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from "../../../types.js";
+declare const ask: ToolDefinition;
+export default ask;
+//# sourceMappingURL=ask.d.ts.map

package/dist/extensions/cursor-grokbot-agents/tools/ask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/tools/ask.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAKxD,QAAA,MAAM,GAAG,EAAE,cAsBT,CAAC;eAEY,GAAG"}

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

@@ -0,0 +1,37 @@
+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";
+import { ask as askAgent } from "../lib/conversation.js";
+import { agentName, waitSeconds } from "../lib/inputs.js";
+const ask = defineTool({
+    description: 'Send a message to one of your Grok Bot agents and wait for its reply. The message lands in your own conversation with that agent, which does not see this one, so include everything it needs. Long turns return status "running": call check to keep waiting.',
+    effect: "write",
+    needsApproval: () => extension.config.needsApproval,
+    inputSchema: z.object({
+        agent: agentName,
+        message: z
+            .string()
+            .min(1)
+            .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,
+            });
+        });
+    },
+});
+export default ask;

package/dist/extensions/cursor-grokbot-agents/tools/check.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from "../../../types.js";
+declare const check: ToolDefinition;
+export default check;
+//# sourceMappingURL=check.d.ts.map

package/dist/extensions/cursor-grokbot-agents/tools/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/tools/check.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAIxD,QAAA,MAAM,KAAK,EAAE,cAgBX,CAAC;eAEY,KAAK"}

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

@@ -0,0 +1,32 @@
+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";
+import { agentName, waitSeconds } from "../lib/inputs.js";
+const check = defineTool({
+    description: 'Wait for, or poll, the reply of a Grok Bot agent you asked: everything it has sent since you last read, and whether it is still working. Returns status "running" to keep waiting; pass wait_seconds 0 for a single look.',
+    // Reading advances the caller's cursor, which their other sessions read
+    // back, so a dry run answers this instead of running it.
+    effect: "write",
+    inputSchema: z.object({
+        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,
+            });
+        });
+    },
+});
+export default check;

package/dist/extensions/cursor-grokbot-agents/tools/interrupt.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from "../../../types.js";
+declare const interrupt: ToolDefinition;
+export default interrupt;
+//# sourceMappingURL=interrupt.d.ts.map

package/dist/extensions/cursor-grokbot-agents/tools/interrupt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/tools/interrupt.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAIxD,QAAA,MAAM,SAAS,EAAE,cAQf,CAAC;eAEY,SAAS"}

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

@@ -0,0 +1,24 @@
+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";
+import { agentName } from "../lib/inputs.js";
+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 });
+        });
+    },
+});
+export default interrupt;

package/dist/extensions/cursor-grokbot-agents/tools/list.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDefinition } from "../../../types.js";
+declare const list: ToolDefinition;
+export default list;
+//# sourceMappingURL=list.d.ts.map

package/dist/extensions/cursor-grokbot-agents/tools/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/tools/list.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAIxD,QAAA,MAAM,IAAI,EAAE,cAiBV,CAAC;eAEY,IAAI"}

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

@@ -0,0 +1,34 @@
+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";
+import { listContacts } from "../lib/contacts.js";
+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,
+                })),
+            };
+        });
+    },
+});
+export default list;

package/dist/files-backends/cursor-hosted.js

@@ -753,10 +753,10 @@ export function cursorHostedFiles(options = {}) {
                     if (files.wire !== "flush") {
                         return false;
                     }
-                    // The flush wire's deletes are conditional server-side: when this
-                    // process has no observed etag, the server resolves the current one —
-                    // the lookup that costs a stat round trip on `/v0` — and a key that
-                    // is already absent settles as `already_deleted`.
+                    // With an observed etag the flush delete is If-Match on that version.
+                    // Without one, the server tombstones whatever live object occupies
+                    // the key (no directory walk here) and an absent key settles as
+                    // `already_deleted`.
                     const cached = observedEtags.get(key);
                     const response = yield flushPost(options, "/flush", {
                         store: files.store,

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

@@ -20,13 +20,22 @@ export interface CreateArtifactsStoreOptions {
     config?: ArtifactsConfig;
     /** Explicit sink override (tests). Omitted → hosted store or local disk. */
     sink?: FileSink;
+    /**
+     * Whether `tag` enforces {@link ArtifactsConfig.max} by listing and
+     * deleting. Default true. Hosted architecture v2 passes false: the
+     * installation store is allowed to grow, and a tag must not list the prefix.
+     */
+    enforceCap?: () => boolean;
 }
 /** Kind used by freeform tags when no kinds are declared. */
 export declare const ARTIFACT_DEFAULT_KIND = "artifact";
 /**
  * Upsert + list semantics over one {@link ArtifactRowStore}: kind/schema
- * validation, deterministic ids for keyed tags, and `max` eviction. The
- * engine wraps this into the per-context {@link ArtifactsApi} facades and
+ * validation, deterministic ids for keyed tags, and `max` eviction.
+ * Architecture v1 and self-hosted v2 evict. Hosted architecture v2 sets
+ * {@link CreateArtifactsStoreOptions.enforceCap} false and does not list
+ * or delete on tag. The engine wraps this into the per-context
+ * {@link ArtifactsApi} facades and
  * owns the `artifact.tagged` event append.
  */
 export declare class ArtifactsStore {
@@ -34,6 +43,7 @@ export declare class ArtifactsStore {
     private readonly content;
     private readonly config;
     private readonly max;
+    private readonly enforceCap;
     /** Serializes tags so read-modify-write upserts and eviction don't race. */
     private tagChain;
     constructor(options: CreateArtifactsStoreOptions);

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

@@ -1 +1 @@
-{"version":3,"file":"artifacts-store.d.ts","sourceRoot":"","sources":["../../src/internal/artifacts-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAK5D,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AAGrB,2EAA2E;AAC3E,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAqE9C,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAED,6DAA6D;AAC7D,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAuC;IAEvD,YAAY,OAAO,EAAE,2BAA2B,EAW/C;IAED,GAAG,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAIpD;YAEa,aAAa;IA0C3B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAEnD;IAED,sEAAsE;IACtE,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEtD;IAED;;;;OAIG;IACG,IAAI,CAAC,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAGjE;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACG,IAAI,CACR,OAAO,CAAC,EAAE,mBAAmB,GAAG;QAC9B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC;KAC/C,GACA,OAAO,CAAC,YAAY,CAAC,CAyBvB;IAED;;;;;OAKG;YACW,gBAAgB;IA0F9B;;;;;;OAMG;YACW,eAAe;IAmC7B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;;;;;;;;;;;;;;;;;OAkBG;YACW,YAAY;IAkB1B,sEAAsE;YACxD,YAAY;CAsB3B;AAED,kEAAkE;AAClE,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,cAGC;CACF;AAyDD,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKpD"}
+{"version":3,"file":"artifacts-store.d.ts","sourceRoot":"","sources":["../../src/internal/artifacts-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAK5D,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AAGrB,2EAA2E;AAC3E,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAqE9C,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;CAC5B;AAED,6DAA6D;AAC7D,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;;;;GAQG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAuC;IAEvD,YAAY,OAAO,EAAE,2BAA2B,EAY/C;IAED,GAAG,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAIpD;YAEa,aAAa;IA0C3B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAEnD;IAED,sEAAsE;IACtE,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEtD;IAED;;;;OAIG;IACG,IAAI,CAAC,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAGjE;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACG,IAAI,CACR,OAAO,CAAC,EAAE,mBAAmB,GAAG;QAC9B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC;KAC/C,GACA,OAAO,CAAC,YAAY,CAAC,CAyBvB;IAED;;;;;OAKG;YACW,gBAAgB;IA0F9B;;;;;;OAMG;YACW,eAAe;IAmC7B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;;;;;;;;;;;;;;;;;OAkBG;YACW,YAAY;IAkB1B,sEAAsE;YACxD,YAAY;CAsB3B;AAED,kEAAkE;AAClE,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,cAGC;CACF;AAyDD,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKpD"}