anthropic_gleam - v0.1.0

anthropic_gleam

Anthropic Gleam - A typed Gleam client for Anthropic’s Claude API

This library provides a well-typed, idiomatic interface to Claude’s API, including support for streaming responses and tool use.

Quick Start

import anthropic/types/message.{user_message}
import anthropic/types/request.{create_request, request_to_json_string}

let request = create_request(
  "claude-sonnet-4-20250514",
  [user_message("Hello, Claude!")],
  1024,
)
let json_string = request_to_json_string(request)

Message Types

The library provides comprehensive types for the Messages API:

Request/Response Types

Error Types

All types support JSON encoding/decoding for API communication.

Types

AccumulatorState

</> 
pub type AccumulatorState =
  accumulator.AccumulatorState

AnthropicError

</> 
pub type AnthropicError =
  error.AnthropicError

ApiErrorDetails

</> 
pub type ApiErrorDetails =
  error.ApiErrorDetails

ApiErrorType

</> 
pub type ApiErrorType =
  error.ApiErrorType

Client

</> 
pub type Client =
  client.Client

Config

</> 
pub type Config =
  config.Config

ConfigOptions

</> 
pub type ConfigOptions =
  config.ConfigOptions

ContentBlock

</> 
pub type ContentBlock =
  message.ContentBlock

ContentBlockDelta

</> 
pub type ContentBlockDelta =
  streaming.ContentBlockDelta

ContentBlockDeltaEvent

</> 
pub type ContentBlockDeltaEvent =
  streaming.ContentBlockDeltaEvent

ContentBlockStart

</> 
pub type ContentBlockStart =
  streaming.ContentBlockStart

ContentBlockState

</> 
pub type ContentBlockState =
  accumulator.ContentBlockState

ContentBlockStop

</> 
pub type ContentBlockStop =
  streaming.ContentBlockStop

CreateMessageRequest

</> 
pub type CreateMessageRequest =
  request.CreateMessageRequest

CreateMessageResponse

</> 
pub type CreateMessageResponse =
  request.CreateMessageResponse

DecodeError

</> 
pub type DecodeError =
  decoder.DecodeError

EventCallback

</> 
pub type EventCallback =
  fn(streaming.StreamEvent) -> Nil

ImageSource

</> 
pub type ImageSource =
  message.ImageSource

ImageSourceType

</> 
pub type ImageSourceType =
  message.ImageSourceType

InputJsonDelta

</> 
pub type InputJsonDelta =
  streaming.InputJsonDelta

Message

</> 
pub type Message =
  message.Message

MessageDelta

</> 
pub type MessageDelta =
  streaming.MessageDelta

MessageDeltaEvent

</> 
pub type MessageDeltaEvent =
  streaming.MessageDeltaEvent

MessageDeltaUsage

</> 
pub type MessageDeltaUsage =
  streaming.MessageDeltaUsage

MessageStart

</> 
pub type MessageStart =
  streaming.MessageStart

Metadata

</> 
pub type Metadata =
  request.Metadata

Role

</> 
pub type Role =
  message.Role

SseError

</> 
pub type SseError =
  sse.SseError

SseEvent

</> 
pub type SseEvent =
  sse.SseEvent

SseParseResult

</> 
pub type SseParseResult =
  sse.SseParseResult

SseParserState

</> 
pub type SseParserState =
  sse.SseParserState

StopReason

</> 
pub type StopReason =
  request.StopReason

StreamError

</> 
pub type StreamError =
  streaming.StreamError

StreamEvent

</> 
pub type StreamEvent =
  streaming.StreamEvent

StreamHandlerError

</> 
pub type StreamHandlerError =
  handler.StreamError

StreamResult

</> 
pub type StreamResult =
  handler.StreamResult

TextDelta

</> 
pub type TextDelta =
  streaming.TextDelta

Usage

</> 
pub type Usage =
  request.Usage

Values

accumulate

</> 
pub const accumulate: fn(List(streaming.StreamEvent)) -> Result(
  request.CreateMessageResponse,
  String,
)

accumulator_has_content

</> 
pub const accumulator_has_content: fn(
  accumulator.AccumulatorState,
) -> Bool

accumulator_has_error

