feat(grok): native ACP parity (catalog, effort, usage, plan, multi-agent, compact)

apps/server/scripts/acp-mock-agent.ts

@@ -38,6 +38,7 @@ const emitOverlappingXAiPromptCompleteOutOfOrder =
 const failPrompt = process.env.T3_ACP_FAIL_PROMPT === "1";
 const failSetConfigOption = process.env.T3_ACP_FAIL_SET_CONFIG_OPTION === "1";
 const exitOnSetConfigOption = process.env.T3_ACP_EXIT_ON_SET_CONFIG_OPTION === "1";
+const emitSessionInfoUpdate = process.env.T3_ACP_EMIT_SESSION_INFO === "1";
 const promptResponseText = process.env.T3_ACP_PROMPT_RESPONSE_TEXT;
 const promptDelayMs = Number(process.env.T3_ACP_PROMPT_DELAY_MS ?? "0");
 const permissionOptionIds = {
@@ -68,6 +69,17 @@ function promptIdFromRequestMeta(
   return typeof promptId === "string" && promptId.length > 0 ? promptId : undefined;
 }
 
+function promptTextFromRequest(request: AcpSchema.PromptRequest): string {
+  const parts = Array.isArray(request.prompt) ? request.prompt : [];
+  return parts
+    .flatMap((part) =>
+      part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
+        ? [String(part.text)]
+        : [],
+    )
+    .join("");
+}
+
 function logExit(reason: string): void {
   if (!exitLogPath) {
     return;
@@ -79,6 +91,10 @@ function writeJsonRpcNotification(method: string, params: unknown): void {
   process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
 }
 
+function writeJsonRpcResponse(id: string | number, result: unknown): void {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+}
+
 process.once("SIGTERM", () => {
   logExit("SIGTERM");
   process.exit(0);
@@ -300,9 +316,33 @@ const program = Effect.gen(function* () {
     Effect.sync(() => {
       parameterizedModelPicker =
         request.clientCapabilities?._meta?.parameterizedModelPicker === true;
+      // #4109-class: unsolicited response with non-numeric id must not crash the client.
+      if (process.env.T3_ACP_EMIT_SKILLS_RELOAD_ID === "1") {
+        queueMicrotask(() => {
+          writeJsonRpcResponse("skills-reload", { ok: true });
+        });
+      }
+      const initMeta =
+        process.env.T3_ACP_EMIT_INIT_AVAILABLE_COMMANDS === "1"
+          ? {
+              availableCommands: [
+                {
+                  name: "compact",
+                  description: "Compress conversation history",
+                  input: { hint: "optional context" },
+                },
+                {
+                  name: "session-info",
+                  description: "Show session details",
+                  input: null,
+                },
+              ],
+            }
+          : undefined;
       return {
         protocolVersion: 1,
         agentCapabilities: { loadSession: true },
+        ...(initMeta ? { _meta: initMeta } : {}),
       };
     }),
   );
@@ -465,6 +505,21 @@ const program = Effect.gen(function* () {
         return yield* AcpError.AcpRequestError.internalError("Mock prompt failure");
       }
 
+      // Mirror real Grok: `/compact` is handled as a prompt and emits auto_compact_completed.
+      const promptText = promptTextFromRequest(request).trim();
+      if (/^\/compact(?:\s|$)/i.test(promptText)) {
+        writeJsonRpcNotification("_x.ai/session_notification", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "auto_compact_completed",
+            tokens_before: 12_000,
+            tokens_after: 4_000,
+            summary_preview: null,
+          },
+        });
+        return { stopReason: "end_turn" };
+      }
+
       if (emitStaleXAiPromptCompleteBeforeSecondHang && promptCount === 1) {
         return {
           stopReason: "end_turn",
@@ -865,6 +920,16 @@ const program = Effect.gen(function* () {
         },
       });
 
+      if (emitSessionInfoUpdate) {
+        yield* agent.client.sessionUpdate({
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "session_info_update",
+            title: "Mock Grok session title",
+          },
+        });
+      }
+
       yield* agent.client.sessionUpdate({
         sessionId: requestedSessionId,
         update: {
@@ -873,7 +938,17 @@ const program = Effect.gen(function* () {
         },
       });
 
-      return { stopReason: "end_turn" };
+      // Live Grok stamps usage on prompt result `_meta` (not only usage_update).
+      return {
+        stopReason: "end_turn",
+        _meta: {
+          totalTokens: 12_345,
+          inputTokens: 10_000,
+          outputTokens: 2_000,
+          cachedReadTokens: 8_000,
+          reasoningTokens: 345,
+        },
+      };
     }),
   );
 

apps/server/src/provider/Drivers/GrokDriver.ts

@@ -3,7 +3,10 @@ import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as PubSub from "effect/PubSub";
+import * as Ref from "effect/Ref";
 import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
 import { HttpClient } from "effect/unstable/http";
 import { ChildProcessSpawner } from "effect/unstable/process";
 
@@ -17,6 +20,8 @@ import {
   buildInitialGrokProviderSnapshot,
   checkGrokProviderStatus,
   enrichGrokSnapshot,
+  ensureGrokStaticSlashCommands,
+  mapAcpCommandsToCatalog,
 } from "../Layers/GrokProvider.ts";
 import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
 import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
@@ -106,27 +111,75 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
         env: processEnv,
       });
 
+      const commandCatalogRef = yield* Ref.make({
+        received: false,
+        slashCommands: [] as ServerProvider["slashCommands"],
+        skills: [] as ServerProvider["skills"],
+      });
+      // Live available_commands_update (and initialize meta seed) must push a
+      // snapshot change so clients do not wait for the next health probe.
+      const commandCatalogChanges = yield* Effect.acquireRelease(
+        PubSub.unbounded<void>(),
+        PubSub.shutdown,
+      );
+
+      const mergeCommandCatalog = (snapshot: ServerProvider): Effect.Effect<ServerProvider> =>
+        Ref.get(commandCatalogRef).pipe(
+          Effect.map((catalog) => {
+            // Until a live catalog arrives, keep discovery/probe catalogs on the snapshot.
+            if (!catalog.received) {
+              return {
+                ...snapshot,
+                slashCommands: ensureGrokStaticSlashCommands(snapshot.slashCommands),
+              };
+            }
+            // Once received, apply even when empty so clients clear stale entries,
+            // but always re-attach static commands (e.g. compact) if missing.
+            return {
+              ...snapshot,
+              slashCommands: ensureGrokStaticSlashCommands(catalog.slashCommands),
+              skills: catalog.skills,
+            };
+          }),
+        );
+
       const adapter = yield* makeGrokAdapter(effectiveConfig, {
         environment: processEnv,
         ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}),
         instanceId,
+        onAvailableCommands: (commands) =>
+          Effect.gen(function* () {
+            const catalog = mapAcpCommandsToCatalog(commands);
+            yield* Ref.set(commandCatalogRef, {
+              received: true,
+              slashCommands: ensureGrokStaticSlashCommands(catalog.slashCommands),
+              skills: catalog.skills,
+            });
+            yield* PubSub.publish(commandCatalogChanges, undefined);
+          }),
       });
       const textGeneration = yield* makeGrokTextGeneration(effectiveConfig, processEnv);
 
       const checkProvider = checkGrokProviderStatus(effectiveConfig, processEnv).pipe(
         Effect.map(stampIdentity),
+        Effect.flatMap(mergeCommandCatalog),
         Effect.provideService(Crypto.Crypto, crypto),
         Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
       );
 
       const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
