@desplega.ai/agent-swarm 1.164.1 → 1.166.0

package/src/tools/utils.ts

@@ -20,6 +20,7 @@ import type {
 import * as z from "zod";
 import { sweepExpiredKvPrefix, upsertKv } from "../be/db";
 import { MCP_OVERFLOW_NAMESPACE, mcpOverflowNamespace } from "../kv-overflow";
+import { joinKvPath, type KvShapeEntry, splitKvPath, summarizeKvShape } from "../kv-view";
 import { withSpan } from "../otel";
 import type { PermissionVerb } from "../rbac/permissions";
 import { SCRIPT_LONG_TIMEOUT_HINT_MS } from "../scripts-runtime/executors/types";
@@ -138,6 +139,8 @@ export type SwarmToolTruncation = {
   originalBytes: number;
   limitBytes: number;
   retrieval: string;
+  /** Biggest branches of the stored value; each `path` is a kv-get `path`. */
+  shape?: KvShapeEntry[];
 };
 
 export type SwarmToolResult<TData extends SwarmToolData = SwarmToolData> = {
@@ -153,6 +156,12 @@ export type SwarmToolResult<TData extends SwarmToolData = SwarmToolData> = {
   nudge?: string;
   /** Ctx-control metadata attached centrally when the full wire result is spilled. */
   truncation?: SwarmToolTruncation;
+  /**
+   * Set by ctx-control only. Keeps `details` out of structuredContent when
+   * that channel already carries `data` verbatim and the duplicate rendering
+   * is what pushes it over the size budget. The text channel keeps `details`.
+   */
+  omitStructuredDetails?: boolean;
   /**
    * Skip the finalize pipeline's secret scrubbing for this result. ONLY for
    * deliberate credential-reveal branches (oauth-access-token, script-apis
@@ -186,6 +195,16 @@ const swarmToolTruncationSchema = z.looseObject({
   originalBytes: z.number(),
   limitBytes: z.number(),
   retrieval: z.string(),
+  shape: z
+    .array(
+      z.looseObject({
+        path: z.string().optional(),
+        type: z.string().optional(),
+        bytes: z.number().optional(),
+        items: z.number().optional(),
+      }),
+    )
+    .optional(),
 });
 
 export const swarmToolEnvelopeShape = {
@@ -341,15 +360,21 @@ export const NUDGES: Record<string, (result: SwarmToolResult) => string | undefi
     const rendered =
       typeof entry.value === "string" ? entry.value : (JSON.stringify(entry.value) ?? "");
     return rendered.length > MCP_RESULT_WIRE_LIMIT_BYTES
-      ? "Large value — your harness may truncate this result; to filter or aggregate it, process it in a script via ctx.swarm.kv_get instead."
+      ? "Large value — your harness may truncate this result; re-call kv-get with path/offset/limit for a bounded slice, or process it in a script via ctx.swarm.kv_get."
       : undefined;
   },
 };
 
+/**
+ * Per-channel budget: every harness reads ONE channel (text or structured,
+ * runbook §3), so each channel must fit on its own. See `wireChannelBytes`.
+ */
 export const MCP_RESULT_WIRE_LIMIT_BYTES = 10_000;
 export { MCP_OVERFLOW_NAMESPACE, mcpOverflowNamespace };
 export const MCP_OVERFLOW_TTL_MS = 24 * 60 * 60 * 1_000;
-const MCP_PROSE_PREVIEW_CHARS = 1_200;
+// Floor for the prose preview while the array path sizes its arrays; the
+// preview then grows into whatever budget the arrays leave.
+const MCP_PROSE_PREVIEW_FLOOR_CHARS = 1_200;
 
 type FinalizeContext = {
   toolName: string;
@@ -391,7 +416,14 @@ function composeWireResult(r: SwarmToolResult): CallToolResult {
   // Payload LAST: harnesses truncate oversized text from the tail (or keep
   // head+tail), so message and nudge lead and a cut lands inside the payload
   // rendering — a truncated JSON prefix still shows its first key values.
-  const text = [r.message, r.nudge, normalizedDetails ?? dataFallback]
+  // A spill pointer follows the bounded preview; the text channel renders it
+  // once, the structured channel carries only the `truncation` object.
+  const text = [
+    r.message,
+    r.nudge,
+    normalizedDetails ?? dataFallback,
+    r.truncation ? renderTruncationPointer(r.truncation) : undefined,
+  ]
     .filter((part): part is string => Boolean(part?.trim()))
     .join("\n\n");
   const structuredContent: Record<string, unknown> = {
@@ -399,7 +431,7 @@ function composeWireResult(r: SwarmToolResult): CallToolResult {
     success: r.ok,
     message: r.message,
   };
-  if (normalizedDetails) structuredContent.details = normalizedDetails;
+  if (normalizedDetails && !r.omitStructuredDetails) structuredContent.details = normalizedDetails;
   if (r.nudge) structuredContent.nudge = r.nudge;
   if (r.truncation) structuredContent.truncation = r.truncation;
 
@@ -410,20 +442,121 @@ function composeWireResult(r: SwarmToolResult): CallToolResult {
   };
 }
 
+function renderTruncationPointer(t: SwarmToolTruncation): string {
+  const shape = t.shape?.length ? `\nShape: ${renderShape(t.shape)}` : "";
+  return `Full value: ${t.fullValueAt} (${t.originalBytes} bytes)${shape}\nRetrieval: ${t.retrieval}`;
+}
+
+/**
+ * Bytes the model sees from one wire result: the larger of the two channels.
+ * pi/opencode/claude-managed read only `content.text`; Codex reads only the
+ * JSON-encoded `structuredContent` (runbook §3). Summing both would spill a
+ * result at half the payload any single harness actually receives.
+ */
+export function wireChannelBytes(wire: {
+  content?: ReadonlyArray<{ type: string; text?: string }>;
+  structuredContent?: unknown;
+}): number {
+  const text = (wire.content ?? [])
+    .map((block) => (block.type === "text" ? (block.text ?? "") : ""))
+    .join("");
+  return Math.max(
+    Buffer.byteLength(text, "utf8"),
+    Buffer.byteLength(JSON.stringify(wire.structuredContent ?? {}), "utf8"),
+  );
+}
+
+/** `wireChannelBytes` of the wire result a SwarmToolResult composes to. */
+export function swarmToolResultBytes(r: SwarmToolResult): number {
+  return wireChannelBytes(composeWireResult(r));
+}
+
+function fitsWireLimit(r: SwarmToolResult): boolean {
+  return swarmToolResultBytes(r) <= MCP_RESULT_WIRE_LIMIT_BYTES;
+}
+
+/** A prefix of `source` that never ends on a lone high surrogate. */
+function safePrefix(source: string, chars: number): string {
+  const end = Math.min(chars, source.length);
+  const code = source.charCodeAt(end - 1);
+  return code >= 0xd800 && code <= 0xdbff ? source.slice(0, end - 1) : source.slice(0, end);
+}
+
+function previewWithMarker(source: string, chars: number): string {
+  const preview = safePrefix(source, chars);
+  const omitted = source.length - preview.length;
+  return omitted > 0 ? `${preview}\n… [truncated ${omitted} chars]` : preview;
+}
+
+/**
+ * Largest preview of `source` whose rendered result still fits the per-channel
+ * budget (binary search on characters). Falls back to the empty preview when
+ * nothing fits, so the pointer still goes out.
+ */
+function fillPreviewToBudget(
+  source: string,
+  render: (preview: string) => SwarmToolResult,
+): SwarmToolResult {
+  let low = 0;
+  let high = source.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (fitsWireLimit(render(previewWithMarker(source, mid)))) low = mid;
+    else high = mid - 1;
+  }
+  return render(previewWithMarker(source, low));
+}
+
 function overflowKey(toolName: string, value: string): string {
   const safeToolName = toolName.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 80);
   const hash = new Bun.CryptoHasher("sha256").update(value).digest("hex");
   return `v1/${safeToolName}/${hash}`;
 }
 
-function overflowRetrieval(namespace: string, key: string): string {
+/**
+ * Point the model at a targeted fetch: the biggest array in the shape, else the
+ * biggest object or string, which kv-get returns as a bounded, pageable slice.
+ * A shape of only scalar leaves (a wide object) points at their parent object,
+ * since kv-get rejects offset on a scalar.
+ */
+function overflowRetrieval(namespace: string, key: string, shape: KvShapeEntry[]): string {
+  const target =
+    shape.find((entry) => entry.type === "array") ??
+    shape.find((entry) => entry.type === "object" || entry.type === "string") ??
+    (shape[0] && { path: joinKvPath(splitKvPath(shape[0].path).slice(0, -1)) });
+  if (!target) {
+    return (
+      `kv-get(${JSON.stringify({ namespace, key })}) returns the full value ` +
+      `(your harness may truncate it); in a script, ctx.swarm.kv_get keeps it out of your context.`
+    );
+  }
   return (
-    `kv-get(${JSON.stringify({ namespace, key })}) returns the full value ` +
-    `(your harness may truncate it); to filter or aggregate it instead, ` +
-    `process it in a script via ctx.swarm.kv_get.`
+    `kv-get(${JSON.stringify({ namespace, key, path: target.path, offset: 0 })}) returns a ` +
+    `bounded page (nextOffset pages on; any Shape path works; no path = the full value). ` +
+    `ctx.swarm.kv_get takes the same args in a script.`
   );
 }
 
+function formatBytes(bytes: number): string {
+  return bytes >= 1_024 ? `${(bytes / 1_024).toFixed(1)}KB` : `${bytes}B`;
+}
+
+function renderShape(shape: KvShapeEntry[]): string {
+  return shape
+    .map((entry) => {
+      const count =
+        entry.items === undefined
+          ? ""
+          : entry.type === "array"
+            ? `[${entry.items}]`
+            : entry.type === "object"
+              ? `{${entry.items} keys}`
+              : ` ${entry.items} chars`;
+      return `${entry.path} ${entry.type}${count} ${formatBytes(entry.bytes)}`;
+    })
+    .join("; ");
+}
+
 function canonicalOverflowPayload(toolName: string, result: SwarmToolResult): string {
   // `allowSecretEgress` deliberately bypasses the normal wire scrubber. Never
   // persist that escape hatch: overflow KV is readable by authenticated agents,
@@ -549,15 +682,13 @@ function arrayPreservingOverflowResult(
   data: SwarmToolData,
   targets: ArrayTarget[],
   truncation: SwarmToolTruncation,
-  pointer: string,
+  detailsPreview: string | undefined,
 ): SwarmToolResult {
-  const normalizedDetails = result.details?.trim() || undefined;
-  const details = normalizedDetails
-    ? `${normalizedDetails.slice(0, MCP_PROSE_PREVIEW_CHARS)}\n… [truncated ${Math.max(
-        normalizedDetails.length - MCP_PROSE_PREVIEW_CHARS,
-        0,
-      )} chars]\n${pointer}`
-    : `JSON payload truncated in place:\n${JSON.stringify(data, null, 2)}\n${pointer}`;
+  // The structured channel carries the shortened data verbatim, so `details`
+  // (tool prose, or the data rendered for text-only harnesses) stays out of
+  // it and each channel spends its own budget on payload.
+  const details =
+    detailsPreview ?? `JSON payload truncated in place:\n${JSON.stringify(data, null, 2)}`;
   return {
     ok: result.ok,
     message: arrayTruncationMessage(result.message, targets),
@@ -565,6 +696,7 @@ function arrayPreservingOverflowResult(
     data,
     nudge: result.nudge,
     truncation,
+    omitStructuredDetails: true,
   };
 }
 
@@ -576,7 +708,6 @@ function arrayPreservingOverflowResult(
 function truncateArraysInPlace(
   result: SwarmToolResult,
   truncation: SwarmToolTruncation,
-  pointer: string,
 ): SwarmToolResult | undefined {
   if (!result.data) return undefined;
   const data = cloneResultData(result.data) as SwarmToolData;
@@ -590,10 +721,15 @@ function truncateArraysInPlace(
       Buffer.byteLength(JSON.stringify(a.originalItems), "utf8"),
   );
 
-  const render = () => arrayPreservingOverflowResult(result, data, targets, truncation, pointer);
-  const fits = () =>
-    Buffer.byteLength(JSON.stringify(composeWireResult(render())), "utf8") <=
-    MCP_RESULT_WIRE_LIMIT_BYTES;
+  // Size the arrays against a fixed prose floor, then let the prose preview
+  // grow into whatever budget the arrays leave.
+  const prose = result.details?.trim() || undefined;
+  const renderWith = (preview: string | undefined) =>
+    arrayPreservingOverflowResult(result, data, targets, truncation, preview);
+  const render = () =>
+    renderWith(prose ? previewWithMarker(prose, MCP_PROSE_PREVIEW_FLOOR_CHARS) : undefined);
+  const fits = () => fitsWireLimit(render());
+  const finish = () => (prose ? fillPreviewToBudget(prose, renderWith) : render());
 
   for (const target of targets) {
     setArrayLength(target, 0);
@@ -608,10 +744,10 @@ function truncateArraysInPlace(
       else high = mid - 1;
     }
     setArrayLength(target, low);
-    return render();
+    return finish();
   }
 
-  if (fits()) return render();
+  if (fits()) return finish();
 
   // A large scalar sibling can keep the result oversized even after every
   // array is emptied. Prefer dropping those non-array branches over dropping
@@ -630,7 +766,7 @@ function truncateArraysInPlace(
     }
     setArrayLength(target, low);
   }
-  return render();
+  return finish();
 }
 
 const ctxControlMiddleware: FinalizeMiddleware = async (result, ctx) => {
@@ -640,21 +776,30 @@ const ctxControlMiddleware: FinalizeMiddleware = async (result, ctx) => {
   if (ctx.callOrigin === "script-sdk" || ctx.callOrigin === "extension") return result;
   if (CTX_CONTROL_EXEMPT_TOOLS.has(ctx.toolName)) return result;
 
-  const fullWire = composeWireResult(result);
-  const fullWireJson = JSON.stringify(fullWire);
-  const fullWireBytes = Buffer.byteLength(fullWireJson, "utf8");
+  const fullWireBytes = swarmToolResultBytes(result);
   if (fullWireBytes <= MCP_RESULT_WIRE_LIMIT_BYTES) {
     return result;
   }
 
+  // Lossless first: tools like script-run put the payload in `data` AND a
+  // rendering of it in `details`, so structuredContent carries it twice. That
+  // channel stays self-sufficient with `data` alone; drop the duplicate there
+  // before spilling anything.
+  if (result.details?.trim() && result.data && Object.keys(result.data).length > 0) {
+    const deduped: SwarmToolResult = { ...result, omitStructuredDetails: true };
+    if (fitsWireLimit(deduped)) return deduped;
+  }
+
+  const storedValue = canonicalOverflowPayload(ctx.toolName, result);
+  // Paths are relative to the stored value, so each one is a kv-get `path`.
+  const shape = summarizeKvShape(JSON.parse(storedValue));
   let fullValueAt: string;
   let retrieval: string;
   if (ctx.agentId) {
-    const storedValue = canonicalOverflowPayload(ctx.toolName, result);
     const key = overflowKey(ctx.toolName, storedValue);
     const namespace = mcpOverflowNamespace(ctx.agentId);
     fullValueAt = `kv://${namespace}/${key}`;
-    retrieval = overflowRetrieval(namespace, key);
+    retrieval = overflowRetrieval(namespace, key, shape);
     const expiresAt = Date.now() + MCP_OVERFLOW_TTL_MS;
 
     // The public KV write surfaces cap values at 2 MiB, while the SQLite TEXT
@@ -680,28 +825,26 @@ const ctxControlMiddleware: FinalizeMiddleware = async (result, ctx) => {
     originalBytes: fullWireBytes,
     limitBytes: MCP_RESULT_WIRE_LIMIT_BYTES,
     retrieval,
+    ...(shape.length > 0 ? { shape } : {}),
   };
-  const pointer =
-    `Full value: ${fullValueAt}\nRetrieval: ${retrieval}\n` +
-    `Truncation: ${JSON.stringify(truncation)}`;
-  const arrayPreservingResult = truncateArraysInPlace(result, truncation, pointer);
+  const arrayPreservingResult = truncateArraysInPlace(result, truncation);
   if (arrayPreservingResult) return arrayPreservingResult;
 
-  const normalizedDetails = result.details?.trim() || undefined;
-  const details = normalizedDetails
-    ? `${normalizedDetails.slice(0, MCP_PROSE_PREVIEW_CHARS)}\n… [truncated ${Math.max(
-        normalizedDetails.length - MCP_PROSE_PREVIEW_CHARS,
-        0,
-      )} chars]\n${pointer}`
-    : `JSON payload omitted because the composed result exceeded ${MCP_RESULT_WIRE_LIMIT_BYTES} bytes.\n${pointer}`;
-
-  return {
+  const spilled = (details: string): SwarmToolResult => ({
     ok: result.ok,
     message: result.message,
     details,
     nudge: result.nudge,
     truncation,
-  };
+  });
+  const prose = result.details?.trim() || undefined;
+  if (prose) return fillPreviewToBudget(prose, spilled);
+  // Data without arrays to shorten: show the head of its JSON rendering as
+  // labelled prose. Structured `data` stays omitted, since a cut JSON value
+  // there would read as a real (wrong) value.
+  const json = result.data ? JSON.stringify(result.data, null, 2) : "";
+  if (!json) return spilled("Payload omitted.");
+  return fillPreviewToBudget(json, (preview) => spilled(`JSON payload head:\n${preview}`));
 };
 
 // Ordered and security-sensitive: ctx-control runs only after the result and

package/src/tools/workflows/get-workflow-run.ts

@@ -54,11 +54,12 @@ export const registerGetWorkflowRunTool = (server: McpServer) => {
     },
     async ({ id }) => {
       try {
-        const run = await getWorkflowRun(id);
+        // Display view: the scrubbed context and step outputs, never replay state.
+        const run = await getWorkflowRun(id, "display");
         if (!run) {
           return toolErr(`Workflow run not found: ${id}`, { data: { steps: [] } });
         }
-        const steps = await getWorkflowRunStepsByRunId(id);
+        const steps = await getWorkflowRunStepsByRunId(id, "display");
         return toolOk(`Run ${id} status: ${run.status}.`, {
           details: renderSteps(steps),
           data: { run, steps },

package/src/types.ts

@@ -175,6 +175,15 @@ export const DEFAULT_MODEL_TIER_MAP: Record<ProviderName, Record<ModelTier, stri
     smart: "high",
     ultra: "ultra",
   },
+  // xAI's text models as `grok models` lists them for an API key, cheapest
+  // first: grok-build-0.1 ($1/$2 per 1M), grok-4.3 ($1.25/$2.50), then the
+  // grok-4.6/4.7 frontier pair ($2/$6).
+  grok: {
+    smol: "grok-build-0.1",
+    regular: "grok-4.3",
+    smart: "grok-4.6",
+    ultra: "grok-4.7",
+  },
   // ACP has no portable tier-to-model mapping. Operators may set an explicit
   // MODEL_OVERRIDE, which the adapter applies through an advertised `model`
   // config option with a target-specific startup fallback.
@@ -413,6 +422,7 @@ export const ProviderNameSchema = z.enum([
   "dsh",
   "amp",
   "cursor",
+  "grok",
 ]);
 export type ProviderName = z.infer<typeof ProviderNameSchema>;
 
@@ -510,6 +520,9 @@ export const PROVIDER_STEER_CAPABILITIES: Record<ProviderName, SteerMode[]> = {
   // `run.steer()` reaches the in-flight run; a message the SDK reverts to a
   // follow-up, and every queued one, starts the next run on the same agent.
   cursor: ["steer", "queue"],
+  // Grok runs on the ACP client: one `session/prompt` turn, interrupted only
+  // by `session/cancel`. No Grok surface (ACP or headless) exposes a steer.
+  grok: [],
 };
 
 export type DevinProviderMeta = {
@@ -532,6 +545,7 @@ export type ProviderMetaMap = {
   dsh: NoProviderMeta;
   amp: NoProviderMeta;
   cursor: NoProviderMeta;
+  grok: NoProviderMeta;
 };
 
 export const FollowUpConfigSchema = z
@@ -1307,7 +1321,7 @@ export type AcpSessionConfigOption = z.infer<typeof AcpSessionConfigOptionSchema
 
 export const AgentAcpStatusSchema = z
   .object({
-    target: z.enum(["opencode", "custom"]),
+    target: z.enum(["opencode", "gemini", "copilot", "custom"]),
     configOptions: z.array(AcpSessionConfigOptionSchema),
     reportedAt: z.number(),
   })
@@ -3476,6 +3490,7 @@ export const PricingProviderSchema = z.enum([
   "dsh",
   "amp",
   "cursor",
+  "grok",
 ]);
 export type PricingProvider = z.infer<typeof PricingProviderSchema>;
 

package/src/utils/console-scrub-install.ts

@@ -0,0 +1,5 @@
+// Side-effect entry: import first so every later console wrapper and every
+// module-load log line goes through the scrub.
+import { installConsoleScrub } from "./console-scrub";
+
+installConsoleScrub();

package/src/utils/console-scrub.ts

@@ -0,0 +1,57 @@
+import { format } from "node:util";
+import { scrubSecrets } from "./secret-scrubber";
+
+/**
+ * Process-wide console scrub: every `console.log/info/warn/error/debug` line
+ * is formatted, scrubbed, and handed to the previous method as one string.
+ *
+ * Install it before anything else wraps the console (the OTel log bridge, the
+ * Ink console patch), so every later wrapper sees only scrubbed text.
+ */
+
+const METHODS = ["log", "info", "warn", "error", "debug"] as const;
+type ConsoleMethod = (typeof METHODS)[number];
+
+const SCRUB_FAILED = "[console-scrub] failed to scrub log line";
+const NESTED_SUPPRESSED = "[console-scrub] suppressed a log line written while formatting another";
+
+let restore: (() => void) | undefined;
+
+export function installConsoleScrub(): void {
+  if (restore) return;
+  const originals = new Map<ConsoleMethod, (...args: unknown[]) => void>();
+  let scrubbing = false;
+  for (const method of METHODS) {
+    const original = console[method];
+    originals.set(method, original);
+    console[method] = (...args: unknown[]) => {
+      if (args.length === 0) return original.call(console);
+      // `format` runs custom inspectors synchronously, and one that logs lands
+      // here mid-scrub. Its arguments are unscrubbed and formatting them again
+      // could recurse, so fail closed with a fixed line instead.
+      if (scrubbing) return original.call(console, NESTED_SUPPRESSED);
+      scrubbing = true;
+      let line: string;
+      try {
+        // `format` keeps %s/%d substitution, inspects objects and prints
+        // Error stacks, so the scrub sees exactly what would be printed.
+        line = scrubSecrets(format(...args));
+      } catch {
+        // Never fall back to the raw arguments.
+        line = SCRUB_FAILED;
+      } finally {
+        scrubbing = false;
+      }
+      original.call(console, line);
+    };
+  }
+  restore = () => {
+    for (const [method, original] of originals) console[method] = original;
+    restore = undefined;
+  };
+}
+
+/** Restore the console methods captured at install time (tests only). */
+export function uninstallConsoleScrub(): void {
+  restore?.();
+}

package/src/utils/credentials.ts

@@ -13,6 +13,7 @@ export const CREDENTIAL_POOL_VARS = [
   "DEEPSEEK_API_KEY",
   "AMP_API_KEY",
   "CURSOR_API_KEY",
+  "XAI_API_KEY",
 ] as const;
 
 /**
@@ -34,6 +35,7 @@ export const PROVIDER_CREDENTIAL_VARS: Record<string, readonly string[]> = {
   dsh: ["OPENROUTER_API_KEY", "DEEPSEEK_API_KEY"],
   amp: ["AMP_API_KEY"],
   cursor: ["CURSOR_API_KEY"],
+  grok: ["XAI_API_KEY", "OPENROUTER_API_KEY"],
   opencode: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
 };
 
@@ -69,6 +71,10 @@ export function getModelAwareCredentialVars(provider: string, model?: string): r
   if (provider === "dsh" && model) {
     return model.startsWith("openrouter/") ? ["OPENROUTER_API_KEY"] : ["DEEPSEEK_API_KEY"];
   }
+  // grok routes `openrouter/<id>` to OpenRouter and every other model to xAI.
+  if (provider === "grok" && model) {
+    return model.startsWith("openrouter/") ? ["OPENROUTER_API_KEY"] : ["XAI_API_KEY"];
+  }
   if (!SLASH_MODEL_PROVIDERS.has(provider) || !model) return base;
   if (model.includes("/")) {
     return base.filter((v) => v !== "OPENAI_API_KEY");
@@ -100,6 +106,8 @@ export function deriveProviderFromKeyType(keyType: string): string {
       return "amp";
     case "CURSOR_API_KEY":
       return "cursor";
+    case "XAI_API_KEY":
+      return "grok";
     case "DEVIN_API_KEY":
       return "devin";
     default:

package/src/utils/page-session.ts

@@ -47,6 +47,8 @@ export interface PageSessionPayload {
   uid?: string;
   /** Display name for a user or generated guest session. */
   name?: string;
+  /** Set only when the shared swarm key launched the session. A session with neither this nor `uid` is a guest. */
+  op?: true;
 }
 
 /** base64url encode a byte buffer (no padding). */
@@ -212,7 +214,8 @@ export async function verifyPageSession(
     return null;
   }
 
-  const candidate = payload as { uid?: unknown; name?: unknown };
+  const candidate = payload as { uid?: unknown; name?: unknown; op?: unknown };
+  if (candidate.op !== undefined && candidate.op !== true) return null;
   if (candidate.uid !== undefined && typeof candidate.uid !== "string") return null;
   if (candidate.name !== undefined && typeof candidate.name !== "string") return null;
 
@@ -286,7 +289,7 @@ const PAGE_SESSION_TTL_SECONDS = 3600;
  */
 export async function issuePageSessionCookie(
   pageId: string,
-  opts: { dev: boolean; uid?: string; name?: string },
+  opts: { dev: boolean; uid?: string; name?: string; op?: true },
 ): Promise<string> {
   const exp = Math.floor(Date.now() / 1000) + PAGE_SESSION_TTL_SECONDS;
   const token = await signPageSession({
@@ -294,6 +297,7 @@ export async function issuePageSessionCookie(
     exp,
     ...(opts.uid ? { uid: opts.uid } : {}),
     ...(opts.name ? { name: opts.name } : {}),
+    ...(opts.op ? { op: true as const } : {}),
   });
   const attrs = [
     `page_session=${token}`,