</> 
pub const accumulator_has_error: fn(accumulator.AccumulatorState) -> Bool

api_error

</> 
pub const api_error: fn(Int, error.ApiErrorDetails) -> error.AnthropicError

api_error_details

</> 
pub const api_error_details: fn(error.ApiErrorType, String) -> error.ApiErrorDetails

api_error_details_full

</> 
pub const api_error_details_full: fn(
  error.ApiErrorType,
  String,
  option.Option(String),
  option.Option(String),
) -> error.ApiErrorDetails

api_error_details_to_json

</> 
pub const api_error_details_to_json: fn(error.ApiErrorDetails) -> json.Json

api_error_details_to_string

</> 
pub const api_error_details_to_string: fn(error.ApiErrorDetails) -> String

api_error_type_from_string

</> 
pub const api_error_type_from_string: fn(String) -> error.ApiErrorType

api_error_type_to_string

</> 
pub const api_error_type_to_string: fn(error.ApiErrorType) -> String

api_version

</> 
pub const api_version: String

assistant_message

</> 
pub const assistant_message: fn(String) -> message.Message

authentication_error

</> 
pub const authentication_error: fn(String) -> error.AnthropicError

build_response

</> 
pub const build_response: fn(accumulator.AccumulatorState) -> Result(
  request.CreateMessageResponse,
  String,
)

config_error

</> 
pub const config_error: fn(String) -> error.AnthropicError

config_options

</> 
pub const config_options: fn() -> config.ConfigOptions

content_block_stop

</> 
pub const content_block_stop: fn(Int) -> streaming.ContentBlockStop

content_block_to_json

</> 
pub const content_block_to_json: fn(message.ContentBlock) -> json.Json

content_block_to_json_string

</> 
pub const content_block_to_json_string: fn(message.ContentBlock) -> String

content_block_type

</> 
pub const content_block_type: fn(message.ContentBlock) -> String

create_message

</> 
pub const create_message: fn(
  client.Client,
  request.CreateMessageRequest,
) -> Result(request.CreateMessageResponse, error.AnthropicError)

create_request

</> 
pub const create_request: fn(String, List(message.Message), Int) -> request.CreateMessageRequest

create_response

</> 
pub const create_response: fn(
  String,
  List(message.ContentBlock),
  String,
  option.Option(request.StopReason),
  request.Usage,
) -> request.CreateMessageResponse

create_response_with_stop_sequence

</> 
pub const create_response_with_stop_sequence: fn(
  String,
  List(message.ContentBlock),
  String,
  request.StopReason,
  String,
  request.Usage,
) -> request.CreateMessageResponse

decode_event

</> 
pub const decode_event: fn(sse.SseEvent) -> Result(
  streaming.StreamEvent,
  decoder.DecodeError,
)

default_base_url

</> 
pub const default_base_url: String

default_max_retries

</> 
pub const default_max_retries: Int

default_timeout_ms

</> 
pub const default_timeout_ms: Int

error_category

</> 
pub const error_category: fn(error.AnthropicError) -> String

error_to_json

</> 
pub const error_to_json: fn(error.AnthropicError) -> json.Json

error_to_json_string

</> 
pub const error_to_json_string: fn(error.AnthropicError) -> String

error_to_string

</> 
pub const error_to_string: fn(error.AnthropicError) -> String

event_type_from_string

</> 
pub const event_type_from_string: fn(String) -> Result(
  String,
  String,
)

event_type_string

</> 
pub const event_type_string: fn(streaming.StreamEvent) -> String

fixture_conversation_response

</> 
pub const fixture_conversation_response: fn() -> request.CreateMessageResponse

fixture_max_tokens_response

</> 
pub const fixture_max_tokens_response: fn() -> request.CreateMessageResponse

fixture_simple_response

</> 
pub const fixture_simple_response: fn() -> request.CreateMessageResponse

fixture_stop_sequence_response

</> 
pub const fixture_stop_sequence_response: fn() -> request.CreateMessageResponse

fixture_tool_use_response

</> 
pub const fixture_tool_use_response: fn() -> request.CreateMessageResponse

flush

</> 
pub const flush: fn(sse.SseParserState) -> Result(
  sse.SseEvent,
  sse.SseError,
)

get_accumulated_text

