OCaml Cohttp

https://mirage.github.io/ocaml-cohttp
Admin
OCaml Cohttp is a versatile HTTP client and server library for OCaml, providing support for various...
Tokens:29,370
Snippets:386
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Server/index.html

Starts the HTTP server instance.

```APIDOC
## val create

### Description
Starts a new HTTP server. The server can be configured for simple TCP or TLS encryption depending on the provided mode.

### Parameters
- **timeout** (int) - Optional - Connection timeout.
- **backlog** (int) - Optional - Limit for open connections.
- **stop** (unit Lwt.t) - Optional - A thread that, when determined, terminates the server.
- **on_exn** (exn -> unit) - Optional - Exception handler for callback errors.
- **mode** (Conduit_lwt_unix.server) - Optional - Server mode (e.g., TCP, TLS).
```

--------------------------------

### start

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Static/HTTP/index.html

Starts a static HTTP server that serves files from a read-only key-value store.

```APIDOC
## val start

### Description
Starts a static HTTP server listening on a specified port. Files are served from the provided read-only key-value store.

### Signature
`val start : http_port:int -> ?request_fn:(Uri.t -> Http.Header.t -> Http.Header.t) -> FS.t -> ([> `TCP of int ] -> S.t -> 'a) -> 'a`

### Parameters
- **http_port** (int) - Required - The port number the server will listen on.
- **request_fn** (Uri.t -> Http.Header.t -> Http.Header.t) - Optional - A function to customize response headers based on the request URI and default headers.
- **fs** (FS.t) - Required - The read-only key-value store containing the files to serve.
```

--------------------------------

### run

Source: https://mirage.github.io/ocaml-cohttp/cohttp-eio/Cohttp_eio/Server/index.html

Starts the HTTP server on a given listening socket.

```APIDOC
## val run

### Description
Starts the server and begins accepting connections on the provided listening socket.

### Parameters
- **max_connections** (int) - Optional - Maximum number of concurrent connections.
- **additional_domains** (Eio_domain_manager.t * int) - Optional - Configuration for multi-domain execution.
- **stop** (Eio.Promise.t) - Optional - A promise that, when resolved, stops the server.
- **on_error** (exn -> unit) - Required - Callback for handling server errors.
- **socket** (Eio.Net.listening_socket) - Required - The socket to listen on.
- **server** (t) - Required - The server instance to run.
```

--------------------------------

### listen

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Server/Make/index.html

Starts the server to listen for incoming connections.

```APIDOC
## val listen

### Description
Starts the server instance to listen for incoming connections on the provided conduit server.

### Parameters
- **S.t** (Conduit_mirage.S.t) - Required - The conduit context.
- **Conduit_mirage.server** (Conduit_mirage.server) - Required - The server configuration.
- **t** (t) - Required - The server instance.
```

--------------------------------

### val install_printers : string list -> bool

Source: https://mirage.github.io/ocaml-cohttp/cohttp-top/Cohttp_top/index.html

Installs a list of printers into the top-level environment.

```APIDOC
## val install_printers

### Description
Registers the specified printers for use in the top-level environment.

### Signature
`val install_printers : string list -> bool`

### Parameters
- **printers** (string list) - Required - A list of printer names to install.
```

--------------------------------

### Define a simple HTTP server

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Server/index.html

Starts an HTTP server listening on a specific TCP port.

```ocaml
let run = create (`TCP 8080)
```

--------------------------------

### connect_uri

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make/argument-1-Connection/Net/index.html

Starts a flow on the given URI, handling protocol selection based on the URI scheme.

```APIDOC
## connect_uri

### Description
Starts a flow on the given URI. The protocol (TLS or TCP) is determined by the URI scheme (https or http).

### Signature
`val connect_uri : ctx:ctx -> Uri.t -> (IO.conn * IO.ic * IO.oc) IO.t`

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **uri** (Uri.t) - Required - The URI to connect to.
```

--------------------------------

### connect_uri

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make_no_cache/argument-1-Connection/Net/index.html

Starts a network flow to the given URI, automatically handling protocol selection based on the URI scheme.

```APIDOC
## val connect_uri : ctx:ctx -> Uri.t -> (IO.conn * IO.ic * IO.oc) IO.t

### Description
Starts a flow on the given URI. If the scheme is 'https', it initiates a TLS connection; if 'http', it initiates a standard TCP/IP connection.

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **uri** (Uri.t) - Required - The URI to connect to.
```

--------------------------------

### Convenience Methods (get, post, put, delete, patch, head)

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/Client/index.html

Convenience functions for common HTTP methods.

```APIDOC
## HTTP Convenience Methods

### Description
Standard convenience functions for performing specific HTTP operations.

### Signatures
- `head : (?headers:Http.Header.t -> Uri.t -> Http.Response.t io) with_context`
- `get : (?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `post : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `put : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `delete : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `patch : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
```

--------------------------------

### connect_uri

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection/Make/argument-1-Net/index.html

Starts a network flow to the given URI, automatically handling protocol selection based on the URI scheme.

```APIDOC
## val connect_uri : ctx:ctx -> Uri.t -> (IO.conn * IO.ic * IO.oc) IO.t

### Description
Starts a flow on the given URI. If the scheme is 'https', it attempts a TLS connection; if 'http', it attempts a standard TCP/IP connection.

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **uri** (Uri.t) - Required - The target URI.
```

--------------------------------

### get

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/Make/index.html

Performs an HTTP GET request.

```APIDOC
## get

### Description
Performs an HTTP GET request to the specified URI.

### Signature
`val get : (?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`

### Parameters
- **headers** (Http.Header.t) - Optional - HTTP headers.
- **uri** (Uri.t) - Required - The target URI.
```

--------------------------------

### connect_uri

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/Make/argument-1-Connection/Net/index.html

Starts a network flow to the given URI, automatically handling protocol selection based on the URI scheme.

```APIDOC
## val connect_uri

### Description
Starts a flow on the given URI. The protocol (TLS or TCP) is determined by the URI scheme (https or http).

### Signature
`val connect_uri : ctx:ctx -> Uri.t -> (IO.conn * IO.ic * IO.oc) IO.t`

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **uri** (Uri.t) - Required - The target URI.
```

--------------------------------

### connect_endp

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make/argument-1-Connection/Net/index.html

Starts a flow to a specific endpoint.

```APIDOC
## connect_endp

### Description
Starts a flow to the given endpoint, which describes the address and protocol to connect to.

### Signature
`val connect_endp : ctx:ctx -> endp -> (IO.conn * IO.ic * IO.oc) IO.t`

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **endp** (endp) - Required - The endpoint description.
```

--------------------------------

### connect_endp

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection/Make/argument-1-Net/index.html

Starts a network flow to a pre-resolved endpoint.

```APIDOC
## val connect_endp : ctx:ctx -> endp -> (IO.conn * IO.ic * IO.oc) IO.t

### Description
Starts a flow to the specified endpoint, which describes the address and protocol to connect to.

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **endp** (endp) - Required - The endpoint description.
```

--------------------------------

### connect_endp

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/Make/argument-1-Connection/Net/index.html

Starts a network flow to a pre-resolved endpoint.

```APIDOC
## val connect_endp

### Description
Starts a flow to the given endpoint, which describes the address and protocol.

### Signature
`val connect_endp : ctx:ctx -> endp -> (IO.conn * IO.ic * IO.oc) IO.t`

### Parameters
- **ctx** (ctx) - Required - The Conduit context.
- **endp** (endp) - Required - The endpoint description.
```

--------------------------------

### HTTP Method Helpers

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/Make_client_sync/index.html

Convenience functions for standard HTTP operations such as head, get, delete, post, put, and patch.

```ocaml
val head : (?headers:Http.Header.t -> Uri.t -> Http.Response.t io) with_context
val get :    (?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
val delete :    (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
val post :    (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
val put :    (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
val patch :    (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
```

--------------------------------

### Clean duplicate headers example

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Header/index.html

Demonstrates the transformation of header fields when using clean_dup to resolve duplicates according to RFC7230.

```text
    transfer-encoding: gzip
    host: afirsthost.com
    connection: keep-alive
    host: anhost.com, anotherhost.com
    transfer-encoding: chunked
```

```text
    transfer-encoding: gzip, chunked
    connection: keep-alive
    host: anhost.com, anotherhost.com
```

--------------------------------

### Create a basic HTTP server with Cohttp_server_lwt_unix

Source: https://mirage.github.io/ocaml-cohttp/cohttp-server-lwt-unix/Cohttp_server_lwt_unix/index.html

Demonstrates setting up a server using Lwt_io.establish_server_with_client_address and a custom callback function.

```ocaml
open Lwt.Syntax

let server_callback ctx =
  Lwt.join
    [
      Cohttp_server_lwt_unix.ontext.discard_body ctx;
      Cohttp_server_lwt_unix.ontext.respond ctx (Http.Response.make ())
        (Cohttp_server_lwt_unix.Body.string "hello world");
    ]

let main () =
  let* _server =
    let listen_address = Unix.(ADDR_INET (inet_addr_loopback, 8080)) in
    let server = Cohttp_server_lwt_unix.create server_callback in
    Lwt_io.establish_server_with_client_address ~backlog:10_000
      listen_address (fun _addr ch ->
        Cohttp_server_lwt_unix.handle_connection server ch)
  in
  let forever, _ = Lwt.wait () in
  forever

let () = ignore (Lwt_main.run (main ()))
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Server/module-type-S/index.html

Creates a standard server instance using a simple callback that returns a response.

```APIDOC
## make

### Description
Creates a standard server instance that processes requests via a callback returning a response.

### Parameters
- **conn_closed** (conn -> unit) - Optional - Callback invoked when the connection is closed.
- **callback** (conn -> Http.Request.t -> body -> response IO.t) - Required - Function to handle requests and return a response.
```

--------------------------------

### init

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Net/index.html

Initializes a custom network context.

```APIDOC
## val init

### Description
Creates a network context, optionally overriding the default connection handling or resolution modules.

### Signature
`val init : ?ctx:Conduit_lwt_unix.ctx -> ?resolver:Resolver_lwt.t -> unit -> ctx`
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp-eio/Cohttp_eio/Client/index.html

Creates a new HTTP client instance with a convenience wrapper for connection handling.

```APIDOC
## make

### Description
Creates a new HTTP client instance. It uses the provided network object to establish connections. URIs starting with 'http://' connect via TCP, while 'https://' connections are wrapped by the provided https function.

### Signature
`make ~https net`

### Parameters
- **https** (option) - Optional - A function to wrap TCP connections for HTTPS.
- **net** (Eio.Net.t) - Required - The network object used to make connections.
```

--------------------------------

### Server Creation Functions

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Server/Flow/index.html

Functions to instantiate a server with different callback types for standard or expert response handling.

```ocaml
val make_response_action :    ?conn_closed:(conn -> unit) -> callback:(conn -> Http.Request.t -> body -> response_action IO.t) -> unit -> t
val make_expert :    ?conn_closed:(conn -> unit) -> callback:     (conn -> Http.Request.t -> body -> (Http.Response.t * (IO.ic -> IO.oc -> unit IO.t)) IO.t) -> unit -> t
val make :    ?conn_closed:(conn -> unit) -> callback:(conn -> Http.Request.t -> body -> response IO.t) -> unit -> t
```

--------------------------------

### Create a Client with the Make functor

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/index.html

Instantiate a client by providing a connection module that satisfies the S.Connection interface.

```ocaml
module Make   (Connection : S.Connection) :    S.Client with type ctx = Connection.Net.ctx
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Connection/index.html

Creates a new connection instance.

```APIDOC
## val create

### Description
Creates a new connection instance with optional finalization, persistence, and context settings.

### Signature
`val create : ?finalise:(t -> unit Net.IO.t) -> ?persistent:bool -> ?ctx:Net.ctx -> Net.endp -> t`
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Link/Ext/index.html

Creates a new link extension instance with optional charset and language parameters.

```APIDOC
## val make

### Description
Constructs a new link extension of type 'a t.

### Signature
val make : ?charset:Charset.t -> ?language:Language.t -> 'a -> 'a t
```

--------------------------------

### Configure Logs for Browser Console

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/index.html

Sets up the Logs library to output warnings to the browser's console using the console reporter.

```ocaml
let reporter = Logs_browser.console_reporter () in
Logs.set_reporter reporter
```

--------------------------------

### Make_client_sync Configuration Parameters

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/Make_client_sync/argument-1-_/index.html

Configuration values for the Make_client_sync module.

```APIDOC
## Make_client_sync Configuration

### Parameters

- **chunked_response** (bool) - Determines if the response body data should be chunked.
- **chunk_size** (int) - Specifies the size of the chunks.
- **convert_body_string** (Js_of_ocaml.Js.js_string Js_of_ocaml.Js.t -> string) - Function used for JavaScript string to OCaml string conversion (e.g., Js.to_bytestring or Js.to_string).
- **with_credentials** (bool) - Sets the withCredentials property of the underlying XHR object.
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-async/Cohttp_async/Server/Expert/index.html

Creates a server callback using a user-provided handler, socket address, and Async reader/writer pair.

```APIDOC
## val create

### Description
Accepts a user-provided cohttp handler and creates a server callback that works with a user-provided socket address, Async_unix.Reader.t, and Async_unix.Writer.t. This is useful for scenarios requiring manual control over reader and writer creation.

### Signature
val create : (body:Body.t -> 'addr -> Http.Request.t -> response Async_kernel.Deferred.t) -> 'addr -> Async_unix.Reader.t -> Async_unix.Writer.t -> unit Async_kernel.Deferred.t
```

--------------------------------

### connect

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make/argument-1-Connection/index.html

Establishes a connection and returns a promise.

```APIDOC
## val connect : ?finalise:(t -> unit Net.IO.t) -> ?persistent:bool -> ?ctx:Net.ctx -> Net.endp -> t Net.IO.t

### Description
Similar to create, but returns a promise that resolves when the connection is successfully established or rejects if it fails.
```

--------------------------------

### make_response_action

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Server/module-type-S/index.html

Creates a server instance that handles requests by returning a response_action, allowing for either standard responses or expert-level IO control.

```APIDOC
## make_response_action

### Description
Creates a server instance that handles requests by returning a response_action, which supports either standard responses or expert-level IO operations.

### Parameters
- **conn_closed** (conn -> unit) - Optional - Callback invoked when the connection is closed.
- **callback** (conn -> Http.Request.t -> body -> response_action IO.t) - Required - Function to handle incoming requests and return a response_action.
```

--------------------------------

### Create a Server module using the Make functor

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Server/index.html

Use the Make functor to instantiate a server module by providing an IO implementation.

```ocaml
module Make (IO : S.IO) : S.Server with module IO = IO
```

--------------------------------

### Make_client_async Configuration

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/Make_client_async/argument-1-_/index.html

Configuration parameters for the client, including chunking settings, string conversion, and XHR credentials.

```APIDOC
## Make_client_async Configuration Parameters

### chunked_response
- **Type**: bool
- **Description**: Determines if the response body data should be chunked.

### chunk_size
- **Type**: int
- **Description**: Specifies the size of the chunks.

### convert_body_string
- **Type**: Js_of_ocaml.Js.js_string Js_of_ocaml.Js.t -> string
- **Description**: Function used for JavaScript string to OCaml string conversion (e.g., Js.to_bytestring or Js.to_string).

### with_credentials
- **Type**: bool
- **Description**: Determines whether the withCredentials property of the XHR object is set.
```

--------------------------------

### make_expert

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Server/module-type-S/index.html

Creates a server instance specifically for expert-level IO handling, providing direct access to input and output channels.

```APIDOC
## make_expert

### Description
Creates a server instance that uses an expert callback to handle requests, providing direct access to IO channels for efficient streaming or protocol switching.

### Parameters
- **conn_closed** (conn -> unit) - Optional - Callback invoked when the connection is closed.
- **callback** (conn -> Http.Request.t -> body -> (Http.Response.t * (IO.ic -> IO.oc -> unit IO.t)) IO.t) - Required - Function to handle requests and return a response along with an IO function.
```

--------------------------------

### connect

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection/Make/index.html

Establishes a connection and returns a promise that resolves when the connection is ready.

```APIDOC
## val connect : ?finalise:(t -> unit Net.IO.t) -> ?persistent:bool -> ?ctx:Net.ctx -> Net.endp -> t Net.IO.t

### Description
Similar to create, but returns a promise that is fulfilled when the connection is established or rejected if it fails.
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make/index.html

Creates a new connection cache instance with configurable parameters for connection management.

```APIDOC
## val create

### Description
Creates a new connection cache instance. This cache manages the lifecycle of connections based on the provided configuration parameters.

### Signature
`val create : ?ctx:Connection.Net.ctx -> ?keep:int64 -> ?retry:int -> ?parallel:int -> ?depth:int -> unit -> t`

### Parameters
- **ctx** (Connection.Net.ctx) - Optional - Conduit context to use.
- **keep** (int64) - Optional - Number of nanoseconds to keep an idle connection around.
- **retry** (int) - Optional - Number of times a gracefully failed request is automatically retried.
- **parallel** (int) - Optional - Maximum number of connections to establish to a single endpoint.
- **depth** (int) - Optional - Maximum number of requests to queue and/or send on a single connection.
```

--------------------------------

### connect

Source: https://mirage.github.io/ocaml-cohttp/cohttp-async/Cohttp_async/Client/Connection/index.html

Establishes a new connection to the specified URI.

```APIDOC
## val connect

### Description
Establishes a new connection to the provided URI, optionally configuring SSL and interruption signals.

### Signature
`val connect : ?interrupt:unit Async_kernel.Deferred.t -> ?ssl_config:Conduit_async.V2.Ssl.Config.t -> Uri.t -> t Async_kernel.Deferred.t`
```

--------------------------------

### Open a string for parsing

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Private/String_io/index.html

Initializes a string as a buffer for Cohttp parsing.

```ocaml
val open_in : string -> buf
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Response/index.html

Creates a new HTTP response object with optional parameters for version, status, encoding, and headers.

```APIDOC
## val make

### Description
Creates a new HTTP response object. Default values are: status is `Ok`, version is `HTTP_1_1`, and headers is `Header.empty`.

### Signature
`val make : ?version:Code.version -> ?status:Code.status_code -> ?encoding:Transfer.encoding -> ?headers:Header.t -> unit -> t`
```

--------------------------------

### Cohttp_server_lwt_unix.create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-server-lwt-unix/Cohttp_server_lwt_unix/index.html

Creates an HTTP server instance that handles incoming requests using the provided callback function.

```APIDOC
## val create : ?on_exn:(exn -> unit) -> (Context.t -> unit Lwt.t) -> t

### Description
Creates an HTTP server that will handle every incoming request with the provided callback function concurrently. The optional `on_exn` parameter allows for custom exception handling for errors not caught in the callback or raised by the server.

### Parameters
- **on_exn** (exn -> unit) - Optional - Callback function invoked on exceptions. Defaults to `Lwt.async_exception_hook` if not provided.
- **f** (Context.t -> unit Lwt.t) - Required - The request handler function.
```

--------------------------------

### connect_uri

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Connection/Net/index.html

Establishes a connection to a URI.

```APIDOC
## val connect_uri

### Description
Establishes a connection to the specified URI using the provided context, returning the connection object along with input and output channels.

### Signature
`val connect_uri : ctx:ctx -> Uri.t -> (IO.conn * IO.ic * IO.oc) IO.t`
```

--------------------------------

### callback

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Server/Flow/index.html

Processes an incoming connection using the server configuration.

```APIDOC
## val callback

### Description
Processes an incoming connection using the provided server instance.

### Parameters
- **t** (t) - Required - The server instance.
- **IO.conn** (IO.conn) - Required - The underlying connection flow.
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-eio/Cohttp_eio/Body/String_source/index.html

Creates a new String_source from a given string.

```APIDOC
## val create

### Description
Creates a new instance of `t` initialized with the provided string.

### Signature
`val create : string -> t`
```

--------------------------------

### File Resolution and Callback Execution

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Server/Flow/index.html

Functions for resolving local file paths and executing the server callback.

```ocaml
val resolve_local_file : docroot:string -> uri:Uri.t -> string
val callback : t -> IO.conn -> unit Lwt.t
```

--------------------------------

### Client

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/index.html

A pre-configured asynchronous HTTP client implementation.

```APIDOC
## module Client

### Description
Implements an HTTP client interface using asynchronous XmlHttpRequests. The response body is returned in 128Kb chunks and treated as raw bytes. The `withCredentials` property of the XHR is set to false.
```

--------------------------------

### Client.Make HTTP Methods

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Client/Make/index.html

The Client.Make module provides standard HTTP client methods for executing requests.

```APIDOC
## Client.Make HTTP Methods

### Description
Provides functions to perform HTTP requests such as GET, POST, PUT, DELETE, HEAD, and PATCH.

### Methods
- **call**: (?headers:Http.Header.t -> ?body:body -> ?chunked:bool -> Http.Method.t -> Uri.t -> (Http.Response.t * body) io) with_context
- **get**: (?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
- **post**: (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
- **put**: (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
- **delete**: (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
- **head**: (?headers:Http.Header.t -> Uri.t -> Http.Response.t IO.t) with_context
- **patch**: (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Request/index.html

Creates a new HTTP request object with optional parameters for method, version, encoding, and headers.

```APIDOC
## val make

### Description
Creates a new request object (t). Default values are used if parameters are not specified.

### Signature
`val make : ?meth:Code.meth -> ?version:Code.version -> ?encoding:Transfer.encoding -> ?headers:Header.t -> Uri.t -> t`

### Parameters
- **meth** (Code.meth) - Optional - The HTTP request method.
- **version** (Code.version) - Optional - The HTTP version (default: HTTP_1_1).
- **encoding** (Transfer.encoding) - Optional - The transfer encoding.
- **headers** (Header.t) - Optional - The request headers (default: Header.empty).
- **uri** (Uri.t) - Required - The request URI.
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/S/module-type-Request/index.html

Creates a new HTTP request object with optional parameters for method, version, encoding, and headers.

```APIDOC
## val make

### Description
Creates a new request object. If not specified, defaults are: version is HTTP_1_1, and headers are empty.

### Signature
val make : ?meth:Code.meth -> ?version:Code.version -> ?encoding:Transfer.encoding -> ?headers:Header.t -> Uri.t -> t
```

--------------------------------

### create_with_response_action

Source: https://mirage.github.io/ocaml-cohttp/cohttp-async/Cohttp_async/Server/Expert/index.html

Creates a server callback with support for response_action, allowing access to the underlying reader/writer pair.

```APIDOC
## val create_with_response_action

### Description
Similar to `create`, but the user-provided handler can use `Cohttp_async.Server.response_action`. This allows the handler to access the underlying reader/writer pair directly from within the HTTP handler.

### Signature
val create_with_response_action : (body:Body.t -> 'addr -> Http.Request.t -> response_action Async_kernel.Deferred.t) -> 'addr -> Async_unix.Reader.t -> Async_unix.Writer.t -> unit Async_kernel.Deferred.t
```

--------------------------------

### make_generic

Source: https://mirage.github.io/ocaml-cohttp/cohttp-eio/Cohttp_eio/Client/index.html

Creates a new HTTP client instance using a custom connection function.

```APIDOC
## make_generic

### Description
Creates an HTTP client that uses the provided connect function to establish a connection for a given URI.

### Signature
`make_generic connect`

### Parameters
- **connect** (sw:Eio.Std.Switch.t -> Uri.t -> _ Eio.Flow.two_way) - Required - A function that takes a switch and a URI to return a two-way flow.
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection/Make/index.html

Creates a connection handle to the specified endpoint. The connection may be used immediately before it is fully established.

```APIDOC
## val create : ?finalise:(t -> unit Net.IO.t) -> ?persistent:bool -> ?ctx:Net.ctx -> Net.endp -> t

### Description
Connects to the specified endpoint. Returns a connection handle that can be used immediately.

### Parameters
- **finalise** (t -> unit Net.IO.t) - Optional - Called when the connection is closed, before pending requests are failed.
- **persistent** (bool) - Optional - If false, sends 'Connection: close'. If true, assumes pipelining support.
- **ctx** (Net.ctx) - Optional - Context for the network connection.
- **endp** (Net.endp) - Required - The remote address, port, and protocol.
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/Make/argument-1-Connection/index.html

Creates a new connection handle to the specified endpoint. The connection may be used immediately even if not yet established.

```APIDOC
## val create

### Description
Creates a connection handle to the specified endpoint. The handle can be used immediately.

### Parameters
- **finalise** (t -> unit Net.IO.t) - Optional - Callback invoked when the connection is closed.
- **persistent** (bool) - Optional - If true, assumes the remote end supports pipelining.
- **ctx** (Net.ctx) - Optional - Context for the connection.
- **endp** (Net.endp) - Required - The remote address, port, and protocol.
```

--------------------------------

### connect

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/Make/argument-1-Connection/index.html

Establishes a connection to the specified endpoint and returns a promise.

```APIDOC
## val connect

### Description
Establishes a connection to the specified endpoint, returning a promise that resolves when the connection is established or rejects on failure.
```

--------------------------------

### Client_sync

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/index.html

A pre-configured synchronous HTTP client implementation.

```APIDOC
## module Client_sync

### Description
Implements an HTTP client interface using synchronous XmlHttpRequests. The response is not chunked and is treated as raw bytes. The `withCredentials` property of the XHR is set to false.
```

--------------------------------

### create

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make/argument-1-Connection/index.html

Creates a new connection handle to the specified endpoint.

```APIDOC
## val create : ?finalise:(t -> unit Net.IO.t) -> ?persistent:bool -> ?ctx:Net.ctx -> Net.endp -> t

### Description
Creates a connection handle to the provided endpoint. The handle can be used immediately, even if the connection is not yet established.

### Parameters
- **finalise** (t -> unit Net.IO.t) - Optional - Callback invoked when the connection is closed.
- **persistent** (bool) - Optional - If false, sends 'Connection: close'. If true, assumes pipelining support.
- **ctx** (Net.ctx) - Optional - Context for the connection.
- **endp** (Net.endp) - Required - The remote address, port, and protocol.
```

--------------------------------

### val string

Source: https://mirage.github.io/ocaml-cohttp/cohttp-server-lwt-unix/Cohttp_server_lwt_unix/Body/index.html

Creates a response body from a static string.

```APIDOC
## val string

### Description
Creates a response body from a string. By default, the encoding is set to Encoding.fixed.

### Signature
`val string : ?encoding:Encoding.t -> string -> t`

### Parameters
- **encoding** (Encoding.t) - Optional - The encoding to use for the body.
- **s** (string) - Required - The string content of the body.
```

--------------------------------

### val create : unit -> t

Source: https://mirage.github.io/ocaml-cohttp/cohttp-curl-lwt/Cohttp_curl_lwt/Context/index.html

Creates a new context for sharing curl event handling logic.

```APIDOC
## val create : unit -> t

### Description
Creates a new context that shares the curl event handling logic for all curl requests associated with it.

### Signature
`val create : unit -> t`
```

--------------------------------

### val create : ?ctx:Connection.Net.ctx -> unit -> t

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make_no_cache/index.html

Creates a new connection cache instance that handles a single request per connection.

```APIDOC
## create

### Description
Creates a connection for handling a single request. The connection accepts only a single request and will automatically be closed as soon as possible.

### Parameters
- **ctx** (Connection.Net.ctx) - Optional - The network context used for the connection.
```

--------------------------------

### Initialize empty Link.Arc

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Link/Arc/index.html

Provides an empty instance of the link arc record.

```ocaml
val empty : t
```

--------------------------------

### HTTP Response Helpers

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Server/Flow/index.html

Utility functions for generating common HTTP responses.

```ocaml
val respond :    ?headers:Http.Header.t -> status:Http.Status.t -> body:body -> unit -> response IO.t
val respond_string :    ?headers:Http.Header.t -> status:Http.Status.t -> body:string -> unit -> response IO.t
val respond_error :    ?headers:Http.Header.t -> ?status:Http.Status.t -> body:string -> unit -> (Http.Response.t * body) IO.t
val respond_redirect :    ?headers:Http.Header.t -> uri:Uri.t -> unit -> (Http.Response.t * body) IO.t
val respond_need_auth :    ?headers:Http.Header.t -> auth:Cohttp.Auth.challenge -> unit -> (Http.Response.t * body) IO.t
val respond_not_found : ?uri:Uri.t -> unit -> (Http.Response.t * body) IO.t
```

--------------------------------

### Cohttp_mirage.Static.HTTP

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Static/index.html

A functor that creates an HTTP server capable of serving files from a Mirage read-only key-value store.

```APIDOC
## module Cohttp_mirage.Static.HTTP(FS : Mirage_kv.RO)(S : Cohttp_lwt.S.Server)

### Description
This functor provides a mechanism to serve static files from a Mirage read-only key-value store (FS) using a Cohttp server (S).

### Signature
module HTTP (FS : Mirage_kv.RO) (S : Cohttp_lwt.S.Server) : sig ... end
```

--------------------------------

### module Make (Net : S.Net)

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection/index.html

A functor that creates a connection module given a network implementation.

```APIDOC
## module Make (Net : S.Net)

### Description
Creates a connection module that satisfies the S.Connection interface using the provided network implementation (Net).
```

--------------------------------

### write

Source: https://mirage.github.io/ocaml-cohttp/cohttp-async/Cohttp_async/Io/Response/index.html

Writes a full HTTP response.

```APIDOC
## val write : flush:bool -> (writer -> unit IO.t) -> Http.Response.t -> IO.oc -> unit IO.t

### Description
Writes an entire HTTP response to the output channel, using a callback function to handle the body writing process.
```

--------------------------------

### Make functor

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Client/index.html

The Make functor is used to instantiate a Cohttp client for MirageOS by providing the necessary clock, resolver, and conduit dependencies.

```APIDOC
## module Make

### Description
Creates a Cohttp client module for MirageOS.

### Signature
module Make (_ : Mirage_clock.PCLOCK) (R : Resolver_mirage.S) (S : Conduit_mirage.S) : sig ... end
```

--------------------------------

### make

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Cookie/Set_cookie_hdr/index.html

Constructs a new Set_cookie_hdr record.

```APIDOC
## val make

### Description
Creates a new Set_cookie_hdr record with optional parameters for expiration, path, domain, secure flag, and http_only flag.

### Signature
`val make : ?expiration:expiration -> ?path:string -> ?domain:string -> ?secure:bool -> ?http_only:bool -> cookie -> t`
```

--------------------------------

### val version : string

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Conf/index.html

Retrieves the version number of the Cohttp library as a string.

```APIDOC
## val version : string

### Description
Returns the version number of the Cohttp library as a string value.

### Signature
`val version : string`
```

--------------------------------

### Enable logging to stderr

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Debug/index.html

Configures the default reporter to output logs to stderr with color support.

```ocaml
Fmt_tty.setup_std_outputs ();
Logs.set_level ~all:true (Some level);
Logs.set_reporter Debug.default_reporter
```

--------------------------------

### Define the IO interface

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Private/String_io/index.html

The IO interface implementation using buf for input and Buffer.t for output.

```ocaml
module M :    S.IO with type 'a t = 'a and type ic = buf and type oc = Stdlib.Buffer.t
```

--------------------------------

### Make (IO : S.IO) : S.Server

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Server/index.html

The Make functor creates a server module by providing an IO implementation. This is the primary entry point for constructing an HTTP server in Cohttp_lwt.

```APIDOC
## Make Functor

### Description
The `Make` functor glues together a `Cohttp.S.IO` implementation to send requests down a connection that is established by the user. The resulting module satisfies the `Server` module type.

### Signature
`module Make (IO : S.IO) : S.Server with module IO = IO`
```

--------------------------------

### call

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/Make/argument-1-Connection/index.html

Queues a request on the connection.

```APIDOC
## val call

### Description
Queues a request for transmission over the connection.
```

--------------------------------

### write

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Private/Header_io/Make/index.html

Writes HTTP headers to an output channel.

```APIDOC
## val write : Header.t -> IO.oc -> unit IO.t

### Description
Writes the provided Header.t object to the specified output channel (IO.oc).

### Parameters
- **header** (Header.t) - The header object to write.
- **oc** (IO.oc) - The output channel to write to.
```

--------------------------------

### Connection Lifecycle Methods

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-unix/Cohttp_lwt_unix/Connection/index.html

Methods for managing the state of a connection.

```APIDOC
## Connection Lifecycle

- `val shutdown : t -> unit`: Shuts down the connection.
- `val close : t -> unit`: Closes the connection.
- `val is_closed : t -> bool`: Checks if the connection is closed.
- `val length : t -> int`: Returns the length associated with the connection.
- `val notify : t -> unit Net.IO.t`: Sends a notification over the connection.
```

--------------------------------

### HTTP Convenience Methods

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/S/module-type-Client/index.html

Standard HTTP methods for performing requests.

```APIDOC
## HTTP Methods (get, post, put, delete, patch, head)

### Description
Convenience functions for common HTTP operations.

### Signatures
- `head : (?headers:Http.Header.t -> Uri.t -> Http.Response.t io) with_context`
- `get : (?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `post : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `put : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `delete : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
- `patch : (?body:body -> ?chunked:bool -> ?headers:Http.Header.t -> Uri.t -> (Http.Response.t * body) io) with_context`
```

--------------------------------

### Make functor

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Client/index.html

The Make functor creates a client module by providing a connection implementation that satisfies the S.Connection interface.

```APIDOC
## module Make(Connection : S.Connection)

### Description
Creates a new client module by providing a connection implementation. The resulting module satisfies the S.Client module type.

### Parameters
- **Connection** (S.Connection) - Required - A module implementing the S.Connection interface to handle network transport.

### Returns
- **S.Client** - A module providing HTTP client functionality with a context type 'ctx' derived from the connection's network context.
```

--------------------------------

### call

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Client/module-type-BASE/index.html

Executes an HTTP request using the specified method and URI, returning the response and the response body.

```APIDOC
## call

### Description
Executes an HTTP request. The returned response body should be consumed in a timely fashion.

### Signature
`val call : (?headers:Http.Header.t -> ?body:body -> ?chunked:bool -> Http.Method.t -> Uri.t -> (Http.Response.t * body) io) with_context`

### Parameters
- **headers** (Http.Header.t) - Optional - HTTP headers to include in the request.
- **body** (body) - Optional - The request body.
- **chunked** (bool) - Optional - Whether to use chunked encoding. Defaults to false.
- **meth** (Http.Method.t) - Required - The HTTP method to use.
- **uri** (Uri.t) - Required - The target URI.

### Returns
- **(Http.Response.t * body) io** - A tuple containing the HTTP response and the response body.
```

--------------------------------

### of_string

Source: https://mirage.github.io/ocaml-cohttp/cohttp-eio/Cohttp_eio/Body/index.html

Creates an Eio source from a string to be used as a request or response body.

```APIDOC
## val of_string

### Description
Creates an Eio source from a string, allowing the string content to be treated as a streamable body.

### Signature
`val of_string : string -> Eio.Flow.source_ty Eio.Resource.t`

### Parameters
- **s** (string) - The string content to convert into a body source.

### Returns
- **Eio.Flow.source_ty Eio.Resource.t** - An Eio resource representing the string as a flow source.
```

--------------------------------

### Cohttp_lwt_jsoo.Params

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/module-type-Params/index.html

Configuration parameters for the XmlHttpRequest engines.

```APIDOC
## Module type Cohttp_lwt_jsoo.Params

### Description
Configuration parameters for the XmlHttpRequest engines.

### Values
- **chunked_response** (bool) - Should the response body data be chunked?
- **chunk_size** (int) - Size of chunks.
- **convert_body_string** (Js_of_ocaml.Js.js_string Js_of_ocaml.Js.t -> string) - JavaScript string to OCaml conversion function (e.g., Js.to_bytestring or Js.to_string).
- **with_credentials** (bool) - Whether the withCredentials property of XHR is set.
```

--------------------------------

### submit

Source: https://mirage.github.io/ocaml-cohttp/cohttp-curl-lwt/Cohttp_curl_lwt/index.html

Submits an HTTP request using the provided context and returns the response. Note that once a request is submitted, it cannot be submitted again.

```APIDOC
## val submit : Context.t -> 'a Request.t -> 'a Response.t

### Description
Submits an HTTP request using the provided context and returns the response. Once a request is submitted, it may not be submitted again.

### Parameters
- **ctx** (Context.t) - The curl context sharing event handling logic.
- **request** ('a Request.t) - The HTTP request to be executed.

### Returns
- **'a Response.t** - The response resulting from the HTTP request.
```

--------------------------------

### respond

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Server/module-type-S/index.html

Responds to an HTTP request with a given status and body.

```APIDOC
## respond

### Description
Responds to an HTTP request with the specified status code and body. The transfer encoding is automatically detected unless overridden by headers.

### Parameters
- **headers** (Http.Header.t) - Optional - HTTP headers to include in the response.
- **status** (Http.Status.t) - Required - The HTTP status code for the response.
- **body** (body) - Required - The response body.
```

--------------------------------

### make_writer

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Private/Transfer_io/Make/index.html

Creates a writer instance for a given transfer encoding and output channel.

```APIDOC
### val make_writer

Creates a writer that processes output to an IO channel based on the specified transfer encoding, with an optional flush parameter.

**Signature:** `flush:bool -> Transfer.encoding -> IO.oc -> writer`
```

--------------------------------

### make_for_client

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Request/index.html

Creates a request object specifically configured for client-side usage.

```APIDOC
## val make_for_client

### Description
Constructs a request object for client-side requests.

### Signature
`val make_for_client : ?headers:Header.t -> ?chunked:bool -> ?body_length:int64 -> Code.meth -> Uri.t -> t`

### Parameters
- **headers** (Header.t) - Optional - Request headers.
- **chunked** (bool) - Optional - Whether to use chunked encoding.
- **body_length** (int64) - Optional - The length of the request body.
- **meth** (Code.meth) - Required - The HTTP method.
- **uri** (Uri.t) - Required - The request URI.
```

--------------------------------

### Client Interface Signature

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt-jsoo/Cohttp_lwt_jsoo/Make_client_sync/index.html

The module signature includes the core client types and the primary call function for executing HTTP requests.

```ocaml
include Cohttp.Generic.Client.S with type 'a io = 'a Lwt.t and type body = Cohttp_lwt.Body.t and type 'a with_context = ?ctx:ctx -> 'a
type 'a io = 'a Lwt.t
type 'a with_context = ?ctx:ctx -> 'a
type body = Cohttp_lwt.Body.t
val map_context : 'a with_context -> ('a -> 'b) -> 'b with_context
val call :    (?headers:Http.Header.t -> ?body:body -> ?chunked:bool -> Http.Method.t -> Uri.t -> (Http.Response.t * body) io) with_context
```

--------------------------------

### call

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/Connection_cache/Make/argument-1-Connection/index.html

Queues a request.

```APIDOC
## val call : t -> S.call

### Description
Queues a request to be sent over the connection.
```

--------------------------------

### Define Response Action Types

Source: https://mirage.github.io/ocaml-cohttp/cohttp-mirage/Cohttp_mirage/Server/Flow/index.html

Defines the possible ways a request handler can respond, either with a standard response or an expert IO function.

```ocaml
type response_action = [ 
  1. | Expert of Http.Response.t * (IO.ic -> IO.oc -> unit IO.t)
  2. | Response of response

 ]
```

--------------------------------

### respond_string

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Server/module-type-S/index.html

Responds to an HTTP request with a string body.

```APIDOC
## respond_string

### Description
Responds to an HTTP request with a string as the response body.

### Parameters
- **headers** (Http.Header.t) - Optional - HTTP headers to include in the response.
- **status** (Http.Status.t) - Required - The HTTP status code for the response.
- **body** (string) - Required - The string content of the response body.
```

--------------------------------

### call

Source: https://mirage.github.io/ocaml-cohttp/cohttp/Cohttp/Generic/Client/module-type-S/index.html

Performs a generic HTTP request with specified method, headers, and body.

```APIDOC
## call

### Description
Performs an HTTP request using the specified method and URI. Returns a tuple containing the response and the response body.

### Signature
`val call : (?headers:Http.Header.t -> ?body:body -> ?chunked:bool -> Http.Method.t -> Uri.t -> (Http.Response.t * body) io) with_context`

### Parameters
- **headers** (Http.Header.t) - Optional - HTTP headers to include in the request.
- **body** (body) - Optional - The request body.
- **chunked** (bool) - Optional - Whether to use chunked encoding. Defaults to false.
- **meth** (Http.Method.t) - Required - The HTTP method to use.
- **uri** (Uri.t) - Required - The target URI.
```

--------------------------------

### request

Source: https://mirage.github.io/ocaml-cohttp/cohttp-server-lwt-unix/Cohttp_server_lwt_unix/Context/index.html

Retrieves the HTTP request object from the context.

```APIDOC
## val request : t -> Http.Request.t

### Description
Returns the HTTP request associated with the given context.

### Parameters
- **t** (Context.t) - Required - The request context.
```

--------------------------------

### call

Source: https://mirage.github.io/ocaml-cohttp/cohttp-lwt/Cohttp_lwt/S/module-type-Client/index.html

Performs a generic HTTP request with the specified method and URI.

```APIDOC
## call

### Description
Performs a generic HTTP request. Returns a tuple containing the response and the response body, which should be consumed in a timely fashion.

### Signature
`val call : (?headers:Http.Header.t -> ?body:body -> ?chunked:bool -> Http.Method.t -> Uri.t -> (Http.Response.t * body) io) with_context`

### Parameters
- **headers** (Http.Header.t) - Optional - HTTP headers to include in the request.
- **body** (body) - Optional - The request body.
- **chunked** (bool) - Optional - Whether to use chunked encoding. Defaults to false.
- **meth** (Http.Method.t) - Required - The HTTP method to use.
- **uri** (Uri.t) - Required - The target URI.
```
Tokens:
Raw