@cursor/bdk 0.2.2 → 0.2.4

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

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/lib/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE9D,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,UAAU,EAAE,sBAAsB,EAAE,GAAG,SAAS,GAC/C,MAAM,CA2BR"}

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

@@ -0,0 +1,31 @@
+/**
+ * Which Grok Bot agent a call addresses. The model names one per call, but
+ * the author's `agents` are the allowlist: with them configured, a name
+ * outside the list is refused (the backend would create an agent of that
+ * name), and a lone configured agent stands in when the call names none.
+ * Matching is case-insensitive and resolves to the configured spelling,
+ * since the backend looks names up exactly.
+ */
+export function resolveAgentName(requested, configured) {
+    var _a;
+    const name = requested === null || requested === void 0 ? void 0 : requested.trim();
+    if (configured === undefined) {
+        if (name === undefined || name === "") {
+            throw new Error("`agent` is required: this extension has no configured Grok Bot agents.");
+        }
+        return name;
+    }
+    const names = configured.map(agent => `"${agent.name}"`).join(", ");
+    if (name === undefined || name === "") {
+        const only = configured.length === 1 ? configured[0] : undefined;
+        if (only === undefined) {
+            throw new Error(`\`agent\` is required: this extension configures several Grok Bot agents (${names}).`);
+        }
+        return only.name;
+    }
+    const match = (_a = configured.find(agent => agent.name === name)) !== null && _a !== void 0 ? _a : configured.find(agent => agent.name.toLowerCase() === name.toLowerCase());
+    if (match === undefined) {
+        throw new Error(`"${name}" is not one of this extension's configured Grok Bot agents (${names}).`);
+    }
+    return match.name;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * The `/v0/grokbot` session API as the tools use it: the same four routes
+ * the grokbot runtime drives, on the external API host (`api.cursor.com`;
+ * they 404 on api2), under the host's Cursor API key. A session is a hosted
+ * Grok Bot agent of the key's account, get-or-created by name; messages go
+ * into its one conversation, and the transcript is read back as entries
+ * after a cursor, with the turn's status alongside.
+ */
+export declare class GrokBotApiError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+export type GrokBotSession = {
+    /** The hosted agent's durable id; every other route addresses it. */
+    sessionId: string;
+    /** The name as the backend stores it (trimmed). */
+    name: string;
+    createdAtMs: number;
+    /** Transcript tail: reading after it skips the conversation's history. */
+    latestUpdatedSeq: string;
+};
+export type GrokBotEntry = {
+    seq: string;
+    updatedSeq: string;
+    kind: string;
+    role?: string;
+    text?: string;
+    createdAtMs: number;
+};
+export type GrokBotTurnStatus = {
+    idle: boolean;
+    inFlight: boolean;
+    queued: number;
+};
+export type GrokBotEntriesPage = {
+    entries: GrokBotEntry[];
+    latestUpdatedSeq: string;
+    turn: GrokBotTurnStatus;
+};
+export declare class GrokBotAgentsBackend {
+    private readonly apiKey;
+    private readonly fetchImpl;
+    constructor(apiKey: () => string, fetchImpl?: typeof fetch);
+    /** `POST /v0/grokbot/sessions`: the account's agent of that name, created when missing. */
+    session(name: string): Promise<GrokBotSession>;
+    /** Deliver one user message to the agent's conversation. */
+    send(sessionId: string, text: string): Promise<void>;
+    /** Transcript entries after `afterUpdatedSeq`, oldest first, with the turn's status. */
+    entries(sessionId: string, afterUpdatedSeq: string): Promise<GrokBotEntriesPage>;
+    interrupt(sessionId: string, reason: string): Promise<void>;
+    private request;
+}
+/** The process-wide backend for this mount, built on first use. */
+export declare function grokBotAgentsBackend(): GrokBotAgentsBackend;
+export declare function apiKey(): string;
+//# sourceMappingURL=backend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/lib/backend.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,qBAAa,eAAgB,SAAQ,KAAK;IAGtC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM;IAF1B,YACE,OAAO,EAAE,MAAM,EACN,MAAM,CAAC,EAAE,MAAM,YAAA,EAIzB;CACF;AAGD,MAAM,MAAM,cAAc,GAAG;IAC3B,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAiCF,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAF5B,YACmB,MAAM,EAAE,MAAM,MAAM,EACpB,SAAS,GAAE,OAAO,KAAa,EAC9C;IAEJ,2FAA2F;IACrF,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAYnD;IAED,4DAA4D;IACtD,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYzD;IAED,wFAAwF;IAClF,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAOrF;IAEK,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhE;YAEa,OAAO;CA+BtB;AAID,mEAAmE;AACnE,wBAAgB,oBAAoB,IAAI,oBAAoB,CAG3D;AAED,wBAAgB,MAAM,IAAI,MAAM,CAO/B"}

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

@@ -0,0 +1,158 @@
+/**
+ * The `/v0/grokbot` session API as the tools use it: the same four routes
+ * the grokbot runtime drives, on the external API host (`api.cursor.com`;
+ * they 404 on api2), under the host's Cursor API key. A session is a hosted
+ * Grok Bot agent of the key's account, get-or-created by name; messages go
+ * into its one conversation, and the transcript is read back as entries
+ * after a cursor, with the turn's status alongside.
+ */
+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 { z } from "zod";
+import { cursorExternalApiUrl, resolveApiKeySync, SIGN_IN_HINT, } from "../../../internal/cursor/credentials.js";
+import extension from "../extension.js";
+const REQUEST_TIMEOUT_MS = 60000;
+export class GrokBotApiError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "GrokBotApiError";
+    }
+}
+const sessionSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    createdAtMs: z.number(),
+    latestUpdatedSeq: z.string(),
+});
+const sendSchema = z.object({
+    messageId: z.string(),
+    delivery: z.string(),
+});
+const entriesSchema = z.object({
+    entries: z.array(z.object({
+        seq: z.string(),
+        updatedSeq: z.string(),
+        kind: z.string(),
+        role: z.string().optional(),
+        text: z.string().optional(),
+        createdAtMs: z.number(),
+    })),
+    latestUpdatedSeq: z.string(),
+    turn: z.object({
+        idle: z.boolean(),
+        inFlight: z.boolean(),
+        queued: z.number(),
+    }),
+});
+export class GrokBotAgentsBackend {
+    constructor(apiKey, fetchImpl = fetch) {
+        this.apiKey = apiKey;
+        this.fetchImpl = fetchImpl;
+    }
+    /** `POST /v0/grokbot/sessions`: the account's agent of that name, created when missing. */
+    session(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // No `instructions`: the agent is somebody's, configured in the app, and
+            // an omitted field never touches its stored profile.
+            const parsed = sessionSchema.parse(yield this.request("POST", "/v0/grokbot/sessions", { name }));
+            return {
+                sessionId: parsed.id,
+                name: parsed.name,
+                createdAtMs: parsed.createdAtMs,
+                latestUpdatedSeq: parsed.latestUpdatedSeq,
+            };
+        });
+    }
+    /** Deliver one user message to the agent's conversation. */
+    send(sessionId, text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { delivery } = sendSchema.parse(yield this.request("POST", `/v0/grokbot/sessions/${sessionId}/messages`, {
+                text,
+                messageId: randomUUID(),
+            }));
+            if (delivery !== "accepted_temporal" && delivery !== "duplicate") {
+                throw new GrokBotApiError(`The Grok Bot agent's harness did not accept the message (delivery: ${delivery}).`);
+            }
+        });
+    }
+    /** Transcript entries after `afterUpdatedSeq`, oldest first, with the turn's status. */
+    entries(sessionId, afterUpdatedSeq) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return entriesSchema.parse(yield this.request("GET", `/v0/grokbot/sessions/${sessionId}/entries?afterUpdatedSeq=${encodeURIComponent(afterUpdatedSeq)}`));
+        });
+    }
+    interrupt(sessionId, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.request("POST", `/v0/grokbot/sessions/${sessionId}/interrupt`, {
+                reason,
+            });
+        });
+    }
+    request(method, path, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = {
+                authorization: `Bearer ${this.apiKey()}`,
+                "x-cursor-client-type": "agent-serve",
+                "x-request-id": randomUUID(),
+            };
+            if (body !== undefined) {
+                headers["content-type"] = "application/json";
+            }
+            let response;
+            try {
+                response = yield this.fetchImpl(`${cursorExternalApiUrl()}${path}`, {
+                    method,
+                    headers,
+                    body: body === undefined ? undefined : JSON.stringify(body),
+                    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                });
+            }
+            catch (error) {
+                throw new GrokBotApiError(`Grok Bot API ${method} ${path} failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const text = yield response.text();
+            if (!response.ok) {
+                throw new GrokBotApiError(`Grok Bot API ${method} ${path} failed (${response.status}): ${apiErrorMessage(text)}`, response.status);
+            }
+            return JSON.parse(text);
+        });
+    }
+}
+let backend;
+/** The process-wide backend for this mount, built on first use. */
+export function grokBotAgentsBackend() {
+    backend !== null && backend !== void 0 ? backend : (backend = new GrokBotAgentsBackend(apiKey));
+    return backend;
+}
+export function apiKey() {
+    // Read per call: the host can sign in after the mount.
+    const key = resolveApiKeySync({ apiKey: extension.config.apiKey });
+    if (key === undefined) {
+        throw new Error(`Grok Bot agents need a Cursor API key. ${SIGN_IN_HINT}`);
+    }
+    return key.apiKey;
+}
+/** The route's `{ error }` envelope when it is one, the raw body otherwise. */
+function apiErrorMessage(text) {
+    var _a;
+    try {
+        const parsed = JSON.parse(text);
+        const message = (_a = parsed.error) !== null && _a !== void 0 ? _a : parsed.message;
+        if (typeof message === "string" && message !== "") {
+            return message;
+        }
+    }
+    catch (_b) {
+        // Not JSON; fall through to the raw body.
+    }
+    return text.slice(0, 300);
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Who has talked to which Grok Bot agent, and how far into its transcript
+ * they have read. The tools authenticate with the serve host's one Cursor
+ * API key, so every agent is that account's; what the host keeps per
+ * principal is the read cursor, so `check` returns what the agent said
+ * since that caller last read, and a lookup by name for `check` and
+ * `interrupt`, which never create an agent the caller has not spoken to.
+ */
+import type { ToolContext } from "../../../types.js";
+export type Contact = {
+    /** The agent's name as the backend stores it. */
+    name: string;
+    /** The hosted agent's `/v0/grokbot` session id. */
+    sessionId: string;
+    /** Newest transcript `updatedSeq` this principal has read. */
+    cursor: string;
+    firstContactAt: string;
+    lastContactAt: string;
+};
+/** Unauthenticated sessions (local dev, direct calls) share one principal. */
+export declare function principalOf(ctx: ToolContext): string;
+/** The caller's contacts, most recently spoken to first. */
+export declare function listContacts(ctx: ToolContext): Promise<Contact[]>;
+/** The contact of that name, exact spelling first, then case-insensitively. */
+export declare function findContact(contacts: Contact[], name: string): Contact | undefined;
+/** Insert or replace the caller's record of one agent, newest first. */
+export declare function saveContact(ctx: ToolContext, contact: Contact): Promise<void>;
+//# sourceMappingURL=contacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../../../../src/extensions/cursor-grokbot-agents/lib/contacts.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMrD,MAAM,MAAM,OAAO,GAAG;IACpB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAcF,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAGpD;AAED,4DAA4D;AAC5D,wBAAsB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGvE;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAMlF;AAED,wEAAwE;AACxE,wBAAsB,WAAW,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAQnF"}

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

@@ -0,0 +1,59 @@
+/**
+ * Who has talked to which Grok Bot agent, and how far into its transcript
+ * they have read. The tools authenticate with the serve host's one Cursor
+ * API key, so every agent is that account's; what the host keeps per
+ * principal is the read cursor, so `check` returns what the agent said
+ * since that caller last read, and a lookup by name for `check` and
+ * `interrupt`, which never create an agent the caller has not spoken to.
+ */
+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 { KeyedLock } from "./lock.js";
+const PREFIX = "grokbot-agents";
+const contactsSchema = z.array(z.object({
+    name: z.string(),
+    sessionId: z.string(),
+    cursor: z.string(),
+    firstContactAt: z.string(),
+    lastContactAt: z.string(),
+}));
+const locks = new KeyedLock();
+/** Unauthenticated sessions (local dev, direct calls) share one principal. */
+export function principalOf(ctx) {
+    const auth = ctx.session.auth;
+    return auth === null ? "anonymous" : `${auth.principalType}:${auth.principalId}`;
+}
+/** The caller's contacts, most recently spoken to first. */
+export function listContacts(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contacts = contactsSchema.safeParse(yield ctx.host.kv.get(contactsKey(principalOf(ctx))));
+        return contacts.success ? contacts.data : [];
+    });
+}
+/** The contact of that name, exact spelling first, then case-insensitively. */
+export function findContact(contacts, name) {
+    var _a;
+    const wanted = name.trim();
+    return ((_a = contacts.find(contact => contact.name === wanted)) !== null && _a !== void 0 ? _a : contacts.find(contact => contact.name.toLowerCase() === wanted.toLowerCase()));
+}
+/** Insert or replace the caller's record of one agent, newest first. */
+export function saveContact(ctx, contact) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const key = contactsKey(principalOf(ctx));
+        yield locks.run(key, () => __awaiter(this, void 0, void 0, function* () {
+            const others = (yield listContacts(ctx)).filter(existing => existing.sessionId !== contact.sessionId);
+            yield ctx.host.kv.put(key, [contact, ...others]);
+        }));
+    });
+}
+function contactsKey(principal) {
+    return `${PREFIX}/principals/${encodeURIComponent(principal)}`;
+}

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"}