</> 
pub const get_accumulated_text: fn(accumulator.AccumulatorState) -> String

get_accumulated_tool_inputs

</> 
pub const get_accumulated_tool_inputs: fn(
  accumulator.AccumulatorState,
) -> List(#(String, String, String))

get_data

</> 
pub const get_data: fn(sse.SseEvent) -> String

get_delta_json

</> 
pub const get_delta_json: fn(streaming.ContentBlockDelta) -> option.Option(
  String,
)

get_delta_text

</> 
pub const get_delta_text: fn(streaming.ContentBlockDelta) -> option.Option(
  String,
)

get_event_type

</> 
pub const get_event_type: fn(sse.SseEvent) -> String

get_full_text

</> 
pub const get_full_text: fn(List(streaming.StreamEvent)) -> String

get_message_id

</> 
pub const get_message_id: fn(List(streaming.StreamEvent)) -> Result(
  String,
  Nil,
)

get_model

</> 
pub const get_model: fn(List(streaming.StreamEvent)) -> Result(
  String,
  Nil,
)

get_status_code

</> 
pub const get_status_code: fn(error.AnthropicError) -> option.Option(
  Int,
)

get_stream_error

</> 
pub const get_stream_error: fn(List(streaming.StreamEvent)) -> Result(
  streaming.StreamError,
  Nil,
)

get_text_deltas

</> 
pub const get_text_deltas: fn(List(streaming.StreamEvent)) -> List(
  String,
)

get_tool_uses

</> 
pub const get_tool_uses: fn(message.Message) -> List(
  message.ContentBlock,
)

handle_response

</> 
pub const handle_response: fn(response.Response(String)) -> Result(
  String,
  error.AnthropicError,
)

has_api_key

</> 
pub const has_api_key: fn() -> Bool

has_tool_use

</> 
pub const has_tool_use: fn(message.Message) -> Bool

http_error

</> 
pub const http_error: fn(String) -> error.AnthropicError

image

</> 
pub const image: fn(String, String) -> message.ContentBlock

image_source_to_json

</> 
pub const image_source_to_json: fn(message.ImageSource) -> json.Json

input_json_delta

</> 
pub const input_json_delta: fn(String) -> streaming.InputJsonDelta

input_json_delta_event

</> 
pub const input_json_delta_event: fn(Int, String) -> streaming.ContentBlockDeltaEvent

internal_api_error

</> 
pub const internal_api_error: fn(String) -> error.AnthropicError

invalid_api_key_error

</> 
pub const invalid_api_key_error: fn() -> error.AnthropicError

invalid_request_error

</> 
pub const invalid_request_error: fn(String) -> error.AnthropicError

is_authentication_error

</> 
pub const is_authentication_error: fn(error.AnthropicError) -> Bool

is_keepalive

</> 
pub const is_keepalive: fn(sse.SseEvent) -> Bool

is_overloaded_error

</> 
pub const is_overloaded_error: fn(error.AnthropicError) -> Bool

is_rate_limit_error

</> 
pub const is_rate_limit_error: fn(error.AnthropicError) -> Bool

is_retryable

</> 
pub const is_retryable: fn(error.AnthropicError) -> Bool

is_terminal_event

</> 
pub const is_terminal_event: fn(streaming.StreamEvent) -> Bool

json_error

</> 
pub const json_error: fn(String) -> error.AnthropicError

load_config

</> 
pub const load_config: fn(config.ConfigOptions) -> Result(
  config.Config,
  error.AnthropicError,
)

message_delta_event

</> 
pub const message_delta_event: fn(
  option.Option(request.StopReason),
  option.Option(String),
  Int,
) -> streaming.MessageDeltaEvent

message_start

</> 
pub const message_start: fn(String, message.Role, String, Int) -> streaming.MessageStart

message_text

</> 
pub const message_text: fn(message.Message) -> String

message_to_json

</> 
pub const message_to_json: fn(message.Message) -> json.Json

message_to_json_string

</> 
pub const message_to_json_string: fn(message.Message) -> String

messages_endpoint

</> 
pub const messages_endpoint: String

messages_to_json

</> 
pub const messages_to_json: fn(List(message.Message)) -> json.Json

metadata_to_json

</> 
pub const metadata_to_json: fn(request.Metadata) -> json.Json

missing_api_key_error

</> 
pub const missing_api_key_error: fn() -> error.AnthropicError

mock_auth_error

</> 
pub const mock_auth_error: fn() -> response.Response(String)

mock_error_body

</> 
pub const mock_error_body: fn(String, String) -> String

mock_error_response

</> 
pub const mock_error_response: fn(Int, String, String) -> response.Response(
  String,
)

mock_invalid_request_error

</> 
pub const mock_invalid_request_error: fn(String) -> response.Response(
  String,
)

mock_overloaded_error

</> 
pub const mock_overloaded_error: fn() -> response.Response(String)

mock_rate_limit_error

</> 
pub const mock_rate_limit_error: fn() -> response.Response(String)

mock_text_response

</> 
pub const mock_text_response: fn(String) -> response.Response(
  String,
)

mock_text_response_body

</> 
pub const mock_text_response_body: fn(String, String) -> String

mock_tool_use_response

</> 
pub const mock_tool_use_response: fn(String, String, String) -> response.Response(
  String,
)

mock_tool_use_response_body

</> 
pub const mock_tool_use_response_body: fn(
  String,
  String,
  String,
  String,
) -> String

network_error

</> 
pub const network_error: fn(String) -> error.AnthropicError

new_accumulator

</> 
pub const new_accumulator: fn() -> accumulator.AccumulatorState

new_client

</> 
pub const new_client: fn(config.Config) -> client.Client

new_parser_state

</> 
pub const new_parser_state: fn() -> sse.SseParserState

overloaded_error

</> 
pub const overloaded_error: fn(String) -> error.AnthropicError

parse_chunk

</> 
pub const parse_chunk: fn(sse.SseParserState, String) -> sse.SseParseResult

parse_event

</> 
pub const parse_event: fn(String) -> Result(
  sse.SseEvent,
  sse.SseError,
)

parse_event_lines

</> 
pub const parse_event_lines: fn(List(String)) -> Result(
  sse.SseEvent,
  sse.SseError,
)

parse_line

</> 
pub const parse_line: fn(sse.SseParserState, String) -> sse.SseParserState

post_and_handle

</> 
pub const post_and_handle: fn(client.Client, String, String) -> Result(
  String,
  error.AnthropicError,
)

post_json

</> 
pub const post_json: fn(client.Client, String, String) -> Result(
  response.Response(String),
  error.AnthropicError,
)

process_event

</> 
pub const process_event: fn(
  accumulator.AccumulatorState,
  streaming.StreamEvent,
) -> accumulator.AccumulatorState

process_events

</> 
pub const process_events: fn(List(streaming.StreamEvent)) -> accumulator.AccumulatorState

process_events_with_callback

</> 
pub const process_events_with_callback: fn(
  List(streaming.StreamEvent),
  fn(streaming.StreamEvent, accumulator.AccumulatorState) -> Nil,
) -> accumulator.AccumulatorState

rate_limit_error

</> 
pub const rate_limit_error: fn(String) -> error.AnthropicError

request_to_json

</> 
pub const request_to_json: fn(request.CreateMessageRequest) -> json.Json

request_to_json_string

</> 
pub const request_to_json_string: fn(request.CreateMessageRequest) -> String

reset_event_state

</> 
pub const reset_event_state: fn(sse.SseParserState) -> sse.SseParserState

response_get_tool_uses

</> 
pub const response_get_tool_uses: fn(
  request.CreateMessageResponse,
) -> List(message.ContentBlock)

response_has_tool_use

</> 
pub const response_has_tool_use: fn(request.CreateMessageResponse) -> Bool

response_text

</> 
pub const response_text: fn(request.CreateMessageResponse) -> String

response_to_json

</> 
pub const response_to_json: fn(request.CreateMessageResponse) -> json.Json

response_to_json_string

</> 
pub const response_to_json_string: fn(
  request.CreateMessageResponse,
) -> String

role_from_string

</> 
pub const role_from_string: fn(String) -> Result(
  message.Role,
  String,
)

role_to_json

</> 
pub const role_to_json: fn(message.Role) -> json.Json

role_to_string

</> 
pub const role_to_string: fn(message.Role) -> String

sse_event

</> 
pub const sse_event: fn(
  option.Option(String),
  option.Option(String),
) -> sse.SseEvent

sse_event_full

</> 
pub const sse_event_full: fn(
  option.Option(String),
  option.Option(String),
  option.Option(String),
  option.Option(Int),
) -> sse.SseEvent

stop_reason_from_string

</> 
pub const stop_reason_from_string: fn(String) -> Result(
  request.StopReason,
  String,
)

stop_reason_to_string

</> 
pub const stop_reason_to_string: fn(request.StopReason) -> String

stream_error

</> 
pub const stream_error: fn(String, String) -> streaming.StreamError

stream_has_error

</> 
pub const stream_has_error: fn(List(streaming.StreamEvent)) -> Bool

stream_is_complete

</> 
pub const stream_is_complete: fn(List(streaming.StreamEvent)) -> Bool

stream_message

</> 
pub const stream_message: fn(
  client.Client,
  request.CreateMessageRequest,
) -> Result(handler.StreamResult, handler.StreamError)

stream_message_with_callback

</> 
pub const stream_message_with_callback: fn(
  client.Client,
  request.CreateMessageRequest,
  fn(streaming.StreamEvent) -> Nil,
) -> Result(handler.StreamResult, handler.StreamError)

text

</> 
pub const text: fn(String) -> message.ContentBlock

text_block_start

</> 
pub const text_block_start: fn(Int) -> streaming.ContentBlockStart

text_delta

</> 
pub const text_delta: fn(String) -> streaming.TextDelta

text_delta_event

</> 
pub const text_delta_event: fn(Int, String) -> streaming.ContentBlockDeltaEvent

timeout_error

</> 
pub const timeout_error: fn(Int) -> error.AnthropicError

tool_error

</> 
pub const tool_error: fn(String, String) -> message.ContentBlock

tool_result

</> 
pub const tool_result: fn(String, String) -> message.ContentBlock

tool_use

</> 
pub const tool_use: fn(String, String, String) -> message.ContentBlock

tool_use_block_start

</> 
pub const tool_use_block_start: fn(Int, String, String) -> streaming.ContentBlockStart

total_tokens

</> 
pub const total_tokens: fn(accumulator.AccumulatorState) -> Int

usage

</> 
pub const usage: fn(Int, Int) -> request.Usage

usage_to_json

</> 
pub const usage_to_json: fn(request.Usage) -> json.Json

user_message

</> 
pub const user_message: fn(String) -> message.Message

with_api_key

</> 
pub const with_api_key: fn(config.ConfigOptions, String) -> config.ConfigOptions

with_base_url

</> 
pub const with_base_url: fn(config.ConfigOptions, String) -> config.ConfigOptions

with_default_model

</> 
pub const with_default_model: fn(config.ConfigOptions, String) -> config.ConfigOptions

with_max_retries

</> 
pub const with_max_retries: fn(config.ConfigOptions, Int) -> config.ConfigOptions

with_metadata

</> 
pub const with_metadata: fn(
  request.CreateMessageRequest,
  request.Metadata,
) -> request.CreateMessageRequest

with_stop_sequences

</> 
pub const with_stop_sequences: fn(
  request.CreateMessageRequest,
  List(String),
) -> request.CreateMessageRequest

with_stream

</> 
pub const with_stream: fn(request.CreateMessageRequest, Bool) -> request.CreateMessageRequest

with_system

</> 
pub const with_system: fn(request.CreateMessageRequest, String) -> request.CreateMessageRequest

with_temperature

</> 
pub const with_temperature: fn(
  request.CreateMessageRequest,
  Float,
) -> request.CreateMessageRequest

with_timeout_ms

</> 
pub const with_timeout_ms: fn(config.ConfigOptions, Int) -> config.ConfigOptions

with_top_k

</> 
pub const with_top_k: fn(request.CreateMessageRequest, Int) -> request.CreateMessageRequest

with_top_p

</> 
pub const with_top_p: fn(request.CreateMessageRequest, Float) -> request.CreateMessageRequest

with_user_id

</> 
pub const with_user_id: fn(request.CreateMessageRequest, String) -> request.CreateMessageRequest
✨ Search Document