grokbot-control 0.0.0-stage → 0.1.3

package/dist/ops/bot.js

@@ -0,0 +1,211 @@
+import { GrokBotAgentHarnessKind } from "#proto-gen/aiserver";
+import { mapConnectError } from "../connect/client.js";
+import { failResult, newRequestId, okResult, } from "../dto/result.js";
+import { GbcError } from "../errors.js";
+import { mapBot } from "./map.js";
+import { validateLimit } from "./limits.js";
+function requireWrite(opts, action) {
+    if (opts?.dryRun)
+        return;
+    if (!opts?.allowWrite && process.env.GBT_ALLOW_WRITES !== "1") {
+        throw new GbcError("denied", `refusing ${action}: pass allowWrite / --allow-writes or GBT_ALLOW_WRITES=1`, {
+            exitCode: 7,
+            hint: "Writes are explicit; dry-run is pure and does not call RPC.",
+        });
+    }
+}
+export class BotOps {
+    client;
+    flags;
+    constructor(client, flags = {}) {
+        this.client = client;
+        this.flags = flags;
+    }
+    wrapSim(r) {
+        if (this.flags.simulated)
+            r.simulated = true;
+        return r;
+    }
+    /** Update/Delete RPC `id` is the numeric server id (App: serverId); accept agent_id UUID by resolving via list. */
+    async serverId(idOrAgentId) {
+        if (/^\d+$/.test(idOrAgentId))
+            return idOrAgentId;
+        const res = await this.client.listGrokBotAgents({});
+        const bot = (res.agents ?? [])
+            .map(mapBot)
+            .find((b) => b.agent_id === idOrAgentId);
+        if (bot?.id)
+            return bot.id;
+        throw new GbcError(res.truncated ? "lookup_incomplete" : "not_found", res.truncated
+            ? "agent list truncated; cannot resolve server id"
+            : `bot ${idOrAgentId} not found; no write sent`, { exitCode: 5 });
+    }
+    async list(opts) {
+        const request_id = newRequestId();
+        try {
+            const limit = validateLimit(opts?.limit);
+            const res = await this.client.listGrokBotAgents({});
+            const all = (res.agents ?? []).map(mapBot);
+            const truncated = Boolean(res.truncated) || all.length > limit;
+            return this.wrapSim(okResult({
+                bots: all.slice(0, limit),
+                truncated,
+            }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    /** No GetBot RPC — filter ListGrokBotAgents client-side (full server page, not the user-facing cap). */
+    async get(agentId) {
+        const request_id = newRequestId();
+        try {
+            const res = await this.client.listGrokBotAgents({});
+            const all = (res.agents ?? []).map(mapBot);
+            const bot = all.find((b) => b.agent_id === agentId || b.id === agentId);
+            if (bot)
+                return this.wrapSim(okResult({ bot }, { request_id }));
+            if (res.truncated) {
+                return this.wrapSim(failResult("lookup_incomplete", `bot ${agentId} not in a truncated ListGrokBotAgents page; existence unknown`, {
+                    request_id,
+                    outcome: "unknown",
+                    hint: "Server list was truncated; absence is not proof of non-existence.",
+                }));
+            }
+            return this.wrapSim(failResult("not_found", `bot ${agentId} not found in ListGrokBotAgents`, {
+                request_id,
+                hint: "There is no GetGrokBotAgent RPC; get = list + filter.",
+            }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    async create(input, write) {
+        const request_id = newRequestId();
+        if (write?.dryRun) {
+            return this.wrapSim(okResult({
+                bot: {
+                    agent_id: input.agentId || "(dry-run-nonce)",
+                    id: "",
+                    name: input.name,
+                    description: input.description || "",
+                    title: input.title || input.name,
+                    harness: "TEMPORAL",
+                    role: "",
+                    kind: "",
+                    viewer_session_id: "",
+                },
+                agent_id: input.agentId || "(dry-run-nonce)",
+            }, { request_id, code: "dry_run" }));
+        }
+        try {
+            requireWrite(write, "bot.create");
+            const agentId = input.agentId || crypto.randomUUID();
+            // App Temporal path: CreateGrokBotTemporalAgent with CreateGrokBotAgentRequest fields.
+            // Drift (visibility/teamId/botBuilderRequested) intentionally NOT sent — not in 0.78.4 Request.
+            const res = await this.client.createGrokBotTemporalAgent({
+                agentId,
+                name: input.name,
+                description: input.description ?? "",
+                title: input.title ?? input.name,
+                avatarShape: "circle",
+                avatarColor: "#888888",
+                harness: GrokBotAgentHarnessKind.TEMPORAL,
+                kickstartRequested: input.kickstart ?? false,
+                introductionSuppressed: !(input.kickstart ?? false),
+                language: input.language,
+            });
+            const bot = mapBot(res.agent);
+            return this.wrapSim(okResult({ bot, agent_id: bot.agent_id || agentId }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id, true);
+        }
+    }
+    async update(agentId, patch, write) {
+        const request_id = newRequestId();
+        if (write?.dryRun) {
+            return this.wrapSim(okResult({
+                bot: {
+                    agent_id: agentId,
+                    id: agentId,
+                    name: patch.name || "",
+                    description: patch.description || "",
+                    title: patch.title || "",
+                    harness: "",
+                    role: "",
+                    kind: "",
+                    viewer_session_id: "",
+                },
+            }, { request_id, code: "dry_run" }));
+        }
+        try {
+            requireWrite(write, "bot.update");
+            const res = await this.client.updateGrokBotAgent({
+                id: await this.serverId(agentId),
+                name: patch.name,
+                description: patch.description,
+                title: patch.title,
+                partialUpdate: true,
+            });
+            return this.wrapSim(okResult({ bot: mapBot(res.agent) }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id, true);
+        }
+    }
+    async delete(agentId, write) {
+        const request_id = newRequestId();
+        if (write?.dryRun) {
+            return this.wrapSim(okResult({
+                deleted: false,
+                note: "dry-run: would call DeleteGrokBotAgent; sidebar cleanup unverified",
+            }, { request_id, code: "dry_run" }));
+        }
+        if (write?.confirm !== agentId) {
+            return this.wrapSim(failResult("denied", "delete requires --confirm=<agent_id> matching the resource", {
+                request_id,
+                hint: `gbc bot delete --agent-id ${agentId} --confirm=${agentId} --allow-writes`,
+            }));
+        }
+        try {
+            requireWrite(write, "bot.delete");
+            await this.client.deleteGrokBotAgent({
+                id: await this.serverId(agentId),
+            });
+            return this.wrapSim(okResult({
+                deleted: true,
+                note: "DeleteGrokBotAgent succeeded. Sidebar section cleanup after delete is unverified.",
+            }, { request_id }));
+        }
+        catch (e) {
+            if (e instanceof GbcError && e.code === "not_found")
+                return this.wrapSim(okResult({
+                    deleted: false,
+                    note: "agent_id not present in complete ListGrokBotAgents; no delete RPC sent (already absent).",
+                }, { request_id }));
+            if (e instanceof GbcError)
+                return this.fromErr(e, request_id, true);
+            const mapped = mapConnectError(e, request_id, { write: true });
+            // App treats NotFound as ok on delete.
+            if (mapped.code === "not_found") {
+                return this.wrapSim(okResult({
+                    deleted: true,
+                    note: "Delete NotFound normalized to ok (App behavior). Sidebar residual unverified.",
+                }, { request_id }));
+            }
+            return this.fromErr(mapped, request_id, true);
+        }
+    }
+    fromErr(e, request_id, write = false) {
+        const err = e instanceof GbcError ? e : mapConnectError(e, request_id, { write });
+        return this.wrapSim(failResult(err.code, err.message, {
+            outcome: err.outcome,
+            retryable: err.retryable,
+            hint: err.hint,
+            request_id,
+            details: err.details,
+        }));
+    }
+}

package/dist/ops/limits.d.ts

@@ -0,0 +1,10 @@
+/** Documented list caps (CLI/MCP/SDK share these). */
+export declare const LIMIT_DEFAULT = 50;
+export declare const LIMIT_MAX = 1000;
+/**
+ * Validate a list limit. undefined -> default. Anything not a positive integer
+ * <= LIMIT_MAX throws invalid_argument (exit 2) — never silently empty.
+ */
+export declare function validateLimit(v: unknown, max?: number): number;
+/** Parse a CLI string limit strictly (digits only). */
+export declare function parseCliLimit(raw: string | undefined, max?: number): number;

package/dist/ops/limits.js

@@ -0,0 +1,31 @@
+import { GbcError } from "../errors.js";
+/** Documented list caps (CLI/MCP/SDK share these). */
+export const LIMIT_DEFAULT = 50;
+export const LIMIT_MAX = 1000;
+/**
+ * Validate a list limit. undefined -> default. Anything not a positive integer
+ * <= LIMIT_MAX throws invalid_argument (exit 2) — never silently empty.
+ */
+export function validateLimit(v, max = LIMIT_MAX) {
+    if (v === undefined || v === null)
+        return LIMIT_DEFAULT;
+    if (typeof v !== "number" || !Number.isInteger(v) || v < 1 || v > max) {
+        throw new GbcError("invalid_argument", `limit must be an integer in 1..${max} (got: ${String(v)})`, {
+            exitCode: 2,
+            hint: `pass --limit=<1..${max}>`,
+        });
+    }
+    return v;
+}
+/** Parse a CLI string limit strictly (digits only). */
+export function parseCliLimit(raw, max = LIMIT_MAX) {
+    if (raw === undefined)
+        return LIMIT_DEFAULT;
+    if (!/^\d+$/.test(raw)) {
+        throw new GbcError("usage", `--limit must be an integer in 1..${max} (got: "${raw}")`, {
+            exitCode: 2,
+            hint: `gbc ... --limit=50`,
+        });
+    }
+    return validateLimit(Number(raw), max);
+}

package/dist/ops/map.d.ts

@@ -0,0 +1,7 @@
+import type { BotSummary, ProgressStatus, SessionSummary, SidebarSection } from "../dto/types.js";
+/** int64 from protobuf JSON/TS may be bigint | string | number — normalize to string. */
+export declare function int64ToString(v: unknown): string | undefined;
+export declare function mapBot(a: any): BotSummary;
+export declare function mapSection(s: any): SidebarSection;
+export declare function mapSession(s: any): SessionSummary;
+export declare function mapStatus(s: any): ProgressStatus;

package/dist/ops/map.js

@@ -0,0 +1,57 @@
+/** int64 from protobuf JSON/TS may be bigint | string | number — normalize to string. */
+export function int64ToString(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    return String(v);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mapBot(a) {
+    return {
+        agent_id: a.agentId || a.agent_id || a.id || "",
+        id: a.id || "",
+        name: a.name || "",
+        description: a.description || "",
+        title: a.title || "",
+        harness: String(a.harness ?? ""),
+        role: a.role || "",
+        kind: String(a.kind ?? ""),
+        viewer_session_id: a.viewerSessionId || a.viewer_session_id || "",
+        created_at_ms: int64ToString(a.createdAtMs ?? a.created_at_ms),
+        updated_at_ms: int64ToString(a.updatedAtMs ?? a.updated_at_ms),
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mapSection(s) {
+    return {
+        id: s.id || "",
+        name: s.name || "",
+        agent_ids: [...(s.agentIds || s.agent_ids || [])],
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mapSession(s) {
+    return {
+        agent_id: s.agentId || s.agent_id || "",
+        session_id: s.sessionId || s.session_id || "",
+        kind: String(s.kind ?? ""),
+        created_at_ms: int64ToString(s.createdAtMs ?? s.created_at_ms),
+        updated_at_ms: int64ToString(s.updatedAtMs ?? s.updated_at_ms),
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mapStatus(s) {
+    const live = s.live;
+    return {
+        agent_id: s.agentId || s.agent_id || "",
+        is_running: Boolean(s.isRunning ?? s.is_running ?? live?.isRunning),
+        session_id: live?.sessionId || live?.session_id,
+        live: live
+            ? {
+                is_composing_message: live.isComposingMessage ?? live.is_composing_message,
+                is_retrying: live.isRetrying ?? live.is_retrying,
+                awaiting: live.awaiting,
+                working_task_ids: live.workingTaskIds || live.working_task_ids,
+            }
+            : undefined,
+    };
+}

package/dist/ops/message.d.ts

@@ -0,0 +1,33 @@
+import type { GrokBotClient } from "../connect/client.js";
+import { type ResultEnvelope } from "../dto/result.js";
+import type { SendDelivery, SendStatusView, TranscriptEntryView } from "../dto/types.js";
+export declare class MessageOps {
+    private client;
+    private flags;
+    constructor(client: GrokBotClient, flags?: {
+        simulated?: boolean;
+    });
+    private sim;
+    send(input: {
+        agentId: string;
+        sessionId: string;
+        text: string;
+        messageId?: string;
+        dryRun?: boolean;
+        allowWrite?: boolean;
+    }): Promise<ResultEnvelope<SendDelivery>>;
+    status(input: {
+        agentId: string;
+        sessionId: string;
+        messageId: string;
+    }): Promise<ResultEnvelope<SendStatusView>>;
+    history(input: {
+        agentId: string;
+        limit?: number;
+    }): Promise<ResultEnvelope<{
+        entries: TranscriptEntryView[];
+        generation?: number;
+        note: string;
+    }>>;
+    private fromErr;
+}

package/dist/ops/message.js

@@ -0,0 +1,118 @@
+import { mapConnectError } from "../connect/client.js";
+import { failResult, newRequestId, okResult } from "../dto/result.js";
+import { GbcError } from "../errors.js";
+import { validateLimit } from "./limits.js";
+function requireWrite(allow, action) {
+    if (!allow && process.env.GBT_ALLOW_WRITES !== "1") {
+        throw new GbcError("denied", `refusing ${action}: need --allow-writes / GBT_ALLOW_WRITES=1`, { exitCode: 7 });
+    }
+}
+export class MessageOps {
+    client;
+    flags;
+    constructor(client, flags = {}) {
+        this.client = client;
+        this.flags = flags;
+    }
+    sim(r) {
+        if (this.flags.simulated)
+            r.simulated = true;
+        return r;
+    }
+    async send(input) {
+        const request_id = newRequestId();
+        const message_id = input.messageId || crypto.randomUUID();
+        if (input.dryRun) {
+            return this.sim(okResult({
+                message_id,
+                agent_id: input.agentId,
+                session_id: input.sessionId,
+                note: "dry-run: would SendGrokBotUserMessage (no task_id required)",
+            }, { request_id, code: "dry_run" }));
+        }
+        try {
+            requireWrite(input.allowWrite, "message.send");
+            const res = await this.client.sendGrokBotUserMessage({
+                agentId: input.agentId,
+                sessionId: input.sessionId,
+                messageId: message_id,
+                text: input.text,
+                sentAtMs: BigInt(Date.now()),
+            });
+            return this.sim(okResult({
+                message_id,
+                agent_id: input.agentId,
+                session_id: input.sessionId,
+                dispatched: res.dispatched,
+                delivery: String(res.delivery ?? ""),
+                note: "delivery/acceptance only — NOT task or business success",
+            }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id, true);
+        }
+    }
+    async status(input) {
+        const request_id = newRequestId();
+        try {
+            const res = await this.client.getGrokBotSendStatus({
+                agentId: input.agentId,
+                sessionId: input.sessionId,
+                messageId: input.messageId,
+            });
+            return this.sim(okResult({
+                agent_id: input.agentId,
+                session_id: input.sessionId,
+                message_id: input.messageId,
+                status: String(res.status ?? ""),
+                rejection_code: res.rejectionCode,
+                accepted_at_ms: res.acceptedAtMs != null ? String(res.acceptedAtMs) : undefined,
+                note: "send_status ≠ final user-visible success",
+            }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    async history(input) {
+        const request_id = newRequestId();
+        try {
+            const limit = validateLimit(input.limit);
+            // NOTE: server-side `limit`/`session_id` are still not sent (semantics of 0 unverified); client caps.
+            const res = await this.client.listGrokBotTranscriptEntries({
+                agentId: input.agentId,
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const entries = (res.entries ?? []).slice(0, limit).map((e) => {
+                const id = e.id || e.entryId || e.entry_id;
+                const preview = e.plaintext || e.text || e.preview ||
+                    (e.ciphertext || e.omitted ? undefined : undefined);
+                return {
+                    entry_id: id,
+                    kind: String(e.entryKind ?? e.kind ?? e.type ?? ""),
+                    omitted: Boolean(e.bodyOmitted || e.omitted || e.ciphertext),
+                    preview: preview ? String(preview).slice(0, 200) : undefined,
+                    untrusted: true,
+                };
+            });
+            return this.sim(okResult({
+                entries,
+                generation: res.generation,
+                note: "Ciphertext/omitted entries are not decrypted. Bodies marked untrusted.",
+            }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    fromErr(e, request_id, write = false) {
+        const err = e instanceof GbcError ? e : mapConnectError(e, request_id, { write });
+        return this.sim(failResult(err.code, err.message, {
+            outcome: err.outcome,
+            retryable: err.retryable,
+            hint: err.hint,
+            request_id,
+            details: err.details,
+        }));
+    }
+}

package/dist/ops/plane.d.ts

@@ -0,0 +1,26 @@
+import { SyncOps } from "../sync/core.js";
+import type { AuthProvider } from "../auth/types.js";
+import { type ConnectConfig, type GrokBotClient } from "../connect/client.js";
+import { AuthOps } from "./auth.js";
+import { BotOps } from "./bot.js";
+import { MessageOps } from "./message.js";
+import { ProgressOps } from "./progress.js";
+import { SessionOps } from "./session.js";
+import { SidebarOps } from "./sidebar.js";
+export type ControlPlaneOptions = ConnectConfig & {
+    /** Marks all results as simulated (mock/in-memory). */
+    simulated?: boolean;
+};
+export declare class ControlPlane {
+    readonly client: GrokBotClient;
+    readonly sync: SyncOps;
+    readonly bot: BotOps;
+    readonly message: MessageOps;
+    readonly session: SessionOps;
+    readonly progress: ProgressOps;
+    readonly sidebar: SidebarOps;
+    readonly auth?: AuthProvider;
+    readonly authOps: AuthOps;
+    readonly simulated: boolean;
+    constructor(opts: ControlPlaneOptions);
+}

package/dist/ops/plane.js

@@ -0,0 +1,33 @@
+import { SyncOps } from "../sync/core.js";
+import { createGrokBotClient } from "../connect/client.js";
+import { AuthOps } from "./auth.js";
+import { BotOps } from "./bot.js";
+import { MessageOps } from "./message.js";
+import { ProgressOps } from "./progress.js";
+import { SessionOps } from "./session.js";
+import { SidebarOps } from "./sidebar.js";
+export class ControlPlane {
+    client;
+    sync;
+    bot;
+    message;
+    session;
+    progress;
+    sidebar;
+    auth;
+    authOps;
+    simulated;
+    constructor(opts) {
+        this.auth = opts.auth;
+        this.simulated = Boolean(opts.simulated);
+        this.client = createGrokBotClient(opts);
+        this.sync = new SyncOps(createGrokBotClient({ ...opts, readMaxBytes: 16 * 1024 * 1024 }), opts.baseUrl, this.simulated);
+        const f = { simulated: this.simulated };
+        this.authOps = new AuthOps(this.auth, f);
+        this.bot = new BotOps(this.client, f);
+        this.message = new MessageOps(this.client, f);
+        this.session = new SessionOps(this.client, f);
+        this.progress = new ProgressOps(this.client, f);
+        this.sidebar = new SidebarOps(this.client, f);
+    }
+}

package/dist/ops/progress.d.ts

@@ -0,0 +1,34 @@
+import type { GrokBotClient } from "../connect/client.js";
+import { type ResultEnvelope } from "../dto/result.js";
+import type { ProgressStatus } from "../dto/types.js";
+export declare class ProgressOps {
+    private client;
+    private flags;
+    constructor(client: GrokBotClient, flags?: {
+        simulated?: boolean;
+    });
+    private sim;
+    status(agentIds: string[]): Promise<ResultEnvelope<{
+        statuses: ProgressStatus[];
+    }>>;
+    todos(agentId: string): Promise<ResultEnvelope<{
+        todos: unknown[];
+    }>>;
+    tasks(agentId: string): Promise<ResultEnvelope<{
+        tasks: unknown[];
+    }>>;
+    subagents(agentId: string): Promise<ResultEnvelope<{
+        subagents: unknown[];
+    }>>;
+    interrupt(agentId: string, opts: {
+        confirm?: string;
+        reason?: string;
+        sessionId?: string;
+        dryRun?: boolean;
+        allowWrite?: boolean;
+    }): Promise<ResultEnvelope<{
+        had_active_run?: boolean;
+        note: string;
+    }>>;
+    private fromErr;
+}

package/dist/ops/progress.js

@@ -0,0 +1,92 @@
+import { mapConnectError } from "../connect/client.js";
+import { failResult, newRequestId, okResult } from "../dto/result.js";
+import { GbcError } from "../errors.js";
+import { mapStatus } from "./map.js";
+export class ProgressOps {
+    client;
+    flags;
+    constructor(client, flags = {}) {
+        this.client = client;
+        this.flags = flags;
+    }
+    sim(r) {
+        if (this.flags.simulated)
+            r.simulated = true;
+        return r;
+    }
+    async status(agentIds) {
+        const request_id = newRequestId();
+        try {
+            const res = await this.client.listGrokBotAgentStatuses({ agentIds });
+            return this.sim(okResult({ statuses: (res.statuses ?? []).map(mapStatus) }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    async todos(agentId) {
+        const request_id = newRequestId();
+        try {
+            const res = await this.client.listGrokBotAgentTodos({ agentId });
+            return this.sim(okResult({ todos: res.todos ?? [] }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    async tasks(agentId) {
+        const request_id = newRequestId();
+        try {
+            const res = await this.client.listGrokBotAgentTasks({ agentId });
+            return this.sim(okResult({ tasks: res.tasks ?? [] }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    async subagents(agentId) {
+        const request_id = newRequestId();
+        try {
+            const res = await this.client.listGrokBotSubagents({ agentId });
+            return this.sim(okResult({ subagents: res.subagents ?? [] }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id);
+        }
+    }
+    async interrupt(agentId, opts) {
+        const request_id = newRequestId();
+        if (opts.dryRun) {
+            return this.sim(okResult({ note: "dry-run: would InterruptGrokBotAgentRun (MCP cancel ≠ this)" }, { request_id, code: "dry_run" }));
+        }
+        if (opts.confirm !== agentId) {
+            return this.sim(failResult("denied", "interrupt requires --confirm=<agent_id>", { request_id }));
+        }
+        if (!opts.allowWrite && process.env.GBT_ALLOW_WRITES !== "1") {
+            return this.sim(failResult("denied", "need --allow-writes", { request_id }));
+        }
+        try {
+            const res = await this.client.interruptGrokBotAgentRun({
+                agentId,
+                reason: opts.reason ?? "gbc interrupt",
+                sessionId: opts.sessionId,
+            });
+            return this.sim(okResult({
+                had_active_run: res.hadActiveRun,
+                note: "InterruptGrokBotAgentRun invoked. Canceling an MCP/CLI HTTP request does NOT call this.",
+            }, { request_id }));
+        }
+        catch (e) {
+            return this.fromErr(e, request_id, true);
+        }
+    }
+    fromErr(e, request_id, write = false) {
+        const err = e instanceof GbcError ? e : mapConnectError(e, request_id, { write });
+        return this.sim(failResult(err.code, err.message, {
+            outcome: err.outcome,
+            retryable: err.retryable,
+            hint: err.hint,
+            request_id,
+        }));
+    }
+}

package/dist/ops/session.d.ts

@@ -0,0 +1,13 @@
+import type { GrokBotClient } from "../connect/client.js";
+import { type ResultEnvelope } from "../dto/result.js";
+import type { SessionSummary } from "../dto/types.js";
+export declare class SessionOps {
+    private client;
+    private flags;
+    constructor(client: GrokBotClient, flags?: {
+        simulated?: boolean;
+    });
+    list(agentId: string): Promise<ResultEnvelope<{
+        sessions: SessionSummary[];
+    }>>;
+}