Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Add Cursor CLI stream event schemas and decoding tests

Julius Marminge04a931fc7992
diff --git a/.plans/18-cursor-agent-provider.md b/.plans/18-cursor-agent-provider.md
new file mode 100644
index 000000000..03ea93438
--- /dev/null
+++ b/.plans/18-cursor-agent-provider.md
@@ -0,0 +1,310 @@
+# Plan: Cursor CLI (`agent`) Provider Integration
+
+## Goal
+
+Add Cursor as a first-class provider in T3 Code using Cursor CLI stream JSON mode (`agent -p --output-format stream-json`), with robust session lifecycle handling and canonical `ProviderRuntimeEvent` projection.
+
+---
+
+## 1) Exploration Findings (from live CLI runs)
+
+### 1.1 Core invocation shape
+
+1. Binary is `agent` on PATH (`2026.02.27-e7d2ef6` observed).
+2. Non-interactive streaming mode:
+ - `agent -p --trust --output-format stream-json --stream-partial-output ...`
+3. Session continuity:
+ - `agent create-chat` returns a chat UUID.
+ - `--resume <chatId>` and `--continue` preserve history.
+ - Stream `session_id` equals chat UUID.
+
+### 1.2 Stream JSON event families observed
+
+1. `system/init`
+2. `user`
+3. `thinking/delta`, `thinking/completed`
+4. `assistant` (partial and final)
+5. `tool_call/started`, `tool_call/completed`
+6. `result/success` (`is_error: false` in all successful process exits)
+7. Previously observed under load/rate-limit:
+ - `connection/reconnecting`, `connection/reconnected`
+ - `retry/starting`, `retry/resuming`
+ - followed by non-JSON terminal line `v: [resource_exhausted] Error` and process exit code `1`
+
+### 1.3 Tool call variants observed
+
+1. `shellToolCall`
+2. `readToolCall`
+3. `editToolCall`
+4. `grepToolCall`
+5. `globToolCall`
+
+Tool completion outcomes observed:
+
+1. `result.success`
+2. `result.failure` (non-zero exit, stderr)
+3. `result.rejected` (permission denied by Cursor approval layer)
+
+### 1.4 Critical protocol quirks
+
+1. `tool_call.call_id` contains embedded newline characters (must sanitize for IDs).
+2. Startup failures are plain text, not JSON:
+ - invalid model -> plain error + exit `1`
+ - invalid API key -> plain warning + exit `1`
+3. `result.subtype` can be `success` even when tool calls failed/rejected inside the turn.
+4. Running multiple `agent` commands concurrently can race on `~/.cursor/cli-config.json` writes (`ENOENT rename ...cli-config.json.tmp` observed).
+
+Fixtures recorded in repo:
+
+1. `.tmp/cursor-observations/*.ndjson`
+2. `.tmp/cursor-observations/startup-invalid-*.txt`
+
+---
+
+## 2) Integration Constraints for T3
+
+1. T3 requires adapter contract support for:
+ - `startSession`, `sendTurn`, `interruptTurn`, `respondToRequest`, `readThread`, `rollbackThread`, `stopSession`, `listSessions`, `hasSession`, `stopAll`, `streamEvents`.
+2. Orchestration depends on canonical runtime events (`ProviderRuntimeEvent`) only.
+3. Current `ProviderCommandReactor` ignores `thread.turn-start-requested.payload.provider` and prefers existing provider/session; this must be fixed for reliable provider selection (including Cursor).
+4. Cursor CLI currently has no external approval callback API; approvals are internal to CLI behavior.
+
+---
+
+## 3) Proposed Architecture
+
+## 3.1 New server components
+
+1. `apps/server/src/provider/Services/CursorAdapter.ts` (service contract/tag only for DI parity)
+2. `apps/server/src/provider/Layers/CursorAdapter.ts` (single implementation unit; owns Cursor process lifecycle + stream parsing + runtime projection)
+3. No separate `cursorCliManager.ts` abstraction in v1.
+
+### 3.2 Session model
+
+1. T3 `ProviderSessionId` = synthetic UUID managed by adapter (stable for T3 APIs).
+2. Cursor chat UUID stored as:
+ - `ProviderSession.resumeCursor = { chatId: string }`
+ - `ProviderSession.threadId = ProviderThreadId(chatId)` for adapter contract compatibility.
+3. Adapter keeps runtime map:
+ - `sessionId -> { chatId, cwd, model, activeChildProcess?, activeTurnId?, turnLog }`
+
+### 3.3 Command strategy
+
+1. `startSession`:
+ - call `agent create-chat` unless `resumeCursor.chatId` exists.
+ - validate provider is `cursor` when provided.
+2. `sendTurn`:
+ - spawn `agent -p --trust --output-format stream-json --stream-partial-output --resume <chatId>`.
+ - add `--model` when provided.
+ - map runtime mode:
+ - `approvalPolicy = never` -> include `--force`
+ - otherwise omit `--force` (commands may be rejected by CLI).
+ - use `--workspace <cwd>` when available.
+3. `interruptTurn`:
+ - terminate active child process for session (`SIGINT` then hard kill fallback).
+
+### 3.4 Effect-first implementation style (required)
+
+1. Keep adapter logic inside `CursorAdapterLive` layer constructor (no manager indirection).
+2. Use Effect process primitives first:
+ - `ChildProcessSpawner` + `ChildProcess.make` from `effect/unstable/process` for `agent` execution.
+3. Use Effect concurrency/state primitives:
+ - `Queue` for adapter event queue, `Stream.fromQueue` for `streamEvents`
+ - `Ref` / `Ref.Synchronized` for session maps and active-turn process handles
+ - `Effect.scoped` + `Effect.forkScoped` for worker fibers and cleanup
+4. Use Effect stream parsing path for stdout/stderr:
+ - decode bytes -> line buffer -> JSON parse -> typed projection
+ - keep non-JSON lines on a fallback branch that emits `runtime.error`
+5. Keep errors in typed adapter error algebra (`ProviderAdapter*Error`) via `Effect.mapError` boundaries, not ad-hoc exceptions.
+
+---
+
+## 4) Canonical Event Mapping Plan
+
+For each parsed NDJSON line, emit zero or more `ProviderRuntimeEvent`s:
+
+1. `system/init`
+ - emit `session.started` (once per adapter session lifecycle)
+ - emit `thread.started` if thread not yet emitted
+2. `assistant` partial chunks
+ - emit `message.delta` with stable per-turn synthetic `itemId`
+3. final `assistant` message
+ - emit `message.completed`
+4. `tool_call/started`
+ - emit `tool.started`
+ - map kind:
+ - shell -> `command`
+ - edit -> `file-change`
+ - read/grep/glob -> `other`
+5. `tool_call/completed`
+ - emit `tool.completed`
+ - include summary detail from nested payload (`command`, `path`, stderr fragment, rejection reason)
+6. `thinking/*`
+ - initial version: ignore for canonical events (optional later: map to `tool.*` “Thinking”)
+7. `result/success`
+ - emit `turn.completed` with `status: completed` unless unrecoverable parse/process error already set failure
+8. non-JSON stdout/stderr protocol line
+ - emit `runtime.error`
+ - emit `turn.completed` with `status: failed`
+9. `connection/*` + `retry/*` (when present)
+ - emit `tool.started/completed` with `toolKind: other`, title like “Connection retry”
+ - if final failure follows, also emit `runtime.error`
+
+Synthetic IDs:
+
+1. `turnId`: adapter-generated UUID per `sendTurn`.
+2. `itemId`: `${turnId}:assistant` for assistant stream; `${turnId}:${sanitizedCallId}` for tool calls.
+3. `call_id` sanitization: replace whitespace (including newline) with `_`.
+
+---
+
+## 5) Approval and Checkpoint Behavior (explicit limitations)
+
+### 5.1 Approvals
+
+1. Cursor CLI approval is internal; adapter cannot accept/reject mid-turn via `respondToRequest`.
+2. Plan for v1:
+ - `respondToRequest` returns `ProviderAdapterRequestError` (“Cursor CLI does not expose external approval response API”).
+ - approval-required runtime uses no `--force`, so dangerous commands become `tool_call.result.rejected`.
+3. Future:
+ - if Cursor exposes approval RPC/hooks, implement `approval.requested` + `approval.resolved` fully.
+
+### 5.2 Rollback / thread read
+
+1. Cursor CLI has no observed equivalent to `thread/read` or `thread/rollback`.
+2. Plan for v1:
+ - `readThread` returns adapter-maintained in-memory turn snapshot.
+ - `rollbackThread` returns `ProviderAdapterRequestError` unsupported.
+3. Product guard:
+ - disable checkpoint revert for Cursor threads until rollback is implemented.
+
+---
+
+## 6) Required Contract and Runtime Changes
+
+## 6.1 Contracts
+
+1. `packages/contracts/src/orchestration.ts`
+ - add `cursor` to `ProviderKind`.
+2. `packages/contracts/src/provider.ts`
+ - add `CursorProviderStartOptions` under `providerOptions.cursor`:
+ - `binaryPath?`
+ - `apiKey?` (optional; default login auth)
+ - `trust?` (default true for headless)
+3. `packages/contracts/src/model.ts`
+ - add `cursor` provider model options baseline.
+ - initial set should mirror observed supported IDs that are stable enough for UX.
+4. Update related contract tests.
+
+## 6.2 Server orchestration and registry
+
+1. Add `CursorAdapter` to provider registry and server layer wiring.
+2. Update provider-kind decoding in:
+ - `apps/server/src/provider/Layers/ProviderSessionDirectory.ts`
+ - persistence schemas that currently literal-match provider kinds.
+3. Fix provider selection in `ProviderCommandReactor`:
+ - honor `thread.turn-start-requested.payload.provider` as highest precedence.
+ - fallback to existing session provider, then default.
+
+## 6.3 Web
+
+1. Enable Cursor in provider selector (`apps/web/src/session-logic.ts`).
+2. Add Cursor label/icon treatment.
+3. Add optional Cursor settings fields if using per-user overrides (binary path/api key).
+4. Ensure thread/provider display and legacy mapping code handles `cursor`.
+
+---
+
+## 7) Implementation Phases
+
+### Phase A: Protocol-safe adapter skeleton
+
+1. Implement `CursorAdapter` service/layer with all runtime logic in `CursorAdapterLive` (no CLI manager), plus session map + event queue.
+2. Implement robust NDJSON parser with:
+ - line buffering
+ - tolerant non-JSON handling
+ - explicit process-exit mapping.
+3. Wire into registry and server layers.
+
+### Phase B: Event projection completeness
+
+1. Map assistant/tool/result events to canonical runtime events.
+2. Add synthetic ID strategy and item lifecycle consistency.
+3. Add runtime error and retry handling.
+
+### Phase C: Provider selection and UX
+
+1. Fix `ProviderCommandReactor` provider precedence.
+2. Enable Cursor provider in web UI.
+3. Add Cursor model defaults/options.
+
+### Phase D: Safeguards and unsupported surfaces
+
+1. Explicit unsupported errors for `respondToRequest` and `rollbackThread` (v1).
+2. Guard checkpoint-revert path for Cursor threads.
+3. Document limitations in UI/help text.
+
+---
+
+## 8) Test Plan
+
+Follow project rule: backend external-service integrations tested via layered fakes, not by mocking core business logic.
+
+### 8.1 Unit tests (`CursorAdapter`)
+
+1. stream JSON parse and mapping:
+ - assistant partial/final
+ - each tool type
+ - shell success/failure/rejected
+ - non-JSON line failure
+2. process lifecycle:
+ - start/send/interrupt/stop
+ - stale session errors
+3. ID sanitization:
+ - `call_id` with newline.
+
+### 8.2 Provider service/routing tests
+
+1. Registry resolves `cursor`.
+2. Session directory persistence reads/writes `cursor` provider.
+3. ProviderService fan-out/order with Cursor events.
+
+### 8.3 Orchestration tests
+
+1. `thread.turn.start` with `provider: cursor` routes to Cursor adapter.
+2. checkpoint revert on Cursor thread returns controlled failure activity.
+3. approval response command on Cursor session surfaces “unsupported approval API”.
+
+### 8.4 Smoke/integration harness
+
+1. Optional local smoke behind env flag (`CURSOR_SMOKE=1`) to run real `agent`:
+ - create session
+ - send simple turn
+ - verify message delta/completion + turn completion.
+
+---
+
+## 9) Operational Notes
+
+1. Do not run concurrent `agent` processes per workspace by default; serialize per adapter session to avoid config races.
+2. Keep native event NDJSON logs for Cursor similar to Codex adapter logs.
+3. Treat startup plain-text failures as process-level errors and surface full message.
+
+---
+
+## 10) Open Questions
+
+1. Should Cursor provider expose full model list dynamically (`agent --list-models`) or use curated static list in contracts?
+2. Should T3 keep strict approval UX parity with Codex, or accept Cursor’s current non-interactive approval limitation in v1?
+3. Is checkpoint revert required for initial Cursor release, or can it ship as explicitly unsupported?
+
+---
+
+## 11) Delivery Checklist
+
+1. Contracts updated (`ProviderKind`, provider start options, models).
+2. Cursor adapter + layer implemented and registered.
+3. Provider selection precedence fixed in `ProviderCommandReactor`.
+4. Cursor enabled in web provider picker.
+5. Tests added for adapter mapping, routing, and orchestration behavior.
+6. Lint + test suite green.
diff --git a/apps/server/src/provider/Services/CursorAdapter.test.ts b/apps/server/src/provider/Services/CursorAdapter.test.ts
new file mode 100644
index 000000000..1284d0970
--- /dev/null
+++ b/apps/server/src/provider/Services/CursorAdapter.test.ts
@@ -0,0 +1,132 @@
+import { Schema } from "effect";
+import { describe, expect, it } from "vitest";
+
+import { CursorCliStreamEvent } from "./CursorAdapter.ts";
+
+describe("CursorCliStreamEvent", () => {
+ it("decodes system/init events", () => {
+ const decoded = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "system",
+ subtype: "init",
+ session_id: "sess-1",
+ apiKeySource: "login",
+ cwd: "/tmp/project",
+ model: "Auto",
+ permissionMode: "default",
+ });
+
+ expect(decoded.type).toBe("system");
+ if (decoded.type !== "system") {
+ return;
+ }
+ expect(decoded.subtype).toBe("init");
+ expect(decoded.session_id).toBe("sess-1");
+ });
+
+ it("decodes thinking delta/completed events", () => {
+ const delta = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "thinking",
+ subtype: "delta",
+ text: "draft",
+ session_id: "sess-1",
+ timestamp_ms: 123,
+ });
+
+ expect(delta.type).toBe("thinking");
+ if (delta.type !== "thinking") {
+ return;
+ }
+ expect(delta.subtype).toBe("delta");
+
+ const completed = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "thinking",
+ subtype: "completed",
+ session_id: "sess-1",
+ });
+
+ expect(completed.type).toBe("thinking");
+ if (completed.type !== "thinking") {
+ return;
+ }
+ expect(completed.subtype).toBe("completed");
+ });
+
+ it("decodes tool_call completed events with rejected results", () => {
+ const decoded = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "tool_call",
+ subtype: "completed",
+ call_id: "tool-1\nline-2",
+ session_id: "sess-1",
+ tool_call: {
+ shellToolCall: {
+ args: {
+ command: "rm -rf /tmp/nope",
+ },
+ result: {
+ rejected: {
+ reason: "approval denied",
+ },
+ },
+ },
+ },
+ });
+
+ expect(decoded.type).toBe("tool_call");
+ if (decoded.type !== "tool_call") {
+ return;
+ }
+ expect(decoded.subtype).toBe("completed");
+ expect(decoded.call_id).toContain("\n");
+ });
+
+ it("decodes result success events with usage payload", () => {
+ const decoded = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "result",
+ subtype: "success",
+ duration_ms: 100,
+ duration_api_ms: 90,
+ is_error: false,
+ result: "OK",
+ session_id: "sess-1",
+ request_id: "req-1",
+ usage: {
+ inputTokens: 10,
+ outputTokens: 5,
+ cacheReadTokens: 2,
+ cacheWriteTokens: 1,
+ },
+ });
+
+ expect(decoded.type).toBe("result");
+ if (decoded.type !== "result") {
+ return;
+ }
+ expect(decoded.subtype).toBe("success");
+ expect(decoded.is_error).toBe(false);
+ });
+
+ it("decodes connection/retry lifecycle events", () => {
+ const reconnecting = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "connection",
+ subtype: "reconnecting",
+ session_id: "sess-1",
+ });
+ expect(reconnecting.type).toBe("connection");
+
+ const retry = Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "retry",
+ subtype: "resuming",
+ session_id: "sess-1",
+ });
+ expect(retry.type).toBe("retry");
+ });
+
+ it("rejects unsupported stream event types", () => {
+ expect(() =>
+ Schema.decodeUnknownSync(CursorCliStreamEvent)({
+ type: "bogus",
+ session_id: "sess-1",
+ }),
+ ).toThrow();
+ });
+});
diff --git a/apps/server/src/provider/Services/CursorAdapter.ts b/apps/server/src/provider/Services/CursorAdapter.ts
new file mode 100644
index 000000000..c7ee46d46
--- /dev/null
+++ b/apps/server/src/provider/Services/CursorAdapter.ts
@@ -0,0 +1,214 @@
+/**
+ * CursorAdapter - Cursor CLI implementation of the generic provider adapter contract.
+ *
+ * This service will own Cursor CLI (`agent`) process / stream-json semantics and emit
+ * canonical provider runtime events via the shared provider adapter contract.
+ *
+ * This file intentionally defines raw Cursor stream-json schemas up front so the future
+ * layer implementation can decode/validate NDJSON lines in a single place.
+ *
+ * @module CursorAdapter
+ */
+import { Schema, ServiceMap } from "effect";
+
+import type { ProviderAdapterError } from "../Errors.ts";
+import type { ProviderAdapterShape } from "./ProviderAdapter.ts";
+
+export const CursorCliSessionId = Schema.String.check(Schema.isNonEmpty());
+export type CursorCliSessionId = typeof CursorCliSessionId.Type;
+
+export const CursorCliTextContentPart = Schema.Struct({
+ type: Schema.Literal("text"),
+ text: Schema.String,
+});
+export type CursorCliTextContentPart = typeof CursorCliTextContentPart.Type;
+
+export const CursorCliContentPart = Schema.Union([
+ CursorCliTextContentPart,
+ Schema.Struct({
+ type: Schema.String,
+ }),
+]);
+export type CursorCliContentPart = typeof CursorCliContentPart.Type;
+
+export const CursorCliUserMessage = Schema.Struct({
+ role: Schema.Literal("user"),
+ content: Schema.Array(CursorCliContentPart),
+});
+export type CursorCliUserMessage = typeof CursorCliUserMessage.Type;
+
+export const CursorCliAssistantMessage = Schema.Struct({
+ role: Schema.Literal("assistant"),
+ content: Schema.Array(CursorCliContentPart),
+});
+export type CursorCliAssistantMessage = typeof CursorCliAssistantMessage.Type;
+
+export const CursorCliToolCallResult = Schema.Struct({
+ success: Schema.optional(Schema.Unknown),
+ failure: Schema.optional(Schema.Unknown),
+ rejected: Schema.optional(Schema.Unknown),
+});
+export type CursorCliToolCallResult = typeof CursorCliToolCallResult.Type;
+
+export const CursorCliToolCallEntry = Schema.Struct({
+ args: Schema.optional(Schema.Unknown),
+ result: Schema.optional(CursorCliToolCallResult),
+});
+export type CursorCliToolCallEntry = typeof CursorCliToolCallEntry.Type;
+
+export const CursorCliFunctionToolCall = Schema.Struct({
+ name: Schema.String,
+ arguments: Schema.String,
+ result: Schema.optional(CursorCliToolCallResult),
+});
+export type CursorCliFunctionToolCall = typeof CursorCliFunctionToolCall.Type;
+
+export const CursorCliToolCallPayload = Schema.Struct({
+ readToolCall: Schema.optional(CursorCliToolCallEntry),
+ writeToolCall: Schema.optional(CursorCliToolCallEntry),
+ editToolCall: Schema.optional(CursorCliToolCallEntry),
+ shellToolCall: Schema.optional(CursorCliToolCallEntry),
+ grepToolCall: Schema.optional(CursorCliToolCallEntry),
+ globToolCall: Schema.optional(CursorCliToolCallEntry),
+ function: Schema.optional(CursorCliFunctionToolCall),
+});
+export type CursorCliToolCallPayload = typeof CursorCliToolCallPayload.Type;
+
+export const CursorCliTokenUsage = Schema.Struct({
+ inputTokens: Schema.optional(Schema.Number),
+ outputTokens: Schema.optional(Schema.Number),
+ cacheReadTokens: Schema.optional(Schema.Number),
+ cacheWriteTokens: Schema.optional(Schema.Number),
+});
+export type CursorCliTokenUsage = typeof CursorCliTokenUsage.Type;
+
+const CursorCliTimestampMs = {
+ timestamp_ms: Schema.optional(Schema.Number),
+} as const;
+
+export const CursorCliSystemInitEvent = Schema.Struct({
+ type: Schema.Literal("system"),
+ subtype: Schema.Literal("init"),
+ session_id: CursorCliSessionId,
+ apiKeySource: Schema.optional(Schema.String),
+ cwd: Schema.optional(Schema.String),
+ model: Schema.optional(Schema.String),
+ permissionMode: Schema.optional(Schema.String),
+ ...CursorCliTimestampMs,
+});
+export type CursorCliSystemInitEvent = typeof CursorCliSystemInitEvent.Type;
+
+export const CursorCliUserEvent = Schema.Struct({
+ type: Schema.Literal("user"),
+ message: CursorCliUserMessage,
+ session_id: CursorCliSessionId,
+ ...CursorCliTimestampMs,
+});
+export type CursorCliUserEvent = typeof CursorCliUserEvent.Type;
+
+export const CursorCliAssistantEvent = Schema.Struct({
+ type: Schema.Literal("assistant"),
+ message: CursorCliAssistantMessage,
+ session_id: CursorCliSessionId,
+ ...CursorCliTimestampMs,
+});
+export type CursorCliAssistantEvent = typeof CursorCliAssistantEvent.Type;
+
+export const CursorCliThinkingDeltaEvent = Schema.Struct({
+ type: Schema.Literal("thinking"),
+ subtype: Schema.Literal("delta"),
+ text: Schema.String,
+ session_id: CursorCliSessionId,
+ ...CursorCliTimestampMs,
+});
+export type CursorCliThinkingDeltaEvent = typeof CursorCliThinkingDeltaEvent.Type;
+
+export const CursorCliThinkingCompletedEvent = Schema.Struct({
+ type: Schema.Literal("thinking"),
+ subtype: Schema.Literal("completed"),
+ session_id: CursorCliSessionId,
+ ...CursorCliTimestampMs,
+});
+export type CursorCliThinkingCompletedEvent = typeof CursorCliThinkingCompletedEvent.Type;
+
+export const CursorCliToolCallStartedEvent = Schema.Struct({
+ type: Schema.Literal("tool_call"),
+ subtype: Schema.Literal("started"),
+ call_id: Schema.String,
+ tool_call: CursorCliToolCallPayload,
+ session_id: CursorCliSessionId,
+ ...CursorCliTimestampMs,
+});
+export type CursorCliToolCallStartedEvent = typeof CursorCliToolCallStartedEvent.Type;
+
+export const CursorCliToolCallCompletedEvent = Schema.Struct({
+ type: Schema.Literal("tool_call"),
+ subtype: Schema.Literal("completed"),
+ call_id: Schema.String,
+ tool_call: CursorCliToolCallPayload,
+ session_id: CursorCliSessionId,
+ ...CursorCliTimestampMs,
+});
+export type CursorCliToolCallCompletedEvent = typeof CursorCliToolCallCompletedEvent.Type;
+
+export const CursorCliResultSuccessEvent = Schema.Struct({
+ type: Schema.Literal("result"),
+ subtype: Schema.Literal("success"),
+ duration_ms: Schema.Number,
+ duration_api_ms: Schema.optional(Schema.Number),
+ is_error: Schema.Boolean,
+ result: Schema.String,
+ session_id: CursorCliSessionId,
+ request_id: Schema.optional(Schema.String),
+ usage: Schema.optional(CursorCliTokenUsage),
+ ...CursorCliTimestampMs,
+});
+export type CursorCliResultSuccessEvent = typeof CursorCliResultSuccessEvent.Type;
+
+export const CursorCliConnectionEvent = Schema.Struct({
+ type: Schema.Literal("connection"),
+ subtype: Schema.Literals(["reconnecting", "reconnected"]),
+ session_id: Schema.optional(CursorCliSessionId),
+ ...CursorCliTimestampMs,
+});
+export type CursorCliConnectionEvent = typeof CursorCliConnectionEvent.Type;
+
+export const CursorCliRetryEvent = Schema.Struct({
+ type: Schema.Literal("retry"),
+ subtype: Schema.Literals(["starting", "resuming"]),
+ session_id: Schema.optional(CursorCliSessionId),
+ ...CursorCliTimestampMs,
+});
+export type CursorCliRetryEvent = typeof CursorCliRetryEvent.Type;
+
+export const CursorCliStreamEvent = Schema.Union([
+ CursorCliSystemInitEvent,
+ CursorCliUserEvent,
+ CursorCliAssistantEvent,
+ CursorCliThinkingDeltaEvent,
+ CursorCliThinkingCompletedEvent,
+ CursorCliToolCallStartedEvent,
+ CursorCliToolCallCompletedEvent,
+ CursorCliResultSuccessEvent,
+ CursorCliConnectionEvent,
+ CursorCliRetryEvent,
+]);
+export type CursorCliStreamEvent = typeof CursorCliStreamEvent.Type;
+
+/**
+ * CursorAdapterShape - Service API for the Cursor provider adapter.
+ *
+ * `provider` is intentionally narrowed to `"cursor"` here. Until contracts add
+ * Cursor to `ProviderKind`, this shape is defined via `Omit<...,"provider">`.
+ */
+export interface CursorAdapterShape
+ extends Omit<ProviderAdapterShape<ProviderAdapterError>, "provider"> {
+ readonly provider: "cursor";
+}
+
+/**
+ * CursorAdapter - Service tag for Cursor provider adapter operations.
+ */
+export class CursorAdapter extends ServiceMap.Service<CursorAdapter, CursorAdapterShape>()(
+ "t3/provider/Services/CursorAdapter",
+) {}