@effect-agent/platform-cloudflare 0.1.0-beta.13 → 0.1.0-beta.130

package/dist/BrowserSession-DxCN-5F9.d.mts

@@ -0,0 +1,109 @@
+import { BrowserCredentialAccess, CredentialFillError, CredentialFillResult, FillCredentialRequest } from "./BrowserCredentials.mjs";
+import { A as BrowserRunSessionLifecycle, O as BrowserRunCleanupError, _ as BrowserRunLiveViewRequest, i as BrowserRunHandoffState, k as BrowserRunLifecycleOptions, n as BrowserRunHandoffRequest, r as BrowserRunHandoffResult, v as BrowserRunLiveViewResult } from "./InteractiveBrowser-BnqY_Y-F.mjs";
+import { Cause, Context, Effect, ErrorReporter, Layer, Redacted, Schema, Scope } from "effect";
+import { Browser, Page } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+//#region src/internal/browser-failure.d.ts
+declare const BrowserRunFailure_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "BrowserRunFailure";
+} & Readonly<A>;
+/** Source-authored stages and classifications only; never retain SDK text or session capabilities. */
+declare class BrowserRunFailure extends BrowserRunFailure_base<{
+  readonly operation: string;
+  readonly reason: "provider" | "timeout" | "malformed" | "configuration" | "authorization" | "rate-limited" | "pending";
+  readonly status?: number;
+  readonly cause?: BrowserRunFailure | {
+    readonly name: string;
+  };
+}> {
+  readonly [ErrorReporter.severity]: "Error";
+}
+//#endregion
+//#region src/internal/browser-binding.d.ts
+/** Private attachment ownership is available before asynchronous SDK initialization completes. */
+interface BrowserRunAttachment {
+  readonly browser: Promise<Browser>;
+  /** Fence SDK dispatch/callbacks and await local socket closure; never terminate the provider. */
+  readonly retire: Effect.Effect<void, BrowserRunFailure>;
+}
+declare const BrowserRunBinding_base: Context.ServiceClass<BrowserRunBinding, "@effect-agent/platform-cloudflare/internal/BrowserRunBinding", {
+  readonly acquire: (keepAliveMillis: number, operation: "interactive.acquire" | "session.acquire") => Promise<string>;
+  readonly connect: (sessionId: string, operation: string, signal?: AbortSignal) => BrowserRunAttachment;
+  readonly keepAlive: (sessionId: string) => Effect.Effect<void, BrowserRunFailure>;
+}>;
+/** Native transport port shared by both scoped adapters; the Layer owns the foreign binding. */
+declare class BrowserRunBinding extends BrowserRunBinding_base {
+  static layer(browser: Pick<BrowserRun, "fetch">): Layer.Layer<BrowserRunBinding, never, never>;
+}
+declare namespace BrowserSession_d_exports {
+  export { BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserSession, BrowserSessionError, BrowserSessionOptions, BrowserSessionReference, BrowserSessions, BrowserSessionsOptions };
+}
+declare const BrowserSessionReference_base: Schema.Class<BrowserSessionReference, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly sessionId: Schema.Redacted<Schema.String>;
+  readonly contextId: Schema.Redacted<Schema.NonEmptyString>;
+  readonly targetId: Schema.Redacted<Schema.NonEmptyString>;
+  readonly expiresAt: Schema.Int;
+  readonly commandTimeoutMillis: Schema.Int;
+}>, {}>;
+/** Private host record, not a model capability. Persist together with the owner's controller state. */
+declare class BrowserSessionReference extends BrowserSessionReference_base {}
+declare const BrowserSessionOptions_base: Schema.Class<BrowserSessionOptions, Schema.Struct<{
+  readonly maxElapsedMillis: Schema.Int;
+  readonly keepAliveMillis: Schema.optionalKey<Schema.Int>;
+  readonly commandTimeoutMillis: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+declare class BrowserSessionOptions extends BrowserSessionOptions_base {}
+declare const BrowserSessionError_base: Schema.Class<BrowserSessionError, Schema.TaggedStruct<"BrowserSessionError", {
+  readonly reason: Schema.Literals<readonly ["invalid", "expired", "missing-page", "busy", "closed", "provider", "timeout", "cleanup"]>;
+  readonly dispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched"]>;
+  readonly cleanup: Schema.Literals<readonly ["not-requested", "confirmed", "unconfirmed"]>;
+}>, Cause.YieldableError>;
+/** No SDK text, selectors, page data, or credential values are retained in public failures. */
+declare class BrowserSessionError extends BrowserSessionError_base {}
+/**
+ * One local attachment to an application-owned browser. Scope release disconnects; it never
+ * transfers ownership or closes a healthy remote session. The owner serializes attachments,
+ * fences old attempts, authorizes human access, and calls BrowserSessions.close on expiry/stop.
+ * Native callbacks are trusted host code: never retain SDK handles or start unawaited work.
+ */
+interface BrowserSession {
+  readonly reference: BrowserSessionReference;
+  /**
+   * Check current authority under the lock before native dispatch. A settled SDK rejection leaves
+   * the session available for inspection, but may have changed the website; never retry blindly.
+   * Timeout/interruption fences outstanding SDK work and terminates the exact browser.
+   */
+  readonly run: <A, E, R>(authorize: Effect.Effect<void, E, R>, action: (page: Page) => Promise<A>) => Effect.Effect<A, E | BrowserSessionError, R>;
+  /**
+   * Resolves host-owned material under fresh credential grants. Never submits or retries a write.
+   * Credential timeouts retain acknowledged writes and dispatch evidence alongside cleanup.
+   */
+  readonly fillCredential: (request: FillCredentialRequest) => Effect.Effect<CredentialFillResult, CredentialFillError | BrowserSessionError, BrowserCredentialAccess>;
+  readonly handoff: <E, R>(authorize: Effect.Effect<void, E, R>, request: BrowserRunHandoffRequest) => Effect.Effect<BrowserRunHandoffResult, E | BrowserSessionError, R>;
+  readonly getLiveView: <E, R>(authorize: Effect.Effect<void, E, R>, request: BrowserRunLiveViewRequest) => Effect.Effect<BrowserRunLiveViewResult, E | BrowserSessionError, R>;
+  readonly getHandoffState: <E, R>(authorize: Effect.Effect<void, E, R>) => Effect.Effect<BrowserRunHandoffState, E | BrowserSessionError, R>;
+}
+interface BrowserSessionsOptions extends BrowserRunLifecycleOptions {
+  readonly browser: Pick<BrowserRun, "fetch">;
+}
+declare const BrowserSessions_base: Context.ServiceClass<BrowserSessions, "@effect-agent/platform-cloudflare/BrowserSessions", {
+  /**
+   * Allocate once and commit its private reference in retain. Failed/uncommitted creation closes
+   * the allocation. After retain succeeds the application owns remote cleanup, independent of
+   * attempt Scopes. A lost allocation reply can remain indeterminate until provider idle expiry.
+   */
+  readonly create: <E, R>(options: BrowserSessionOptions, retain: (reference: BrowserSessionReference) => Effect.Effect<void, E, R>) => Effect.Effect<BrowserSessionReference, E | BrowserSessionError, R>;
+  /** Attach only the exact saved context/page. Never recreate missing/expired state. */
+  readonly attach: (reference: BrowserSessionReference) => Effect.Effect<BrowserSession, BrowserSessionError, Scope.Scope>;
+  /** Refresh provider inactivity only; the owner must still enforce its expiresAt. */
+  readonly keepAlive: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, BrowserSessionError>;
+  readonly close: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, BrowserSessionError>;
+}>;
+/** Native Cloudflare sessions; no framework browser workflow, checkpoint transfer, or observation policy. */
+declare class BrowserSessions extends BrowserSessions_base {
+  static readonly layerNoDeps: Layer.Layer<BrowserSessions, never, BrowserRunBinding | BrowserRunSessionLifecycle>;
+  static layer(options: BrowserSessionsOptions): Layer.Layer<BrowserSessions, BrowserRunCleanupError, import("effect/unstable/http/HttpClient").HttpClient>;
+}
+//#endregion
+export { BrowserSession_d_exports as a, BrowserSessionReference as i, BrowserSessionError as n, BrowserSessions as o, BrowserSessionOptions as r, BrowserSessionsOptions as s, BrowserSession as t };
+//# sourceMappingURL=BrowserSession-DxCN-5F9.d.mts.map

package/dist/BrowserSession.d.mts

@@ -0,0 +1,3 @@
+import { _ as BrowserRunLiveViewRequest, i as BrowserRunHandoffState, n as BrowserRunHandoffRequest, r as BrowserRunHandoffResult, v as BrowserRunLiveViewResult } from "./InteractiveBrowser-BnqY_Y-F.mjs";
+import { i as BrowserSessionReference, n as BrowserSessionError, o as BrowserSessions, r as BrowserSessionOptions, s as BrowserSessionsOptions, t as BrowserSession } from "./BrowserSession-DxCN-5F9.mjs";
+export { BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserSession, BrowserSessionError, BrowserSessionOptions, BrowserSessionReference, BrowserSessions, BrowserSessionsOptions };

package/dist/BrowserSession.mjs

@@ -0,0 +1,4 @@
+import "./BrowserCredentials.mjs";
+import { c as BrowserRunLiveViewResult, n as BrowserRunHandoffResult, r as BrowserRunHandoffState, s as BrowserRunLiveViewRequest, t as BrowserRunHandoffRequest } from "./InteractiveBrowser-D-xxDv_f.mjs";
+import { a as BrowserSessions, n as BrowserSessionOptions, r as BrowserSessionReference, t as BrowserSessionError } from "./BrowserSession-BplIoNfi.mjs";
+export { BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserSessionError, BrowserSessionOptions, BrowserSessionReference, BrowserSessions };

package/dist/CloudflareAiGateway.d.mts

@@ -0,0 +1,64 @@
+import { Layer, Redacted } from "effect";
+import { HttpClient } from "effect/unstable/http";
+declare namespace CloudflareAiGateway_d_exports {
+  export { ClientOptions, ProviderOptions, RestOptions, RouteOptions, provide, provider, rest };
+}
+/** Options understood by upstream Effect AI clients; no model or provider wrapper is created. */
+export interface ClientOptions {
+  readonly apiUrl: string;
+  readonly transformClient: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
+}
+export interface ProviderOptions {
+  readonly accountId: string;
+  readonly gatewayId: string;
+  /** Cloudflare's provider path, such as openai, anthropic, google-ai-studio, or perplexity-ai. */
+  readonly provider: string;
+  /** Omit only for an unauthenticated gateway with a separately supplied provider key. */
+  readonly apiToken?: Redacted.Redacted<string>;
+}
+export interface RestOptions {
+  readonly accountId: string;
+  readonly gatewayId: string;
+  /** Cloudflare API token with Workers AI Read permission. */
+  readonly apiToken: Redacted.Redacted<string>;
+  /** Matches the paths appended by the upstream Effect client. */
+  readonly protocol: "responses" | "chat-completions" | "messages";
+}
+/** Choose exactly one route: a native provider path or an account REST protocol. */
+export type RouteOptions = (ProviderOptions & {
+  readonly protocol?: never;
+}) | (RestOptions & {
+  readonly provider?: never;
+});
+/**
+ * Provider-native proxy for model calls, streaming, embeddings, and hosted tools supported
+ * by that provider. Pass the result to the upstream client's layer along with its apiKey
+ * for BYOK-in-request, or omit apiKey for Gateway stored keys / Unified Billing.
+ * Provider model names and request bodies pass through unchanged. This module is Node-safe.
+ * Custom transforms and redirect policies must retain this endpoint and credential boundary.
+ */
+export declare const provider: (options: ProviderOptions) => ClientOptions;
+/**
+ * Cloudflare's account REST API (not the deprecated /compat API). Use provider-qualified
+ * model names, e.g. openai/gpt-4.1 or anthropic/claude-haiku-4.5, and omit provider apiKey.
+ * OpenAI clients append /responses or /chat/completions; Anthropic appends /v1/messages.
+ * Compatibility remains the responsibility of the selected upstream client and model.
+ */
+export declare const rest: (options: RestOptions) => ClientOptions;
+/**
+ * Provide a Gateway-configured upstream client directly in a Layer pipeline.
+ * Pass the client's `layer` factory, or a callback adding client-specific options.
+ * The factory's errors and remaining services (such as HttpClient) stay visible.
+ * Model selection and resource ownership remain with the supplied upstream Layers.
+ *
+ * @example
+ * ```ts
+ * AnthropicLanguageModel.model("claude-haiku-4-5").pipe(
+ *   Gateway.provide(AnthropicClient.layer, { ...options, provider: "anthropic" }),
+ * )
+ * ```
+ */
+export declare const provide: <Client, E, R>(clientLayer: (options: ClientOptions) => Layer.Layer<Client, E, R>, options: RouteOptions) => <RIn2, E2, ROut2>(self: Layer.Layer<ROut2, E2, RIn2>) => Layer.Layer<ROut2, E | E2, R | Exclude<RIn2, Client>>;
+//#endregion
+export { CloudflareAiGateway_d_exports as t };
+//# sourceMappingURL=CloudflareAiGateway.d.mts.map

package/dist/CloudflareAiGateway.mjs

@@ -0,0 +1,70 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Option, Redactable, Redacted, Schema } from "effect";
+import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/http";
+//#region src/CloudflareAiGateway.ts
+var CloudflareAiGateway_exports = /* @__PURE__ */ __exportAll({
+	provide: () => provide,
+	provider: () => provider,
+	rest: () => rest
+});
+const Segment = Schema.NonEmptyString.check(Schema.isMaxLength(256), Schema.isPattern(/^[a-zA-Z0-9_-]+$/));
+const decodeSegment = Schema.decodeUnknownSync(Segment);
+const redactGatewayToken = (headers, tokenHeader) => {
+	Object.defineProperty(headers, Redactable.symbolRedactable, {
+		configurable: true,
+		value: (context) => Headers.redact(headers, [...Context.get(context, Headers.CurrentRedactedNames), tokenHeader])
+	});
+};
+const clientOptions = (apiUrl, tokenHeader, apiToken, gatewayId) => Object.freeze({
+	apiUrl,
+	transformClient: (client) => client.pipe(HttpClient.mapRequestEffect((request) => {
+		const url = URL.parse(request.url);
+		if (url === null || url.username !== "" || url.password !== "" || !(url.href === apiUrl || url.href.startsWith(`${apiUrl}/`))) return Effect.fail(new HttpClientError.HttpClientError({ reason: new HttpClientError.InvalidUrlError({
+			request,
+			description: "Request is outside the configured Cloudflare AI Gateway endpoint"
+		}) }));
+		let prepared = request;
+		if (apiToken !== void 0) prepared = HttpClientRequest.setHeader(prepared, tokenHeader, `Bearer ${Redacted.value(apiToken)}`);
+		if (gatewayId !== void 0) prepared = HttpClientRequest.setHeader(prepared, "cf-aig-gateway-id", gatewayId);
+		return Effect.succeed(prepared);
+	}), HttpClient.transformResponse((effect) => Effect.gen(function* () {
+		const defaults = yield* Effect.serviceOption(FetchHttpClient.RequestInit);
+		return yield* effect.pipe(Effect.provideService(FetchHttpClient.RequestInit, {
+			...Option.getOrElse(defaults, () => ({})),
+			redirect: "error"
+		}));
+	})), HttpClient.transformResponse((effect) => effect.pipe(Effect.tap((response) => Effect.sync(() => redactGatewayToken(response.request.headers, tokenHeader))), Effect.tapError((error) => Effect.sync(() => redactGatewayToken(error.reason.request.headers, tokenHeader))), Effect.updateService(Headers.CurrentRedactedNames, (names) => [...names, tokenHeader]))))
+});
+/**
+* Provider-native proxy for model calls, streaming, embeddings, and hosted tools supported
+* by that provider. Pass the result to the upstream client's layer along with its apiKey
+* for BYOK-in-request, or omit apiKey for Gateway stored keys / Unified Billing.
+* Provider model names and request bodies pass through unchanged. This module is Node-safe.
+* Custom transforms and redirect policies must retain this endpoint and credential boundary.
+*/
+const provider = (options) => clientOptions(`https://gateway.ai.cloudflare.com/v1/${decodeSegment(options.accountId)}/${decodeSegment(options.gatewayId)}/${decodeSegment(options.provider)}`, "cf-aig-authorization", options.apiToken);
+/**
+* Cloudflare's account REST API (not the deprecated /compat API). Use provider-qualified
+* model names, e.g. openai/gpt-4.1 or anthropic/claude-haiku-4.5, and omit provider apiKey.
+* OpenAI clients append /responses or /chat/completions; Anthropic appends /v1/messages.
+* Compatibility remains the responsibility of the selected upstream client and model.
+*/
+const rest = (options) => clientOptions(`https://api.cloudflare.com/client/v4/accounts/${decodeSegment(options.accountId)}/ai${options.protocol === "messages" ? "" : "/v1"}`, "authorization", options.apiToken, decodeSegment(options.gatewayId));
+/**
+* Provide a Gateway-configured upstream client directly in a Layer pipeline.
+* Pass the client's `layer` factory, or a callback adding client-specific options.
+* The factory's errors and remaining services (such as HttpClient) stay visible.
+* Model selection and resource ownership remain with the supplied upstream Layers.
+*
+* @example
+* ```ts
+* AnthropicLanguageModel.model("claude-haiku-4-5").pipe(
+*   Gateway.provide(AnthropicClient.layer, { ...options, provider: "anthropic" }),
+* )
+* ```
+*/
+const provide = (clientLayer, options) => Layer.provide(clientLayer(options.provider !== void 0 ? provider(options) : rest(options)));
+//#endregion
+export { provide, provider, rest, CloudflareAiGateway_exports as t };
+
+//# sourceMappingURL=CloudflareAiGateway.mjs.map

