@effect/ai-anthropic 0.16.1 → 0.17.0

package/dist/dts/AnthropicClient.d.ts

@@ -1,6 +1,8 @@
-import * as AiResponse from "@effect/ai/AiResponse";
+/**
+ * @since 1.0.0
+ */
+import * as AiError from "@effect/ai/AiError";
 import * as HttpClient from "@effect/platform/HttpClient";
-import type * as HttpClientError from "@effect/platform/HttpClientError";
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
 import * as Config from "effect/Config";
 import type { ConfigError } from "effect/ConfigError";
@@ -8,9 +10,11 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import type * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 import * as Generated from "./Generated.js";
-declare const AnthropicClient_base: Context.TagClass<AnthropicClient, "@effect/ai-anthropic/AnthropicClient", AnthropicClient.Service>;
+declare const AnthropicClient_base: Context.TagClass<AnthropicClient, "@effect/ai-anthropic/AnthropicClient", Service>;
 /**
  * @since 1.0.0
  * @category Context
@@ -18,39 +22,629 @@ declare const AnthropicClient_base: Context.TagClass<AnthropicClient, "@effect/a
 export declare class AnthropicClient extends AnthropicClient_base {
 }
 /**
+ * Represents the interface that the `AnthropicClient` service provides.
+ *
+ * This service abstracts the complexity of communicating with Anthropic's API,
+ * providing both high-level text generation methods and low-level HTTP access
+ * for advanced use cases.
+ *
  * @since 1.0.0
+ * @category Models
  */
