GitHub

API reference for client.

The TypeSafe client (Effect's TypeSafeClient): System One decisions and the model list over the HttpClient service.

layer(api_key=...) provides TypeSafeClient; requests go to api_url (https://api.typesafe.ai/v1) with the key as a bearer token, through transform_client and then a provided TypeSafeConfig's transform. Every failure is an AiError, and nothing is retried.

Re-exports

Values

AttributeTypeDescription
DEFAULT_API_URLLiteral['https://api.typesafe.ai/v1'] = 'https://api.typesafe.ai/v1'

Classes

Functions

make

make(*, api_key=None, api_url=None, transform_client=None, max_response_bytes=None) -> Effect[Service, Never, HttpClient]

A client over the HttpClient service. A response body larger than max_response_bytes (256 MiB) fails the call.

ParameterTypeDescription
api_keyRedacted[str] | None = None
api_urlstr | None = None
transform_clientClientTransform | None = None
max_response_bytesbyte_size.Input | None = None

Returns Effect[Service, Never, HttpClient]

def make(
    *,
    api_key: Redacted[str] | None = None,
    api_url: str | None = None,
    transform_client: ClientTransform | None = None,
    max_response_bytes: byte_size.Input | None = None,
) -> Effect[Service, Never, HttpClient]:
    """A client over the ``HttpClient`` service. A response body larger
    than ``max_response_bytes`` (256 MiB) fails the call."""
    limit = P.response_limit(max_response_bytes)

    def prepare(request: http_request.HttpClientRequest) -> http_request.HttpClientRequest:
        request = request.prepend_url(or_default(api_url, DEFAULT_API_URL))
        if api_key is not None:
            request = request.bearer_token(redacted_value(api_key))
        return request.accept_json()

    def build(base: HttpClientService[HttpClientError]) -> Service:
        mapped = base.map_request(prepare).filter_status_ok()
        http_client = mapped if transform_client is None else transform_client(mapped)
        limited = P.limit_responses(http_client, limit)

        def execute[T](
            request: http_request.HttpClientRequest,
            decode: Callable[[object], Effect[T, Any]],
            method: str,
        ) -> Effect[T, AiError]:
            sent: Effect[Any, Any] = (
                P.resolve_client(TypeSafeConfig, limited)
                .flat_map(lambda client: client.execute(request))
                .flat_map(lambda response: response.json.flat_map(decode))
            )
            return sent.catch_all(Errors.mapper(method)).pipe(_redacted)

        def system_one(payload: W.SystemOneRequest) -> Effect[W.SystemOneResponse, AiError]:
            request = http_request.post("/systemone")
            if _uses_images(payload):
                request = request.set_header("TypeSafe-Danger-Zone-Images", "true")
            request = request.body_json_unsafe(payload)
            return execute(request, _decode_system_one, "systemOne")

        def list_models() -> Effect[W.ListModelsResponse, AiError]:
            return execute(http_request.get("/models"), _decode_models, "listModels")

        return Service(http_client, system_one, list_models)

    return HttpClient().map(build).pipe(_redacted)

layer

layer(*, api_key=None, api_url=None, transform_client=None, max_response_bytes=None) -> L.Layer[TypeSafeClient, Never, HttpClient]

TypeSafeClient from these options (see make).

ParameterTypeDescription
api_keyRedacted[str] | None = None
api_urlstr | None = None
transform_clientClientTransform | None = None
max_response_bytesbyte_size.Input | None = None

Returns L.Layer[TypeSafeClient, Never, HttpClient]

def layer(
    *,
    api_key: Redacted[str] | None = None,
    api_url: str | None = None,
    transform_client: ClientTransform | None = None,
    max_response_bytes: byte_size.Input | None = None,
) -> L.Layer[TypeSafeClient, Never, HttpClient]:
    """``TypeSafeClient`` from these options (see ``make``)."""
    return L.effect(
        TypeSafeClient,
        make(
            api_key=api_key,
            api_url=api_url,
            transform_client=transform_client,
            max_response_bytes=max_response_bytes,
        ),
    )

layer_config

layer_config(*, api_key=None, api_url=None, transform_client=None, max_response_bytes=None) -> L.Layer[TypeSafeClient, ConfigError, HttpClient]

TypeSafeClient with its options read from Config; the key is TYPESAFE_API_KEY by default.

ParameterTypeDescription
api_keyConfig[Redacted[str]] | Config[Redacted[str] | None] | None = None
api_urlConfig[str] | None = None
transform_clientClientTransform | None = None
max_response_bytesbyte_size.Input | None = None

Returns L.Layer[TypeSafeClient, ConfigError, HttpClient]

def layer_config(
    *,
    api_key: Config[Redacted[str]] | Config[Redacted[str] | None] | None = None,
    api_url: Config[str] | None = None,
    transform_client: ClientTransform | None = None,
    max_response_bytes: byte_size.Input | None = None,
) -> L.Layer[TypeSafeClient, ConfigError, HttpClient]:
    """``TypeSafeClient`` with its options read from ``Config``; the key is
    ``TYPESAFE_API_KEY`` by default."""
    key: Config[Redacted[str]] | Config[Redacted[str] | None] = api_key or C.redacted(
        "TYPESAFE_API_KEY"
    )
    built: Effect[Service, ConfigError, HttpClient] = key.flat_map(
        lambda found: P.optional_config(api_url).flat_map(
            lambda url: make(
                api_key=found,
                api_url=url,
                transform_client=transform_client,
                max_response_bytes=max_response_bytes,
            )
        )
    )
    return L.effect(TypeSafeClient, built)