-      const snapshot = yield* makeManagedServerProvider<ProviderSnapshotSettings<GrokSettings>>({
+      const managedSnapshot = yield* makeManagedServerProvider<
+        ProviderSnapshotSettings<GrokSettings>
+      >({
         maintenanceCapabilities,
         getSettings: snapshotSettings.getSettings,
         streamSettings: snapshotSettings.streamSettings,
         haveSettingsChanged: haveProviderSnapshotSettingsChanged,
         initialSnapshot: (settings) =>
-          buildInitialGrokProviderSnapshot(settings.provider).pipe(Effect.map(stampIdentity)),
+          buildInitialGrokProviderSnapshot(settings.provider).pipe(
+            Effect.map(stampIdentity),
+            Effect.flatMap(mergeCommandCatalog),
+          ),
         checkProvider,
         enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) =>
           enrichGrokSnapshot({
@@ -148,6 +201,22 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
         ),
       );
 
+      const snapshot = {
+        ...managedSnapshot,
+        getSnapshot: managedSnapshot.getSnapshot.pipe(Effect.flatMap(mergeCommandCatalog)),
+        get streamChanges() {
+          const managedChanges = Stream.mapEffect(
+            managedSnapshot.streamChanges,
+            mergeCommandCatalog,
+          );
+          const catalogDrivenChanges = Stream.mapEffect(
+            Stream.fromPubSub(commandCatalogChanges),
+            () => managedSnapshot.getSnapshot.pipe(Effect.flatMap(mergeCommandCatalog)),
+          );
+          return Stream.merge(managedChanges, catalogDrivenChanges);
+        },
+      };
+
       return {
         instanceId,
         driverKind: DRIVER_KIND,

apps/server/src/provider/Layers/CursorAdapter.ts

@@ -863,6 +863,7 @@ export function makeCursorAdapter(
                         turnId: ctx.activeTurnId,
                         ...(event.itemId ? { itemId: event.itemId } : {}),
                         text: event.text,
+                        streamKind: event.streamKind,
                         rawPayload: event.rawPayload,
                       }),
                     );