effect-cursor-sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,1186 @@
+import { Config, ConfigProvider, Context, Data, Effect, Layer, ManagedRuntime, Match, Metric, Option, Redacted, Schema, Stream } from "effect";
+import { Agent, AuthenticationError, AuthenticationError as AuthenticationError$1, ConfigurationError, ConfigurationError as ConfigurationError$1, Cursor, CursorAgentError, CursorAgentError as CursorAgentError$1, CursorAgentPlatform, IntegrationNotConnectedError, IntegrationNotConnectedError as IntegrationNotConnectedError$1, NetworkError, NetworkError as NetworkError$1, RateLimitError, RateLimitError as RateLimitError$1, UnknownAgentError, UnknownAgentError as UnknownAgentError$1, UnsupportedRunOperationError, UnsupportedRunOperationError as UnsupportedRunOperationError$1, createAgentPlatform, createInMemoryRunEventNotifier, createLocalRunEventNotifier, createSdkMessageRunStreamEvent, decodeLocalRunStreamEvent, decodeSdkMessageRunStreamEvent, getTurnType, isTerminalLocalRunStreamEvent, localRunStreamEventToSdkMessage, startLocalRunEventNotifierServer } from "@cursor/sdk";
+//#region src/cursor-error.ts
+/**
+* Authentication or permission failure reported by the Cursor SDK.
+*
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorAuthenticationError = class extends Data.TaggedError("CursorAuthenticationError") {};
+/**
+* Cursor rate limit or usage-limit failure.
+*
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorRateLimitError = class extends Data.TaggedError("CursorRateLimitError") {};
+/**
+* Invalid configuration, model, prompt, repository, or request options.
+*
+* @see {@link AgentOptions}
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorConfigurationError = class extends Data.TaggedError("CursorConfigurationError") {};
+/**
+* SCM integration is not connected for a requested cloud repository.
+*
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorIntegrationNotConnectedError = class extends Data.TaggedError("CursorIntegrationNotConnectedError") {};
+/**
+* Network, service availability, timeout, or backend failure.
+*
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorNetworkError = class extends Data.TaggedError("CursorNetworkError") {};
+/**
+* A run operation is unavailable for the current runtime or run state.
+*
+* @see {@link RunOperation}
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorUnsupportedOperationError = class extends Data.TaggedError("CursorUnsupportedOperationError") {};
+/**
+* A run reached an error terminal state or failed to produce a usable result.
+*
+* @see {@link RunResult}
+* @category errors
+*/
+var CursorRunFailedError = class extends Data.TaggedError("CursorRunFailedError") {};
+/**
+* Stream creation or iteration failed.
+*
+* @see {@link CursorRunService}
+* @see {@link SDKMessage}
+* @category errors
+*/
+var CursorStreamError = class extends Data.TaggedError("CursorStreamError") {};
+/**
+* Fallback for unknown SDK or JavaScript failures.
+*
+* @see {@link mapCursorError}
+* @category errors
+*/
+var CursorUnknownError = class extends Data.TaggedError("CursorUnknownError") {};
+const messageFrom = (cause) => {
+	return cause instanceof Error ? cause.message : String(cause);
+};
+const retryableFrom = (cause) => {
+	return cause instanceof CursorAgentError$1 ? cause.isRetryable : false;
+};
+function mapCursorError(cause, context) {
+	const fields = {
+		...context,
+		message: messageFrom(cause),
+		cause,
+		isRetryable: retryableFrom(cause)
+	};
+	if (context.operation === "run.stream") return new CursorStreamError(fields);
+	return Match.value(cause).pipe(Match.when(Match.instanceOf(AuthenticationError$1), () => {
+		return new CursorAuthenticationError(fields);
+	}), Match.when(Match.instanceOf(RateLimitError$1), () => {
+		return new CursorRateLimitError(fields);
+	}), Match.when(Match.instanceOf(IntegrationNotConnectedError$1), (error) => {
+		return new CursorIntegrationNotConnectedError({
+			...fields,
+			provider: error.provider,
+			helpUrl: error.helpUrl
+		});
+	}), Match.when(Match.instanceOf(UnsupportedRunOperationError$1), (error) => {
+		return new CursorUnsupportedOperationError({
+			...fields,
+			sdkOperation: error.operation
+		});
+	}), Match.when(Match.instanceOf(ConfigurationError$1), () => {
+		return new CursorConfigurationError(fields);
+	}), Match.when(Match.instanceOf(NetworkError$1), () => {
+		return new CursorNetworkError(fields);
+	}), Match.when(Match.instanceOf(UnknownAgentError$1), () => {
+		return new CursorUnknownError(fields);
+	}), Match.when(Match.instanceOf(CursorAgentError$1), () => {
+		return new CursorUnknownError(fields);
+	}), Match.orElse(() => {
+		return new CursorUnknownError(fields);
+	}));
+}
+//#endregion
+//#region src/cursor-sdk-factory.ts
+/**
+* Context service that provides the live `@cursor/sdk` static API boundary.
+*
+* Use {@link CursorSdkFactory.Live} in production layers and override the
+* service in tests with {@link makeMockSdkFactoryLayer} or a custom layer.
+*
+* @example
+* ```ts
+* const program = Effect.gen(function*() {
+*   const sdk = yield* CursorSdkFactory
+*   return sdk.create({ model: { id: "composer-2" }, local: { cwd: process.cwd() } })
+* })
+* ```
+*
+* @see {@link CursorSdkFactoryShape}
+* @see {@link liveLayer}
+* @category services
+*/
+var CursorSdkFactory = class CursorSdkFactory extends Context.Service()("effect-cursor-sdk/cursor-sdk-factory/CursorSdkFactory") {
+	static Live = Layer.succeed(CursorSdkFactory)(CursorSdkFactory.of({
+		create: (options) => {
+			return Agent.create(options);
+		},
+		resume: (agentId, options) => {
+			return Agent.resume(agentId, options);
+		},
+		prompt: (message, options) => {
+			return Agent.prompt(message, options);
+		},
+		listAgents: (options) => {
+			return Agent.list(options);
+		},
+		listRuns: (agentId, options) => {
+			return Agent.listRuns(agentId, options);
+		},
+		getRun: (runId, options) => {
+			return Agent.getRun(runId, options);
+		},
+		getAgent: (agentId, options) => {
+			return Agent.get(agentId, options);
+		},
+		archiveAgent: (agentId, options) => {
+			return Agent.archive(agentId, options);
+		},
+		unarchiveAgent: (agentId, options) => {
+			return Agent.unarchive(agentId, options);
+		},
+		deleteAgent: (agentId, options) => {
+			return Agent.delete(agentId, options);
+		},
+		listMessages: (agentId, options) => {
+			return Agent.messages.list(agentId, options);
+		},
+		me: (options) => {
+			return Cursor.me(options);
+		},
+		listModels: (options) => {
+			return Cursor.models.list(options);
+		},
+		listRepositories: (options) => {
+			return Cursor.repositories.list(options);
+		}
+	}));
+};
+//#endregion
+//#region src/cursor-telemetry.ts
+/**
+* Telemetry helpers for the Effect Cursor SDK boundary.
+*
+* Services wrap SDK calls with {@link instrument}, which records Effect metrics
+* and opens an OpenTelemetry-style span per {@link CursorOperation}. Named
+* `Metric.counter` values are exported so applications can wire them into a
+* metrics backend via Effect's metrics layer.
+*
+* {@link redact} is a small helper for scrubbing structured metadata before it
+* leaves a trust boundary (for example log attributes or debug payloads).
+*
+* @see {@link CursorOperation}
+* @see {@link CursorAgentService}
+* @see {@link CursorRunService}
+* @see {@link CursorInspectionService}
+* @see {@link CursorArtifactService}
+*
+* @module
+*/
+/**
+* Increments once when an instrumented SDK effect **starts** execution.
+*
+* Bound to the metric key `cursor_operations_started`. Used by
+* {@link instrument} on every wrapped call; pair with
+* {@link cursorOperationsFailed} to compute failure rates per operation when
+* both counters are exported to your metrics stack.
+*
+* @see {@link instrument}
+* @see {@link cursorOperationsFailed}
+*
+* @category telemetry
+*/
+const cursorOperationsStarted = Metric.counter("cursor_operations_started");
+/**
+* Increments once when an instrumented SDK effect **fails** (any error channel
+* value), after {@link cursorOperationsStarted} has already been recorded for
+* that run.
+*
+* Bound to the metric key `cursor_operations_failed`. Failures are tracked in
+* `Effect.tapError` so the effect still fails with the original error; this
+* counter is observability-only.
+*
+* @see {@link instrument}
+* @see {@link cursorOperationsStarted}
+*
+* @category telemetry
+*/
+const cursorOperationsFailed = Metric.counter("cursor_operations_failed");
+/**
+* Counter reserved for **per-message** or **per-chunk** stream throughput.
+*
+* Bound to the metric key `cursor_stream_events`. The service wrappers do not
+* attach this metric automatically to {@link CursorRunService.streamEvents};
+* export it from your app if you want to `Metric.track` inside a
+* `Stream.tapEffect` (or similar) when consuming SDK stream payloads.
+*
+* @see {@link CursorRunService}
+*
+* @category telemetry
+*/
+const cursorStreamEvents = Metric.counter("cursor_stream_events");
+/** String substituted for values under sensitive-looking keys. */
+const REDACTED_MARKER = "[redacted]";
+/** Replaces non-plain objects (for example `Date`, `Map`) so they are not mistaken for empty `{}`. */
+const OPAQUE_MARKER = "[opaque]";
+/** Replaces a value when the same object appears on the recursion stack (true cycles only). */
+const CIRCULAR_MARKER = "[circular]";
+/** Replaces nested values when recursion depth exceeds this limit (prevents stack overflow). */
+const MAX_REDACT_DEPTH = 64;
+const isPlainObject = (value) => {
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+};
+/**
+* Lower-cased key substring / equality checks. Substrings such as `key` also
+* match `apiKey` (and unfortunately unrelated keys like `monkey`); that is an
+* intentional tradeoff for simple log scrubbing.
+*/
+const isSensitiveKeyName = (normalized) => {
+	if (normalized === "authorization" || normalized === "data") return true;
+	return normalized.includes("key") || normalized.includes("token") || normalized.includes("secret") || normalized.includes("password") || normalized.includes("passwd") || normalized.includes("credential") || normalized.includes("cookie") || normalized.includes("jwt") || normalized.includes("bearer");
+};
+const redactInner = (value, path, depth) => {
+	if (depth > MAX_REDACT_DEPTH) return OPAQUE_MARKER;
+	if (Array.isArray(value)) {
+		if (path.has(value)) return CIRCULAR_MARKER;
+		path.add(value);
+		const out = value.map((item) => {
+			return redactInner(item, path, depth + 1);
+		});
+		path.delete(value);
+		return out;
+	}
+	if (value === null || typeof value !== "object") return value;
+	if (!isPlainObject(value)) return OPAQUE_MARKER;
+	if (path.has(value)) return CIRCULAR_MARKER;
+	path.add(value);
+	const out = Object.fromEntries(Object.entries(value).map(([key, item]) => {
+		if (isSensitiveKeyName(key.toLowerCase())) return [key, REDACTED_MARKER];
+		return [key, redactInner(item, path, depth + 1)];
+	}));
+	path.delete(value);
+	return out;
+};
+/**
+* Deep-clones **plain** objects and arrays while replacing values under keys that
+* often carry secrets, bearer material, or large opaque blobs (for example API
+* keys, tokens, passwords, cookies, `Authorization`, or a generic `data` field).
+*
+* Matching is **substring-based on the lower-cased key name** (for example
+* `apiKey`, `CURSOR_API_TOKEN`, `client_secret`, `setCookie` all match). Primitives
+* and `null` pass through unchanged. Non-plain objects (for example `Date`, `Map`,
+* class instances) are replaced by `"[opaque]"` so they are not serialized as empty
+* objects. True circular references in the input are replaced by `"[circular]"`.
+* Recursion deeper than 64 levels falls back to `"[opaque]"` for the overflow branch.
+*
+* This is a best-effort redactor for logs and attributes—not a cryptographic
+* guarantee; do not rely on it for compliance redaction without review.
+*
+* @param value - Arbitrary JSON-like value to sanitize.
+* @returns A structure of the same shape with sensitive-looking entries replaced
+*   by the string `"[redacted]"`.
+*
+* @example
+* ```ts
+* redact({ apiKey: "secret", nested: { token: "x" }, safe: 1 })
+* // => { apiKey: "[redacted]", nested: { token: "[redacted]" }, safe: 1 }
+* ```
+*
+* @category telemetry
+*/
+const redact = (value) => {
+	return redactInner(value, /* @__PURE__ */ new Set(), 0);
+};
+/**
+* Wraps an SDK-backed {@link Effect.Effect | Effect} with consistent
+* observability: increments {@link cursorOperationsStarted} at execution start,
+* increments {@link cursorOperationsFailed} on the error channel, and attaches
+* a span named `cursor.<operation>` (for example `cursor.agent.list`).
+*
+* The span name is stable and includes the {@link CursorOperation} tag space
+* so traces can be filtered consistently across agent, run, artifact, and
+* inspection APIs.
+*
+* @param operation - Logical SDK operation; must match {@link CursorOperation}
+*   for typed error mapping and trace taxonomy.
+* @param effect - The effect produced by `Effect.tryPromise` (or similar)
+*   around a single SDK call.
+* @returns The same effect type `Effect<A, E, R>` with metrics and span
+*   attached; success and failure values are unchanged.
+*
+* @example
+* ```ts
+* import { Effect } from "effect"
+* import { instrument } from "./cursor-telemetry"
+*
+* const eff = instrument(
+*   "agent.get",
+*   Effect.tryPromise({
+*     try: () => sdk.getAgent(id),
+*     catch: (e) => e,
+*   }),
+* )
+* ```
+*
+* @see {@link cursorOperationsStarted}
+* @see {@link cursorOperationsFailed}
+* @see {@link CursorOperation}
+*
+* @category telemetry
+*/
+const instrument = (operation, effect) => {
+	return effect.pipe(Effect.track(cursorOperationsStarted.pipe(Metric.withConstantInput(1))), Effect.tapError(() => {
+		return Effect.track(Effect.void, cursorOperationsFailed.pipe(Metric.withConstantInput(1)));
+	}), Effect.withSpan(`cursor.${operation}`));
+};
+//#endregion
+//#region src/cursor-agent.ts
+/**
+* Effect-native agent lifecycle and prompt service.
+*
+* The service wraps `Agent.create`, `Agent.resume`, `Agent.prompt`, and
+* instance lifecycle methods while preserving SDK-owned option and result
+* types.
+*
+* @example
+* ```ts
+* import { CursorAgentService, liveLayer } from "effect-cursor-sdk"
+* import { Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const agents = yield* CursorAgentService
+*   const agent = yield* agents.create({ model: { id: "composer-2" }, local: { cwd: process.cwd() } })
+*   return yield* agents.send(agent, "Summarize this repository")
+* }).pipe(Effect.provide(liveLayer))
+* ```
+*
+* @see {@link CursorRunService} for operations on returned `Run` handles.
+* @see {@link CursorSdkFactory} for replacing SDK construction in tests.
+*
+* @remarks
+* Inherits the **API boundary notice** on {@link CursorAgentServiceShape} about
+* a possible future switch from raw {@link AgentOptions} to
+* {@link loadCursorConfig} / {@link agentOptionsFromConfig}.
+*
+* @category services
+*/
+var CursorAgentService = class CursorAgentService extends Context.Service()("effect-cursor-sdk/cursor-agent/CursorAgentService") {
+	static Live = Layer.effect(CursorAgentService)(Effect.gen(function* () {
+		const sdk = yield* CursorSdkFactory;
+		const create = (options) => {
+			return instrument("agent.create", Effect.tryPromise({
+				try: () => sdk.create(options),
+				catch: (cause) => {
+					return mapCursorError(cause, { operation: "agent.create" });
+				}
+			}));
+		};
+		const resume = (agentId, options) => {
+			return instrument("agent.resume", Effect.tryPromise({
+				try: () => sdk.resume(agentId, options),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "agent.resume",
+						agentId
+					});
+				}
+			}));
+		};
+		const prompt = (message, options) => {
+			return instrument("agent.prompt", Effect.tryPromise({
+				try: () => sdk.prompt(message, options),
+				catch: (cause) => {
+					return mapCursorError(cause, { operation: "agent.prompt" });
+				}
+			}));
+		};
+		const send = (agent, message, options) => {
+			return instrument("agent.send", Effect.tryPromise({
+				try: () => agent.send(message, options),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "agent.send",
+						agentId: agent.agentId
+					});
+				}
+			}));
+		};
+		const reload = (agent) => {
+			return instrument("agent.reload", Effect.tryPromise({
+				try: () => agent.reload(),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "agent.reload",
+						agentId: agent.agentId
+					});
+				}
+			}));
+		};
+		const close = (agent) => {
+			return instrument("agent.close", Effect.sync(() => agent.close()));
+		};
+		const dispose = (agent) => {
+			return instrument("agent.dispose", Effect.tryPromise({
+				try: () => agent[Symbol.asyncDispose](),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "agent.dispose",
+						agentId: agent.agentId
+					});
+				}
+			}));
+		};
+		const scoped = (options) => {
+			return Effect.acquireRelease(create(options), (agent) => {
+				return Effect.ignore(dispose(agent));
+			});
+		};
+		return {
+			create,
+			resume,
+			prompt,
+			send,
+			reload,
+			close,
+			dispose,
+			scoped
+		};
+	}));
+};
+//#endregion
+//#region src/cursor-artifacts.ts
+/**
+* Effect-native wrappers for agent artifacts.
+*
+* @example
+* ```ts
+* const artifacts = yield* CursorArtifactService
+* const items = yield* artifacts.listArtifacts(agent)
+* const bytes = yield* artifacts.downloadArtifact(agent, items[0]!.path)
+* ```
+*
+* @see {@link SDKArtifact}
+*
+* @category services
+*/
+var CursorArtifactService = class CursorArtifactService extends Context.Service()("effect-cursor-sdk/cursor-artifacts/CursorArtifactService") {
+	static Live = Layer.succeed(CursorArtifactService)(CursorArtifactService.of({
+		listArtifacts: (agent) => {
+			return instrument("artifacts.list", Effect.tryPromise({
+				try: () => agent.listArtifacts(),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "artifacts.list",
+						agentId: agent.agentId
+					});
+				}
+			}));
+		},
+		downloadArtifact: (agent, path) => {
+			return instrument("artifacts.download", Effect.tryPromise({
+				try: () => agent.downloadArtifact(path),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "artifacts.download",
+						agentId: agent.agentId
+					});
+				}
+			}));
+		}
+	}));
+};
+//#endregion
+//#region src/cursor-config.ts
+/**
+* Branded secret material for the Cursor API key.
+*
+* Values are held inside {@link Redacted} on {@link CursorConfig}; this schema
+* only brands the decoded plaintext type so it cannot be confused with other
+* strings at the type level.
+*/
+const CursorApiKey = Schema.Redacted(Schema.String).pipe(Schema.brand("CursorApiKey"));
+/**
+* Branded model identifier from wrapper config.
+*
+* Populated from the `CURSOR_MODEL` environment variable when using
+* {@link loadCursorConfig}.
+*/
+const CursorModelId = Schema.String.pipe(Schema.brand("CursorModelId"));
+/**
+* Branded local working directory for agent runs.
+*
+* Populated from `CURSOR_LOCAL_CWD` when using {@link loadCursorConfig}.
+*/
+const CursorLocalCwd = Schema.String.pipe(Schema.brand("CursorLocalCwd"));
+/**
+* Minimal configuration owned by this wrapper.
+*
+* The SDK's `AgentOptions` type remains the source of truth for complete
+* runtime options. This schema only models environment-derived defaults.
+* Use {@link agentOptionsFromConfig} to merge those defaults into SDK-owned
+* {@link AgentOptions}.
+*
+* @remarks
+* **Forward path:** A future major version of this package may require all
+* agent-related options to be supplied through this module (for example
+* {@link loadCursorConfig} plus {@link agentOptionsFromConfig}) instead of raw
+* {@link AgentOptions} on {@link CursorAgentService}.
+* Prefer this path for new code.
+*
+* @example
+* ```ts
+* const config = new CursorConfig({
+*   apiKey: Redacted.make(CursorApiKey.make(process.env.CURSOR_API_KEY!)),
+*   modelId: CursorModelId.make("composer-2"),
+*   cwd: CursorLocalCwd.make(process.cwd())
+* })
+* ```
+*
+* @see {@link cursorConfig}
+* @see {@link loadCursorConfig}
+*
+* @category config
+*/
+var CursorConfig = class extends Schema.Class("CursorConfig")({
+	apiKey: Schema.optional(CursorApiKey),
+	modelId: Schema.optional(CursorModelId),
+	cwd: Schema.optional(CursorLocalCwd)
+}) {};
+/**
+* Effect Config descriptors for common Cursor environment variables.
+*
+* Reads `CURSOR_API_KEY`, `CURSOR_MODEL`, and `CURSOR_LOCAL_CWD` from the active
+* Effect {@link ConfigProvider.ConfigProvider}. All fields are optional so
+* callers can still pass complete SDK options explicitly.
+*
+* @example
+* ```ts
+* const config = yield* loadCursorConfig
+* const options = agentOptionsFromConfig(config)
+* ```
+*
+* @see {@link Config}
+* @see {@link loadCursorConfig}
+*
+* @category config
+*/
+const cursorConfig = Config.all({
+	apiKey: Config.redacted("CURSOR_API_KEY").pipe(Config.option),
+	modelId: Config.string("CURSOR_MODEL").pipe(Config.option),
+	cwd: Config.string("CURSOR_LOCAL_CWD").pipe(Config.option)
+});
+/**
+* Build SDK `AgentOptions` from wrapper config and optional overrides.
+*
+* Explicit override values always win over environment-derived defaults.
+*
+* @param config - Wrapper-owned environment defaults.
+* @param overrides - Complete or partial SDK-owned options to merge over the defaults.
+*
+* @example
+* ```ts
+* const options = agentOptionsFromConfig(config, {
+*   cloud: {
+*     repos: [{ url: "https://github.com/acme/app" }],
+*     autoCreatePR: true
+*   }
+* })
+* ```
+*
+* @see {@link CursorConfig}
+* @see {@link AgentOptions}
+*
+* @remarks
+* Same **forward path** notice as {@link CursorConfig}: this merge is the
+* intended boundary for redacted keys and env defaults ahead of a possible
+* requirement to use it for all agent entry points.
+*
+* @category config
+*/
+const agentOptionsFromConfig = (config, overrides = {}) => {
+	const model = overrides.model ?? (config.modelId ? { id: config.modelId } : void 0);
+	return {
+		...overrides,
+		apiKey: overrides.apiKey ?? (config.apiKey ? Redacted.value(config.apiKey) : void 0),
+		model,
+		local: overrides.local ?? config.cwd ? {
+			cwd: config.cwd,
+			...overrides.local
+		} : void 0
+	};
+};
+/**
+* Load environment-derived defaults as a schema-backed value.
+*
+* @example
+* ```ts
+* const config = yield* loadCursorConfig
+* const options = agentOptionsFromConfig(config, { local: { cwd: process.cwd() } })
+* ```
+*
+* @see {@link cursorConfig}
+* @see {@link agentOptionsFromConfig}
+*
+* @remarks
+* Same **forward path** notice as {@link CursorConfig}: this effect is the
+* intended entry for redacted env defaults ahead of a possible requirement to
+* use it (with {@link agentOptionsFromConfig}) for all agent entry points.
+*
+* @category config
+*/
+const loadCursorConfig = Effect.gen(function* () {
+	const provider = yield* ConfigProvider.ConfigProvider;
+	const raw = yield* cursorConfig.parse(provider);
+	const apiKey = Option.getOrUndefined(raw.apiKey);
+	const modelId = Option.getOrUndefined(raw.modelId);
+	const cwd = Option.getOrUndefined(raw.cwd);
+	return new CursorConfig({
+		apiKey: apiKey ? CursorApiKey.make(apiKey) : void 0,
+		modelId: modelId !== void 0 ? CursorModelId.make(modelId) : void 0,
+		cwd: cwd !== void 0 ? CursorLocalCwd.make(cwd) : void 0
+	});
+});
+//#endregion
+//#region src/cursor-inspection.ts
+/**
+* Effect-native wrappers for SDK inspection, lifecycle, and account catalog APIs.
+*
+* @example
+* ```ts
+* const inspection = yield* CursorInspectionService
+* const agents = yield* inspection.listAgents({ runtime: "cloud", includeArchived: true })
+* const models = yield* inspection.listModels()
+* ```
+*
+* @see {@link CursorSdkFactory}
+* @see {@link SDKAgentInfo}
+*
+* @category services
+*/
+var CursorInspectionService = class CursorInspectionService extends Context.Service()("effect-cursor-sdk/cursor-inspection/CursorInspectionService") {
+	static Live = Layer.effect(CursorInspectionService)(Effect.gen(function* () {
+		const sdk = yield* CursorSdkFactory;
+		return {
+			listAgents: (options) => {
+				return instrument("agent.list", Effect.tryPromise({
+					try: () => sdk.listAgents(options),
+					catch: (cause) => {
+						return mapCursorError(cause, { operation: "agent.list" });
+					}
+				}));
+			},
+			getAgent: (agentId, options) => {
+				return instrument("agent.get", Effect.tryPromise({
+					try: () => sdk.getAgent(agentId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "agent.get",
+							agentId
+						});
+					}
+				}));
+			},
+			archiveAgent: (agentId, options) => {
+				return instrument("agent.archive", Effect.tryPromise({
+					try: () => sdk.archiveAgent(agentId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "agent.archive",
+							agentId
+						});
+					}
+				}));
+			},
+			unarchiveAgent: (agentId, options) => {
+				return instrument("agent.unarchive", Effect.tryPromise({
+					try: () => sdk.unarchiveAgent(agentId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "agent.unarchive",
+							agentId
+						});
+					}
+				}));
+			},
+			deleteAgent: (agentId, options) => {
+				return instrument("agent.delete", Effect.tryPromise({
+					try: () => sdk.deleteAgent(agentId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "agent.delete",
+							agentId
+						});
+					}
+				}));
+			},
+			listRuns: (agentId, options) => {
+				return instrument("run.list", Effect.tryPromise({
+					try: () => sdk.listRuns(agentId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "run.list",
+							agentId
+						});
+					}
+				}));
+			},
+			getRun: (runId, options) => {
+				return instrument("run.get", Effect.tryPromise({
+					try: () => sdk.getRun(runId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "run.get",
+							runId
+						});
+					}
+				}));
+			},
+			listMessages: (agentId, options) => {
+				return instrument("messages.list", Effect.tryPromise({
+					try: () => sdk.listMessages(agentId, options),
+					catch: (cause) => {
+						return mapCursorError(cause, {
+							operation: "messages.list",
+							agentId
+						});
+					}
+				}));
+			},
+			me: (options) => {
+				return instrument("cursor.me", Effect.tryPromise({
+					try: () => sdk.me(options),
+					catch: (cause) => {
+						return mapCursorError(cause, { operation: "cursor.me" });
+					}
+				}));
+			},
+			listModels: (options) => {
+				return instrument("cursor.models.list", Effect.tryPromise({
+					try: () => sdk.listModels(options),
+					catch: (cause) => {
+						return mapCursorError(cause, { operation: "cursor.models.list" });
+					}
+				}));
+			},
+			listRepositories: (options) => {
+				return instrument("cursor.repositories.list", Effect.tryPromise({
+					try: () => sdk.listRepositories(options),
+					catch: (cause) => {
+						return mapCursorError(cause, { operation: "cursor.repositories.list" });
+					}
+				}));
+			}
+		};
+	}));
+};
+//#endregion
+//#region src/cursor-mock.ts
+/**
+* Deterministic SDK `Run` implementation for tests.
+*
+* @param streamEvents - Events yielded by {@link MockCursorRun.stream}.
+* @param waitResult - Result returned by {@link MockCursorRun.wait}.
+*
+* @example
+* ```ts
+* const run = new MockCursorRun([assistantEvent], {
+*   id: "run-1",
+*   status: "finished",
+*   result: "Done"
+* })
+* ```
+*
+* @see {@link makeMockRun}
+* @category testing
+*/
+var MockCursorRun = class {
+	id;
+	agentId;
+	createdAt = Date.now();
+	#status;
+	#listeners = /* @__PURE__ */ new Set();
+	constructor(streamEvents, waitResult) {
+		this.streamEvents = streamEvents;
+		this.waitResult = waitResult;
+		this.id = waitResult.id;
+		this.agentId = streamEvents[0]?.agent_id ?? "mock-agent";
+		this.#status = waitResult.status;
+	}
+	get status() {
+		return this.#status;
+	}
+	get result() {
+		return this.waitResult.result;
+	}
+	get model() {
+		return this.waitResult.model;
+	}
+	get durationMs() {
+		return this.waitResult.durationMs;
+	}
+	get git() {
+		return this.waitResult.git;
+	}
+	supports(_operation) {
+		return true;
+	}
+	unsupportedReason(_operation) {}
+	async *stream() {
+		yield* this.streamEvents;
+	}
+	async conversation() {
+		return [];
+	}
+	async wait() {
+		return this.waitResult;
+	}
+	async cancel() {
+		this.#status = "cancelled";
+		for (const listener of this.#listeners) listener(this.#status);
+	}
+	onDidChangeStatus(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+};
+/**
+* Deterministic SDK `Agent` implementation for tests.
+*
+* @param fixtures - Static data used by `send`, artifact methods, and metadata methods.
+*
+* @example
+* ```ts
+* const agent = new MockCursorAgent({ result: { id: "run-1", status: "finished" } })
+* const run = await agent.send("hello")
+* ```
+*
+* @see {@link makeMockAgent}
+* @see {@link CursorMockFixtures}
+* @category testing
+*/
+var MockCursorAgent = class {
+	agentId;
+	runs = [];
+	closed = false;
+	constructor(fixtures = {}) {
+		this.fixtures = fixtures;
+		this.agentId = fixtures.agentId ?? "mock-agent";
+	}
+	get model() {
+		return this.fixtures.result?.model;
+	}
+	async send(_message, _options) {
+		const run = makeMockRun(this.fixtures);
+		this.runs.push(run);
+		return run;
+	}
+	close() {
+		this.closed = true;
+	}
+	async reload() {}
+	async [Symbol.asyncDispose]() {
+		this.closed = true;
+	}
+	async listArtifacts() {
+		return [...this.fixtures.artifacts ?? []];
+	}
+	async downloadArtifact(_path) {
+		return this.fixtures.artifactData ?? Buffer.from("");
+	}
+};
+/**
+* Create a mock run from fixtures.
+*
+* @param fixtures - Optional mock run and stream data.
+*
+* @see {@link MockCursorRun}
+* @category testing
+*/
+const makeMockRun = (fixtures = {}) => {
+	const runId = fixtures.runId ?? "mock-run";
+	return new MockCursorRun(fixtures.stream ?? [], fixtures.result ?? {
+		id: runId,
+		status: "finished",
+		result: ""
+	});
+};
+/**
+* Create a mock agent from fixtures.
+*
+* @param fixtures - Optional mock agent, run, artifact, and metadata data.
+*
+* @see {@link MockCursorAgent}
+* @category testing
+*/
+const makeMockAgent = (fixtures = {}) => {
+	return new MockCursorAgent(fixtures);
+};
+/**
+* Layer replacing the SDK factory with deterministic mock behavior.
+*
+* This is the lowest-level mock entry point. Prefer {@link mockLayer} when you
+* want all higher-level services wired together for tests.
+*
+* @param fixtures - Static SDK responses returned by the factory methods.
+*
+* @example
+* ```ts
+* const layer = makeMockSdkFactoryLayer({
+*   agents: [{ agentId: "mock-agent", name: "Mock", summary: "Test", lastModified: 0 }]
+* })
+* ```
+*
+* @see {@link CursorSdkFactory}
+* @see {@link mockLayer}
+* @category testing
+*/
+const makeMockSdkFactoryLayer = (fixtures = {}) => {
+	return Layer.succeed(CursorSdkFactory, CursorSdkFactory.of({
+		create: (_options) => {
+			return Promise.resolve(makeMockAgent(fixtures));
+		},
+		resume: (_agentId, _options) => {
+			return Promise.resolve(makeMockAgent(fixtures));
+		},
+		prompt: async (_message, _options) => {
+			return fixtures.result ?? {
+				id: fixtures.runId ?? "mock-run",
+				status: "finished",
+				result: ""
+			};
+		},
+		listAgents: async (_options) => {
+			return { items: [...fixtures.agents ?? []] };
+		},
+		listRuns: async (_agentId, _options) => {
+			return { items: [makeMockRun(fixtures)] };
+		},
+		getRun: async (_runId, _options) => {
+			return makeMockRun(fixtures);
+		},
+		getAgent: async (_agentId, _options) => {
+			return fixtures.agents?.[0] ?? {
+				agentId: fixtures.agentId ?? "mock-agent",
+				name: "Mock Agent",
+				summary: "Deterministic mock agent",
+				lastModified: 0
+			};
+		},
+		archiveAgent: async (_agentId, _options) => {},
+		unarchiveAgent: async (_agentId, _options) => {},
+		deleteAgent: async (_agentId, _options) => {},
+		listMessages: async (_agentId, _options) => {
+			return [...fixtures.messages ?? []];
+		},
+		me: async (_options) => {
+			return fixtures.user ?? {
+				apiKeyName: "mock",
+				createdAt: "1970-01-01T00:00:00.000Z"
+			};
+		},
+		listModels: async (_options) => {
+			return [...fixtures.models ?? []];
+		},
+		listRepositories: async (_options) => {
+			return [...fixtures.repositories ?? []];
+		}
+	}));
+};
+//#endregion
+//#region src/cursor-run.ts
+/**
+* Effect-native helpers for SDK run handles.
+*
+* @example
+* ```ts
+* const run = yield* agents.send(agent, "Refactor auth")
+* const text = yield* runs.collectText(run)
+* ```
+*
+* @see {@link CursorAgentService} for creating and sending runs.
+* @see {@link SDKMessage} for the SDK-owned stream event shape.
+*
+* @category services
+*/
+var CursorRunService = class CursorRunService extends Context.Service()("effect-cursor-sdk/cursor-run/CursorRunService") {
+	static Live = Layer.succeed(CursorRunService)(CursorRunService.of({
+		supports: (run, operation) => {
+			return run.supports(operation);
+		},
+		unsupportedReason: (run, operation) => {
+			return run.unsupportedReason(operation);
+		},
+		wait: (run) => {
+			return instrument("run.wait", Effect.tryPromise({
+				try: () => run.wait(),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "run.wait",
+						agentId: run.agentId,
+						runId: run.id
+					});
+				}
+			}));
+		},
+		cancel: (run) => {
+			return instrument("run.cancel", Effect.tryPromise({
+				try: () => run.cancel(),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "run.cancel",
+						agentId: run.agentId,
+						runId: run.id
+					});
+				}
+			}));
+		},
+		conversation: (run) => {
+			return instrument("run.conversation", Effect.tryPromise({
+				try: () => run.conversation(),
+				catch: (cause) => {
+					return mapCursorError(cause, {
+						operation: "run.conversation",
+						agentId: run.agentId,
+						runId: run.id
+					});
+				}
+			}));
+		},
+		streamEvents: (run) => {
+			return Stream.fromAsyncIterable(run.stream(), (cause) => {
+				return mapCursorError(cause, {
+					operation: "run.stream",
+					agentId: run.agentId,
+					runId: run.id
+				});
+			});
+		},
+		onDidChangeStatus: (run, listener) => {
+			return Effect.sync(() => run.onDidChangeStatus(listener));
+		},
+		collectText: (run) => {
+			return Stream.fromAsyncIterable(run.stream(), (cause) => {
+				return mapCursorError(cause, {
+					operation: "run.stream",
+					agentId: run.agentId,
+					runId: run.id
+				});
+			}).pipe(Stream.runFold(() => "", (text, event) => {
+				if (event.type !== "assistant") return text;
+				return text + event.message.content.filter((block) => {
+					return block.type === "text";
+				}).map((block) => {
+					return block.text;
+				}).join("");
+			}));
+		}
+	}));
+};
+//#endregion
+//#region src/cursor-runtime.ts
+/**
+* Live service layer for the SDK-backed Effect wrapper.
+*
+* Provides {@link CursorAgentService}, {@link CursorRunService},
+* {@link CursorArtifactService}, and {@link CursorInspectionService} using
+* {@link CursorSdkFactory.Live}.
+*
+* @example
+* ```ts
+* const result = yield* program.pipe(Effect.provide(liveLayer))
+* ```
+*
+* @see {@link CursorSdkFactory}
+* @see {@link liveRuntime}
+*
+* @category layers
+*/
+const liveLayer = Layer.mergeAll(CursorAgentService.Live, CursorRunService.Live, CursorArtifactService.Live, CursorInspectionService.Live).pipe(Layer.provideMerge(CursorSdkFactory.Live));
+/**
+* Deterministic mock layer for tests and examples.
+*
+* @param fixtures - Static SDK responses returned by the mock factory.
+*
+* @example
+* ```ts
+* const layer = mockLayer({
+*   result: { id: "run-1", status: "finished", result: "ok" }
+* })
+* ```
+*
+* @see {@link CursorMockFixtures}
+* @see {@link makeMockSdkFactoryLayer}
+*
+* @category layers
+*/
+const mockLayer = (fixtures = {}) => {
+	return Layer.mergeAll(CursorAgentService.Live, CursorRunService.Live, CursorArtifactService.Live, CursorInspectionService.Live).pipe(Layer.provideMerge(makeMockSdkFactoryLayer(fixtures)));
+};
+/**
+* Ready-made live runtime.
+*
+* Use this for small scripts that prefer `ManagedRuntime.runPromise` over
+* manually providing {@link liveLayer}.
+*
+* @example
+* ```ts
+* const value = await liveRuntime.runPromise(program)
+* ```
+*
+* @see {@link liveLayer}
+*
+* @category runtimes
+*/
+const liveRuntime = ManagedRuntime.make(liveLayer);
+/**
+* Ready-made mock runtime.
+*
+* @param fixtures - Static SDK responses returned by the mock services.
+*
+* @example
+* ```ts
+* const runtime = makeMockRuntime({ result: { id: "run-1", status: "finished" } })
+* const value = await runtime.runPromise(program)
+* ```
+*
+* @see {@link mockLayer}
+* @see {@link CursorMockFixtures}
+*
+* @category runtimes
+*/
+const makeMockRuntime = (fixtures = {}) => {
+	return ManagedRuntime.make(mockLayer(fixtures));
+};
+//#endregion
+//#region src/index.ts
+/**
+* Public package name.
+*
+* @category metadata
+*/
+const packageName = "effect-cursor-sdk";
+//#endregion
+export { AuthenticationError, ConfigurationError, CursorAgentError, CursorAgentPlatform, CursorAgentService, CursorApiKey, CursorArtifactService, CursorAuthenticationError, CursorConfig, CursorConfigurationError, CursorInspectionService, CursorIntegrationNotConnectedError, CursorLocalCwd, CursorModelId, CursorNetworkError, CursorRateLimitError, CursorRunFailedError, CursorRunService, CursorSdkFactory, CursorStreamError, CursorUnknownError, CursorUnsupportedOperationError, IntegrationNotConnectedError, MockCursorAgent, MockCursorRun, NetworkError, RateLimitError, UnknownAgentError, UnsupportedRunOperationError, agentOptionsFromConfig, createAgentPlatform, createInMemoryRunEventNotifier, createLocalRunEventNotifier, createSdkMessageRunStreamEvent, cursorConfig, cursorOperationsFailed, cursorOperationsStarted, cursorStreamEvents, decodeLocalRunStreamEvent, decodeSdkMessageRunStreamEvent, getTurnType, instrument, isTerminalLocalRunStreamEvent, liveLayer, liveRuntime, loadCursorConfig, localRunStreamEventToSdkMessage, makeMockAgent, makeMockRun, makeMockRuntime, makeMockSdkFactoryLayer, mapCursorError, mockLayer, packageName, redact, startLocalRunEventNotifierServer };
+
+//# sourceMappingURL=index.js.map