package/dist/CloudflareAiGateway.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareAiGateway.mjs","names":[],"sources":["../src/CloudflareAiGateway.ts"],"sourcesContent":["import { Context, Effect, Layer, Option, Redactable, Redacted, Schema } from \"effect\";\nimport {\n  FetchHttpClient,\n  Headers,\n  HttpClient,\n  HttpClientError,\n  HttpClientRequest,\n} from \"effect/unstable/http\";\n\nconst Segment = Schema.NonEmptyString.check(\n  Schema.isMaxLength(256),\n  Schema.isPattern(/^[a-zA-Z0-9_-]+$/),\n);\n\nconst decodeSegment = Schema.decodeUnknownSync(Segment);\n\n/** Options understood by upstream Effect AI clients; no model or provider wrapper is created. */\nexport interface ClientOptions {\n  readonly apiUrl: string;\n  readonly transformClient: (client: HttpClient.HttpClient) => HttpClient.HttpClient;\n}\n\nexport interface ProviderOptions {\n  readonly accountId: string;\n  readonly gatewayId: string;\n  /** Cloudflare's provider path, such as openai, anthropic, google-ai-studio, or perplexity-ai. */\n  readonly provider: string;\n  /** Omit only for an unauthenticated gateway with a separately supplied provider key. */\n  readonly apiToken?: Redacted.Redacted<string>;\n}\n\nexport interface RestOptions {\n  readonly accountId: string;\n  readonly gatewayId: string;\n  /** Cloudflare API token with Workers AI Read permission. */\n  readonly apiToken: Redacted.Redacted<string>;\n  /** Matches the paths appended by the upstream Effect client. */\n  readonly protocol: \"responses\" | \"chat-completions\" | \"messages\";\n}\n\n/** Choose exactly one route: a native provider path or an account REST protocol. */\nexport type RouteOptions =\n  | (ProviderOptions & { readonly protocol?: never })\n  | (RestOptions & { readonly provider?: never });\n\nconst redactGatewayToken = (headers: Headers.Headers, tokenHeader: string): void => {\n  // HTTP tracing can copy headers after preprocessing. Attach the public redaction\n  // protocol to the final request as well, before a provider builds error details.\n  Object.defineProperty(headers, Redactable.symbolRedactable, {\n    configurable: true,\n    value: (context: Context.Context<never>) =>\n      Headers.redact(headers, [...Context.get(context, Headers.CurrentRedactedNames), tokenHeader]),\n  });\n};\n\nconst clientOptions = (\n  apiUrl: string,\n  tokenHeader: \"authorization\" | \"cf-aig-authorization\",\n  apiToken: Redacted.Redacted<string> | undefined,\n  gatewayId?: string,\n): ClientOptions =>\n  Object.freeze({\n    apiUrl,\n    transformClient: (client: HttpClient.HttpClient) =>\n      client.pipe(\n        HttpClient.mapRequestEffect((request) => {\n          const url = URL.parse(request.url);\n\n          // Check the normalized URL too: dot segments must not escape this account or gateway.\n          if (\n            url === null ||\n            url.username !== \"\" ||\n            url.password !== \"\" ||\n            !(url.href === apiUrl || url.href.startsWith(`${apiUrl}/`))\n          ) {\n            return Effect.fail(\n              new HttpClientError.HttpClientError({\n                reason: new HttpClientError.InvalidUrlError({\n                  request,\n                  description: \"Request is outside the configured Cloudflare AI Gateway endpoint\",\n                }),\n              }),\n            );\n          }\n          let prepared = request;\n\n          if (apiToken !== undefined) {\n            prepared = HttpClientRequest.setHeader(\n              prepared,\n              tokenHeader,\n              `Bearer ${Redacted.value(apiToken)}`,\n            );\n          }\n          if (gatewayId !== undefined) {\n            prepared = HttpClientRequest.setHeader(prepared, \"cf-aig-gateway-id\", gatewayId);\n          }\n\n          return Effect.succeed(prepared);\n        }),\n        HttpClient.transformResponse((effect) =>\n          Effect.gen(function* () {\n            const defaults = yield* Effect.serviceOption(FetchHttpClient.RequestInit);\n\n            return yield* effect.pipe(\n              Effect.provideService(FetchHttpClient.RequestInit, {\n                ...Option.getOrElse(defaults, () => ({})),\n                redirect: \"error\",\n              }),\n            );\n          }),\n        ),\n        HttpClient.transformResponse((effect) =>\n          effect.pipe(\n            Effect.tap((response) =>\n              Effect.sync(() => redactGatewayToken(response.request.headers, tokenHeader)),\n            ),\n            Effect.tapError((error) =>\n              Effect.sync(() => redactGatewayToken(error.reason.request.headers, tokenHeader)),\n            ),\n            Effect.updateService(Headers.CurrentRedactedNames, (names) => [...names, tokenHeader]),\n          ),\n        ),\n      ),\n  });\n\n/**\n * Provider-native proxy for model calls, streaming, embeddings, and hosted tools supported\n * by that provider. Pass the result to the upstream client's layer along with its apiKey\n * for BYOK-in-request, or omit apiKey for Gateway stored keys / Unified Billing.\n * Provider model names and request bodies pass through unchanged. This module is Node-safe.\n * Custom transforms and redirect policies must retain this endpoint and credential boundary.\n */\nexport const provider = (options: ProviderOptions): ClientOptions =>\n  clientOptions(\n    `https://gateway.ai.cloudflare.com/v1/${decodeSegment(options.accountId)}/${decodeSegment(options.gatewayId)}/${decodeSegment(options.provider)}`,\n    \"cf-aig-authorization\",\n    options.apiToken,\n  );\n\n/**\n * Cloudflare's account REST API (not the deprecated /compat API). Use provider-qualified\n * model names, e.g. openai/gpt-4.1 or anthropic/claude-haiku-4.5, and omit provider apiKey.\n * OpenAI clients append /responses or /chat/completions; Anthropic appends /v1/messages.\n * Compatibility remains the responsibility of the selected upstream client and model.\n */\nexport const rest = (options: RestOptions): ClientOptions =>\n  clientOptions(\n    `https://api.cloudflare.com/client/v4/accounts/${decodeSegment(options.accountId)}/ai${options.protocol === \"messages\" ? \"\" : \"/v1\"}`,\n    \"authorization\",\n    options.apiToken,\n    decodeSegment(options.gatewayId),\n  );\n\n/**\n * Provide a Gateway-configured upstream client directly in a Layer pipeline.\n * Pass the client's `layer` factory, or a callback adding client-specific options.\n * The factory's errors and remaining services (such as HttpClient) stay visible.\n * Model selection and resource ownership remain with the supplied upstream Layers.\n *\n * @example\n * ```ts\n * AnthropicLanguageModel.model(\"claude-haiku-4-5\").pipe(\n *   Gateway.provide(AnthropicClient.layer, { ...options, provider: \"anthropic\" }),\n * )\n * ```\n */\nexport const provide = <Client, E, R>(\n  clientLayer: (options: ClientOptions) => Layer.Layer<Client, E, R>,\n  options: RouteOptions,\n) => Layer.provide(clientLayer(options.provider !== undefined ? provider(options) : rest(options)));\n"],"mappings":";;;;;;;;;AASA,MAAM,UAAU,OAAO,eAAe,MACpC,OAAO,YAAY,GAAG,GACtB,OAAO,UAAU,kBAAkB,CACrC;AAEA,MAAM,gBAAgB,OAAO,kBAAkB,OAAO;AA+BtD,MAAM,sBAAsB,SAA0B,gBAA8B;CAGlF,OAAO,eAAe,SAAS,WAAW,kBAAkB;EAC1D,cAAc;EACd,QAAQ,YACN,QAAQ,OAAO,SAAS,CAAC,GAAG,QAAQ,IAAI,SAAS,QAAQ,oBAAoB,GAAG,WAAW,CAAC;CAChG,CAAC;AACH;AAEA,MAAM,iBACJ,QACA,aACA,UACA,cAEA,OAAO,OAAO;CACZ;CACA,kBAAkB,WAChB,OAAO,KACL,WAAW,kBAAkB,YAAY;EACvC,MAAM,MAAM,IAAI,MAAM,QAAQ,GAAG;EAGjC,IACE,QAAQ,QACR,IAAI,aAAa,MACjB,IAAI,aAAa,MACjB,EAAE,IAAI,SAAS,UAAU,IAAI,KAAK,WAAW,GAAG,OAAO,EAAE,IAEzD,OAAO,OAAO,KACZ,IAAI,gBAAgB,gBAAgB,EAClC,QAAQ,IAAI,gBAAgB,gBAAgB;GAC1C;GACA,aAAa;EACf,CAAC,EACH,CAAC,CACH;EAEF,IAAI,WAAW;EAEf,IAAI,aAAa,KAAA,GACf,WAAW,kBAAkB,UAC3B,UACA,aACA,UAAU,SAAS,MAAM,QAAQ,GACnC;EAEF,IAAI,cAAc,KAAA,GAChB,WAAW,kBAAkB,UAAU,UAAU,qBAAqB,SAAS;EAGjF,OAAO,OAAO,QAAQ,QAAQ;CAChC,CAAC,GACD,WAAW,mBAAmB,WAC5B,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAO,OAAO,cAAc,gBAAgB,WAAW;EAExE,OAAO,OAAO,OAAO,KACnB,OAAO,eAAe,gBAAgB,aAAa;GACjD,GAAG,OAAO,UAAU,iBAAiB,CAAC,EAAE;GACxC,UAAU;EACZ,CAAC,CACH;CACF,CAAC,CACH,GACA,WAAW,mBAAmB,WAC5B,OAAO,KACL,OAAO,KAAK,aACV,OAAO,WAAW,mBAAmB,SAAS,QAAQ,SAAS,WAAW,CAAC,CAC7E,GACA,OAAO,UAAU,UACf,OAAO,WAAW,mBAAmB,MAAM,OAAO,QAAQ,SAAS,WAAW,CAAC,CACjF,GACA,OAAO,cAAc,QAAQ,uBAAuB,UAAU,CAAC,GAAG,OAAO,WAAW,CAAC,CACvF,CACF,CACF;AACJ,CAAC;;;;;;;;AASH,MAAa,YAAY,YACvB,cACE,wCAAwC,cAAc,QAAQ,SAAS,EAAE,GAAG,cAAc,QAAQ,SAAS,EAAE,GAAG,cAAc,QAAQ,QAAQ,KAC9I,wBACA,QAAQ,QACV;;;;;;;AAQF,MAAa,QAAQ,YACnB,cACE,iDAAiD,cAAc,QAAQ,SAAS,EAAE,KAAK,QAAQ,aAAa,aAAa,KAAK,SAC9H,iBACA,QAAQ,UACR,cAAc,QAAQ,SAAS,CACjC;;;;;;;;;;;;;;AAeF,MAAa,WACX,aACA,YACG,MAAM,QAAQ,YAAY,QAAQ,aAAa,KAAA,IAAY,SAAS,OAAO,IAAI,KAAK,OAAO,CAAC,CAAC"}