-export declare namespace AnthropicClient {
+export interface Service {
     /**
-     * @since 1.0.0
-     * @category Models
+     * The underlying HTTP client capable of communicating with the Anthropic API.
+     *
+     * This client is pre-configured with authentication, base URL, and standard
+     * headers required for Anthropic API communication. It provides direct access
+     * to the generated Anthropic API client for operations not covered by the
+     * higher-level methods.
+     *
+     * Use this when you need to:
+     * - Access provider-specific API endpoints not available through the AI SDK
+     * - Implement custom request/response handling
+     * - Use Anthropic API features not yet supported by the Effect AI abstractions
+     * - Perform batch operations or non-streaming requests
+     *
+     * The client automatically handles authentication and follows Anthropic's
+     * API conventions for request formatting and error handling.
      */
-    interface Service {
-        readonly client: Generated.Client;
-        readonly streamRequest: <A>(request: HttpClientRequest.HttpClientRequest) => Stream.Stream<A, HttpClientError.HttpClientError>;
-        readonly stream: (request: StreamCompletionRequest) => Stream.Stream<AiResponse.AiResponse, HttpClientError.HttpClientError>;
-    }
+    readonly client: Generated.Client;
+    readonly streamRequest: <A, I, R>(request: HttpClientRequest.HttpClientRequest, schema: Schema.Schema<A, I, R>) => Stream.Stream<A, AiError.AiError, R>;
+    readonly createMessage: (options: {
+        readonly params?: typeof Generated.BetaMessagesPostParams.Encoded | undefined;
+        readonly payload: typeof Generated.BetaCreateMessageParams.Encoded;
+    }) => Effect.Effect<Generated.BetaMessage, AiError.AiError>;
+    readonly createMessageStream: (options: {
+        readonly params?: typeof Generated.BetaMessagesPostParams.Encoded | undefined;
+        readonly payload: Omit<typeof Generated.BetaCreateMessageParams.Encoded, "stream">;
+    }) => Stream.Stream<MessageStreamEvent, AiError.AiError>;
 }
 /**
  * @since 1.0.0
  * @category Constructors
  */
 export declare const make: (options: {
+    /**
+     * The API key that will be used to authenticate with Anthropic's API.
+     *
+     * The key is wrapped in a `Redacted` type to prevent accidental logging or
+     * exposure in debugging output, helping maintain security best practices.
+     *
+     * The key is automatically included in the `x-api-key` header for all API
+     * requests made through this client, which is automatically redacted in logs
+     * output by Effect loggers.
+     *
+     * Leave `undefined` if authentication will be handled through other means
+     * (e.g., environment-based authentication, proxy authentication, or when
+     * using a mock server that doesn't require authentication).
+     */
     readonly apiKey?: Redacted.Redacted | undefined;
+    /**
+     * The base URL endpoint used to communicate with Anthropic's API.
+     *
+     * This property determines the HTTP destination for all API requests made by
+     * this client.
+     *
+     * Defaults to `"https://api.anthropic.com"`.
+     *
+     * Override this value when you need to:
+     * - Point to a different Anthropic environment (e.g., staging or sandbox
+     *   servers).
+     * - Use a proxy between your application and Anthropic's API for security,
+     *   caching, or logging.
+     * - Employ a mock server for local development or testing.
+     *
+     * You may leave this property `undefined` to accept the default value.
+     */
     readonly apiUrl?: string | undefined;
+    /**
+     * The Anthropic API version to use for requests.
+     *
+     * This version string determines which API schema and features are available
+     * for your requests. Different versions may have different capabilities,
+     * request/response formats, or available models.
+     *
+     * Defaults to `"2023-06-01"`.
+     *
+     * You should specify a version that:
+     * - Supports the features and models you need
+     * - Is stable and well-tested for your use case
+     * - Matches your application's integration requirements
+     *
+     * Consult Anthropic's API documentation for available versions and their
+     * differences.
+     */
     readonly anthropicVersion?: string | undefined;
+    /**
+     * The organization ID to associate with API requests.
+     *
+     * This identifier links requests to a specific organization within your
+     * Anthropic account, enabling proper billing, usage tracking, and access
+     * control at the organizational level.
+     *
+     * Provide this when:
+     * - Your account belongs to multiple organizations
+     * - You need to ensure requests are billed to the correct organization
+     * - Organization-level access policies apply to your use case
+     *
+     * Leave `undefined` if you're using a personal account or the default
+     * organization.
+     */
     readonly organizationId?: Redacted.Redacted | undefined;
+    /**
+     * The project ID to associate with API requests.
+     *
+     * This identifier scopes requests to a specific project within your
+     * organization, enabling granular resource management, billing allocation,
+     * and access control at the project level.
+     *
+     * Specify this when:
+     * - You have multiple projects and need to separate their API usage
+     * - Project-level billing or quota management is required
+     * - Access policies are configured at the project level
+     *
+     * Leave `undefined` to use the default project or when project-level
+     * scoping is not needed.
+     */
     readonly projectId?: Redacted.Redacted | undefined;
+    /**
+     * A function to transform the underlying HTTP client before it's used for API requests.
+     *
+     * This transformation function receives the configured HTTP client and returns
+     * a modified version. It's applied after all standard client configuration
+     * (authentication, base URL, headers) but before any requests are made.
+     *
+     * Use this for:
+     * - Adding custom middleware (logging, metrics, caching)
+     * - Modifying request/response processing behavior
+     * - Adding custom retry logic or error handling
+     * - Integrating with monitoring or debugging tools
+     * - Applying organization-specific HTTP client policies
+     *
+     * The transformation is applied once during client initialization and affects
+     * all subsequent API requests made through this client instance.
+     *
+     * Leave `undefined` if no custom HTTP client behavior is needed.
+     */
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;
-}) => Effect.Effect<AnthropicClient.Service, never, HttpClient.HttpClient>;
+}) => Effect.Effect<Service, never, HttpClient.HttpClient | Scope.Scope>;
+declare const PingEvent_base: Schema.Class<PingEvent, {
+    type: Schema.Literal<["ping"]>;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["ping"]>;
+}>, never, {
+    readonly type: "ping";
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class PingEvent extends PingEvent_base {
+}
+declare const ErrorEvent_base: Schema.Class<ErrorEvent, {
+    type: Schema.Literal<["error"]>;
+    error: Schema.Struct<{
+        type: Schema.Literal<["invalid_request_error", "authentication_error", "permission_error", "not_found_error", "request_too_large", "rate_limit_error", "api_error", "overloaded_error"]>;
+        message: typeof Schema.String;
+    }>;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["error"]>;
+    error: Schema.Struct<{
+        type: Schema.Literal<["invalid_request_error", "authentication_error", "permission_error", "not_found_error", "request_too_large", "rate_limit_error", "api_error", "overloaded_error"]>;
+        message: typeof Schema.String;
+    }>;
+}>, never, {
+    readonly type: "error";
+} & {
+    readonly error: {
+        readonly type: "invalid_request_error" | "authentication_error" | "permission_error" | "not_found_error" | "rate_limit_error" | "api_error" | "overloaded_error" | "request_too_large";
+        readonly message: string;
+    };
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class ErrorEvent extends ErrorEvent_base {
+}
+declare const MessageStartEvent_base: Schema.Class<MessageStartEvent, {
+    type: Schema.Literal<["message_start"]>;
+    message: typeof Generated.BetaMessage;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["message_start"]>;
+    message: typeof Generated.BetaMessage;
+}>, never, {
+    readonly type: "message_start";
+} & {
+    readonly message: Generated.BetaMessage;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class MessageStartEvent extends MessageStartEvent_base {
+}
+declare const ServerToolUsage_base: Schema.Class<ServerToolUsage, {
+    /**
+     * The number of web search tool requests.
+     */
+    web_search_requests: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => number;
+    }>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The number of web search tool requests.
+     */
+    web_search_requests: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => number;
+    }>;
+}>, never, {
+    readonly web_search_requests?: number | null | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class ServerToolUsage extends ServerToolUsage_base {
+}
+declare const MessageDelta_base: Schema.Class<MessageDelta, {
+    stop_reason: Schema.optionalWith<Schema.NullOr<Schema.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal"]>>, {
+        default: () => null;
+    }>;
+    stop_sequence: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
+        default: () => null;
+    }>;
+}, Schema.Struct.Encoded<{
+    stop_reason: Schema.optionalWith<Schema.NullOr<Schema.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal"]>>, {
+        default: () => null;
+    }>;
+    stop_sequence: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
+        default: () => null;
+    }>;
+}>, never, {
+    readonly stop_sequence?: string | null | undefined;
+} & {
+    readonly stop_reason?: "tool_use" | "max_tokens" | "end_turn" | "stop_sequence" | "pause_turn" | "refusal" | null | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class MessageDelta extends MessageDelta_base {
+}
+declare const MessageDeltaUsage_base: Schema.Class<MessageDeltaUsage, {
+    /**
+     * The cumulative number of input tokens which were used.
+     */
+    input_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The cumulative number of output tokens which were used.
+     */
+    output_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The cumulative number of input tokens used to create the cache entry.
+     */
+    cache_creation_input_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The cumulative number of input tokens read from the cache.
+     */
+    cache_read_input_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The number of server tool requests.
+     */
+    server_tool_use: Schema.optionalWith<Schema.NullOr<typeof ServerToolUsage>, {
+        default: () => null;
+    }>;
+}, Schema.Struct.Encoded<{
+    /**
+     * The cumulative number of input tokens which were used.
+     */
+    input_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The cumulative number of output tokens which were used.
+     */
+    output_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The cumulative number of input tokens used to create the cache entry.
+     */
+    cache_creation_input_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The cumulative number of input tokens read from the cache.
+     */
+    cache_read_input_tokens: Schema.optionalWith<Schema.NullOr<Schema.filter<typeof Schema.Int>>, {
+        default: () => null;
+    }>;
+    /**
+     * The number of server tool requests.
+     */
+    server_tool_use: Schema.optionalWith<Schema.NullOr<typeof ServerToolUsage>, {
+        default: () => null;
+    }>;
+}>, never, {
+    readonly server_tool_use?: ServerToolUsage | null | undefined;
+} & {
+    readonly cache_creation_input_tokens?: number | null | undefined;
+} & {
+    readonly cache_read_input_tokens?: number | null | undefined;
+} & {
+    readonly input_tokens?: number | null | undefined;
+} & {
+    readonly output_tokens?: number | null | undefined;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class MessageDeltaUsage extends MessageDeltaUsage_base {
+}
+declare const MessageDeltaEvent_base: Schema.Class<MessageDeltaEvent, {
+    type: Schema.Literal<["message_delta"]>;
+    delta: typeof MessageDelta;
+    /**
+     * Billing and rate-limit usage.
+     *
+     * Anthropic's API bills and rate-limits by token counts, as tokens represent
+     * the underlying cost to our systems.
+     *
+     * Under the hood, the API transforms requests into a format suitable for the
+     * model. The model's output then goes through a parsing stage before becoming
+     * an API response. As a result, the token counts in `usage` will not match
+     * one-to-one with the exact visible content of an API request or response.
+     *
+     * For example, `output_tokens` will be non-zero, even for an empty string
+     * response from Claude.\n\nTotal input tokens in a request is the summation
+     * of `input_tokens`, `cache_creation_input_tokens`, and `cache_read_input_tokens`.
+     */
+    usage: typeof MessageDeltaUsage;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["message_delta"]>;
+    delta: typeof MessageDelta;
+    /**
+     * Billing and rate-limit usage.
+     *
+     * Anthropic's API bills and rate-limits by token counts, as tokens represent
+     * the underlying cost to our systems.
+     *
+     * Under the hood, the API transforms requests into a format suitable for the
+     * model. The model's output then goes through a parsing stage before becoming
+     * an API response. As a result, the token counts in `usage` will not match
+     * one-to-one with the exact visible content of an API request or response.
+     *
+     * For example, `output_tokens` will be non-zero, even for an empty string
+     * response from Claude.\n\nTotal input tokens in a request is the summation
+     * of `input_tokens`, `cache_creation_input_tokens`, and `cache_read_input_tokens`.
+     */
+    usage: typeof MessageDeltaUsage;
+}>, never, {
+    readonly type: "message_delta";
+} & {
+    readonly usage: MessageDeltaUsage;
+} & {
+    readonly delta: MessageDelta;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class MessageDeltaEvent extends MessageDeltaEvent_base {
+}
+declare const MessageStopEvent_base: Schema.Class<MessageStopEvent, {
+    type: Schema.Literal<["message_stop"]>;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["message_stop"]>;
+}>, never, {
+    readonly type: "message_stop";
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class MessageStopEvent extends MessageStopEvent_base {
+}
+declare const ContentBlockStartEvent_base: Schema.Class<ContentBlockStartEvent, {
+    type: Schema.Literal<["content_block_start"]>;
+    index: typeof Schema.Int;
+    content_block: typeof Generated.BetaContentBlock;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["content_block_start"]>;
+    index: typeof Schema.Int;
+    content_block: typeof Generated.BetaContentBlock;
+}>, never, {
+    readonly type: "content_block_start";
+} & {
+    readonly index: number;
+} & {
+    readonly content_block: Generated.BetaResponseTextBlock | Generated.BetaResponseThinkingBlock | Generated.BetaResponseRedactedThinkingBlock | Generated.BetaResponseToolUseBlock | Generated.BetaResponseServerToolUseBlock | Generated.BetaResponseWebSearchToolResultBlock | Generated.BetaResponseCodeExecutionToolResultBlock | Generated.BetaResponseBashCodeExecutionToolResultBlock | Generated.BetaResponseTextEditorCodeExecutionToolResultBlock | Generated.BetaResponseMCPToolUseBlock | Generated.BetaResponseMCPToolResultBlock | Generated.BetaResponseContainerUploadBlock;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class ContentBlockStartEvent extends ContentBlockStartEvent_base {
+}
+declare const CitationsDelta_base: Schema.Class<CitationsDelta, {
+    type: Schema.Literal<["citations_delta"]>;
+    citation: Schema.Union<[typeof Generated.BetaResponseCharLocationCitation, typeof Generated.BetaResponsePageLocationCitation, typeof Generated.BetaResponseContentBlockLocationCitation, typeof Generated.BetaResponseWebSearchResultLocationCitation, typeof Generated.BetaResponseSearchResultLocationCitation]>;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["citations_delta"]>;
+    citation: Schema.Union<[typeof Generated.BetaResponseCharLocationCitation, typeof Generated.BetaResponsePageLocationCitation, typeof Generated.BetaResponseContentBlockLocationCitation, typeof Generated.BetaResponseWebSearchResultLocationCitation, typeof Generated.BetaResponseSearchResultLocationCitation]>;
+}>, never, {
+    readonly type: "citations_delta";
+} & {
+    readonly citation: Generated.BetaResponseCharLocationCitation | Generated.BetaResponsePageLocationCitation | Generated.BetaResponseContentBlockLocationCitation | Generated.BetaResponseWebSearchResultLocationCitation | Generated.BetaResponseSearchResultLocationCitation;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class CitationsDelta extends CitationsDelta_base {
+}
+declare const InputJsonContentBlockDelta_base: Schema.Class<InputJsonContentBlockDelta, {
+    type: Schema.Literal<["input_json_delta"]>;
+    partial_json: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["input_json_delta"]>;
+    partial_json: typeof Schema.String;
+}>, never, {
+    readonly type: "input_json_delta";
+} & {
+    readonly partial_json: string;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class InputJsonContentBlockDelta extends InputJsonContentBlockDelta_base {
+}
+declare const SignatureContentBlockDelta_base: Schema.Class<SignatureContentBlockDelta, {
+    type: Schema.Literal<["signature_delta"]>;
+    signature: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["signature_delta"]>;
+    signature: typeof Schema.String;
+}>, never, {
+    readonly type: "signature_delta";
+} & {
+    readonly signature: string;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class SignatureContentBlockDelta extends SignatureContentBlockDelta_base {
+}
+declare const TextContentBlockDelta_base: Schema.Class<TextContentBlockDelta, {
+    type: Schema.Literal<["text_delta"]>;
+    text: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["text_delta"]>;
+    text: typeof Schema.String;
+}>, never, {
+    readonly type: "text_delta";
+} & {
+    readonly text: string;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class TextContentBlockDelta extends TextContentBlockDelta_base {
+}
+declare const ThinkingContentBlockDelta_base: Schema.Class<ThinkingContentBlockDelta, {
+    type: Schema.Literal<["thinking_delta"]>;
+    thinking: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["thinking_delta"]>;
+    thinking: typeof Schema.String;
+}>, never, {
+    readonly type: "thinking_delta";
+} & {
+    readonly thinking: string;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class ThinkingContentBlockDelta extends ThinkingContentBlockDelta_base {
+}
+declare const ContentBlockDeltaEvent_base: Schema.Class<ContentBlockDeltaEvent, {
+    type: Schema.Literal<["content_block_delta"]>;
+    index: typeof Schema.Int;
+    delta: Schema.Union<[typeof CitationsDelta, typeof InputJsonContentBlockDelta, typeof SignatureContentBlockDelta, typeof TextContentBlockDelta, typeof ThinkingContentBlockDelta]>;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["content_block_delta"]>;
+    index: typeof Schema.Int;
+    delta: Schema.Union<[typeof CitationsDelta, typeof InputJsonContentBlockDelta, typeof SignatureContentBlockDelta, typeof TextContentBlockDelta, typeof ThinkingContentBlockDelta]>;
+}>, never, {
+    readonly type: "content_block_delta";
+} & {
+    readonly delta: CitationsDelta | InputJsonContentBlockDelta | SignatureContentBlockDelta | TextContentBlockDelta | ThinkingContentBlockDelta;
+} & {
+    readonly index: number;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class ContentBlockDeltaEvent extends ContentBlockDeltaEvent_base {
+}
+declare const ContentBlockStopEvent_base: Schema.Class<ContentBlockStopEvent, {
+    type: Schema.Literal<["content_block_stop"]>;
+    index: typeof Schema.Int;
+}, Schema.Struct.Encoded<{
+    type: Schema.Literal<["content_block_stop"]>;
+    index: typeof Schema.Int;
+}>, never, {
+    readonly type: "content_block_stop";
+} & {
+    readonly index: number;
+}, {}, {}>;
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare class ContentBlockStopEvent extends ContentBlockStopEvent_base {
+}
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare const MessageStreamEvent: Schema.Union<[typeof PingEvent, typeof ErrorEvent, typeof MessageStartEvent, typeof MessageDeltaEvent, typeof MessageStopEvent, typeof ContentBlockStartEvent, typeof ContentBlockDeltaEvent, typeof ContentBlockStopEvent]>;
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+export type MessageStreamEvent = typeof MessageStreamEvent.Type;
 /**
  * @since 1.0.0
  * @category Layers
  */
 export declare const layer: (options: {
+    /**
+     * The API key that will be used to authenticate with Anthropic's API.
+     *
+     * The key is wrapped in a `Redacted` type to prevent accidental logging or
+     * exposure in debugging output, helping maintain security best practices.
+     *
+     * The key is automatically included in the `x-api-key` header for all API
+     * requests made through this client, which is automatically redacted in logs
+     * output by Effect loggers.
+     *
+     * Leave `undefined` if authentication will be handled through other means
+     * (e.g., environment-based authentication, proxy authentication, or when
+     * using a mock server that doesn't require authentication).
+     */
     readonly apiKey?: Redacted.Redacted | undefined;
+    /**
+     * The base URL endpoint used to communicate with Anthropic's API.
+     *
+     * This property determines the HTTP destination for all API requests made by
+     * this client.
+     *
+     * Defaults to `"https://api.anthropic.com"`.
+     *
+     * Override this value when you need to:
+     * - Point to a different Anthropic environment (e.g., staging or sandbox
+     *   servers).
+     * - Use a proxy between your application and Anthropic's API for security,
+     *   caching, or logging.
+     * - Employ a mock server for local development or testing.
+     *
+     * You may leave this property `undefined` to accept the default value.
+     */
     readonly apiUrl?: string | undefined;
+    /**
+     * The Anthropic API version to use for requests.
+     *
+     * This version string determines which API schema and features are available
+     * for your requests. Different versions may have different capabilities,
+     * request/response formats, or available models.
+     *
+     * Defaults to `"2023-06-01"`.
+     *
+     * You should specify a version that:
+     * - Supports the features and models you need
+     * - Is stable and well-tested for your use case
+     * - Matches your application's integration requirements
+     *
+     * Consult Anthropic's API documentation for available versions and their
+     * differences.
+     */
     readonly anthropicVersion?: string | undefined;
+    /**
+     * A function to transform the underlying HTTP client before it's used for API requests.
+     *
+     * This transformation function receives the configured HTTP client and returns
+     * a modified version. It's applied after all standard client configuration
+     * (authentication, base URL, headers) but before any requests are made.
+     *
+     * Use this for:
+     * - Adding custom middleware (logging, metrics, caching)
+     * - Modifying request/response processing behavior
+     * - Adding custom retry logic or error handling
+     * - Integrating with monitoring or debugging tools
+     * - Applying organization-specific HTTP client policies
+     *
+     * The transformation is applied once during client initialization and affects
+     * all subsequent API requests made through this client instance.
+     *
+     * Leave `undefined` if no custom HTTP client behavior is needed.
+     */
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;
 }) => Layer.Layer<AnthropicClient, never, HttpClient.HttpClient>;
 /**
@@ -58,15 +652,77 @@ export declare const layer: (options: {
  * @category Layers
  */
 export declare const layerConfig: (options: {
+    /**
+     * The API key that will be used to authenticate with Anthropic's API.
+     *
+     * The key is wrapped in a `Redacted` type to prevent accidental logging or
+     * exposure in debugging output, helping maintain security best practices.
+     *
+     * The key is automatically included in the `x-api-key` header for all API
+     * requests made through this client, which is automatically redacted in logs
+     * output by Effect loggers.
+     *
+     * Leave `undefined` if authentication will be handled through other means
+     * (e.g., environment-based authentication, proxy authentication, or when
+     * using a mock server that doesn't require authentication).
+     */
     readonly apiKey?: Config.Config<Redacted.Redacted | undefined> | undefined;
+    /**
+     * The base URL endpoint used to communicate with Anthropic's API.
+     *
+     * This property determines the HTTP destination for all API requests made by
+     * this client.
+     *
+     * Defaults to `"https://api.anthropic.com"`.
+     *
+     * Override this value when you need to:
+     * - Point to a different Anthropic environment (e.g., staging or sandbox
+     *   servers).
+     * - Use a proxy between your application and Anthropic's API for security,
+     *   caching, or logging.
+     * - Employ a mock server for local development or testing.
+     *
+     * You may leave this property `undefined` to accept the default value.
+     */
     readonly apiUrl?: Config.Config<string | undefined> | undefined;
+    /**
+     * The Anthropic API version to use for requests.
+     *
+     * This version string determines which API schema and features are available
+     * for your requests. Different versions may have different capabilities,
+     * request/response formats, or available models.
+     *
+     * Defaults to `"2023-06-01"`.
+     *
+     * You should specify a version that:
+     * - Supports the features and models you need
+     * - Is stable and well-tested for your use case
+     * - Matches your application's integration requirements
+     *
+     * Consult Anthropic's API documentation for available versions and their
+     * differences.
+     */
     readonly anthropicVersion?: Config.Config<string | undefined> | undefined;
+    /**
+     * A function to transform the underlying HTTP client before it's used for API requests.
+     *
+     * This transformation function receives the configured HTTP client and returns
+     * a modified version. It's applied after all standard client configuration
+     * (authentication, base URL, headers) but before any requests are made.
+     *
+     * Use this for:
+     * - Adding custom middleware (logging, metrics, caching)
+     * - Modifying request/response processing behavior
+     * - Adding custom retry logic or error handling
+     * - Integrating with monitoring or debugging tools
+     * - Applying organization-specific HTTP client policies
+     *
+     * The transformation is applied once during client initialization and affects
+     * all subsequent API requests made through this client instance.
+     *
+     * Leave `undefined` if no custom HTTP client behavior is needed.
+     */
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;
 }) => Layer.Layer<AnthropicClient, ConfigError, HttpClient.HttpClient>;
-/**
- * @since 1.0.0
- * @category Models
- */
-export type StreamCompletionRequest = Omit<typeof Generated.CreateMessageParams.Encoded, "stream">;
 export {};
 //# sourceMappingURL=AnthropicClient.d.ts.map