feat(server): Grok Build effort, auth, rewind, and usage [WIP - for content]

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

@@ -279,9 +279,26 @@ function modeState(): AcpSchema.SessionModeState {
 }
 
 const grokAcpModels: ReadonlyArray<AcpSchema.ModelInfo> = [
-  { modelId: "grok-build", name: "Grok Build" },
+  {
+    modelId: "grok-build",
+    name: "Grok Build",
+    _meta: {
+      supportsReasoningEffort: true,
+      reasoningEffort: "high",
+      totalContextTokens: 500000,
+      reasoningEfforts: [
+        { id: "xhigh", value: "xhigh", label: "Extra High Effort" },
+        { id: "high", value: "high", label: "High Effort", default: true },
+        { id: "medium", value: "medium", label: "Medium Effort" },
+        { id: "low", value: "low", label: "Low Effort" },
+      ],
+    },
+  },
   { modelId: "grok-mock-alt", name: "Grok Mock Alt" },
 ];
+const enableRewind = process.env.T3_ACP_ENABLE_REWIND === "1";
+const emitUsage = process.env.T3_ACP_EMIT_USAGE === "1";
+let rewindPoints: Array<{ prompt_index: number; prompt_preview: string }> = [];
 
 function modelState(): AcpSchema.SessionModelState {
   const modelId = grokAcpModels.some((model) => model.modelId === currentModelId)
@@ -392,7 +409,12 @@ const program = Effect.gen(function* () {
         );
       }
       currentModelId = request.modelId;
-      return {};
+      return {
+        _meta: {
+          model: { Ok: request.modelId },
+          ...(request._meta ?? {}),
+        },
+      };
     }),
   );
 
@@ -873,11 +895,52 @@ const program = Effect.gen(function* () {
         },
       });
 