package/dist/CloudflareBindings.d.mts

@@ -0,0 +1,115 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { ThreadId } from "effect-agent/identifiers";
+import { ProducerId } from "effect-agent/records";
+declare namespace CloudflareBindings_d_exports {
+  export { CloudflareBindingError, DurableObjectContext, ThreadObjectClient, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPlacement, ThreadObjectRpc, callThreadObject, threadNamespaceFromEnv, threadNamespaceLayer };
+}
+declare const CloudflareBindingError_base: Schema.Class<CloudflareBindingError, Schema.TaggedStruct<"CloudflareBindingError", {
+  readonly binding: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Cloudflare platform bindings as Effect services (DEPLOY-010: "Cloudflare platform bindings
+ * are supplied as Effect services/Layers"). Application code never reads `env` or touches a
+ * `DurableObjectState` directly — the Thread Object class constructs these Layers once
+ * per incarnation and everything downstream consumes the services.
+ */
+/** A Cloudflare platform binding was missing or carried the wrong shape (DEPLOY-003/010). */
+export declare class CloudflareBindingError extends CloudflareBindingError_base {}
+/**
+ * The RPC surface one Thread Durable Object exposes to Workers and to sibling
+ * Thread Objects. `ThreadObject.make` implements it; the Worker-side client
+ * and the cross-Object transport call it through `DurableObjectNamespace` stubs. Every
+ * `encoded` value is a Schema-encoded envelope (`client.ts` wire schemas for host entry
+ * points, `@effect-agent/storage-cloudflare` port envelopes for `portCall`), so the RPC
+ * boundary carries only structured-cloneable JSON. The optional trailing trace context is
+ * transient native RPC metadata, stripped by an opted-in effect-cf receiver before decoding
+ * the host envelope. It never enters durable state.
+ */
+export interface ThreadObjectRpc extends Rpc.DurableObjectBranded {
+  /** Admission-limits gate + `DurableAgentRuntime.submit`; answers a `SubmitResponse`. */
+  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */
+  submissionStatusEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */
+  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Best-effort cancellation for one in-flight progress wait. */
+  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** One bounded page of canonical records; answers an `ObservePageResponse`. */
+  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Durable abort intent; answers an `AbortResponse`. */
+  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Durable approval decision (plan §2.6); answers a `ResolveApprovalResponse`. */
+  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Authorized DUR-017 Unknown-Outcome resolution; answers a `ResolveUnknownResponse`. */
+  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  /** Owner-side cross-Object port endpoint (WP2 envelopes, executed on LOCAL facets). */
+  portCall(encoded: unknown): Promise<unknown>;
+  /** Droppable liveness hint from another Object: arms an immediate alarm. */
+  wake(): Promise<void>;
+}
+/** A logical Thread endpoint may be bound to an application Object without forging its brand. */
+export type ThreadObjectClient = Omit<ThreadObjectRpc, keyof Rpc.DurableObjectBranded>;
+declare const ThreadObjectNamespace_base: Context.ServiceClass<ThreadObjectNamespace, "@effect-agent/platform-cloudflare/ThreadObjectNamespace", {
+  readonly get: (threadId: ThreadId) => ThreadObjectClient;
+  /** Stable binding name for opted-in native RPC tracing; absent by default. */
+  readonly rpcTracing?: string;
+}>;
+/**
+ * Deterministic logical Thread placement. The native adapter uses `idFromName(threadId)`;
+ * a shared application owner can bind that logical identity into its RPC adapter instead.
+ * Lookup performs no I/O and grants no authority. Calls reuse a native target within
+ * one invocation; incoming requests and durable retries acquire their own targets.
+ */
+export declare class ThreadObjectNamespace extends ThreadObjectNamespace_base {
+  static layer(namespace: DurableObjectNamespace<ThreadObjectRpc>, options?: {
+    readonly rpcTracing?: string;
+  }): Layer.Layer<ThreadObjectNamespace>;
+}
+/** Invoke a placed Thread using the current invocation's native RPC channel. */
+export declare const callThreadObject: <A, E>(threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">, invoke: (target: ThreadObjectClient) => Promise<A>, onError: (cause: unknown) => E) => Effect.Effect<A, E, ThreadObjectNamespace>;
+/**
+ * Narrow one `env` member to a `DurableObjectNamespace`. `env` is an untyped platform value,
+ * and a namespace binding is a host object no Schema can decode, so this is the documented
+ * narrowest-boundary check (structural probe for the namespace surface the transport uses);
+ * a missing or misshaped binding fails typed before any Layer is built.
+ */
+export declare const threadNamespaceFromEnv: (env: unknown, binding: string) => Effect.Effect<DurableObjectNamespace<ThreadObjectRpc>, CloudflareBindingError, never>;
+/**
+ * Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the
+ * receiver also opts into the effect-cf native RPC trace-context contract.
+ */
+export declare const threadNamespaceLayer: (env: unknown, binding: string, options?: {
+  readonly rpcTracing?: boolean;
+}) => Layer.Layer<ThreadObjectNamespace, CloudflareBindingError>;
+declare const DurableObjectContext_base: Context.ServiceClass<DurableObjectContext, "@effect-agent/platform-cloudflare/DurableObjectContext", {
+  readonly ctx: DurableObjectState;
+  readonly env: unknown;
+}>;
+/**
+ * The live Durable Object execution context of THIS incarnation. Only Layer construction and
+ * the alarm service consume it; important state never lives on it (`ctx.storage` is truth,
+ * everything in memory is a cache — deployment spec §11).
+ */
+export declare class DurableObjectContext extends DurableObjectContext_base {
+  static layer(ctx: DurableObjectState, env: unknown): Layer.Layer<DurableObjectContext>;
+}
+declare const ThreadObjectIdentity_base: Context.ServiceClass<ThreadObjectIdentity, "@effect-agent/platform-cloudflare/ThreadObjectIdentity", {
+  readonly threadId: ThreadId;
+  readonly producerId: ProducerId;
+}>;
+/**
+ * The Thread identity this Object serializes and the producer identity its Attempts
+ * write with (`{producerPrefix}:{threadId}`, plan §1.4). Derived once per incarnation
+ * from `ctx.id.name` — the Object identity rule guarantees the name IS the Thread ID.
+ */
+export declare class ThreadObjectIdentity extends ThreadObjectIdentity_base {}
+declare const ThreadObjectPlacement_base: Context.ServiceClass<ThreadObjectPlacement, "@effect-agent/platform-cloudflare/ThreadObjectPlacement", {
+  readonly ownsThread: (threadId: ThreadId) => boolean;
+}>;
+/** Logical Threads whose canonical stores and admission ledger live in this physical Object. */
+export declare class ThreadObjectPlacement extends ThreadObjectPlacement_base {}
+//#endregion
+export { CloudflareBindings_d_exports as t };
+//# sourceMappingURL=CloudflareBindings.d.mts.map

package/dist/CloudflareBindings.mjs

@@ -0,0 +1,113 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Predicate, Schema } from "effect";
+import "effect-agent/identifiers";
+import { RpcTargets } from "effect-cf";
+import "effect-agent/records";
+//#region src/CloudflareBindings.ts
+var CloudflareBindings_exports = /* @__PURE__ */ __exportAll({
+	CloudflareBindingError: () => CloudflareBindingError,
+	DurableObjectContext: () => DurableObjectContext,
+	ThreadObjectIdentity: () => ThreadObjectIdentity,
+	ThreadObjectNamespace: () => ThreadObjectNamespace,
+	ThreadObjectPlacement: () => ThreadObjectPlacement,
+	callThreadObject: () => callThreadObject,
+	threadNamespaceFromEnv: () => threadNamespaceFromEnv,
+	threadNamespaceLayer: () => threadNamespaceLayer
+});
+/**
+* Cloudflare platform bindings as Effect services (DEPLOY-010: "Cloudflare platform bindings
+* are supplied as Effect services/Layers"). Application code never reads `env` or touches a
+* `DurableObjectState` directly — the Thread Object class constructs these Layers once
+* per incarnation and everything downstream consumes the services.
+*/
+/** A Cloudflare platform binding was missing or carried the wrong shape (DEPLOY-003/010). */
+var CloudflareBindingError = class extends Schema.TaggedError()("CloudflareBindingError", {
+	binding: Schema.String,
+	message: Schema.String
+}) {};
+/**
+* Deterministic logical Thread placement. The native adapter uses `idFromName(threadId)`;
+* a shared application owner can bind that logical identity into its RPC adapter instead.
+* Lookup performs no I/O and grants no authority. Calls reuse a native target within
+* one invocation; incoming requests and durable retries acquire their own targets.
+*/
+var ThreadObjectNamespace = class ThreadObjectNamespace extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectNamespace") {
+	static layer(namespace, options = {}) {
+		return Layer.succeed(ThreadObjectNamespace)({
+			get: (threadId) => namespace.get(namespace.idFromName(threadId)),
+			...options.rpcTracing === void 0 ? {} : { rpcTracing: options.rpcTracing }
+		});
+	}
+};
+/** Invoke a placed Thread using the current invocation's native RPC channel. */
+const callThreadObject = Effect.fn("callThreadObject")(function* (threadId, invoke, onError) {
+	const namespace = yield* ThreadObjectNamespace;
+	const target = yield* RpcTargets.get(namespace, threadId, () => namespace.get(threadId)).pipe(Effect.mapError(onError));
+	return yield* Effect.tryPromise({
+		try: () => invoke(target),
+		catch: onError
+	}).pipe(Effect.tapCause(() => RpcTargets.invalidate(target)));
+});
+/**
+* Narrow one `env` member to a `DurableObjectNamespace`. `env` is an untyped platform value,
+* and a namespace binding is a host object no Schema can decode, so this is the documented
+* narrowest-boundary check (structural probe for the namespace surface the transport uses);
+* a missing or misshaped binding fails typed before any Layer is built.
+*/
+const threadNamespaceFromEnv = Effect.fn("threadNamespaceFromEnv")(function* (env, binding) {
+	if (!Predicate.isObjectKeyword(env)) return yield* CloudflareBindingError.make({
+		binding,
+		message: "The Worker environment is not an object; no bindings are available."
+	});
+	const candidate = yield* Effect.try({
+		try: () => {
+			const value = Reflect.get(env, binding);
+			if (!Predicate.isObjectKeyword(value)) return void 0;
+			const idFromName = Reflect.get(value, "idFromName");
+			const get = Reflect.get(value, "get");
+			return typeof idFromName === "function" && typeof get === "function" ? value : void 0;
+		},
+		catch: () => CloudflareBindingError.make({
+			binding,
+			message: `env.${binding} could not be inspected as a DurableObjectNamespace binding.`
+		})
+	});
+	if (candidate !== void 0) return candidate;
+	return yield* CloudflareBindingError.make({
+		binding,
+		message: `env.${binding} is not a DurableObjectNamespace binding; declare the Thread Object class under this binding in the Worker configuration.`
+	});
+});
+/**
+* Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the
+* receiver also opts into the effect-cf native RPC trace-context contract.
+*/
+const threadNamespaceLayer = (env, binding, options = {}) => Layer.effect(ThreadObjectNamespace)(Effect.map(threadNamespaceFromEnv(env, binding), (namespace) => ({
+	get: (threadId) => namespace.get(namespace.idFromName(threadId)),
+	...options.rpcTracing === true ? { rpcTracing: binding } : {}
+})));
+/**
+* The live Durable Object execution context of THIS incarnation. Only Layer construction and
+* the alarm service consume it; important state never lives on it (`ctx.storage` is truth,
+* everything in memory is a cache — deployment spec §11).
+*/
+var DurableObjectContext = class DurableObjectContext extends Context.Service()("@effect-agent/platform-cloudflare/DurableObjectContext") {
+	static layer(ctx, env) {
+		return Layer.succeed(DurableObjectContext)({
+			ctx,
+			env
+		});
+	}
+};
+/**
+* The Thread identity this Object serializes and the producer identity its Attempts
+* write with (`{producerPrefix}:{threadId}`, plan §1.4). Derived once per incarnation
+* from `ctx.id.name` — the Object identity rule guarantees the name IS the Thread ID.
+*/
+var ThreadObjectIdentity = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectIdentity") {};
+/** Logical Threads whose canonical stores and admission ledger live in this physical Object. */
+var ThreadObjectPlacement = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectPlacement") {};
+//#endregion
+export { CloudflareBindingError, DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPlacement, callThreadObject, CloudflareBindings_exports as t, threadNamespaceFromEnv, threadNamespaceLayer };
+
+//# sourceMappingURL=CloudflareBindings.mjs.map

package/dist/CloudflareBindings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareBindings.mjs","names":[],"sources":["../src/CloudflareBindings.ts"],"sourcesContent":["import { Context, Effect, Layer, Predicate, Schema } from \"effect\";\nimport { type ThreadId } from \"effect-agent/identifiers\";\nimport { type ProducerId } from \"effect-agent/records\";\nimport { RpcTargets } from \"effect-cf\";\n\n/**\n * Cloudflare platform bindings as Effect services (DEPLOY-010: \"Cloudflare platform bindings\n * are supplied as Effect services/Layers\"). Application code never reads `env` or touches a\n * `DurableObjectState` directly — the Thread Object class constructs these Layers once\n * per incarnation and everything downstream consumes the services.\n */\n\n/** A Cloudflare platform binding was missing or carried the wrong shape (DEPLOY-003/010). */\nexport class CloudflareBindingError extends Schema.TaggedError<CloudflareBindingError>()(\n  \"CloudflareBindingError\",\n  {\n    binding: Schema.String,\n    message: Schema.String,\n  },\n) {}\n\n/**\n * The RPC surface one Thread Durable Object exposes to Workers and to sibling\n * Thread Objects. `ThreadObject.make` implements it; the Worker-side client\n * and the cross-Object transport call it through `DurableObjectNamespace` stubs. Every\n * `encoded` value is a Schema-encoded envelope (`client.ts` wire schemas for host entry\n * points, `@effect-agent/storage-cloudflare` port envelopes for `portCall`), so the RPC\n * boundary carries only structured-cloneable JSON. The optional trailing trace context is\n * transient native RPC metadata, stripped by an opted-in effect-cf receiver before decoding\n * the host envelope. It never enters durable state.\n */\nexport interface ThreadObjectRpc extends Rpc.DurableObjectBranded {\n  /** Admission-limits gate + `DurableAgentRuntime.submit`; answers a `SubmitResponse`. */\n  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */\n  submissionStatusEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */\n  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Best-effort cancellation for one in-flight progress wait. */\n  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** One bounded page of canonical records; answers an `ObservePageResponse`. */\n  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Durable abort intent; answers an `AbortResponse`. */\n  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Durable approval decision (plan §2.6); answers a `ResolveApprovalResponse`. */\n  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Authorized DUR-017 Unknown-Outcome resolution; answers a `ResolveUnknownResponse`. */\n  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Owner-side cross-Object port endpoint (WP2 envelopes, executed on LOCAL facets). */\n  portCall(encoded: unknown): Promise<unknown>;\n  /** Droppable liveness hint from another Object: arms an immediate alarm. */\n  wake(): Promise<void>;\n}\n\n/** A logical Thread endpoint may be bound to an application Object without forging its brand. */\nexport type ThreadObjectClient = Omit<ThreadObjectRpc, keyof Rpc.DurableObjectBranded>;\n\n/**\n * Deterministic logical Thread placement. The native adapter uses `idFromName(threadId)`;\n * a shared application owner can bind that logical identity into its RPC adapter instead.\n * Lookup performs no I/O and grants no authority. Calls reuse a native target within\n * one invocation; incoming requests and durable retries acquire their own targets.\n */\nexport class ThreadObjectNamespace extends Context.Service<\n  ThreadObjectNamespace,\n  {\n    readonly get: (threadId: ThreadId) => ThreadObjectClient;\n    /** Stable binding name for opted-in native RPC tracing; absent by default. */\n    readonly rpcTracing?: string;\n  }\n>()(\"@effect-agent/platform-cloudflare/ThreadObjectNamespace\") {\n  static layer(\n    namespace: DurableObjectNamespace<ThreadObjectRpc>,\n    options: { readonly rpcTracing?: string } = {},\n  ): Layer.Layer<ThreadObjectNamespace> {\n    return Layer.succeed(ThreadObjectNamespace)({\n      get: (threadId) => namespace.get(namespace.idFromName(threadId)),\n      ...(options.rpcTracing === undefined ? {} : { rpcTracing: options.rpcTracing }),\n    });\n  }\n}\n\n/** Invoke a placed Thread using the current invocation's native RPC channel. */\nexport const callThreadObject = Effect.fn(\"callThreadObject\")(function* <A, E>(\n  threadId: ThreadId,\n  invoke: (target: ThreadObjectClient) => Promise<A>,\n  onError: (cause: unknown) => E,\n): Effect.fn.Return<A, E, ThreadObjectNamespace> {\n  const namespace = yield* ThreadObjectNamespace;\n\n  const target = yield* RpcTargets.get(namespace, threadId, () => namespace.get(threadId)).pipe(\n    Effect.mapError(onError),\n  );\n\n  return yield* Effect.tryPromise({ try: () => invoke(target), catch: onError }).pipe(\n    Effect.tapCause(() => RpcTargets.invalidate(target)),\n  );\n});\n\n/**\n * Narrow one `env` member to a `DurableObjectNamespace`. `env` is an untyped platform value,\n * and a namespace binding is a host object no Schema can decode, so this is the documented\n * narrowest-boundary check (structural probe for the namespace surface the transport uses);\n * a missing or misshaped binding fails typed before any Layer is built.\n */\nexport const threadNamespaceFromEnv = Effect.fn(\"threadNamespaceFromEnv\")(function* (\n  env: unknown,\n  binding: string,\n): Effect.fn.Return<DurableObjectNamespace<ThreadObjectRpc>, CloudflareBindingError> {\n  if (!Predicate.isObjectKeyword(env)) {\n    return yield* CloudflareBindingError.make({\n      binding,\n      message: \"The Worker environment is not an object; no bindings are available.\",\n    });\n  }\n\n  const candidate = yield* Effect.try({\n    try: () => {\n      const value: unknown = Reflect.get(env, binding);\n\n      if (!Predicate.isObjectKeyword(value)) return undefined;\n      const idFromName: unknown = Reflect.get(value, \"idFromName\");\n      const get: unknown = Reflect.get(value, \"get\");\n\n      return typeof idFromName === \"function\" && typeof get === \"function\" ? value : undefined;\n    },\n    catch: () =>\n      CloudflareBindingError.make({\n        binding,\n        message: `env.${binding} could not be inspected as a DurableObjectNamespace binding.`,\n      }),\n  });\n\n  if (candidate !== undefined) {\n    // The structural probe above is the entire runtime contract this package relies on;\n    // the assertion records that `idFromName`/`get` name a DurableObjectNamespace.\n    return candidate as unknown as DurableObjectNamespace<ThreadObjectRpc>;\n  }\n\n  return yield* CloudflareBindingError.make({\n    binding,\n    message:\n      `env.${binding} is not a DurableObjectNamespace binding; declare the Thread ` +\n      \"Object class under this binding in the Worker configuration.\",\n  });\n});\n\n/**\n * Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the\n * receiver also opts into the effect-cf native RPC trace-context contract.\n */\nexport const threadNamespaceLayer = (\n  env: unknown,\n  binding: string,\n  options: { readonly rpcTracing?: boolean } = {},\n): Layer.Layer<ThreadObjectNamespace, CloudflareBindingError> =>\n  Layer.effect(ThreadObjectNamespace)(\n    Effect.map(threadNamespaceFromEnv(env, binding), (namespace) => ({\n      get: (threadId) => namespace.get(namespace.idFromName(threadId)),\n      ...(options.rpcTracing === true ? { rpcTracing: binding } : {}),\n    })),\n  );\n\n/**\n * The live Durable Object execution context of THIS incarnation. Only Layer construction and\n * the alarm service consume it; important state never lives on it (`ctx.storage` is truth,\n * everything in memory is a cache — deployment spec §11).\n */\nexport class DurableObjectContext extends Context.Service<\n  DurableObjectContext,\n  {\n    readonly ctx: DurableObjectState;\n    readonly env: unknown;\n  }\n>()(\"@effect-agent/platform-cloudflare/DurableObjectContext\") {\n  static layer(ctx: DurableObjectState, env: unknown): Layer.Layer<DurableObjectContext> {\n    return Layer.succeed(DurableObjectContext)({ ctx, env });\n  }\n}\n\n/**\n * The Thread identity this Object serializes and the producer identity its Attempts\n * write with (`{producerPrefix}:{threadId}`, plan §1.4). Derived once per incarnation\n * from `ctx.id.name` — the Object identity rule guarantees the name IS the Thread ID.\n */\nexport class ThreadObjectIdentity extends Context.Service<\n  ThreadObjectIdentity,\n  {\n    readonly threadId: ThreadId;\n    readonly producerId: ProducerId;\n  }\n>()(\"@effect-agent/platform-cloudflare/ThreadObjectIdentity\") {}\n\n/** Logical Threads whose canonical stores and admission ledger live in this physical Object. */\nexport class ThreadObjectPlacement extends Context.Service<\n  ThreadObjectPlacement,\n  { readonly ownsThread: (threadId: ThreadId) => boolean }\n>()(\"@effect-agent/platform-cloudflare/ThreadObjectPlacement\") {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAaA,IAAa,yBAAb,cAA4C,OAAO,YAAoC,CAAC,CACtF,0BACA;CACE,SAAS,OAAO;CAChB,SAAS,OAAO;AAClB,CACF,CAAC,CAAC,CAAC;;;;;;;AA6CH,IAAa,wBAAb,MAAa,8BAA8B,QAAQ,QAOjD,CAAC,CAAC,yDAAyD,CAAC,CAAC;CAC7D,OAAO,MACL,WACA,UAA4C,CAAC,GACT;EACpC,OAAO,MAAM,QAAQ,qBAAqB,CAAC,CAAC;GAC1C,MAAM,aAAa,UAAU,IAAI,UAAU,WAAW,QAAQ,CAAC;GAC/D,GAAI,QAAQ,eAAe,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY,QAAQ,WAAW;EAC/E,CAAC;CACH;AACF;;AAGA,MAAa,mBAAmB,OAAO,GAAG,kBAAkB,CAAC,CAAC,WAC5D,UACA,QACA,SAC+C;CAC/C,MAAM,YAAY,OAAO;CAEzB,MAAM,SAAS,OAAO,WAAW,IAAI,WAAW,gBAAgB,UAAU,IAAI,QAAQ,CAAC,CAAC,CAAC,KACvF,OAAO,SAAS,OAAO,CACzB;CAEA,OAAO,OAAO,OAAO,WAAW;EAAE,WAAW,OAAO,MAAM;EAAG,OAAO;CAAQ,CAAC,CAAC,CAAC,KAC7E,OAAO,eAAe,WAAW,WAAW,MAAM,CAAC,CACrD;AACF,CAAC;;;;;;;AAQD,MAAa,yBAAyB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WACxE,KACA,SACmF;CACnF,IAAI,CAAC,UAAU,gBAAgB,GAAG,GAChC,OAAO,OAAO,uBAAuB,KAAK;EACxC;EACA,SAAS;CACX,CAAC;CAGH,MAAM,YAAY,OAAO,OAAO,IAAI;EAClC,WAAW;GACT,MAAM,QAAiB,QAAQ,IAAI,KAAK,OAAO;GAE/C,IAAI,CAAC,UAAU,gBAAgB,KAAK,GAAG,OAAO,KAAA;GAC9C,MAAM,aAAsB,QAAQ,IAAI,OAAO,YAAY;GAC3D,MAAM,MAAe,QAAQ,IAAI,OAAO,KAAK;GAE7C,OAAO,OAAO,eAAe,cAAc,OAAO,QAAQ,aAAa,QAAQ,KAAA;EACjF;EACA,aACE,uBAAuB,KAAK;GAC1B;GACA,SAAS,OAAO,QAAQ;EAC1B,CAAC;CACL,CAAC;CAED,IAAI,cAAc,KAAA,GAGhB,OAAO;CAGT,OAAO,OAAO,uBAAuB,KAAK;EACxC;EACA,SACE,OAAO,QAAQ;CAEnB,CAAC;AACH,CAAC;;;;;AAMD,MAAa,wBACX,KACA,SACA,UAA6C,CAAC,MAE9C,MAAM,OAAO,qBAAqB,CAAC,CACjC,OAAO,IAAI,uBAAuB,KAAK,OAAO,IAAI,eAAe;CAC/D,MAAM,aAAa,UAAU,IAAI,UAAU,WAAW,QAAQ,CAAC;CAC/D,GAAI,QAAQ,eAAe,OAAO,EAAE,YAAY,QAAQ,IAAI,CAAC;AAC/D,EAAE,CACJ;;;;;;AAOF,IAAa,uBAAb,MAAa,6BAA6B,QAAQ,QAMhD,CAAC,CAAC,wDAAwD,CAAC,CAAC;CAC5D,OAAO,MAAM,KAAyB,KAAiD;EACrF,OAAO,MAAM,QAAQ,oBAAoB,CAAC,CAAC;GAAE;GAAK;EAAI,CAAC;CACzD;AACF;;;;;;AAOA,IAAa,uBAAb,cAA0C,QAAQ,QAMhD,CAAC,CAAC,wDAAwD,CAAC,CAAC,CAAC;;AAG/D,IAAa,wBAAb,cAA2C,QAAQ,QAGjD,CAAC,CAAC,yDAAyD,CAAC,CAAC,CAAC"}