-      return { stopReason: "end_turn" };
+      if (enableRewind) {
+        const preview =
+          request.prompt.find((block) => block.type === "text" && "text" in block)?.text ?? "";
+        rewindPoints.push({
+          prompt_index: rewindPoints.length,
+          prompt_preview: typeof preview === "string" ? preview : "",
+        });
+      }
+
+      return {
+        stopReason: "end_turn",
+        ...(emitUsage
+          ? {
+              _meta: {
+                usage: {
+                  input_tokens: 10,
+                  output_tokens: 4,
+                  reasoning_tokens: 3,
+                },
+              },
+            }
+          : {}),
+      };
     }),
   );
 
   yield* agent.handleUnknownExtRequest((method, params) => {
+    if (method === "_x.ai/rewind/points") {
+      return Effect.succeed({ rewind_points: rewindPoints });
+    }
+    if (method === "_x.ai/rewind/execute") {
+      const record = typeof params === "object" && params !== null ? params : {};
+      const target =
+        "targetPromptIndex" in record && typeof record.targetPromptIndex === "number"
+          ? record.targetPromptIndex
+          : undefined;
+      if (target === undefined) {
+        return Effect.succeed({ success: false, error: "missing targetPromptIndex" });
+      }
+      rewindPoints = rewindPoints.filter((point) => point.prompt_index < target);
+      return Effect.succeed({
+        success: true,
+        target_prompt_index: target,
+        mode: "conversation_only",
+      });
+    }
     if (method === "cursor/list_available_models") {
       return Effect.succeed({
         models: availableModels(),

apps/server/src/provider/Layers/GrokAdapter.test.ts

@@ -1197,4 +1197,120 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
       yield* adapter.stopSession(threadId);
     }),
   );
+
+  it.effect("sends session/set_model _meta.reasoningEffort", () =>
+    Effect.gen(function* () {
+      const threadId = ThreadId.make("grok-effort-set-model");
+      const tempDir = yield* Effect.promise(() =>
+        NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "grok-effort-")),
+      );
+      const requestLogPath = NodePath.join(tempDir, "requests.ndjson");
+      const wrapperPath = yield* Effect.promise(() =>
+        makeMockGrokWrapper({ T3_ACP_REQUEST_LOG_PATH: requestLogPath }),
+      );
+      const adapter = yield* makeTestAdapter(wrapperPath);
+
+      yield* adapter.startSession({
+        threadId,
+        provider: ProviderDriverKind.make("grok"),
+        cwd: process.cwd(),
+        runtimeMode: "full-access",
+        modelSelection: {
+          instanceId: ProviderInstanceId.make("grok"),
+          model: "grok-build",
+          options: [{ id: "reasoningEffort", value: "xhigh" }],
+        },
+      });
+
+      yield* waitForFileContent(requestLogPath, 80, "session/set_model");
+      const lines = yield* Effect.promise(() => readJsonLines(requestLogPath));
+      const setModel = lines.find((line) => line.method === "session/set_model");
+      assert.isDefined(setModel);
+      assert.equal(
+        (setModel?.params as { _meta?: { reasoningEffort?: string } } | undefined)?._meta
+          ?.reasoningEffort,
+        "xhigh",
+      );
+
+      yield* adapter.stopSession(threadId);
+    }),
+  );
+
+  it.effect("emits token usage from the Grok prompt result", () =>
+    Effect.gen(function* () {
+      const threadId = ThreadId.make("grok-usage");
+      const wrapperPath = yield* Effect.promise(() =>
+        makeMockGrokWrapper({ T3_ACP_EMIT_USAGE: "1" }),
+      );
+      const adapter = yield* makeTestAdapter(wrapperPath);
+      const usage = yield* Deferred.make<ProviderRuntimeEvent>();
+      const eventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
+        event.type === "thread.token-usage.updated" ? Deferred.succeed(usage, event) : Effect.void,
+      ).pipe(Effect.forkChild);
+
+      yield* adapter.startSession({
+        threadId,
+        provider: ProviderDriverKind.make("grok"),
+        cwd: process.cwd(),
+        runtimeMode: "full-access",
+        modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
+      });
+      yield* adapter.sendTurn({ threadId, input: "count tokens", attachments: [] });
+      const event = yield* Deferred.await(usage);
+      assert.equal(event.type, "thread.token-usage.updated");
+      if (event.type === "thread.token-usage.updated") {
+        assert.equal(event.payload.usage.usedTokens, 17);
+        assert.equal(event.payload.usage.inputTokens, 10);
+      }
+
+      yield* Fiber.interrupt(eventsFiber);
+      yield* adapter.stopSession(threadId);
+    }),
+  );
+
+  it.effect("rolls back Grok conversation turns through rewind", () =>
+    Effect.gen(function* () {
+      const threadId = ThreadId.make("grok-rewind");
+      const wrapperPath = yield* Effect.promise(() =>
+        makeMockGrokWrapper({ T3_ACP_ENABLE_REWIND: "1" }),
+      );
+      const adapter = yield* makeTestAdapter(wrapperPath);
+      const firstTurnDone = yield* Deferred.make<void>();
+      const secondTurnDone = yield* Deferred.make<void>();
+      const completedTurns = yield* Ref.make(0);
+      const eventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
+        event.type === "turn.completed"
+          ? Ref.updateAndGet(completedTurns, (count) => count + 1).pipe(
+              Effect.flatMap((count) => {
+                if (count === 1) {
+                  return Deferred.succeed(firstTurnDone, undefined);
+                }
+                if (count === 2) {
+                  return Deferred.succeed(secondTurnDone, undefined);
+                }
+                return Effect.void;
+              }),
+            )
+          : Effect.void,
+      ).pipe(Effect.forkChild);
+
+      yield* adapter.startSession({
+        threadId,
+        provider: ProviderDriverKind.make("grok"),
+        cwd: process.cwd(),
+        runtimeMode: "full-access",
+        modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
+      });
+      yield* adapter.sendTurn({ threadId, input: "first", attachments: [] });
+      yield* Deferred.await(firstTurnDone);
+      yield* adapter.sendTurn({ threadId, input: "second", attachments: [] });
+      yield* Deferred.await(secondTurnDone);
+
+      const rolled = yield* adapter.rollbackThread(threadId, 1);
+      assert.equal(rolled.turns.length, 1);
+
+      yield* Fiber.interrupt(eventsFiber);
+      yield* adapter.stopSession(threadId);
+    }),
+  );
 });