---
title: Functions API
description: Generated public TypeScript reference for @relkit/functions.
search:
  exclude: true
sidebar:
  icon: braces
---

{/* Generated by apps/docs/scripts/generate.ts. Do not edit. */}

## Common APIs

- [defineFunction](/docs/api/functions#definefunction)
- [defineError](/docs/api/functions#defineerror)

For configuration and examples, read [Functions](/docs/learn/concepts/functions), [Declared errors](/docs/learn/concepts/errors), [migration](/docs/modules/service/migration).

For a complete workflow, follow [upload product images](/guides/storage/upload-product-images), [connect react](/guides/frontend/connect-react), [cache product prices](/guides/caching/cache-product-prices), [react to order events](/guides/events/react-to-order-events), [register users in a transaction](/guides/database/register-users-in-a-transaction).

## Frontend usage

[Call a public service operation](/docs/modules/service/routes#use-from-the-frontend) shows the client side of this capability.

## Public imports

- `@relkit/functions` — 119 exports

## All exported APIs

Names link to their complete contracts. Re-exports share their original contract; legacy exports keep their separate identity. Examples link to the API's inline sample, a maintained repository usage, or the shared module walkthrough.

| API                                                                                                  | Kind  | Import from         | Example                                                                      |
| ---------------------------------------------------------------------------------------------------- | ----- | ------------------- | ---------------------------------------------------------------------------- |
| [AgentClientFor](/docs/api/functions#agentclientfor-type-alias)                                      | Type  | `@relkit/functions` | [API example](/docs/api/functions#agentclientfor-type-alias)                 |
| [AgentClients](/docs/api/functions#agentclients-type-alias)                                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#agentclients-type-alias)                   |
| [AgentRef](/docs/api/functions#agentref-interface)                                                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#agentref-interface)                        |
| [AgentRefAny](/docs/api/functions#agentrefany-type-alias)                                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#agentrefany-type-alias)                    |
| [AuthContext](/docs/api/functions#authcontext-interface)                                             | Type  | `@relkit/functions` | [API example](/docs/api/functions#authcontext-interface)                     |
| [BucketClient](/docs/api/buckets#bucketclient-interface)                                             | Type  | `@relkit/functions` | [API example](/docs/api/buckets#bucketclient-interface)                      |
| [BucketClientFor](/docs/api/functions#bucketclientfor-type-alias)                                    | Type  | `@relkit/functions` | [API example](/docs/api/functions#bucketclientfor-type-alias)                |
| [BucketClients](/docs/api/functions#bucketclients-type-alias)                                        | Type  | `@relkit/functions` | [API example](/docs/api/functions#bucketclients-type-alias)                  |
| [BucketObjectMetadata](/docs/api/buckets#bucketobjectmetadata-interface)                             | Type  | `@relkit/functions` | [API example](/docs/api/buckets#bucketobjectmetadata-interface)              |
| [BucketRef](/docs/api/functions#bucketref-type-alias)                                                | Type  | `@relkit/functions` | [API example](/docs/api/functions#bucketref-type-alias)                      |
| [BucketRefAny](/docs/api/functions#bucketrefany-type-alias)                                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#bucketrefany-type-alias)                   |
| [CacheClient](/docs/api/cache#cacheclient-type-alias)                                                | Type  | `@relkit/functions` | [API example](/docs/api/cache#cacheclient-type-alias)                        |
| [CacheClientFor](/docs/api/functions#cacheclientfor-type-alias)                                      | Type  | `@relkit/functions` | [API example](/docs/api/functions#cacheclientfor-type-alias)                 |
| [CacheClients](/docs/api/functions#cacheclients-type-alias)                                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#cacheclients-type-alias)                   |
| [CacheOperationOptions](/docs/api/cache#cacheoperationoptions-interface)                             | Type  | `@relkit/functions` | [API example](/docs/api/cache#cacheoperationoptions-interface)               |
| [CacheRef](/docs/api/functions#cacheref-interface)                                                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#cacheref-interface)                        |
| [CacheRefAny](/docs/api/functions#cacherefany-type-alias)                                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#cacherefany-type-alias)                    |
| [copyFunctionToolHooks](/docs/api/functions#copyfunctiontoolhooks)                                   | Value | `@relkit/functions` | [API example](/docs/api/functions#copyfunctiontoolhooks)                     |
| [copyFunctionToolHooksEffect](/docs/api/functions#copyfunctiontoolhookseffect)                       | Value | `@relkit/functions` | [API example](/docs/api/functions#copyfunctiontoolhookseffect)               |
| [createFunctionGraphNode](/docs/api/functions#createfunctiongraphnode)                               | Value | `@relkit/functions` | [API example](/docs/api/functions#createfunctiongraphnode)                   |
| [createFunctionGraphNodeEffect](/docs/api/functions#createfunctiongraphnodeeffect)                   | Value | `@relkit/functions` | [API example](/docs/api/functions#createfunctiongraphnodeeffect)             |
| [createFunctionToolInvoker](/docs/api/functions#createfunctiontoolinvoker)                           | Value | `@relkit/functions` | [API example](/docs/api/functions#createfunctiontoolinvoker)                 |
| [createFunctionToolInvokerEffect](/docs/api/functions#createfunctiontoolinvokereffect)               | Value | `@relkit/functions` | [API example](/docs/api/functions#createfunctiontoolinvokereffect)           |
| [DeclaredError](/docs/api/functions#declarederror-class)                                             | Value | `@relkit/functions` | [API example](/docs/api/functions#declarederror-class)                       |
| [DeclaredErrorOf](/docs/api/functions#declarederrorof-type-alias)                                    | Type  | `@relkit/functions` | [API example](/docs/api/functions#declarederrorof-type-alias)                |
| [DeclaredErrorsOf](/docs/api/functions#declarederrorsof-type-alias)                                  | Type  | `@relkit/functions` | [API example](/docs/api/functions#declarederrorsof-type-alias)               |
| [defineError](/docs/api/functions#defineerror)                                                       | Value | `@relkit/functions` | [API example](/docs/api/functions#defineerror)                               |
| [defineErrorEffect](/docs/api/functions#defineerroreffect)                                           | Value | `@relkit/functions` | [API example](/docs/api/functions#defineerroreffect)                         |
| [DefineErrorOptions](/docs/api/functions#defineerroroptions-interface)                               | Type  | `@relkit/functions` | [API example](/docs/api/functions#defineerroroptions-interface)              |
| [defineFunction](/docs/api/functions#definefunction)                                                 | Value | `@relkit/functions` | [API example](/docs/api/functions#definefunction)                            |
| [defineFunctionEffect](/docs/api/functions#definefunctioneffect)                                     | Value | `@relkit/functions` | [API example](/docs/api/functions#definefunctioneffect)                      |
| [DefineFunctionOptions](/docs/api/functions#definefunctionoptions-interface)                         | Type  | `@relkit/functions` | [API example](/docs/api/functions#definefunctionoptions-interface)           |
| [DescriptorRef](/docs/api/functions#descriptorref-interface)                                         | Type  | `@relkit/functions` | [API example](/docs/api/functions#descriptorref-interface)                   |
| [ErrorDescriptor](/docs/api/functions#errordescriptor-interface)                                     | Type  | `@relkit/functions` | [API example](/docs/api/functions#errordescriptor-interface)                 |
| [ErrorDescriptorAny](/docs/api/functions#errordescriptorany-type-alias)                              | Type  | `@relkit/functions` | [Module example](/docs/learn/concepts/functions)                             |
| [ErrorHttpMapping](/docs/api/functions#errorhttpmapping-interface)                                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#errorhttpmapping-interface)                |
| [ErrorRef](/docs/api/functions#errorref-interface)                                                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#errorref-interface)                        |
| [ErrorRetry](/docs/api/functions#errorretry-type-alias)                                              | Type  | `@relkit/functions` | [API example](/docs/api/functions#errorretry-type-alias)                     |
| [ErrorRetryInput](/docs/api/functions#errorretryinput-type-alias)                                    | Type  | `@relkit/functions` | [API example](/docs/api/functions#errorretryinput-type-alias)                |
| [EventAttributeValue](/docs/api/functions#eventattributevalue-type-alias)                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventattributevalue-type-alias)            |
| [EventClientFor](/docs/api/functions#eventclientfor-type-alias)                                      | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventclientfor-type-alias)                 |
| [EventClients](/docs/api/functions#eventclients-type-alias)                                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventclients-type-alias)                   |
| [EventPublishOptions](/docs/api/functions#eventpublishoptions-interface)                             | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventpublishoptions-interface)             |
| [EventPublishResult](/docs/api/functions#eventpublishresult-interface)                               | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventpublishresult-interface)              |
| [EventRef](/docs/api/functions#eventref-interface)                                                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventref-interface)                        |
| [EventRefAny](/docs/api/functions#eventrefany-type-alias)                                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#eventrefany-type-alias)                    |
| [fail](/docs/api/functions#fail)                                                                     | Value | `@relkit/functions` | [API example](/docs/api/functions#fail)                                      |
| [failEffect](/docs/api/functions#faileffect)                                                         | Value | `@relkit/functions` | [API example](/docs/api/functions#faileffect)                                |
| [FunctionAsGraphNode](/docs/api/functions#functionasgraphnode-type-alias)                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionasgraphnode-type-alias)            |
| [functionAttempt](/docs/api/functions#functionattempt)                                               | Value | `@relkit/functions` | [API example](/docs/api/functions#functionattempt)                           |
| [FunctionContext](/docs/api/functions#functioncontext-type-alias)                                    | Type  | `@relkit/functions` | [API example](/docs/api/functions#functioncontext-type-alias)                |
| [FunctionDependencies](/docs/api/functions#functiondependencies-interface)                           | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiondependencies-interface)            |
| [FunctionDescriptor](/docs/api/functions#functiondescriptor-interface)                               | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiondescriptor-interface)              |
| [FunctionEffectValue](/docs/api/functions#functioneffectvalue-interface)                             | Type  | `@relkit/functions` | [API example](/docs/api/functions#functioneffectvalue-interface)             |
| [FunctionFailure](/docs/api/functions#functionfailure-interface)                                     | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionfailure-interface)                 |
| [FunctionGraphNodeDescriptor](/docs/api/functions#functiongraphnodedescriptor-interface)             | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiongraphnodedescriptor-interface)     |
| [FunctionGraphNodeOptions](/docs/api/functions#functiongraphnodeoptions-interface)                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiongraphnodeoptions-interface)        |
| [FunctionHandlerResult](/docs/api/functions#functionhandlerresult-type-alias)                        | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionhandlerresult-type-alias)          |
| [FunctionHandlerValidation](/docs/api/functions#functionhandlervalidation-type-alias)                | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionhandlervalidation-type-alias)      |
| [FunctionOperation](/docs/api/functions#functionoperation-type-alias)                                | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionoperation-type-alias)              |
| [FunctionOperationError](/docs/api/functions#functionoperationerror-class)                           | Value | `@relkit/functions` | [API example](/docs/api/functions#functionoperationerror-class)              |
| [FunctionRef](/docs/api/functions#functionref-interface)                                             | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionref-interface)                     |
| [FunctionRefAny](/docs/api/functions#functionrefany-type-alias)                                      | Type  | `@relkit/functions` | [API example](/docs/api/functions#functionrefany-type-alias)                 |
| [FunctionTelemetry](/docs/api/functions#functiontelemetry-class)                                     | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontelemetry-class)                   |
| [FunctionTelemetryLive](/docs/api/functions#functiontelemetrylive)                                   | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontelemetrylive)                     |
| [FunctionTelemetryService](/docs/api/functions#functiontelemetryservice-interface)                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontelemetryservice-interface)        |
| [FunctionToolApproval](/docs/api/functions#functiontoolapproval-type-alias)                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapproval-type-alias)           |
| [FunctionToolApprovalDecision](/docs/api/functions#functiontoolapprovaldecision-type-alias)          | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovaldecision-type-alias)   |
| [FunctionToolApprovalDeniedError](/docs/api/functions#functiontoolapprovaldeniederror-class)         | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovaldeniederror-class)     |
| [FunctionToolApprovalDeniedFailure](/docs/api/functions#functiontoolapprovaldeniedfailure-class)     | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovaldeniedfailure-class)   |
| [FunctionToolApprovalRequest](/docs/api/functions#functiontoolapprovalrequest-interface)             | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovalrequest-interface)     |
| [FunctionToolApprovalRequiredError](/docs/api/functions#functiontoolapprovalrequirederror-class)     | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovalrequirederror-class)   |
| [FunctionToolApprovalRequiredFailure](/docs/api/functions#functiontoolapprovalrequiredfailure-class) | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovalrequiredfailure-class) |
| [FunctionToolApprovalResolver](/docs/api/functions#functiontoolapprovalresolver-type-alias)          | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolapprovalresolver-type-alias)   |
| [FunctionToolArgumentFailure](/docs/api/functions#functiontoolargumentfailure-class)                 | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolargumentfailure-class)         |
| [FunctionToolArgumentValidationError](/docs/api/functions#functiontoolargumentvalidationerror-class) | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolargumentvalidationerror-class) |
| [FunctionToolCancelledFailure](/docs/api/functions#functiontoolcancelledfailure-class)               | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontoolcancelledfailure-class)        |
| [FunctionToolContext](/docs/api/functions#functiontoolcontext-type-alias)                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolcontext-type-alias)            |
| [FunctionToolDescriptor](/docs/api/functions#functiontooldescriptor-interface)                       | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontooldescriptor-interface)          |
| [FunctionToolHook](/docs/api/functions#functiontoolhook-type-alias)                                  | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolhook-type-alias)               |
| [FunctionToolInvokeOptions](/docs/api/functions#functiontoolinvokeoptions-interface)                 | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolinvokeoptions-interface)       |
| [FunctionToolMetadata](/docs/api/functions#functiontoolmetadata-interface)                           | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolmetadata-interface)            |
| [FunctionToolOperationCancelledError](/docs/api/functions#functiontooloperationcancellederror-class) | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontooloperationcancellederror-class) |
| [FunctionToolOptions](/docs/api/functions#functiontooloptions-interface)                             | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontooloptions-interface)             |
| [FunctionToolSideEffect](/docs/api/functions#functiontoolsideeffect-type-alias)                      | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontoolsideeffect-type-alias)         |
| [FunctionToolTarget](/docs/api/functions#functiontooltarget-type-alias)                              | Type  | `@relkit/functions` | [API example](/docs/api/functions#functiontooltarget-type-alias)             |
| [functionTry](/docs/api/functions#functiontry)                                                       | Value | `@relkit/functions` | [API example](/docs/api/functions#functiontry)                               |
| [InvocationMetadata](/docs/api/functions#invocationmetadata-type-alias)                              | Type  | `@relkit/functions` | [API example](/docs/api/functions#invocationmetadata-type-alias)             |
| [InvocationSource](/docs/api/functions#invocationsource-type-alias)                                  | Type  | `@relkit/functions` | [API example](/docs/api/functions#invocationsource-type-alias)               |
| [invokeFunctionGraphNodeEffect](/docs/api/functions#invokefunctiongraphnodeeffect)                   | Value | `@relkit/functions` | [API example](/docs/api/functions#invokefunctiongraphnodeeffect)             |
| [invokeFunctionToolEffect](/docs/api/functions#invokefunctiontooleffect)                             | Value | `@relkit/functions` | [API example](/docs/api/functions#invokefunctiontooleffect)                  |
| [isErrorDescriptor](/docs/api/functions#iserrordescriptor)                                           | Value | `@relkit/functions` | [API example](/docs/api/functions#iserrordescriptor)                         |
| [isErrorDescriptorEffect](/docs/api/functions#iserrordescriptoreffect)                               | Value | `@relkit/functions` | [API example](/docs/api/functions#iserrordescriptoreffect)                   |
| [isFunctionGraphNode](/docs/api/functions#isfunctiongraphnode)                                       | Value | `@relkit/functions` | [API example](/docs/api/functions#isfunctiongraphnode)                       |
| [isFunctionGraphNodeEffect](/docs/api/functions#isfunctiongraphnodeeffect)                           | Value | `@relkit/functions` | [API example](/docs/api/functions#isfunctiongraphnodeeffect)                 |
| [isStreamOutputSchema](/docs/api/functions#isstreamoutputschema)                                     | Value | `@relkit/functions` | [API example](/docs/api/functions#isstreamoutputschema)                      |
| [isStreamOutputSchemaEffect](/docs/api/functions#isstreamoutputschemaeffect)                         | Value | `@relkit/functions` | [API example](/docs/api/functions#isstreamoutputschemaeffect)                |
| [JobClientFor](/docs/api/functions#jobclientfor-type-alias)                                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#jobclientfor-type-alias)                   |
| [JobClients](/docs/api/functions#jobclients-type-alias)                                              | Type  | `@relkit/functions` | [API example](/docs/api/functions#jobclients-type-alias)                     |
| [JobEnqueueOptions](/docs/api/functions#jobenqueueoptions-interface)                                 | Type  | `@relkit/functions` | [API example](/docs/api/functions#jobenqueueoptions-interface)               |
| [JobEnqueueResult](/docs/api/functions#jobenqueueresult-interface)                                   | Type  | `@relkit/functions` | [API example](/docs/api/functions#jobenqueueresult-interface)                |
| [JobRef](/docs/api/app#jobref-interface)                                                             | Type  | `@relkit/functions` | [Module example](/docs/learn/concepts/functions)                             |
| [JobRefAny](/docs/api/app#jobrefany-type-alias)                                                      | Type  | `@relkit/functions` | [Module example](/docs/learn/concepts/functions)                             |
| [JobState](/docs/api/functions#jobstate-type-alias)                                                  | Type  | `@relkit/functions` | [API example](/docs/api/functions#jobstate-type-alias)                       |
| [JobStatus](/docs/api/functions#jobstatus-interface)                                                 | Type  | `@relkit/functions` | [API example](/docs/api/functions#jobstatus-interface)                       |
| [NormalizedErrorRetry](/docs/api/functions#normalizederrorretry-interface)                           | Type  | `@relkit/functions` | [API example](/docs/api/functions#normalizederrorretry-interface)            |
| [observeFunction](/docs/api/functions#observefunction)                                               | Value | `@relkit/functions` | [API example](/docs/api/functions#observefunction)                           |
| [PublicClock](/docs/api/functions#publicclock-type-alias)                                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#publicclock-type-alias)                    |
| [PublicLogger](/docs/api/functions#publiclogger-type-alias)                                          | Type  | `@relkit/functions` | [API example](/docs/api/functions#publiclogger-type-alias)                   |
| [RELKIT_FUNCTION_GRAPH_NODE](/docs/api/functions#relkit_function_graph_node)                         | Value | `@relkit/functions` | [API example](/docs/api/functions#relkit_function_graph_node)                |
| [ResolvedApplicationEnv](/docs/api/functions#resolvedapplicationenv-type-alias)                      | Type  | `@relkit/functions` | [API example](/docs/api/functions#resolvedapplicationenv-type-alias)         |
| [runFunctionPromise](/docs/api/functions#runfunctionpromise)                                         | Value | `@relkit/functions` | [API example](/docs/api/functions#runfunctionpromise)                        |
| [runFunctionSync](/docs/api/functions#runfunctionsync)                                               | Value | `@relkit/functions` | [API example](/docs/api/functions#runfunctionsync)                           |
| [streamOf](/docs/api/functions#streamof)                                                             | Value | `@relkit/functions` | [API example](/docs/api/functions#streamof)                                  |
| [streamOfEffect](/docs/api/functions#streamofeffect)                                                 | Value | `@relkit/functions` | [API example](/docs/api/functions#streamofeffect)                            |
| [StreamOutputSchema](/docs/api/functions#streamoutputschema-interface)                               | Type  | `@relkit/functions` | [API example](/docs/api/functions#streamoutputschema-interface)              |
| [TaskClientFor](/docs/api/functions#taskclientfor-type-alias)                                        | Type  | `@relkit/functions` | [API example](/docs/api/functions#taskclientfor-type-alias)                  |
| [TaskClients](/docs/api/functions#taskclients-type-alias)                                            | Type  | `@relkit/functions` | [API example](/docs/api/functions#taskclients-type-alias)                    |
| [TaskTriggerOptions](/docs/api/functions#tasktriggeroptions-interface)                               | Type  | `@relkit/functions` | [API example](/docs/api/functions#tasktriggeroptions-interface)              |

## `client-maps.types.ts`

### AgentClientFor (type alias)

Typed callable client for an agent descriptor.

**Example**

```ts
const invoke: AgentClientFor<typeof agent> = async (input) => output;
```

**Signature**

```ts
type AgentClientFor<T> = (input: InputOf<T>) => Promise<OutputOf<T>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L58)

### AgentClients (type alias)

Named agent clients projected from dependencies.

**Example**

```ts
const agents: AgentClients<typeof dependencies.agents> = context.agents;
```

**Signature**

```ts
type AgentClients<M> = {
  readonly [Name in keyof NonNullable<M> & string]: AgentClientFor<NonNullable<M>[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L151)

### BucketClientFor (type alias)

Bucket client exposed for a declared bucket.

**Example**

```ts
const client: BucketClientFor<typeof bucket> = buckets.uploads;
```

**Signature**

```ts
type BucketClientFor<T> = BucketClient;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L112)

### BucketClients (type alias)

Named bucket clients projected from dependencies.

**Example**

```ts
const buckets: BucketClients<typeof dependencies.buckets> = context.buckets;
```

**Signature**

```ts
type BucketClients<M> = {
  readonly [Name in keyof NonNullable<M> & string]: BucketClientFor<NonNullable<M>[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L139)

### CacheClientFor (type alias)

Key and value typed cache client.

**Example**

```ts
const client: CacheClientFor<typeof cache> = caches.sessions;
```

**Signature**

```ts
type CacheClientFor<T> = CacheClient<KeyOf<T>, ValueOf<T>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L116)

### CacheClients (type alias)

Named cache clients projected from dependencies.

**Example**

```ts
const cache: CacheClients<typeof dependencies.cache> = context.cache;
```

**Signature**

```ts
type CacheClients<M> = {
  readonly [Name in keyof NonNullable<M> & string]: CacheClientFor<NonNullable<M>[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L145)

### EventClientFor (type alias)

Typed publish client for an event descriptor.

**Example**

```ts
const client: EventClientFor<typeof event> = events.created;
```

**Signature**

```ts
type EventClientFor<T> = {
  /** Publishes an event.
   * @param payload - Event payload.
   * @param options - Optional key and attributes.
   * @returns Accepted event envelope.
   * @example await events.created.publish(payload);
   */
  publish(
    payload: EventInputOf<T>,
    options?: EventPublishOptions,
  ): Promise<EventPublishResult<EventIdOf<T>, EventVersionOf<T>, EventOutputOf<T>>>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L97)

### EventClients (type alias)

Named event clients projected from published events.

**Example**

```ts
const events: EventClients<typeof published> = context.events;
```

**Signature**

```ts
type EventClients<M> = {
  readonly [Name in keyof NonNullable<M> & string]: EventClientFor<NonNullable<M>[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L133)

### JobClientFor (type alias)

Typed enqueue client for a job descriptor.

**Example**

```ts
const client: JobClientFor<typeof job> = jobs.myJob;
```

**Signature**

```ts
type JobClientFor<T> = {
  /** Enqueues a job invocation.
   * @param input - Job input.
   * @param options - Optional correlation metadata.
   * @returns Acceptance receipt.
   * @example await jobs.send.enqueue(input);
   */
  enqueue(input: InputOf<T>, options?: JobEnqueueOptions): Promise<JobEnqueueResult>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L62)

### JobClients (type alias)

Named job clients projected from dependencies.

**Example**

```ts
const jobs: JobClients<typeof dependencies.jobs> = context.jobs;
```

**Signature**

```ts
type JobClients<M> = {
  readonly [Name in keyof NonNullable<M> & string]: JobClientFor<NonNullable<M>[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L121)

### TaskClientFor (type alias)

Typed trigger client for a task descriptor.

**Example**

```ts
const client: TaskClientFor<typeof task> = tasks.send;
```

**Signature**

```ts
type TaskClientFor<T> = {
  /** Triggers a task run.
   * @param input - Task input.
   * @param options - Optional scheduling and idempotency controls.
   * @returns Handle for the new run.
   * @example await tasks.send.trigger(input);
   */
  trigger(input: InputOf<T>, options?: TaskTriggerOptions): Promise<RunHandle>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L85)

### TaskClients (type alias)

Named task clients projected from dependencies.

**Example**

```ts
const tasks: TaskClients<typeof dependencies.tasks> = context.tasks;
```

**Signature**

```ts
type TaskClients<M> = {
  readonly [Name in keyof NonNullable<M> & string]: TaskClientFor<NonNullable<M>[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L127)

### TaskTriggerOptions (interface)

Scheduling and idempotency options for a task.

**Example**

```ts
await tasks.send.trigger(input, { operationId: "send-1" });
```

**Signature**

```ts
export interface TaskTriggerOptions {
  readonly operationId?: string;
  readonly idempotencyKey?: string;
  readonly delay?: string;
  readonly at?: string;
  readonly tags?: readonly string[];
  readonly correlationId?: string;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/client-maps.types.ts#L74)

## `clients.types.ts`

### "./client-maps.types.js" (namespace export)

Re-exports all named exports from the "./client-maps.types.js" module.

**Signature**

```ts
export * from "./client-maps.types.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L84)

### BucketClient

**Signature**

```ts
declare const BucketClient: BucketClient;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L81)

### BucketObjectMetadata

**Signature**

```ts
declare const BucketObjectMetadata: BucketObjectMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L81)

### BucketPutOptions

**Signature**

```ts
declare const BucketPutOptions: BucketPutOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L81)

### CacheClient

**Signature**

```ts
declare const CacheClient: CacheClient<Key, Value>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L82)

### CacheOperationOptions

**Signature**

```ts
declare const CacheOperationOptions: CacheOperationOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L82)

### EventAttributeValue (type alias)

Scalar value accepted in event attributes.

**Example**

```ts
const value: EventAttributeValue = true;
```

**Signature**

```ts
type EventAttributeValue = string | number | boolean;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L44)

### EventPublishOptions (interface)

Metadata supplied with an event publication.

**Example**

```ts
await events.publish(payload, { key: "order-1" });
```

**Signature**

```ts
export interface EventPublishOptions {
  readonly key?: string;
  readonly attributes?: Readonly<Record<string, EventAttributeValue>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L65)

### EventPublishResult (interface)

Accepted event envelope returned by publication.

**Example**

```ts
const published: EventPublishResult = await events.publish(payload);
```

**Signature**

```ts
export interface EventPublishResult<
  Id extends string = string,
  Version extends number = number,
  Payload = unknown,
> extends EventEnvelope<Id, Version, Payload> {
  readonly accepted: true;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L73)

### JobEnqueueOptions (interface)

Options for enqueuing a job.

**Example**

```ts
await jobs.enqueue(input, { correlationId: "trace-1" });
```

**Signature**

```ts
export interface JobEnqueueOptions {
  readonly correlationId?: string;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L23)

### JobEnqueueResult (interface)

Receipt returned when a job is accepted.

**Example**

```ts
const receipt: JobEnqueueResult = await jobs.enqueue(input);
```

**Signature**

```ts
export interface JobEnqueueResult {
  readonly instanceId: string;
  readonly accepted: true;
  readonly duplicate?: boolean;
  readonly idempotencyKey?: string;
  readonly idempotencyExpiresAt?: number;
  readonly status: Extract<JobState, "accepted">;
  readonly profile: string;
  readonly correlationId?: string;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L30)

### JobState (type alias)

Lifecycle state of a queued job.

**Example**

```ts
const state: JobState = "accepted";
```

**Signature**

```ts
type JobState = "accepted" | "available" | "leased" | "delayed" | "completed" | "dead-lettered";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L6)

### JobStatus (interface)

Snapshot of one queued job.

**Example**

```ts
const status: JobStatus = await jobs.status(id);
```

**Signature**

```ts
export interface JobStatus {
  readonly instanceId: string;
  readonly state: JobState;
  readonly profile: string;
  readonly attempt: number;
  readonly correlationId?: string;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/clients.types.ts#L12)

## `define-error-validation.ts`

### assertErrorSchema

Asserts a declared error data schema.

**Throws**

TypeError for a nonstandard schema.

**Example**

```ts
assertErrorSchema(z.string());
```

**Signature**

```ts
declare const assertErrorSchema: (value: unknown) => asserts value is StandardSchemaV1;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L100)

### assertErrorSchemaEffect

Validates a Standard Schema through Effect.

**Example**

```ts
Effect.runSync(assertErrorSchemaEffect(z.string()));
```

**Signature**

```ts
declare const assertErrorSchemaEffect: (
  value: unknown,
) => Effect.Effect<StandardSchemaV1<unknown, unknown>, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L77)

### isErrorDescriptor

Recognizes a declared error descriptor.

**Example**

```ts
if (isErrorDescriptor(value)) console.log(value.id);
```

**Signature**

```ts
declare const isErrorDescriptor: (value: unknown) => value is ErrorDescriptorAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L41)

### isErrorDescriptorEffect

Checks a declared error descriptor through Effect.

**Example**

```ts
Effect.runSync(isErrorDescriptorEffect(value));
```

**Signature**

```ts
declare const isErrorDescriptorEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L14)

### isRecord

Recognizes a nonarray record-like value.

**Example**

```ts
isRecord({ id: "one" });
```

**Signature**

```ts
declare const isRecord: (value: unknown) => value is Record<PropertyKey, unknown>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L124)

### isRecordEffect

Checks a record-like value through Effect.

**Example**

```ts
Effect.runSync(isRecordEffect({}));
```

**Signature**

```ts
declare const isRecordEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L109)

### validateErrorHttp

Validates a declared error HTTP mapping.

**Throws**

TypeError for an invalid status.

**Example**

```ts
validateErrorHttp({ status: 404 });
```

**Signature**

```ts
declare const validateErrorHttp: (http: ErrorHttpMapping | undefined) => void;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L68)

### validateErrorHttpEffect

Validates an HTTP status mapping through Effect.

**Example**

```ts
Effect.runSync(validateErrorHttpEffect({ status: 404 }));
```

**Signature**

```ts
declare const validateErrorHttpEffect: (
  http: ErrorHttpMapping | undefined,
) => Effect.Effect<void, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error-validation.ts#L50)

## `define-error.ts`

### defineError

Defines a typed application error.

**Throws**

TypeError for invalid schema, retry, HTTP status, or message.

**Example**

```ts
import { defineError } from "@relkit/functions";
import { z } from "@relkit/schema";
const NotFound = defineError({
  id: "orders.not-found",
  data: z.object({ id: z.string() }),
  message: "Missing",
});
const error = new NotFound({ id: "order-1" });
```

**Signature**

```ts
declare const defineError: <const Id extends string, const DataSchema extends StandardSchemaV1>(
  options: DefineErrorOptions<Id, DataSchema>,
) => ErrorDescriptor<Id, InferOutput<DataSchema>, DataSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L206)

Since v0.1.0

### defineErrorEffect

Defines a typed application error with safe data, transport metadata, and an optional retry hint.
The compiler derives omitted IDs. Omitted retry means never; `later` only hints to durable work.

**Example**

```ts
const NotFound = Effect.runSync(
  defineErrorEffect({
    id: "orders.not-found",
    data: z.object({ orderId: z.string() }),
    message: ({ orderId }) => `Order ${orderId} was not found`,
  }),
);
new NotFound({ orderId: "order-1" });
```

**Signature**

```ts
declare const defineErrorEffect: <
  const Id extends string,
  const DataSchema extends StandardSchemaV1,
>(
  options: DefineErrorOptions<Id, DataSchema>,
) => Effect.Effect<
  ErrorDescriptor<Id, InferOutput<DataSchema>, DataSchema>,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L90)

Since v0.1.0

### DeclaredError (class)

Validated application error instance.

**Example**

```ts
const error = new NotFound({ id: "one" });
```

**Signature**

```ts
declare class DeclaredError<Id, Data> {
  constructor(
    id: Id,
    ref: ErrorRef<Id>,
    data: Data,
    message: string,
    retry: ErrorRetry,
    afterMs: number | undefined,
    http: ErrorHttpMapping | undefined,
  );
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L45)

### id (property)

**Signature**

```ts
readonly id: Id
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L46)

### ref (property)

**Signature**

```ts
readonly ref: ErrorRef<Id>
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L47)

### data (property)

**Signature**

```ts
readonly data: Data
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L48)

### retry (property)

**Signature**

```ts
readonly retry: ErrorRetry
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L49)

### afterMs (property)

**Signature**

```ts
readonly afterMs: number | undefined
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L50)

### http (property)

**Signature**

```ts
readonly http: ErrorHttpMapping | undefined
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L51)

### DefineErrorOptions

**Signature**

```ts
declare const DefineErrorOptions: DefineErrorOptions<Id, DataSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L35)

### ErrorDescriptor

**Signature**

```ts
declare const ErrorDescriptor: ErrorDescriptor<Id, Data, DataSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L36)

### ErrorDescriptorAny

**Signature**

```ts
declare const ErrorDescriptorAny: ErrorDescriptorAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L37)

### ErrorHttpMapping

**Signature**

```ts
declare const ErrorHttpMapping: ErrorHttpMapping;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L38)

### ErrorRef

**Signature**

```ts
declare const ErrorRef: ErrorRef<Id>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L39)

### ErrorRetry

**Signature**

```ts
declare const ErrorRetry: ErrorRetry;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L33)

### ErrorRetryInput

**Signature**

```ts
declare const ErrorRetryInput: ErrorRetryInput;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L33)

### NormalizedErrorRetry

**Signature**

```ts
declare const NormalizedErrorRetry: NormalizedErrorRetry;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L33)

### isErrorDescriptor

**Signature**

```ts
declare const isErrorDescriptor: (value: unknown) => value is ErrorDescriptorAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L31)

### isErrorDescriptorEffect

**Signature**

```ts
declare const isErrorDescriptorEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.ts#L31)

## `define-error.types.ts`

### DefineErrorOptions (interface)

Options for constructing a declared error descriptor.

**Example**

```ts
defineError({ id: "orders.not-found", data: z.object({ id: z.string() }), message: "Missing" });
```

**Signature**

```ts
export interface DefineErrorOptions<
  Id extends string,
  DataSchema extends StandardSchemaV1,
> extends DescriptorMetadata {
  readonly id?: Id;
  readonly data: DataSchema;
  readonly message: string | ((data: InferOutput<DataSchema>) => string);
  readonly http?: ErrorHttpMapping;
  readonly retry?: ErrorRetryInput;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.types.ts#L47)

### ErrorDescriptor (interface)

Callable descriptor for creating a declared error.

**Example**

```ts
const error = new NotFound({ id: "one" });
```

**Signature**

```ts
export interface ErrorDescriptor<
  Id extends string,
  Data,
  DataSchema extends StandardSchemaV1 = StandardSchemaV1,
> extends DescriptorMetadata {
  readonly kind: "error";
  readonly id: Id;
  readonly ref: ErrorRef<Id>;
  readonly data: DataSchema;
  readonly message: string | ((data: Data) => string);
  readonly http?: ErrorHttpMapping;
  readonly retry: ErrorRetry;
  readonly afterMs?: number;
  readonly create: (input: InferInput<DataSchema>) => DeclaredError<Id, Data>;
  new (input: InferInput<DataSchema>): DeclaredError<Id, Data>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.types.ts#L24)

### ErrorDescriptorAny (type alias)

Any declared error descriptor for heterogeneous collections.

**Signature**

```ts
type ErrorDescriptorAny = ErrorDescriptor<string, any, StandardSchemaV1<any, any>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.types.ts#L42)

### ErrorHttpMapping (interface)

HTTP mapping for a declared error.

**Example**

```ts
const http: ErrorHttpMapping = { status: 404 };
```

**Signature**

```ts
export interface ErrorHttpMapping {
  readonly status: number;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.types.ts#L9)

### ErrorRef (interface)

Stable reference to an application error.

**Example**

```ts
const ref: ErrorRef = { kind: "error", id: "orders.not-found" };
```

**Signature**

```ts
export interface ErrorRef<Id extends string = string> {
  readonly kind: "error";
  readonly id: Id;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-error.types.ts#L16)

## `define-function-inference.types.ts`

## `define-function-validation.ts`

### assertHook

Checks an optional function lifecycle hook.

**Throws**

TypeError when the hook is not callable.

**Example**

```ts
assertHook(() => {}, "onBefore");
```

**Signature**

```ts
declare const assertHook: (value: unknown, name: string) => void;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L63)

### assertHookEffect

Checks an optional hook through Effect.

**Example**

```ts
Effect.runSync(assertHookEffect(() => {}, "onBefore"));
```

**Signature**

```ts
declare const assertHookEffect: (
  value: unknown,
  name: string,
) => Effect.Effect<void, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L47)

### assertSchema

Asserts a Standard Schema validator.

**Throws**

TypeError for malformed schemas.

**Example**

```ts
assertSchema(z.string(), "input");
```

**Signature**

```ts
declare const assertSchema: (value: unknown, name: string) => asserts value is StandardSchemaV1;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L97)

### assertSchemaEffect

Checks a function schema through Effect.

**Example**

```ts
Effect.runSync(assertSchemaEffect(z.string(), "input"));
```

**Signature**

```ts
declare const assertSchemaEffect: (
  value: unknown,
  name: string,
) => Effect.Effect<StandardSchemaV1<unknown, unknown>, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L73)

### copyDependencies

**Signature**

```ts
declare const copyDependencies: <D extends FunctionDependencies>(
  dependencies: D | undefined,
) => D | undefined;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L9)

### copyDependenciesEffect

**Signature**

```ts
declare const copyDependenciesEffect: <D extends FunctionDependencies>(
  dependencies: D | undefined,
) => Effect.Effect<D | undefined, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L10)

### copyPublishes

**Signature**

```ts
declare const copyPublishes: <Names extends readonly string[]>(
  publishes: Names | undefined,
) => Names | undefined;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L11)

### copyPublishesEffect

**Signature**

```ts
declare const copyPublishesEffect: <Names extends readonly string[]>(
  publishes: Names | undefined,
) => Effect.Effect<Names | undefined, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L12)

### functionTargetForReceiver

Resolves a method receiver to a callable function descriptor.

**Throws**

TypeError when receiver is event-only.

**Example**

```ts
functionTargetForReceiver(fn, fn);
```

**Signature**

```ts
declare const functionTargetForReceiver: (
  receiver: unknown,
  fallback: FunctionRefAny,
) => FunctionRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L136)

### functionTargetForReceiverEffect

Resolves a callable receiver through Effect.

**Example**

```ts
Effect.runSync(functionTargetForReceiverEffect(fn, fn));
```

**Signature**

```ts
declare const functionTargetForReceiverEffect: (
  receiver: unknown,
  fallback: FunctionRefAny,
) => Effect.Effect<FunctionRefAny, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L107)

### validateLimit

Checks a positive integer function limit.

**Throws**

TypeError for an invalid limit.

**Example**

```ts
validateLimit(5, "timeoutMs");
```

**Signature**

```ts
declare const validateLimit: (value: number | undefined, name: string) => void;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L37)

### validateLimitEffect

Checks a function limit through Effect.

**Example**

```ts
Effect.runSync(validateLimitEffect(5, "timeoutMs"));
```

**Signature**

```ts
declare const validateLimitEffect: (
  value: number | undefined,
  name: string,
) => Effect.Effect<void, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function-validation.ts#L21)

## `define-function.ts`

### defineFunction

Defines the graph-visible executable unit shared by HTTP, background, tool, and agent calls.

The `id` is optional for source-scoped functions; the compiler derives it from the
source/export hierarchy. Durable resources keep explicit IDs. The handler receives
validated reusable input and an invocation-scoped context. Use `descriptor.invoke(input)`
for nested calls so the
common engine preserves validation, service policy, limits, and telemetry.

**Throws**

TypeError for invalid definition inputs.

**Example**

```ts
import { defineFunction } from "@relkit/app/functions";
import { z } from "@relkit/app/schema";

const greet = defineFunction({
  input: z.object({ name: z.string() }),
  output: z.object({ message: z.string() }),
  handler: async ({ name }, context) => {
    context.log.info("greeting requested");
    return { message: `Hello, ${name}!` };
  },
});
const result = await greet.invoke({ name: "Ada" });
void result;
void greet;
```

**Signature**

```ts
declare const defineFunction: DefineFunction;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L124)

Since v0.1.0

#### Backend and frontend example

**Backend** — these maintained files define the operation used by the frontend below.

```ts title="templates/default/v1/api/src/services/orders/functions/create-order.function.ts"
/** Validates order input, invokes the service-local pricing function, and returns the calculated order. */
import { defineFunction } from "@relkit/app/functions";
import { z } from "@relkit/app/schema";
import priceOrder from "@app/services/orders/functions/price-order.function.js";

const orderInput = z.object({
  orderId: z.string().min(1),
  sku: z.string().min(1),
  quantity: z.number().int().positive(),
});

const orderOutput = z.object({
  orderId: z.string(),
  sku: z.string(),
  totalCents: z.number().int().nonnegative(),
});

const createOrder = defineFunction({
  input: orderInput,
  output: orderOutput,

  handler: async (input) => {
    const { totalCents } = await priceOrder.invoke({ quantity: input.quantity });
    const order = {
      orderId: input.orderId,
      sku: input.sku,
      totalCents,
    };

    return order;
  },
});

export default createOrder;
```

```ts title="templates/default/v1/api/src/routes/orders/route.ts"
/** Maps the HTTP endpoint to its owning service's public member. */
import { defineServiceRoutes } from "@relkit/app/routes";
import orders from "@app/services/orders/service.js";

export const { POST } = defineServiceRoutes(orders, {
  POST: { member: "createOrder", successStatus: 201 },
});
```

**Frontend**

After [frontend setup and pulling this API example's contract](/guides/frontend/connect-react),
render this component under `RelkitClientProvider`:

```tsx title="src/CreateOrder.tsx — frontend"
"use client";

/** Calls the API example's Orders function through its public route, retaining the generated input and price result. */
import { useRelkitClient, useRouteMutation } from "@relkit/client/react";

/** Creates one order in the API example without importing the backend service.
 * @returns A guarded submission action and its typed price or failure. */
export function CreateOrder() {
  const { status } = useRelkitClient();
  const create = useRouteMutation("POST /orders");

  return (
    <section>
      <button
        disabled={status !== "ready" || !create.isIdle}
        onClick={() => create.mutate({ orderId: crypto.randomUUID(), sku: "book", quantity: 2 })}
      >
        Create an order
      </button>
      {create.isPending && <p role="status">Creating…</p>}
      {create.isSuccess && <p>Total: {create.data.totalCents} cents</p>}
      {create.isError && (
        <p role="alert">{create.error.message}. Check the outcome before retrying.</p>
      )}
    </section>
  );
}
```

This calls the same `createOrder` function through `POST /orders`: `orderId`, `sku`, and `quantity`
come from its input schema, and `totalCents` comes from its output schema. The browser calls RPC;
it never imports the descriptor or calls `.invoke()`. Service membership needs a client-exposed
route to become a browser operation.

Reference: [`useRouteMutation`](/docs/api/client#useroutemutation).
Continue with [mutation state and recovery](/docs/modules/client/mutations).

### AgentClientFor

**Signature**

```ts
declare const AgentClientFor: AgentClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L14)

### AgentClients

**Signature**

```ts
declare const AgentClients: AgentClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L15)

### AgentRef

**Signature**

```ts
declare const AgentRef: AgentRef<Id, InputSchema, OutputSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L16)

### AgentRefAny

**Signature**

```ts
declare const AgentRefAny: AgentRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L17)

### AuthContext

**Signature**

```ts
declare const AuthContext: AuthContext<Session>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L18)

### BucketClient

**Signature**

```ts
declare const BucketClient: BucketClient;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L19)

### BucketClientFor

**Signature**

```ts
declare const BucketClientFor: BucketClient;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L20)

### BucketClients

**Signature**

```ts
declare const BucketClients: BucketClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L21)

### BucketObjectMetadata

**Signature**

```ts
declare const BucketObjectMetadata: BucketObjectMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L22)

### BucketRef

**Signature**

```ts
declare const BucketRef: BucketRef<Id>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L23)

### BucketRefAny

**Signature**

```ts
declare const BucketRefAny: BucketRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L24)

### CacheClient

**Signature**

```ts
declare const CacheClient: CacheClient<Key, Value>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L25)

### CacheClientFor

**Signature**

```ts
declare const CacheClientFor: CacheClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L26)

### CacheClients

**Signature**

```ts
declare const CacheClients: CacheClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L27)

### CacheOperationOptions

**Signature**

```ts
declare const CacheOperationOptions: CacheOperationOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L28)

### CacheRef

**Signature**

```ts
declare const CacheRef: CacheRef<Id, KeySchema, ValueSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L29)

### CacheRefAny

**Signature**

```ts
declare const CacheRefAny: CacheRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L30)

### DefineFunctionOptions

**Signature**

```ts
declare const DefineFunctionOptions: DefineFunctionOptions<
  Id,
  InputSchema,
  OutputSchema,
  Dependencies,
  Errors,
  Publishes,
  ProgressSchema
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L32)

### DescriptorRef

**Signature**

```ts
declare const DescriptorRef: DescriptorRef<Kind, Id>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L31)

### EventAttributeValue

**Signature**

```ts
declare const EventAttributeValue: EventAttributeValue;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L35)

### EventClientFor

**Signature**

```ts
declare const EventClientFor: EventClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L33)

### EventClients

**Signature**

```ts
declare const EventClients: EventClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L34)

### EventPublishOptions

**Signature**

```ts
declare const EventPublishOptions: EventPublishOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L36)

### EventPublishResult

**Signature**

```ts
declare const EventPublishResult: EventPublishResult<Id, Version, Payload>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L37)

### EventRef

**Signature**

```ts
declare const EventRef: EventRef<Id, InputSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L38)

### EventRefAny

**Signature**

```ts
declare const EventRefAny: EventRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L39)

### FunctionContext

**Signature**

```ts
declare const FunctionContext: FunctionContext<D, Publishes, Progress>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L40)

### FunctionDependencies

**Signature**

```ts
declare const FunctionDependencies: FunctionDependencies;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L41)

### FunctionDescriptor

**Signature**

```ts
declare const FunctionDescriptor: FunctionDescriptor<
  Id,
  Input,
  Output,
  Dependencies,
  Errors,
  InputSchema,
  OutputSchema,
  ToolMetadata,
  Publishes,
  ProgressSchema
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L42)

### FunctionRef

**Signature**

```ts
declare const FunctionRef: FunctionRef<Id, Input, Output, Errors, InputSchema, OutputSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L43)

### FunctionRefAny

**Signature**

```ts
declare const FunctionRefAny: FunctionRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L44)

### InvocationMetadata

**Signature**

```ts
declare const InvocationMetadata: InvocationMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L45)

### InvocationSource

**Signature**

```ts
declare const InvocationSource: InvocationSource;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L46)

### JobClientFor

**Signature**

```ts
declare const JobClientFor: JobClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L48)

### JobClients

**Signature**

```ts
declare const JobClients: JobClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L49)

### JobEnqueueOptions

**Signature**

```ts
declare const JobEnqueueOptions: JobEnqueueOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L47)

### JobEnqueueResult

**Signature**

```ts
declare const JobEnqueueResult: JobEnqueueResult;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L50)

### JobRef

**Signature**

```ts
declare const JobRef: JobRef<Id, InputSchema, OutputSchema, Task>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L51)

### JobRefAny

**Signature**

```ts
declare const JobRefAny: JobRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L52)

### JobState

**Signature**

```ts
declare const JobState: JobState;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L53)

### JobStatus

**Signature**

```ts
declare const JobStatus: JobStatus;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L54)

### PublicClock

**Signature**

```ts
declare const PublicClock: PublicClock;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L58)

### PublicLogger

**Signature**

```ts
declare const PublicLogger: PublicLogger;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L59)

### ResolvedApplicationEnv

**Signature**

```ts
declare const ResolvedApplicationEnv: Readonly<Record<string, unknown>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L60)

### TaskClientFor

**Signature**

```ts
declare const TaskClientFor: TaskClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L55)

### TaskClients

**Signature**

```ts
declare const TaskClients: TaskClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L56)

### TaskTriggerOptions

**Signature**

```ts
declare const TaskTriggerOptions: TaskTriggerOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L57)

### defineFunctionEffect

Defines a callable function through Effect.

**Example**

```ts
Effect.runSync(defineFunctionEffect({ input, output, handler }));
```

**Signature**

```ts
declare const defineFunctionEffect: DefineFunctionEffect;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.ts#L90)

## `define-function.types.ts`

### DefineFunction (interface)

Overloaded public function constructor preserving schema inference.

**Example**

```ts
const greet = defineFunction({ input, output, handler });
```

**Signature**

```ts
export interface DefineFunction {
  /** Defines a function without declared dependencies.
   * @param options - Schemas, handler, and function metadata.
   * @returns A callable descriptor with inferred input and output types.
   * @example const greet = defineFunction({ input, output, handler });
   */
  <
    const Id extends string,
    const InputSchema extends StandardSchemaV1,
    const OutputSchema extends StandardSchemaV1,
    const ProgressSchema extends StandardSchemaV1 | undefined = undefined,
    const Publishes extends readonly Extract<keyof Relkit.EventRegistry, string>[] = readonly [],
    const Options extends FunctionCallOptions<
      Id,
      InputSchema,
      OutputSchema,
      {},
      Publishes,
      ProgressSchema
    > = FunctionCallOptions<Id, InputSchema, OutputSchema, {}, Publishes, ProgressSchema>,
  >(
    options: FunctionCallOptions<Id, InputSchema, OutputSchema, {}, Publishes, ProgressSchema> &
      Options &
      FunctionCallValidation<NoInfer<Options>, InferOutput<OutputSchema>> & {
        readonly dependencies?: never;
      },
  ): FunctionDescriptor<
    Id,
    InferOutput<InputSchema>,
    InferOutput<OutputSchema>,
    {},
    ErrorListOf<Options>,
    InputSchema,
    OutputSchema,
    ToolMetadataOf<Options>,
    Publishes,
    ProgressSchema
  >;

  /** Defines a function with declared dependencies.
   * @param options - Schemas, handler, dependency map, and function metadata.
   * @returns A callable descriptor whose context includes the declared dependencies.
   * @example const lookup = defineFunction({ input, output, dependencies, handler });
   */
  <
    const Id extends string,
    const InputSchema extends StandardSchemaV1,
    const OutputSchema extends StandardSchemaV1,
    const Dependencies extends FunctionDependencies,
    const ProgressSchema extends StandardSchemaV1 | undefined = undefined,
    const Publishes extends readonly Extract<keyof Relkit.EventRegistry, string>[] = readonly [],
    const Options extends FunctionCallOptions<
      Id,
      InputSchema,
      OutputSchema,
      Dependencies,
      Publishes,
      ProgressSchema
    > = FunctionCallOptions<Id, InputSchema, OutputSchema, Dependencies, Publishes, ProgressSchema>,
  >(
    options: FunctionCallOptions<
      Id,
      InputSchema,
      OutputSchema,
      Dependencies,
      Publishes,
      ProgressSchema
    > &
      Options &
      FunctionCallValidation<NoInfer<Options>, InferOutput<OutputSchema>>,
  ): FunctionDescriptor<
    Id,
    InferOutput<InputSchema>,
    InferOutput<OutputSchema>,
    Dependencies,
    ErrorListOf<Options>,
    InputSchema,
    OutputSchema,
    ToolMetadataOf<Options>,
    Publishes,
    ProgressSchema
  >;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.types.ts#L27)

### DefineFunctionEffect (interface)

Effect constructor with the same schema and handler inference as defineFunction.

**Signature**

```ts
export interface DefineFunctionEffect {
  <
    const Id extends string,
    const InputSchema extends StandardSchemaV1,
    const OutputSchema extends StandardSchemaV1,
    const ProgressSchema extends StandardSchemaV1 | undefined = undefined,
    const Publishes extends readonly Extract<keyof Relkit.EventRegistry, string>[] = readonly [],
    const Options extends FunctionCallOptions<
      Id,
      InputSchema,
      OutputSchema,
      {},
      Publishes,
      ProgressSchema
    > = FunctionCallOptions<Id, InputSchema, OutputSchema, {}, Publishes, ProgressSchema>,
  >(
    options: FunctionCallOptions<Id, InputSchema, OutputSchema, {}, Publishes, ProgressSchema> &
      Options &
      FunctionCallValidation<NoInfer<Options>, InferOutput<OutputSchema>> & {
        readonly dependencies?: never;
      },
  ): Effect.Effect<
    FunctionDescriptor<
      Id,
      InferOutput<InputSchema>,
      InferOutput<OutputSchema>,
      {},
      ErrorListOf<Options>,
      InputSchema,
      OutputSchema,
      ToolMetadataOf<Options>,
      Publishes,
      ProgressSchema
    >,
    FunctionOperationError
  >;

  <
    const Id extends string,
    const InputSchema extends StandardSchemaV1,
    const OutputSchema extends StandardSchemaV1,
    const Dependencies extends FunctionDependencies,
    const ProgressSchema extends StandardSchemaV1 | undefined = undefined,
    const Publishes extends readonly Extract<keyof Relkit.EventRegistry, string>[] = readonly [],
    const Options extends FunctionCallOptions<
      Id,
      InputSchema,
      OutputSchema,
      Dependencies,
      Publishes,
      ProgressSchema
    > = FunctionCallOptions<Id, InputSchema, OutputSchema, Dependencies, Publishes, ProgressSchema>,
  >(
    options: FunctionCallOptions<
      Id,
      InputSchema,
      OutputSchema,
      Dependencies,
      Publishes,
      ProgressSchema
    > &
      Options &
      FunctionCallValidation<NoInfer<Options>, InferOutput<OutputSchema>>,
  ): Effect.Effect<
    FunctionDescriptor<
      Id,
      InferOutput<InputSchema>,
      InferOutput<OutputSchema>,
      Dependencies,
      ErrorListOf<Options>,
      InputSchema,
      OutputSchema,
      ToolMetadataOf<Options>,
      Publishes,
      ProgressSchema
    >,
    FunctionOperationError
  >;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.types.ts#L112)

### FunctionImplementationOptions (type alias)

Internal callable definition before the invocation mode is fixed.

**Example**

```ts
const options: FunctionImplementationOptions = { input, output, handler };
```

**Signature**

```ts
type FunctionImplementationOptions = Omit<
  FunctionDescriptorFactoryOptions,
  "id" | "invocationMode"
> & {
  readonly id?: string;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/define-function.types.ts#L6)

## `function-as-tool.types.ts`

### FunctionAsTool (type alias)

Overloads for deriving a tool from a callable function.

**Example**

```ts
const tool = fn.asTool({ description: "Lookup", sideEffect: "read", approval: "never" });
```

**Signature**

```ts
type FunctionAsTool<
  FunctionId extends string,
  Input,
  Output,
  Errors extends readonly ErrorDescriptorAny[],
  InputSchema extends StandardSchemaV1,
  OutputSchema extends StandardSchemaV1,
  ToolMetadata extends FunctionToolMetadata | undefined,
> = {
  /** Creates a tool with an explicit ID and metadata.
   * @param options - Tool identity and behavior metadata.
   * @returns Frozen tool descriptor.
   * @example fn.asTool({ id: "lookup", description: "Lookup", sideEffect: "read", approval: "never" });
   */
  <const ToolId extends string>(
    options: FunctionToolOptions<ToolId, Input, Output> & { readonly id: ToolId },
  ): FunctionToolView<ToolId, FunctionId, Input, Output, Errors, InputSchema, OutputSchema>;
  /** Creates a tool with a derived ID.
   * @param options - Tool behavior metadata.
   * @returns Frozen tool descriptor.
   * @example fn.asTool({ description: "Lookup", sideEffect: "read", approval: "never" });
   */
  (
    options: FunctionToolOptions<string, Input, Output>,
  ): FunctionToolView<
    `${FunctionId}.tool`,
    FunctionId,
    Input,
    Output,
    Errors,
    InputSchema,
    OutputSchema
  >;
} & ([ToolMetadata] extends [FunctionToolMetadata]
  ? {
      /** Uses metadata declared on the function.
       * @returns Frozen tool descriptor.
       * @example fn.asTool();
       */
      (): FunctionToolView<
        `${FunctionId}.tool`,
        FunctionId,
        Input,
        Output,
        Errors,
        InputSchema,
        OutputSchema
      >;
    }
  : {});
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-as-tool.types.ts#L35)

## `function-context.types.ts`

### ApplicationContextRegistry (type alias)

Application-owned additions to the handler context.

**Example**

```ts
type Registry = ApplicationContextRegistry;
```

**Signature**

```ts
type ApplicationContextRegistry = Relkit.ApplicationContextRegistry;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L68)

### AuthContext (interface)

Session lookup available to a handler.

**Example**

```ts
const session = await context.auth.getSession();
```

**Signature**

```ts
export interface AuthContext<Session = unknown> {
  /** Looks up the current session.
   * @returns The session or null when unauthenticated.
   * @example const session = await context.auth.getSession();
   */
  readonly getSession: () => Promise<Session | null>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L80)

### FunctionContext (type alias)

Handler context with declared resources and optional progress.

**Example**

```ts
const run = async (_input: unknown, context: FunctionContext) => context.time.now();
```

**Signature**

```ts
type FunctionContext<
  D extends FunctionDependencies = {},
  Publishes extends readonly KnownEventName[] = readonly [],
  Progress = never,
> = FunctionContextBase<D, Publishes> &
  ([Progress] extends [never]
    ? {}
    : { readonly progress: import("@relkit/invocation").ProgressEmitter<Progress> });
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L131)

### FunctionContextBase (interface)

Invocation context before optional progress is added.

**Example**

```ts
const env = context.env;
```

**Signature**

```ts
export interface FunctionContextBase<
  D extends FunctionDependencies = {},
  Publishes extends readonly KnownEventName[] = readonly [],
> {
  readonly invocation: InvocationMetadata;
  readonly signal: AbortSignal;
  readonly env: ResolvedApplicationEnv;
  readonly log: PublicLogger;
  readonly time: PublicClock;
  readonly trace: PublicTrace;
  readonly tasks: TaskClients<D["tasks"]>;
  readonly jobs: JobClients<D["jobs"]>;
  readonly events: EventClients<PublishedEventMap<Publishes>>;
  readonly buckets: BucketClients<D["buckets"]>;
  readonly cache: CacheClients<D["cache"]>;
  readonly agents: AgentClients<D["agents"]>;
  readonly database: RegisteredContext<"database", Readonly<Record<string, never>>>;
  readonly auth: RegisteredContext<"auth", AuthContext>;
  readonly constants: RegisteredContext<"constants", Readonly<Record<string, never>>>;
  readonly prompts: RegisteredContext<"prompts", Readonly<Record<string, never>>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L106)

### FunctionDependencies (interface)

Allowed resources a function may declare.

**Example**

```ts
const dependencies: FunctionDependencies = { buckets: { uploads } };
```

**Signature**

```ts
export interface FunctionDependencies {
  readonly tasks?: Readonly<Record<string, TaskRefAny>>;
  readonly jobs?: Readonly<Record<string, JobRefAny>>;
  readonly buckets?: Readonly<Record<string, BucketRefAny>>;
  readonly cache?: Readonly<Record<string, CacheRefAny>>;
  readonly agents?: Readonly<Record<string, AgentRefAny>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L21)

### FunctionDependencyOptions (type alias)

Rejects unsupported function dependency declarations.

**Example**

```ts
type Allowed = FunctionDependencyOptions<FunctionDependencies>;
```

**Signature**

```ts
type FunctionDependencyOptions<D extends FunctionDependencies> = "functions" extends keyof D
  ? never
  : D;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L91)

### InvocationMetadata (type alias)

Trace and identity metadata for one invocation.

**Example**

```ts
const metadata: InvocationMetadata = context.invocation;
```

**Signature**

```ts
type InvocationMetadata = SharedInvocationMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L36)

### InvocationSource (type alias)

Source category of a function invocation.

**Example**

```ts
const source: InvocationSource = "tool";
```

**Signature**

```ts
type InvocationSource = SharedInvocationSource;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L32)

### KnownEventName (type alias)

Registered event names accepted by publishes.

**Example**

```ts
type EventName = KnownEventName;
```

**Signature**

```ts
type KnownEventName = Extract<keyof Relkit.EventRegistry, string>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L98)

### PublicClock (type alias)

Clock exposed to application handlers.

**Example**

```ts
const clock: PublicClock = context.time;
```

**Signature**

```ts
type PublicClock = SharedPublicClock;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L51)

### PublicLogger (type alias)

Logger exposed to application handlers.

**Example**

```ts
const logger: PublicLogger = context.log;
```

**Signature**

```ts
type PublicLogger = SharedPublicLogger;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L47)

### PublicTrace (type alias)

Trace controls exposed to handlers.

**Example**

```ts
const trace: PublicTrace = context.trace;
```

**Signature**

```ts
type PublicTrace = SharedPublicTrace;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L55)

### ResolvedApplicationEnv (type alias)

Application environment supplied to handlers.

**Example**

```ts
const env: ResolvedApplicationEnv = context.env;
```

**Signature**

```ts
type ResolvedApplicationEnv = keyof Relkit.ApplicationEnv extends never
  ? Readonly<Record<string, unknown>>
  : Readonly<Relkit.ApplicationEnv>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-context.types.ts#L40)

## `function-dependency-copy.ts`

### copyDependencies

Copies and validates function dependencies.

**Throws**

TypeError for unsupported or malformed references.

**Example**

```ts
copyDependencies({ buckets: { uploads } });
```

**Signature**

```ts
declare const copyDependencies: <D extends FunctionDependencies>(
  dependencies: D | undefined,
) => D | undefined;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-dependency-copy.ts#L60)

### copyDependenciesEffect

Validates and freezes a dependency map through Effect.

**Example**

```ts
Effect.runSync(copyDependenciesEffect({ buckets: { uploads } }));
```

**Signature**

```ts
declare const copyDependenciesEffect: <D extends FunctionDependencies>(
  dependencies: D | undefined,
) => Effect.Effect<D | undefined, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-dependency-copy.ts#L12)

### copyPublishes

Copies and validates published event IDs.

**Throws**

TypeError for duplicate or empty IDs.

**Example**

```ts
copyPublishes(["orders.created"]);
```

**Signature**

```ts
declare const copyPublishes: <Names extends readonly string[]>(
  publishes: Names | undefined,
) => Names | undefined;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-dependency-copy.ts#L101)

### copyPublishesEffect

Validates a published event list through Effect.

**Example**

```ts
Effect.runSync(copyPublishesEffect(["orders.created"]));
```

**Signature**

```ts
declare const copyPublishesEffect: <Names extends readonly string[]>(
  publishes: Names | undefined,
) => Effect.Effect<Names | undefined, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-dependency-copy.ts#L71)

## `function-descriptor-factory.ts`

### FunctionDescriptorFactoryOptions

**Signature**

```ts
declare const FunctionDescriptorFactoryOptions: FunctionDescriptorFactoryOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-factory.ts#L18)

### createFunctionDescriptor

Creates a frozen function descriptor for an authoring package.

**Throws**

TypeError for malformed schemas, hooks, limits, or dependencies.

**Example**

```ts
createFunctionDescriptor(options);
```

**Signature**

```ts
declare const createFunctionDescriptor: (options: FunctionDescriptorFactoryOptions) => unknown;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-factory.ts#L78)

### createFunctionDescriptorEffect

Creates a function descriptor through Effect.

**Example**

```ts
Effect.runSync(createFunctionDescriptorEffect(options));
```

**Signature**

```ts
declare const createFunctionDescriptorEffect: (
  options: FunctionDescriptorFactoryOptions,
) => Effect.Effect<unknown, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-factory.ts#L25)

## `function-descriptor-factory.types.ts`

### FunctionDescriptorFactoryOptions (interface)

Inputs for a function descriptor shared by authoring packages.

**Example**

```ts
createFunctionDescriptor({ id: "orders.get", input, output, invocationMode: "callable", handler });
```

**Signature**

```ts
export interface FunctionDescriptorFactoryOptions extends DescriptorMetadata {
  readonly id: string;
  readonly input: StandardSchemaV1;
  readonly output: StandardSchemaV1;
  readonly progress?: StandardSchemaV1;
  readonly invocationMode: "callable" | "event-only";
  readonly handler: (...args: any[]) => unknown;
  readonly errors?: readonly ErrorDescriptorAny[];
  readonly dependencies?: FunctionDependencies;
  readonly publishes?: readonly string[];
  readonly timeoutMs?: number;
  readonly concurrency?: number;
  readonly tool?: FunctionToolMetadata;
  readonly onBefore?: (...args: any[]) => unknown;
  readonly onAfter?: (...args: any[]) => unknown;
  readonly descriptorFields?: Readonly<Record<string, unknown>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-factory.types.ts#L10)

## `function-descriptor-methods.ts`

### addCallableMethods

Installs compatibility methods while the descriptor creation Effect owns mutation.

**Example**

```ts
addCallableMethods(descriptor, metadata);
```

**Signature**

```ts
declare const addCallableMethods: (
  descriptor: Record<string, any>,
  tool: FunctionToolMetadata | undefined,
) => void;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-methods.ts#L128)

### asGraphNodeEffect

Derives a graph node view through Effect.

**Example**

```ts
Effect.runSync(asGraphNodeEffect(fn, fn));
```

**Signature**

```ts
declare const asGraphNodeEffect: (
  receiver: unknown,
  descriptor: FunctionRefAny,
  options?: { readonly id?: string } | undefined,
) => Effect.Effect<
  FunctionGraphNodeDescriptor<
    string,
    string,
    unknown,
    unknown,
    ReadonlyArray<ErrorDescriptorAny>,
    StandardSchemaV1<unknown, unknown>,
    StandardSchemaV1<unknown, unknown>,
    FunctionDependencies
  >,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-methods.ts#L106)

### asToolEffect

Derives a tool view through Effect.

**Example**

```ts
Effect.runSync(asToolEffect(fn, fn, fn.tool));
```

**Signature**

```ts
declare const asToolEffect: (
  receiver: unknown,
  descriptor: FunctionRefAny & { readonly id: string },
  tool: FunctionToolMetadata | undefined,
  options?: FunctionToolOptions<string, unknown, unknown> | undefined,
) => Effect.Effect<FunctionToolDescriptor<string, FunctionRefAny>, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-methods.ts#L66)

### invokeDescriptorEffect

Invokes a callable descriptor through the Effect dispatcher.

**Example**

```ts
Effect.runPromise(invokeDescriptorEffect(fn, fn, { id: "one" }));
```

**Signature**

```ts
declare const invokeDescriptorEffect: (
  receiver: unknown,
  descriptor: FunctionRefAny,
  input: unknown,
) => Effect.Effect<unknown, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor-methods.ts#L37)

## `function-descriptor.types.ts`

### DefineFunctionOptions (interface)

Schemas, handler, and metadata used to define a function.

**Example**

```ts
const options: DefineFunctionOptions<"orders.get", typeof input, typeof output> = {
  input,
  output,
  handler,
};
```

**Signature**

```ts
export interface DefineFunctionOptions<
  Id extends string,
  InputSchema extends StandardSchemaV1,
  OutputSchema extends StandardSchemaV1,
  Dependencies extends FunctionDependencies = {},
  Errors extends readonly ErrorDescriptorAny[] = readonly [],
  Publishes extends readonly KnownEventName[] = readonly [],
  ProgressSchema extends StandardSchemaV1 | undefined = undefined,
> extends DescriptorMetadata {
  readonly id?: Id;
  readonly input: InputSchema;
  readonly output: OutputSchema;
  readonly errors?: Errors;
  readonly dependencies?: Dependencies;
  readonly publishes?: Publishes;
  readonly progress?: ProgressSchema;
  readonly timeoutMs?: number;
  readonly concurrency?: number;
  readonly tool?: FunctionToolMetadata;
  readonly onBefore?: FunctionLifecycleHook<
    InferOutput<InputSchema>,
    Dependencies,
    Publishes,
    ProgressSchema
  >;
  readonly onAfter?: FunctionLifecycleHook<
    InferOutput<OutputSchema>,
    Dependencies,
    Publishes,
    ProgressSchema
  >;
  readonly handler: FunctionHandler<
    InferOutput<InputSchema>,
    InferOutput<OutputSchema>,
    Dependencies,
    Errors,
    Publishes,
    ProgressSchema
  >;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor.types.ts#L74)

### FunctionDescriptor (interface)

Frozen callable descriptor for a defined function.

**Example**

```ts
const descriptor: FunctionDescriptor<"orders.get", Input, Output, {}> = defineFunction(options);
```

**Signature**

```ts
export interface FunctionDescriptor<
  Id extends string,
  Input,
  Output,
  Dependencies extends FunctionDependencies,
  Errors extends readonly ErrorDescriptorAny[] = readonly ErrorDescriptorAny[],
  InputSchema extends StandardSchemaV1 = StandardSchemaV1,
  OutputSchema extends StandardSchemaV1 = StandardSchemaV1,
  ToolMetadata extends FunctionToolMetadata | undefined = undefined,
  Publishes extends readonly KnownEventName[] = readonly [],
  ProgressSchema extends StandardSchemaV1 | undefined = undefined,
>
  extends
    DescriptorBase<"function", Id>,
    FunctionRef<Id, Input, Output, Errors, InputSchema, OutputSchema> {
  readonly dependencies?: FunctionDependencyOptions<Dependencies>;
  readonly invocationMode: "callable";
  readonly publishes?: Publishes;
  readonly progress?: ProgressSchema;
  readonly timeoutMs?: number;
  readonly concurrency?: number;
  readonly tool?: ToolMetadata;
  readonly onBefore?: FunctionLifecycleHook<Input, Dependencies, Publishes, ProgressSchema>;
  readonly onAfter?: FunctionLifecycleHook<Output, Dependencies, Publishes, ProgressSchema>;
  readonly handler: FunctionHandler<Input, Output, Dependencies, Errors, Publishes, ProgressSchema>;
  /** Invokes this function through the common runtime.
   * @param input - Value accepted by the input schema.
   * @returns Validated output, rejecting with an invocation error on failure.
   * @example await descriptor.invoke({ id: "one" });
   */
  readonly invoke: (input: InferInput<InputSchema>) => Promise<Output>;
  /** Creates a tool view when the output is not a stream.
   * @param options - Optional tool metadata overriding the declared metadata.
   * @returns A tool descriptor derived from this function.
   * @example descriptor.asTool({ description: "Lookup", sideEffect: "read", approval: "never" });
   */
  readonly asTool: OutputSchema extends StreamOutputSchema
    ? never
    : FunctionAsTool<Id, Input, Output, Errors, InputSchema, OutputSchema, ToolMetadata>;
  /** Creates a graph node view when the output is not a stream.
   * @param options - Optional graph node identity.
   * @returns A graph node descriptor derived from this function.
   * @example descriptor.asGraphNode({ id: "lookup" });
   */
  readonly asGraphNode: OutputSchema extends StreamOutputSchema
    ? never
    : FunctionAsGraphNode<Id, Input, Output, Errors, InputSchema, OutputSchema, Dependencies>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor.types.ts#L22)

### FunctionHandler (type alias)

Handler contract for a declared function.

**Example**

```ts
const handler: FunctionHandler<Input, Output, {}> = async (input) => input;
```

**Signature**

```ts
type FunctionHandler<
  Input,
  Output,
  Dependencies extends FunctionDependencies,
  Errors extends readonly ErrorDescriptorAny[] = readonly ErrorDescriptorAny[],
  Publishes extends readonly KnownEventName[] = readonly [],
  ProgressSchema extends StandardSchemaV1 | undefined = undefined,
> = (
  input: Input,
  context: FunctionContext<Dependencies, Publishes, ProgressValue<ProgressSchema>>,
) => MaybePromise<FunctionHandlerResult<Output, Errors>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor.types.ts#L121)

### FunctionLifecycleHook

**Signature**

```ts
declare const FunctionLifecycleHook: FunctionLifecycleHook<
  Value,
  Dependencies,
  Publishes,
  ProgressSchema
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-descriptor.types.ts#L17)

## `function-graph-node.ts`

### FunctionAsGraphNode

**Signature**

```ts
declare const FunctionAsGraphNode: FunctionAsGraphNode<
  FunctionId,
  Input,
  Output,
  Errors,
  InputSchema,
  OutputSchema,
  Dependencies
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L30)

### FunctionGraphNodeDescriptor

**Signature**

```ts
declare const FunctionGraphNodeDescriptor: FunctionGraphNodeDescriptor<
  Id,
  FunctionId,
  Input,
  Output,
  Errors,
  InputSchema,
  OutputSchema,
  Dependencies
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L31)

### FunctionGraphNodeOptions

**Signature**

```ts
declare const FunctionGraphNodeOptions: FunctionGraphNodeOptions<Id>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L32)

### RELKIT_FUNCTION_GRAPH_NODE

Marker identifying a frozen function graph node.

**Example**

```ts
if (node[RELKIT_FUNCTION_GRAPH_NODE]) console.log(node.id);
```

**Signature**

```ts
declare const RELKIT_FUNCTION_GRAPH_NODE: unique symbol;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L38)

### createFunctionGraphNode

Creates a frozen graph node view of a function.

**Throws**

TypeError for invalid options or a non-callable function.

**Example**

```ts
createFunctionGraphNode(fn, fn, { id: "lookup" });
```

**Signature**

```ts
declare const createFunctionGraphNode: (
  receiver: unknown,
  fallback: FunctionRefAny,
  options?: FunctionGraphNodeOptions,
) => FunctionGraphNodeDescriptor;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L130)

### createFunctionGraphNodeEffect

Creates a graph node view in the Effect error channel.

**Example**

```ts
Effect.runSync(createFunctionGraphNodeEffect(fn, fn));
```

**Signature**

```ts
declare const createFunctionGraphNodeEffect: (
  receiver: unknown,
  fallback: FunctionRefAny,
  options?: FunctionGraphNodeOptions<string> | undefined,
) => Effect.Effect<
  FunctionGraphNodeDescriptor<
    string,
    string,
    unknown,
    unknown,
    ReadonlyArray<ErrorDescriptorAny>,
    StandardSchemaV1<unknown, unknown>,
    StandardSchemaV1<unknown, unknown>,
    FunctionDependencies
  >,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L69)

### invokeFunctionGraphNodeEffect

Invokes the function retained by a graph node through Effect.

**Example**

```ts
Effect.runPromise(invokeFunctionGraphNodeEffect(fn, { orderId: "one" }));
```

**Signature**

```ts
declare const invokeFunctionGraphNodeEffect: (
  target: FunctionRefAny,
  input: unknown,
) => Effect.Effect<unknown, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L46)

### isFunctionGraphNode

Recognizes a function graph node.

**Example**

```ts
if (isFunctionGraphNode(value)) console.log(value.id);
```

**Signature**

```ts
declare const isFunctionGraphNode: (value: unknown) => value is FunctionGraphNodeDescriptor;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L163)

### isFunctionGraphNodeEffect

Checks the shape of a graph node through Effect.

**Example**

```ts
Effect.runSync(isFunctionGraphNodeEffect(value));
```

**Signature**

```ts
declare const isFunctionGraphNodeEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.ts#L143)

## `function-graph-node.types.ts`

### FunctionAsGraphNode (type alias)

Overloads for creating a graph view with a derived or explicit ID.

**Example**

```ts
const node = fn.asGraphNode({ id: "lookup" });
```

**Signature**

```ts
type FunctionAsGraphNode<
  FunctionId extends string,
  Input,
  Output,
  Errors extends readonly ErrorDescriptorAny[],
  InputSchema extends StandardSchemaV1,
  OutputSchema extends StandardSchemaV1,
  Dependencies extends FunctionDependencies,
> = {
  /** Creates a graph view with an explicit node ID.
   * @param options - Required stable node ID.
   * @returns Frozen graph node descriptor.
   * @example fn.asGraphNode({ id: "lookup" });
   */
  <const NodeId extends string>(
    options: FunctionGraphNodeOptions<NodeId> & { readonly id: NodeId },
  ): FunctionGraphNodeDescriptor<
    NodeId,
    FunctionId,
    Input,
    Output,
    Errors,
    InputSchema,
    OutputSchema,
    Dependencies
  >;
  /** Creates a graph view using the function ID.
   * @returns Frozen graph node descriptor.
   * @example fn.asGraphNode();
   */
  (): FunctionGraphNodeDescriptor<
    FunctionId,
    FunctionId,
    Input,
    Output,
    Errors,
    InputSchema,
    OutputSchema,
    Dependencies
  >;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.types.ts#L58)

### FunctionGraphNodeDescriptor (interface)

Frozen graph view of a callable function descriptor.

**Example**

```ts
const node: FunctionGraphNodeDescriptor = fn.asGraphNode();
```

**Signature**

```ts
export interface FunctionGraphNodeDescriptor<
  Id extends string = string,
  FunctionId extends string = string,
  Input = unknown,
  Output = unknown,
  Errors extends readonly ErrorDescriptorAny[] = readonly ErrorDescriptorAny[],
  InputSchema extends StandardSchemaV1 = StandardSchemaV1,
  OutputSchema extends StandardSchemaV1 = StandardSchemaV1,
  Dependencies extends FunctionDependencies = FunctionDependencies,
> extends DescriptorMetadata {
  readonly [RELKIT_FUNCTION_GRAPH_NODE]: true;
  readonly kind: "function-graph-node";
  readonly id: Id;
  readonly target: Ref<"function", FunctionId>;
  readonly input: InputSchema;
  readonly output: OutputSchema;
  readonly errors?: Errors;
  readonly dependencies?: Dependencies;
  /** Invokes the source function using services supplied when the Effect runs.
   * @param input - Value accepted by the source input schema.
   * @returns Validated output or a tagged dispatch failure.
   * @example yield* node.invokeEffect({ id: "one" });
   */
  readonly invokeEffect: (
    input: InferInput<InputSchema>,
  ) => Effect.Effect<Output, FunctionOperationError>;
  /** Invokes the source function through the common dispatcher.
   * @param input - Value accepted by the source input schema.
   * @returns Validated output or an invocation rejection.
   * @example await node.invoke({ id: "one" });
   */
  readonly invoke: (input: InferInput<InputSchema>) => Promise<Output>;
  readonly __input?: Input;
  readonly __output?: Output;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.types.ts#L19)

### FunctionGraphNodeOptions (interface)

Optional graph node identity override.

**Example**

```ts
const options: FunctionGraphNodeOptions = { id: "lookup" };
```

**Signature**

```ts
export interface FunctionGraphNodeOptions<Id extends string = string> {
  readonly id?: Id;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-graph-node.types.ts#L12)

## `function-input-error.ts`

Internal marker for an expected synchronous input failure.
It remains a TypeError for existing compatibility callers.

**Example**

```ts
throw new FunctionInputError("Invalid function input");
```

### FunctionInputError (class)

Internal marker for an expected synchronous input failure.
It remains a TypeError for existing compatibility callers.

**Example**

```ts
throw new FunctionInputError("Invalid function input");
```

**Signature**

```ts
declare class FunctionInputError {
  constructor(message: string);
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-input-error.ts#L5)

## `function-lifecycle.types.ts`

### FunctionLifecycleHook (type alias)

Hook called before or after a function invocation.

**Example**

```ts
const hook: FunctionLifecycleHook<Input, {}, []> = (value) => value;
```

**Signature**

```ts
type FunctionLifecycleHook<
  Value,
  Dependencies extends FunctionDependencies = {},
  Publishes extends readonly KnownEventName[] = readonly [],
  ProgressSchema extends StandardSchemaV1 | undefined = undefined,
> = (
  value: Value,
  context: FunctionContext<Dependencies, Publishes, ProgressValue<ProgressSchema>>,
) => MaybePromise<Value>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-lifecycle.types.ts#L19)

### ProgressValue (type alias)

Validated progress value inferred from an optional schema.

**Example**

```ts
type Progress = ProgressValue<typeof progressSchema>;
```

**Signature**

```ts
type ProgressValue<Schema extends StandardSchemaV1 | undefined> = Schema extends StandardSchemaV1
  ? InferOutput<Schema>
  : never;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-lifecycle.types.ts#L10)

## `function-observability.ts`

### FunctionOperation

**Signature**

```ts
declare const FunctionOperation: FunctionOperation;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L17)

### FunctionOperationError (class)

Tagged failure of a function authoring operation.

**Example**

```ts
const error = new FunctionOperationError({
  operation: "stream.create",
  cause: new TypeError("Invalid item"),
});
```

**Signature**

```ts
declare class FunctionOperationError
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L24)

### FunctionTelemetry (class)

Replaceable telemetry service for operation spans and metrics.

**Example**

```ts
Effect.provide(streamOfEffect(schema), FunctionTelemetryLive);
```

**Signature**

```ts
declare class FunctionTelemetry
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L32)

### FunctionTelemetryLive

Default telemetry layer for function operations.

**Example**

```ts
Effect.runSync(Effect.provide(Effect.void, FunctionTelemetryLive));
```

**Signature**

```ts
declare const FunctionTelemetryLive: Layer.Layer<FunctionTelemetry, never, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L46)

### FunctionTelemetryService

**Signature**

```ts
declare const FunctionTelemetryService: FunctionTelemetryService;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L18)

### functionAttempt

Evaluates a synchronous step within an already observed operation.

**Example**

```ts
yield * functionAttempt("error.define", () => validateInput(input));
```

**Signature**

```ts
declare const functionAttempt: <A>(
  operation: FunctionOperation,
  evaluate: () => A,
) => Effect.Effect<A, FunctionOperationError>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L149)

### functionTry

Maps an expected input error into the tagged channel and preserves defects.

**Example**

```ts
runFunctionSync(functionTry("stream.is-output", () => true));
```

**Signature**

```ts
declare const functionTry: <A>(
  operation: FunctionOperation,
  evaluate: () => A,
) => Effect.Effect<A, FunctionOperationError>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L136)

### observeFunction

Measures an operation using the provided telemetry service or the live observer.

**Example**

```ts
observeFunction("stream.is-output", Effect.succeed(true));
```

**Signature**

```ts
declare const observeFunction: <A, E, R>(
  operation: FunctionOperation,
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, E, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L54)

### runFunctionPromise

Executes an asynchronous compatibility adapter and restores its original error.

**Throws**

The original domain error or an unexpected defect.

**Example**

```ts
await runFunctionPromise(Effect.succeed(1));
```

**Signature**

```ts
declare const runFunctionPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L106)

### runFunctionSync

Executes a synchronous compatibility adapter and restores its original error.

**Throws**

The original validation error or an unexpected defect.

**Example**

```ts
runFunctionSync(Effect.succeed(1));
```

**Signature**

```ts
declare const runFunctionSync: <A, E>(effect: Effect.Effect<A, E>) => A;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.ts#L91)

## `function-observability.types.ts`

### FunctionOperation (type alias)

Fixed operation name used as a bounded telemetry label.

**Example**

```ts
const operation: FunctionOperation = "tool.invoke";
```

**Signature**

```ts
type FunctionOperation =
  | "error.define"
  | "error.create"
  | "error.is-descriptor"
  | "error.validate-http"
  | "error.assert-schema"
  | "error.is-record"
  | "function.define"
  | "function.invoke"
  | "function.invoke-target"
  | "function.as-tool"
  | "function.as-graph-node"
  | "function.create-descriptor"
  | "function.graph-node"
  | "function.graph-node-invoke"
  | "function.is-graph-node"
  | "function.fail"
  | "function.copy-dependencies"
  | "function.copy-publishes"
  | "function.validate-limit"
  | "function.assert-hook"
  | "function.assert-schema"
  | "function.target-for-receiver"
  | "stream.create"
  | "stream.validate"
  | "stream.is-output"
  | "tool.create"
  | "tool.copy-metadata"
  | "tool.invoke"
  | "tool.invoker-create"
  | "tool.is-target"
  | "tool.is-error-descriptor"
  | "tool.is-record"
  | "tool.has-own"
  | "tool.validate-side-effect"
  | "tool.validate-approval"
  | "tool.required-text"
  | "tool.positive-integer"
  | "tool.copy-hooks";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.types.ts#L6)

### FunctionTelemetryService (interface)

Substitutable observer for function authoring operations.

**Example**

```ts
const observer: FunctionTelemetryService = { observe: (_operation, effect) => effect };
```

**Signature**

```ts
export interface FunctionTelemetryService {
  /** Measures one operation while preserving the original Effect channels.
   * @param operation - Fixed operation name.
   * @param effect - Work to measure.
   * @returns Effect with the same success, error, and requirement channels.
   * @example observer.observe("tool.invoke", Effect.succeed(1));
   */
  readonly observe: <A, E, R>(
    operation: FunctionOperation,
    effect: Effect.Effect<A, E, R>,
  ) => Effect.Effect<A, E, R>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-observability.types.ts#L49)

## `function-ref.types.ts`

### AgentRef (interface)

Input and output schemas for an agent reference.

**Example**

```ts
const ref: AgentRef = agent;
```

**Signature**

```ts
export interface AgentRef<
  Id extends string = string,
  InputSchema extends StandardSchemaV1 = StandardSchemaV1,
  OutputSchema extends StandardSchemaV1 = StandardSchemaV1,
> extends DescriptorRef<"agent", Id> {
  readonly input: InputSchema;
  readonly output: OutputSchema;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L62)

### AgentRefAny (type alias)

Broad agent reference for heterogeneous collections.

**Example**

```ts
const ref: AgentRefAny = agent;
```

**Signature**

```ts
type AgentRefAny = AgentRef;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L90)

### BucketRef (type alias)

Stable reference to a bucket.

**Example**

```ts
const ref: BucketRef = bucket;
```

**Signature**

```ts
type BucketRef<Id extends string = string> = DescriptorRef<"bucket", Id>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L45)

### BucketRefAny (type alias)

Broad bucket reference for heterogeneous collections.

**Example**

```ts
const ref: BucketRefAny = bucket;
```

**Signature**

```ts
type BucketRefAny = BucketRef;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L82)

### CacheRef (interface)

Key and value schemas for a cache reference.

**Example**

```ts
const ref: CacheRef = cache;
```

**Signature**

```ts
export interface CacheRef<
  Id extends string = string,
  KeySchema extends StandardSchemaV1 = StandardSchemaV1,
  ValueSchema extends StandardSchemaV1 = StandardSchemaV1,
> extends DescriptorRef<"cache", Id> {
  readonly key: KeySchema;
  readonly value: ValueSchema;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L50)

### CacheRefAny (type alias)

Broad cache reference for heterogeneous collections.

**Example**

```ts
const ref: CacheRefAny = cache;
```

**Signature**

```ts
type CacheRefAny = CacheRef;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L86)

### DescriptorRef (interface)

Stable reference carried by a descriptor.

**Example**

```ts
const ref: DescriptorRef<"function"> = { ref: { kind: "function", id: "orders.get" } };
```

**Signature**

```ts
export interface DescriptorRef<Kind extends DescriptorKind, Id extends string = string> {
  readonly ref: Ref<Kind, Id>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L8)

### EventRef (interface)

Schema and version view of a declared event.

**Example**

```ts
const ref: EventRef = event;
```

**Signature**

```ts
export interface EventRef<
  Id extends string = string,
  InputSchema extends StandardSchemaV1 = StandardSchemaV1,
> extends DescriptorRef<"event", Id> {
  readonly version: number;
  readonly input: InputSchema;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L34)

### EventRefAny (type alias)

Broad event reference for heterogeneous collections.

**Example**

```ts
const ref: EventRefAny = event;
```

**Signature**

```ts
type EventRefAny = EventRef;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L78)

### FunctionRef (interface)

Schema and identity view of a callable function.

**Example**

```ts
const ref: FunctionRef = descriptor;
```

**Signature**

```ts
export interface FunctionRef<
  Id extends string = string,
  Input = unknown,
  Output = unknown,
  Errors extends readonly ErrorDescriptorAny[] = readonly ErrorDescriptorAny[],
  InputSchema extends StandardSchemaV1 = StandardSchemaV1,
  OutputSchema extends StandardSchemaV1 = StandardSchemaV1,
> extends DescriptorRef<"function", Id> {
  readonly invocationMode?: "callable";
  readonly input: InputSchema;
  readonly output: OutputSchema;
  readonly errors?: Errors;
  readonly __input?: Input;
  readonly __output?: Output;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L15)

### FunctionRefAny (type alias)

Broad function reference for heterogeneous collections.

**Example**

```ts
const ref: FunctionRefAny = descriptor;
```

**Signature**

```ts
type FunctionRefAny = FunctionRef;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-ref.types.ts#L74)

## `function-tool-approval.ts`

### resolveFunctionToolApprovalEffect

Resolves approval within the owning invocation's span and resource scope.

**Example**

```ts
yield * resolveFunctionToolApprovalEffect(request, { approval: () => true });
```

**Signature**

```ts
declare const resolveFunctionToolApprovalEffect: (
  approval: FunctionToolApprovalRequest,
  options: FunctionToolInvokeOptions,
) => Effect.Effect<
  undefined,
  | FunctionOperationError
  | FunctionToolCancelledFailure
  | FunctionToolApprovalRequiredFailure
  | FunctionToolApprovalDeniedFailure,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-approval.ts#L20)

## `function-tool-errors.ts`

### FunctionToolApprovalDeniedError (class)

Compatibility error when a resolver denies execution.

**Example**

```ts
throw new FunctionToolApprovalDeniedError(request);
```

**Signature**

```ts
declare class FunctionToolApprovalDeniedError { constructor(readonly approval: FunctionToolApprovalRequest) }
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L45)

### code (property)

**Signature**

```ts
readonly code: "RELKIT_APPROVAL_DENIED"
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L46)

### FunctionToolApprovalRequiredError (class)

Compatibility error when approval is required but unavailable.

**Example**

```ts
throw new FunctionToolApprovalRequiredError(request);
```

**Signature**

```ts
declare class FunctionToolApprovalRequiredError { constructor(readonly approval: FunctionToolApprovalRequest) }
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L33)

### code (property)

**Signature**

```ts
readonly code: "RELKIT_APPROVAL_REQUIRED"
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L34)

### FunctionToolArgumentValidationError (class)

Compatibility error for malformed tool arguments.

**Example**

```ts
throw new FunctionToolArgumentValidationError([{ message: "Missing id" }]);
```

**Signature**

```ts
declare class FunctionToolArgumentValidationError {
  constructor(issues: readonly StandardIssue[]);
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L7)

### code (property)

**Signature**

```ts
readonly code: "RELKIT_TOOL_ARGUMENT_VALIDATION"
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L8)

### issues (property)

**Signature**

```ts
readonly issues: ReadonlyArray<StandardIssue>
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L9)

### FunctionToolOperationCancelledError (class)

Compatibility cancellation error for a tool operation.

**Example**

```ts
throw new FunctionToolOperationCancelledError();
```

**Signature**

```ts
declare class FunctionToolOperationCancelledError {
  constructor();
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L21)

### code (property)

**Signature**

```ts
readonly code: "ABORT_ERR"
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-errors.ts#L22)

## `function-tool-failures.ts`

### FunctionToolApprovalDeniedFailure (class)

Tagged Effect failure when approval is denied.

**Example**

```ts
Effect.catchTag(
  invokeFunctionToolEffect(target, metadata, input),
  "FunctionToolApprovalDeniedFailure",
  () => Effect.void,
);
```

**Signature**

```ts
declare class FunctionToolApprovalDeniedFailure
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-failures.ts#L40)

### FunctionToolApprovalRequiredFailure (class)

Tagged Effect failure when a tool needs an approval resolver.

**Example**

```ts
Effect.catchTag(
  invokeFunctionToolEffect(target, metadata, input),
  "FunctionToolApprovalRequiredFailure",
  () => Effect.void,
);
```

**Signature**

```ts
declare class FunctionToolApprovalRequiredFailure
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-failures.ts#L25)

### FunctionToolArgumentFailure (class)

Tagged Effect failure for malformed tool arguments.

**Example**

```ts
Effect.catchTag(
  invokeFunctionToolEffect(target, metadata, input),
  "FunctionToolArgumentFailure",
  () => Effect.void,
);
```

**Signature**

```ts
declare class FunctionToolArgumentFailure
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-failures.ts#L6)

### FunctionToolCancelledFailure (class)

Tagged Effect failure when tool execution is cancelled.

**Example**

```ts
Effect.catchTag(
  invokeFunctionToolEffect(target, metadata, input),
  "FunctionToolCancelledFailure",
  () => Effect.void,
);
```

**Signature**

```ts
declare class FunctionToolCancelledFailure
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-failures.ts#L17)

## `function-tool-runtime.ts`

### FunctionToolApprovalDeniedError

**Signature**

```ts
declare const FunctionToolApprovalDeniedError: typeof FunctionToolApprovalDeniedError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L38)

### FunctionToolApprovalDeniedFailure

**Signature**

```ts
declare const FunctionToolApprovalDeniedFailure: typeof FunctionToolApprovalDeniedFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L44)

### FunctionToolApprovalRequiredError

**Signature**

```ts
declare const FunctionToolApprovalRequiredError: typeof FunctionToolApprovalRequiredError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L39)

### FunctionToolApprovalRequiredFailure

**Signature**

```ts
declare const FunctionToolApprovalRequiredFailure: typeof FunctionToolApprovalRequiredFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L45)

### FunctionToolArgumentFailure

**Signature**

```ts
declare const FunctionToolArgumentFailure: typeof FunctionToolArgumentFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L46)

### FunctionToolArgumentValidationError

**Signature**

```ts
declare const FunctionToolArgumentValidationError: typeof FunctionToolArgumentValidationError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L40)

### FunctionToolCancelledFailure

**Signature**

```ts
declare const FunctionToolCancelledFailure: typeof FunctionToolCancelledFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L47)

### FunctionToolOperationCancelledError

**Signature**

```ts
declare const FunctionToolOperationCancelledError: typeof FunctionToolOperationCancelledError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L41)

### createFunctionToolInvoker

Creates a Promise compatibility invoker for a tool.

**Throws**

TypeError if construction metadata is invalid.

**Example**

```ts
const invoke = createFunctionToolInvoker(fn, metadata);
```

**Signature**

```ts
declare const createFunctionToolInvoker: <Target extends FunctionRefAny>(
  target: Target,
  metadata: FunctionToolRuntimeMetadata,
  identity?: object,
) => (
  input: InferInput<Target["input"]>,
  options?: FunctionToolInvokeOptions,
) => Promise<InferOutput<Target["output"]>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L151)

### createFunctionToolInvokerEffect

Creates an Effect invoker that resolves services when each call runs.

**Example**

```ts
Effect.runSync(createFunctionToolInvokerEffect(fn, metadata));
```

**Signature**

```ts
declare const createFunctionToolInvokerEffect: <Target extends FunctionRefAny>(
  target: Target,
  metadata: FunctionToolRuntimeMetadata,
  identity?: object | undefined,
) => Effect.Effect<
  (
    input: InferInput<Target["input"]>,
    options?: FunctionToolInvokeOptions,
  ) => Effect.Effect<
    InferOutput<Target["output"]>,
    | FunctionOperationError
    | FunctionToolArgumentFailure
    | FunctionToolCancelledFailure
    | FunctionToolApprovalRequiredFailure
    | FunctionToolApprovalDeniedFailure,
    SchemaValidator
  >,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L129)

### invokeFunctionToolEffect

Invokes a tool through schema validation, approval, and the Effect dispatcher.

**Example**

```ts
Effect.runPromise(
  Effect.provide(invokeFunctionToolEffect(fn, metadata, input), SchemaValidatorLive),
);
```

**Signature**

```ts
declare const invokeFunctionToolEffect: <Target extends FunctionRefAny>(
  target: Target,
  metadata: FunctionToolRuntimeMetadata,
  input: InferInput<Target["input"]>,
  options?: FunctionToolInvokeOptions | undefined,
  identity?: object | undefined,
) => Effect.Effect<
  InferOutput<Target["output"]>,
  | FunctionOperationError
  | FunctionToolArgumentFailure
  | FunctionToolCancelledFailure
  | FunctionToolApprovalRequiredFailure
  | FunctionToolApprovalDeniedFailure,
  SchemaValidator
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.ts#L59)

## `function-tool-runtime.types.ts`

### FunctionToolRuntimeMetadata (type alias)

Runtime policy and hooks attached to a tool invoker.

**Example**

```ts
const metadata: FunctionToolRuntimeMetadata = {
  id: "lookup",
  sideEffect: "read",
  approval: "never",
};
```

**Signature**

```ts
type FunctionToolRuntimeMetadata = Pick<
  FunctionToolMetadata,
  "sideEffect" | "approval" | "timeoutMs"
> & {
  readonly id: string;
  readonly onBefore?: FunctionToolHook;
  readonly onAfter?: FunctionToolHook;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.types.ts#L7)

### TargetSchema (type alias)

Input schema accepted by a callable function target.

**Example**

```ts
const schema: TargetSchema = target.input;
```

**Signature**

```ts
type TargetSchema = FunctionRefAny["input"];
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-runtime.types.ts#L19)

## `function-tool-shape.ts`

### hasOwn

Checks whether an object owns a property.

**Example**

```ts
hasOwn({ id: "one" }, "id");
```

**Signature**

```ts
declare const hasOwn: (value: object, key: PropertyKey) => boolean;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L110)

### hasOwnEffect

Checks an own property through Effect.

**Example**

```ts
Effect.runSync(hasOwnEffect({}, "id"));
```

**Signature**

```ts
declare const hasOwnEffect: (
  value: object,
  key: PropertyKey,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L100)

### isErrorDescriptor

Recognizes an error descriptor accepted by tool metadata.

**Example**

```ts
isErrorDescriptor(value);
```

**Signature**

```ts
declare const isErrorDescriptor: (value: unknown) => value is ErrorDescriptorAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L61)

### isErrorDescriptorEffect

Checks a declared error shape through Effect.

**Example**

```ts
Effect.runSync(isErrorDescriptorEffect(value));
```

**Signature**

```ts
declare const isErrorDescriptorEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L42)

### isFunctionTarget

Recognizes a function usable as a tool target.

**Example**

```ts
if (isFunctionTarget(value)) console.log(value.ref.id);
```

**Signature**

```ts
declare const isFunctionTarget: (value: unknown) => value is FunctionRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L33)

### isFunctionTargetEffect

Checks a callable function target through Effect.

**Example**

```ts
Effect.runSync(isFunctionTargetEffect(fn));
```

**Signature**

```ts
declare const isFunctionTargetEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L12)

### isRecord

Recognizes a record-like tool value.

**Example**

```ts
isRecord({ id: "one" });
```

**Signature**

```ts
declare const isRecord: (value: unknown) => value is Record<PropertyKey, any>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L90)

### isRecordEffect

Checks a record-like value through Effect.

**Example**

```ts
Effect.runSync(isRecordEffect({}));
```

**Signature**

```ts
declare const isRecordEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-shape.ts#L75)

## `function-tool-validation.ts`

### copyFunctionToolHooks

Copies optional tool hooks.

**Throws**

TypeError for malformed hooks.

**Example**

```ts
copyFunctionToolHooks({ onBefore: (x) => x });
```

**Signature**

```ts
declare const copyFunctionToolHooks: (
  value: unknown,
) => Pick<FunctionToolOptions, "onBefore" | "onAfter">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L148)

### copyFunctionToolHooksEffect

Copies validated tool hooks through Effect.

**Example**

```ts
Effect.runSync(copyFunctionToolHooksEffect({ onBefore: (x) => x }));
```

**Signature**

```ts
declare const copyFunctionToolHooksEffect: (
  value: unknown,
) => Effect.Effect<
  Pick<FunctionToolOptions<string, unknown, unknown>, "onBefore" | "onAfter">,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L120)

### hasOwn

**Signature**

```ts
declare const hasOwn: (value: object, key: PropertyKey) => boolean;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L10)

### isErrorDescriptor

**Signature**

```ts
declare const isErrorDescriptor: (value: unknown) => value is ErrorDescriptorAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L10)

### isFunctionTarget

**Signature**

```ts
declare const isFunctionTarget: (value: unknown) => value is FunctionRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L10)

### isRecord

**Signature**

```ts
declare const isRecord: (value: unknown) => value is Record<PropertyKey, any>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L10)

### positiveInteger

Asserts a positive integer tool field.

**Throws**

TypeError for invalid input.

**Example**

```ts
positiveInteger(5, "timeoutMs");
```

**Signature**

```ts
declare const positiveInteger: (value: unknown, name: string) => asserts value is number;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L111)

### positiveIntegerEffect

Checks a positive integer through Effect.

**Example**

```ts
Effect.runSync(positiveIntegerEffect(5, "timeoutMs"));
```

**Signature**

```ts
declare const positiveIntegerEffect: (
  value: unknown,
  name: string,
) => Effect.Effect<number, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L94)

### requiredText

Requires nonempty tool text.

**Throws**

TypeError for an empty value.

**Example**

```ts
requiredText(" Read order ", "description");
```

**Signature**

```ts
declare const requiredText: (value: unknown, name: string) => string;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L84)

### requiredTextEffect

Requires nonempty text through Effect.

**Example**

```ts
Effect.runSync(requiredTextEffect(" Hello ", "name"));
```

**Signature**

```ts
declare const requiredTextEffect: (
  value: unknown,
  name: string,
) => Effect.Effect<string, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L68)

### validateApproval

Validates a tool approval policy.

**Throws**

TypeError for unknown values.

**Example**

```ts
validateApproval("always");
```

**Signature**

```ts
declare const validateApproval: (value: unknown) => FunctionToolApproval;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L58)

### validateApprovalEffect

Validates an approval policy through Effect.

**Example**

```ts
Effect.runSync(validateApprovalEffect("always"));
```

**Signature**

```ts
declare const validateApprovalEffect: (
  value: unknown,
) => Effect.Effect<"never" | "on-write" | "always", FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L42)

### validateSideEffect

Validates a tool side effect policy.

**Throws**

TypeError for unknown values.

**Example**

```ts
validateSideEffect("read");
```

**Signature**

```ts
declare const validateSideEffect: (value: unknown) => FunctionToolSideEffect;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L33)

### validateSideEffectEffect

Validates a side effect policy through Effect.

**Example**

```ts
Effect.runSync(validateSideEffectEffect("read"));
```

**Signature**

```ts
declare const validateSideEffectEffect: (
  value: unknown,
) => Effect.Effect<"none" | "read" | "write" | "external", FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool-validation.ts#L17)

## `function-tool.ts`

### "./function-tool.types.js" (namespace export)

Re-exports all named exports from the "./function-tool.types.js" module.

**Signature**

```ts
export * from "./function-tool.types.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L20)

### copyFunctionToolHooks

**Signature**

```ts
declare const copyFunctionToolHooks: (
  value: unknown,
) => Pick<FunctionToolOptions, "onBefore" | "onAfter">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L32)

### copyFunctionToolHooksEffect

**Signature**

```ts
declare const copyFunctionToolHooksEffect: (
  value: unknown,
) => Effect.Effect<
  Pick<FunctionToolOptions<string, unknown, unknown>, "onBefore" | "onAfter">,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L32)

### copyFunctionToolMetadata

Copies and validates tool metadata.

**Throws**

TypeError for invalid fields.

**Example**

```ts
copyFunctionToolMetadata({ description: "Get order", sideEffect: "read", approval: "never" });
```

**Signature**

```ts
declare const copyFunctionToolMetadata: (value: unknown) => FunctionToolMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L161)

### copyFunctionToolMetadataEffect

Copies and validates tool metadata through Effect.

**Example**

```ts
Effect.runSync(copyFunctionToolMetadataEffect(raw));
```

**Signature**

```ts
declare const copyFunctionToolMetadataEffect: (
  value: unknown,
) => Effect.Effect<FunctionToolMetadata, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L121)

### createFunctionTool

Creates a frozen tool descriptor.

**Throws**

TypeError for malformed target or metadata.

**Example**

```ts
const tool = createFunctionTool({
  target: fn,
  description: "Get order",
  sideEffect: "read",
  approval: "never",
});
```

**Signature**

```ts
declare const createFunctionTool: <const Id extends string, const Target extends FunctionRefAny>(
  options: FunctionToolCreateOptions<Id, Target>,
) => FunctionToolDescriptor<Id, Target>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L110)

### createFunctionToolEffect

Creates a tool descriptor through Effect.

**Example**

```ts
Effect.runSync(
  createFunctionToolEffect({
    target: fn,
    description: "Get order",
    sideEffect: "read",
    approval: "never",
  }),
);
```

**Signature**

```ts
declare const createFunctionToolEffect: <
  const Id extends string,
  const Target extends FunctionRefAny,
>(
  options: FunctionToolCreateOptions<Id, Target>,
) => Effect.Effect<FunctionToolDescriptor<Id, Target>, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.ts#L38)

## `function-tool.types.ts`

### FunctionToolApproval (type alias)

Approval policy applied before tool dispatch.

**Example**

```ts
const policy: FunctionToolApproval = "on-write";
```

**Signature**

```ts
type FunctionToolApproval = "never" | "on-write" | "always";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L22)

### FunctionToolApprovalDecision (type alias)

Decision returned by an approval resolver.

**Example**

```ts
const decision: FunctionToolApprovalDecision = "approved";
```

**Signature**

```ts
type FunctionToolApprovalDecision = "approved" | "denied" | boolean;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L73)

### FunctionToolApprovalRequest (interface)

Request shown to an approval resolver.

**Example**

```ts
const request: FunctionToolApprovalRequest = {
  toolId: "orders.lookup",
  sideEffect: "read",
  policy: "always",
};
```

**Signature**

```ts
export interface FunctionToolApprovalRequest {
  readonly toolId: string;
  readonly sideEffect: FunctionToolSideEffect;
  readonly policy: FunctionToolApproval;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L65)

### FunctionToolApprovalResolver (type alias)

Callback that decides whether a tool may execute.

**Example**

```ts
const approve: FunctionToolApprovalResolver = async () => "approved";
```

**Signature**

```ts
type FunctionToolApprovalResolver = (
  approval: FunctionToolApprovalRequest,
  signal?: AbortSignal,
) => MaybePromise<FunctionToolApprovalDecision>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L80)

### FunctionToolContext (type alias)

Restricted invocation context passed to tool hooks.

**Example**

```ts
const time = context.time;
```

**Signature**

```ts
type FunctionToolContext = Pick<FunctionContext, "invocation" | "signal" | "env" | "log" | "time">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L36)

### FunctionToolCreateOptions (type alias)

Target and metadata required to construct a tool.

**Example**

```ts
const options: FunctionToolCreateOptions<"lookup", typeof fn> = {
  id: "lookup",
  target: fn,
  description: "Lookup",
  sideEffect: "read",
  approval: "never",
};
```

**Signature**

```ts
type FunctionToolCreateOptions<
  Id extends string,
  Target extends FunctionRefAny,
> = FunctionToolOptions<Id, InferInput<Target["input"]>, InferOutput<Target["output"]>> & {
  readonly id?: Id;
  readonly target: Target;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L150)

### FunctionToolDescriptor (interface)

Frozen tool descriptor with a Promise invoke adapter.

**Example**

```ts
const tool: FunctionToolDescriptor<"lookup", typeof fn> = createFunctionTool(options);
```

**Signature**

```ts
export interface FunctionToolDescriptor<
  Id extends string,
  Target extends FunctionRefAny = FunctionRefAny,
> extends DescriptorBase<"tool", Id> {
  readonly ref: { readonly kind: "tool"; readonly id: Id };
  readonly target: FunctionToolTarget<Target>;
  readonly description: string;
  readonly sideEffect: FunctionToolSideEffect;
  readonly approval: FunctionToolApproval;
  readonly timeoutMs?: number;
  readonly mcp: boolean;
  readonly onBefore?: FunctionToolHook<InferInput<Target["input"]>>;
  readonly onAfter?: FunctionToolHook<InferOutput<Target["output"]>>;
  /** Invokes the target using services supplied when the Effect runs.
   * @param input - Tool argument value.
   * @param options - Optional cancellation and approval controls.
   * @returns Validated output or a tagged tool failure.
   * @example yield* tool.invokeEffect({ id: "one" });
   */
  readonly invokeEffect: (
    input: InferInput<Target["input"]>,
    options?: FunctionToolInvokeOptions,
  ) => Effect.Effect<
    InferOutput<Target["output"]>,
    | FunctionOperationError
    | FunctionToolArgumentFailure
    | FunctionToolCancelledFailure
    | FunctionToolApprovalRequiredFailure
    | FunctionToolApprovalDeniedFailure,
    SchemaValidator
  >;
  /** Invokes the target through the common tool and function runtime.
   * @param input - Tool argument value.
   * @param options - Optional cancellation and approval controls.
   * @returns Validated output, rejecting with a tool error on failure.
   * @example await tool.invoke({ id: "one" });
   */
  readonly invoke: (
    input: InferInput<Target["input"]>,
    options?: FunctionToolInvokeOptions,
  ) => Promise<InferOutput<Target["output"]>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L105)

### FunctionToolHook (type alias)

Optional input or output transform for a tool.

**Example**

```ts
const hook: FunctionToolHook<string> = (value) => value.trim();
```

**Signature**

```ts
type FunctionToolHook<Value = unknown> = (
  value: Value,
  context: FunctionToolContext,
) => MaybePromise<Value>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L46)

### FunctionToolInvokeOptions (interface)

Per-call signal and approval resolver.

**Example**

```ts
await tool.invoke(input, { signal: controller.signal });
```

**Signature**

```ts
export interface FunctionToolInvokeOptions {
  readonly signal?: AbortSignal;
  readonly approval?: FunctionToolApprovalResolver;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L87)

### FunctionToolMetadata (interface)

Display and policy metadata for a tool.

**Example**

```ts
const metadata: FunctionToolMetadata = {
  description: "Lookup",
  sideEffect: "read",
  approval: "never",
};
```

**Signature**

```ts
export interface FunctionToolMetadata extends DescriptorMetadata {
  readonly description: string;
  readonly sideEffect: FunctionToolSideEffect;
  readonly approval: FunctionToolApproval;
  readonly timeoutMs?: number;
  readonly mcp?: boolean;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L26)

### FunctionToolOptions (interface)

Options used when creating a tool view.

**Example**

```ts
const options: FunctionToolOptions = {
  description: "Lookup",
  sideEffect: "read",
  approval: "never",
};
```

**Signature**

```ts
export interface FunctionToolOptions<
  Id extends string = string,
  Input = unknown,
  Output = unknown,
> extends FunctionToolMetadata {
  readonly id?: Id;
  readonly onBefore?: FunctionToolHook<Input>;
  readonly onAfter?: FunctionToolHook<Output>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L53)

### FunctionToolSideEffect (type alias)

Bounded side effect category for a tool.

**Example**

```ts
const effect: FunctionToolSideEffect = "read";
```

**Signature**

```ts
type FunctionToolSideEffect = "none" | "read" | "write" | "external";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L18)

### FunctionToolTarget (type alias)

Function contract copied into a tool view.

**Example**

```ts
const target: FunctionToolTarget<typeof fn> = tool.target;
```

**Signature**

```ts
type FunctionToolTarget<Target extends FunctionRefAny> = FunctionRef<
  Target["ref"]["id"],
  Target extends { readonly __input?: infer Input } ? Input : unknown,
  Target extends { readonly __output?: infer Output } ? Output : unknown,
  TargetErrors<Target>,
  Target["input"],
  Target["output"]
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/function-tool.types.ts#L94)

## `handler-result.ts`

### "./handler-result.types.js" (namespace export)

Re-exports all named exports from the "./handler-result.types.js" module.

**Signature**

```ts
export * from "./handler-result.types.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.ts#L6)

### fail

Returns a typed application failure from a plain function handler.

**Throws**

The descriptor's validation error.

**Example**

```ts
return fail(NotFound, { id: "one" });
```

**Signature**

```ts
declare const fail: <const Descriptor extends ErrorDescriptorAny>(
  descriptor: Descriptor,
  data: Parameters<Descriptor["create"]>[0],
) => FunctionFailure<DeclaredErrorOf<Descriptor>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.ts#L35)

### failEffect

Creates a typed application failure in the Effect error channel.

**Example**

```ts
Effect.runSync(failEffect(NotFound, { id: "one" }));
```

**Signature**

```ts
declare const failEffect: <const Descriptor extends ErrorDescriptorAny>(
  descriptor: Descriptor,
  data: Parameters<Descriptor["create"]>[0],
) => Effect.Effect<
  FunctionFailure<ReturnType<Descriptor["create"]>>,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.ts#L14)

## `handler-result.types.ts`

### DeclaredErrorOf (type alias)

Instance type produced by one error descriptor.

**Example**

```ts
type NotFoundError = DeclaredErrorOf<typeof NotFound>;
```

**Signature**

```ts
type DeclaredErrorOf<Descriptor extends ErrorDescriptorAny> = ReturnType<Descriptor["create"]>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.types.ts#L27)

### DeclaredErrorsOf (type alias)

Union of instances from an error descriptor list.

**Example**

```ts
type Allowed = DeclaredErrorsOf<typeof errors>;
```

**Signature**

```ts
type DeclaredErrorsOf<Descriptors extends readonly ErrorDescriptorAny[]> =
  Descriptors[number] extends infer Descriptor
    ? Descriptor extends ErrorDescriptorAny
      ? DeclaredErrorOf<Descriptor>
      : never
    : never;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.types.ts#L34)

### FunctionEffectValue (interface)

Structural Effect type accepted from a handler.

**Example**

```ts
const result: FunctionEffectValue = Effect.succeed(output);
```

**Signature**

```ts
export interface FunctionEffectValue<Output = unknown, Error = unknown, Requirements = unknown> {
  readonly "~effect/Effect": {
    readonly _A: (_: never) => Output;
    readonly _E: (_: never) => Error;
    readonly _R: (_: never) => Requirements;
  };
  readonly pipe: (...args: never[]) => unknown;
  readonly [Symbol.iterator]: () => unknown;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.types.ts#L14)

### FunctionFailure (interface)

Tagged failure returned by a plain function handler.

**Example**

```ts
const failure: FunctionFailure = fail(NotFound, data);
```

**Signature**

```ts
export interface FunctionFailure<Error extends globalThis.Error = globalThis.Error> {
  readonly _tag: "FunctionFailure";
  readonly error: Error;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.types.ts#L6)

### FunctionHandlerResult (type alias)

Values and declared failures a handler may return.

**Example**

```ts
const result: FunctionHandlerResult<string> = "done";
```

**Signature**

```ts
type FunctionHandlerResult<
  Output,
  Errors extends readonly ErrorDescriptorAny[] = readonly ErrorDescriptorAny[],
> =
  | Output
  | DeclaredErrorsOf<Errors>
  | FunctionFailure<DeclaredErrorsOf<Errors>>
  | FunctionEffectValue<Output, DeclaredErrorsOf<Errors>, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.types.ts#L44)

### FunctionHandlerValidation (type alias)

Compile-time check of handler output and declared errors.

**Example**

```ts
type Valid = FunctionHandlerValidation<ReturnType<typeof handler>, Output, Errors>;
```

**Signature**

```ts
type FunctionHandlerValidation<Result, Output, Errors extends readonly ErrorDescriptorAny[]> = [
  InvalidHandlerResult<Awaited<Result>, Output, DeclaredErrorsOf<Errors>>,
] extends [never]
  ? [MissingDeclaredErrors<Result, Errors>] extends [never]
    ? {}
    : {
        readonly __relkit_handler_error__: "Return every error declared in the function's errors list";
      }
  : {
      readonly __relkit_handler_error__: "Return values and errors must match the function contract";
    };
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/handler-result.types.ts#L116)

## `index.ts`

### "./define-error.js" (namespace export)

Re-exports all named exports from the "./define-error.js" module.

**Signature**

```ts
export * from "./define-error.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L1)

### "./define-function.js" (namespace export)

Re-exports all named exports from the "./define-function.js" module.

**Signature**

```ts
export * from "./define-function.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L2)

### "./function-graph-node.js" (namespace export)

Re-exports all named exports from the "./function-graph-node.js" module.

**Signature**

```ts
export * from "./function-graph-node.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L4)

### "./function-observability.js" (namespace export)

Re-exports all named exports from the "./function-observability.js" module.

**Signature**

```ts
export * from "./function-observability.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L6)

### "./handler-result.js" (namespace export)

Re-exports all named exports from the "./handler-result.js" module.

**Signature**

```ts
export * from "./handler-result.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L3)

### "./stream.js" (namespace export)

Re-exports all named exports from the "./stream.js" module.

**Signature**

```ts
export * from "./stream.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L5)

### FunctionToolApproval

**Signature**

```ts
declare const FunctionToolApproval: FunctionToolApproval;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L8)

### FunctionToolApprovalDecision

**Signature**

```ts
declare const FunctionToolApprovalDecision: FunctionToolApprovalDecision;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L9)

### FunctionToolApprovalDeniedError

**Signature**

```ts
declare const FunctionToolApprovalDeniedError: typeof FunctionToolApprovalDeniedError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L26)

### FunctionToolApprovalDeniedFailure

**Signature**

```ts
declare const FunctionToolApprovalDeniedFailure: typeof FunctionToolApprovalDeniedFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L30)

### FunctionToolApprovalRequest

**Signature**

```ts
declare const FunctionToolApprovalRequest: FunctionToolApprovalRequest;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L10)

### FunctionToolApprovalRequiredError

**Signature**

```ts
declare const FunctionToolApprovalRequiredError: typeof FunctionToolApprovalRequiredError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L27)

### FunctionToolApprovalRequiredFailure

**Signature**

```ts
declare const FunctionToolApprovalRequiredFailure: typeof FunctionToolApprovalRequiredFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L31)

### FunctionToolApprovalResolver

**Signature**

```ts
declare const FunctionToolApprovalResolver: FunctionToolApprovalResolver;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L11)

### FunctionToolArgumentFailure

**Signature**

```ts
declare const FunctionToolArgumentFailure: typeof FunctionToolArgumentFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L32)

### FunctionToolArgumentValidationError

**Signature**

```ts
declare const FunctionToolArgumentValidationError: typeof FunctionToolArgumentValidationError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L28)

### FunctionToolCancelledFailure

**Signature**

```ts
declare const FunctionToolCancelledFailure: typeof FunctionToolCancelledFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L33)

### FunctionToolContext

**Signature**

```ts
declare const FunctionToolContext: FunctionToolContext;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L14)

### FunctionToolDescriptor

**Signature**

```ts
declare const FunctionToolDescriptor: FunctionToolDescriptor<Id, Target>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L12)

### FunctionToolHook

**Signature**

```ts
declare const FunctionToolHook: FunctionToolHook<Value>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L15)

### FunctionToolInvokeOptions

**Signature**

```ts
declare const FunctionToolInvokeOptions: FunctionToolInvokeOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L13)

### FunctionToolMetadata

**Signature**

```ts
declare const FunctionToolMetadata: FunctionToolMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L16)

### FunctionToolOperationCancelledError

**Signature**

```ts
declare const FunctionToolOperationCancelledError: typeof FunctionToolOperationCancelledError;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L29)

### FunctionToolOptions

**Signature**

```ts
declare const FunctionToolOptions: FunctionToolOptions<Id, Input, Output>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L17)

### FunctionToolSideEffect

**Signature**

```ts
declare const FunctionToolSideEffect: FunctionToolSideEffect;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L18)

### FunctionToolTarget

**Signature**

```ts
declare const FunctionToolTarget: FunctionToolTarget<Target>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L19)

### copyFunctionToolHooks

**Signature**

```ts
declare const copyFunctionToolHooks: (
  value: unknown,
) => Pick<FunctionToolOptions, "onBefore" | "onAfter">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L21)

### copyFunctionToolHooksEffect

**Signature**

```ts
declare const copyFunctionToolHooksEffect: (
  value: unknown,
) => Effect<
  Pick<FunctionToolOptions<string, unknown, unknown>, "onBefore" | "onAfter">,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L21)

### createFunctionToolInvoker

**Signature**

```ts
declare const createFunctionToolInvoker: <Target extends FunctionRefAny>(
  target: Target,
  metadata: FunctionToolRuntimeMetadata,
  identity?: object,
) => (
  input: InferInput<Target["input"]>,
  options?: FunctionToolInvokeOptions,
) => Promise<InferOutput<Target["output"]>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L23)

### createFunctionToolInvokerEffect

**Signature**

```ts
declare const createFunctionToolInvokerEffect: <Target extends FunctionRefAny>(
  target: Target,
  metadata: FunctionToolRuntimeMetadata,
  identity?: object | undefined,
) => Effect<
  (
    input: InferInput<Target["input"]>,
    options?: FunctionToolInvokeOptions,
  ) => Effect<
    InferOutput<Target["output"]>,
    | FunctionOperationError
    | FunctionToolArgumentFailure
    | FunctionToolCancelledFailure
    | FunctionToolApprovalRequiredFailure
    | FunctionToolApprovalDeniedFailure,
    SchemaValidator
  >,
  FunctionOperationError,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L24)

### invokeFunctionToolEffect

**Signature**

```ts
declare const invokeFunctionToolEffect: <Target extends FunctionRefAny>(
  target: Target,
  metadata: FunctionToolRuntimeMetadata,
  input: InferInput<Target["input"]>,
  options?: FunctionToolInvokeOptions | undefined,
  identity?: object | undefined,
) => Effect<
  InferOutput<Target["output"]>,
  | FunctionOperationError
  | FunctionToolArgumentFailure
  | FunctionToolCancelledFailure
  | FunctionToolApprovalRequiredFailure
  | FunctionToolApprovalDeniedFailure,
  SchemaValidator
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/index.ts#L25)

## `internal.ts`

### "./function-descriptor-factory.js" (namespace export)

Re-exports all named exports from the "./function-descriptor-factory.js" module.

**Signature**

```ts
export * from "./function-descriptor-factory.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/internal.ts#L1)

## `stream.ts`

### StreamOutputSchema

**Signature**

```ts
declare const StreamOutputSchema: StreamOutputSchema<ItemSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/stream.ts#L12)

### isStreamOutputSchema

Recognizes a stream output schema.

**Example**

```ts
if (isStreamOutputSchema(value)) console.log(value.item);
```

**Signature**

```ts
declare const isStreamOutputSchema: (value: unknown) => value is StreamOutputSchema;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/stream.ts#L91)

### isStreamOutputSchemaEffect

Checks whether a value is a stream output schema through Effect.

**Example**

```ts
Effect.runSync(isStreamOutputSchemaEffect(value));
```

**Signature**

```ts
declare const isStreamOutputSchemaEffect: (
  value: unknown,
) => Effect.Effect<boolean, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/stream.ts#L78)

### streamOf

Declares a validated asynchronous stream result.

**Throws**

TypeError when the item is not a Standard Schema validator.

**Example**

```ts
const output = streamOf(z.string());
```

**Signature**

```ts
declare const streamOf: <const ItemSchema extends StandardSchemaV1>(
  item: ItemSchema,
) => StreamOutputSchema<ItemSchema>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/stream.ts#L67)

#### Backend and frontend example

**Backend** — these maintained files define the operation used by the frontend below.

```ts title="examples/commerce/src/services/orders/functions/stream-order-report.function.ts"
/** Supplies the report route with ten validated stream items, stopping when its invocation signal aborts. */
import { defineFunction, streamOf } from "@relkit/app/functions";
import { z } from "@relkit/app/schema";

const streamOrderReport = defineFunction({
  input: z.object({ reportId: z.string().min(1) }),
  output: streamOf(z.object({ completed: z.number().int(), total: z.number().int() })),
  handler: async function* (_input, context) {
    for (let completed = 1; completed <= 10; completed += 1) {
      // if (completed > 1) {
      //   await Bun.sleep(1_000);
      // }
      if (context.signal.aborted) return;
      yield { completed, total: completed };
    }
  },
});

export default streamOrderReport;
```

```ts title="examples/commerce/src/routes/reports/[reportId]/route.ts"
/** Maps a report path identifier to the order stream and exposes its validated items as server-sent events. */
import { defineRoute, http } from "@relkit/app/routes";
import orders from "../../../services/orders/service.js";

export const GET = defineRoute({
  target: orders.streamOrderReport,
  request: http.input({ reportId: http.path("reportId") }),
  client: { operation: "query" },
  stream: { format: "sse" },
});
```

**Frontend**

After [frontend setup and pulling the commerce contract](/guides/frontend/connect-react), render
this component under the provider. The `GET /reports/:reportId` route exposes the streaming function:

```tsx title="src/Report.tsx"
"use client";

/** Consumes the commerce report route as a cancellable typed stream inside the client provider. */
import { useRelkitClient, useStream } from "@relkit/client/react";

/** Starts one report explicitly and displays its validated progress items.
 * @returns Start/cancel controls and visible progress or stream failure. */
export function Report() {
  const { status } = useRelkitClient();
  const report = useStream("GET /reports/:reportId");

  return (
    <section>
      <button
        disabled={status !== "ready"}
        onClick={() => void report.start({ reportId: "daily" })}
      >
        Run report
      </button>
      <button onClick={() => report.cancel()}>Cancel report</button>
      <p role="status">Completed: {report.items.map((item) => item.completed).join(", ")}</p>
      {report.error && <p role="alert">{String(report.error)}</p>}
    </section>
  );
}
```

`streamOf` supplies the item type, so `report.items` exposes each item's `completed` field.
`start({ reportId })` begins the request; `cancel()` releases it. Use the domain input even when
REST places a field in the URL. Streaming operations are excluded from finite `useRoute` queries.

Reference: [`useStream`](/docs/api/client#usestream).
Continue with [stream lifecycle and failures](/docs/modules/client/streams).

### streamOfEffect

Creates a stream output schema in the Effect error channel.

**Example**

```ts
Effect.runSync(streamOfEffect(z.string()));
```

**Signature**

```ts
declare const streamOfEffect: <const ItemSchema extends StandardSchemaV1>(
  item: ItemSchema,
) => Effect.Effect<StreamOutputSchema<ItemSchema>, FunctionOperationError, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/stream.ts#L19)

## `stream.types.ts`

### StreamOutputSchema (interface)

Standard Schema contract for an asynchronous sequence of validated items.

**Example**

```ts
const output: StreamOutputSchema = streamOf(z.string());
```

**Signature**

```ts
export interface StreamOutputSchema<
  ItemSchema extends StandardSchemaV1 = StandardSchemaV1,
> extends StandardSchemaV1<
  AsyncIterable<InferInput<ItemSchema>>,
  AsyncIterable<InferOutput<ItemSchema>>
> {
  readonly kind: "stream";
  readonly item: ItemSchema;
  readonly relkit: {
    readonly jsonSchema: () => { readonly kind: "stream"; readonly item: object };
  };
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/stream.types.ts#L6)

## `types.ts`

### "./function-context.types.js" (namespace export)

Re-exports all named exports from the "./function-context.types.js" module.

**Signature**

```ts
export * from "./function-context.types.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L29)

### "./function-descriptor.types.js" (namespace export)

Re-exports all named exports from the "./function-descriptor.types.js" module.

**Signature**

```ts
export * from "./function-descriptor.types.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L30)

### "./function-ref.types.js" (namespace export)

Re-exports all named exports from the "./function-ref.types.js" module.

**Signature**

```ts
export * from "./function-ref.types.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L28)

### AgentClientFor

**Signature**

```ts
declare const AgentClientFor: AgentClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L3)

### AgentClients

**Signature**

```ts
declare const AgentClients: AgentClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L4)

### BucketClient

**Signature**

```ts
declare const BucketClient: BucketClient;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L5)

### BucketClientFor

**Signature**

```ts
declare const BucketClientFor: BucketClient;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L6)

### BucketClients

**Signature**

```ts
declare const BucketClients: BucketClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L7)

### BucketObjectMetadata

**Signature**

```ts
declare const BucketObjectMetadata: BucketObjectMetadata;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L8)

### CacheClient

**Signature**

```ts
declare const CacheClient: CacheClient<Key, Value>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L9)

### CacheClientFor

**Signature**

```ts
declare const CacheClientFor: CacheClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L10)

### CacheClients

**Signature**

```ts
declare const CacheClients: CacheClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L11)

### CacheOperationOptions

**Signature**

```ts
declare const CacheOperationOptions: CacheOperationOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L12)

### EventAttributeValue

**Signature**

```ts
declare const EventAttributeValue: EventAttributeValue;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L15)

### EventClientFor

**Signature**

```ts
declare const EventClientFor: EventClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L13)

### EventClients

**Signature**

```ts
declare const EventClients: EventClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L14)

### EventPublishOptions

**Signature**

```ts
declare const EventPublishOptions: EventPublishOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L16)

### EventPublishResult

**Signature**

```ts
declare const EventPublishResult: EventPublishResult<Id, Version, Payload>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L17)

### JobClientFor

**Signature**

```ts
declare const JobClientFor: JobClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L19)

### JobClients

**Signature**

```ts
declare const JobClients: JobClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L20)

### JobEnqueueOptions

**Signature**

```ts
declare const JobEnqueueOptions: JobEnqueueOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L18)

### JobEnqueueResult

**Signature**

```ts
declare const JobEnqueueResult: JobEnqueueResult;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L21)

### JobRef

**Signature**

```ts
declare const JobRef: JobRef<Id, InputSchema, OutputSchema, Task>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L1)

### JobRefAny

**Signature**

```ts
declare const JobRefAny: JobRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L1)

### JobState

**Signature**

```ts
declare const JobState: JobState;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L22)

### JobStatus

**Signature**

```ts
declare const JobStatus: JobStatus;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L23)

### TaskClientFor

**Signature**

```ts
declare const TaskClientFor: TaskClientFor<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L24)

### TaskClients

**Signature**

```ts
declare const TaskClients: TaskClients<M>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L25)

### TaskRef

**Signature**

```ts
declare const TaskRef: TaskRef<Id, InputSchema, OutputSchema, Errors>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L1)

### TaskRefAny

**Signature**

```ts
declare const TaskRefAny: TaskRefAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L1)

### TaskTriggerOptions

**Signature**

```ts
declare const TaskTriggerOptions: TaskTriggerOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/functions/src/types.ts#L26)

## `error-retry.types.ts`

Retry policy for a declared application error.

**Example**

```ts
const retry: ErrorRetry = "later";
```

### ErrorRetry (type alias)

Retry policy for a declared application error.

**Example**

```ts
const retry: ErrorRetry = "later";
```

**Signature**

```ts
type ErrorRetry = "never" | "later";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/error-retry.types.ts#L4)

### ErrorRetryInput (type alias)

Accepted retry policy input.
Normalization validates the optional delay and freezes the result.

**Example**

```ts
const retry: ErrorRetryInput = { kind: "later", afterMs: 500 };
```

**Signature**

```ts
type ErrorRetryInput = ErrorRetry | ErrorRetryLater;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/error-retry.types.ts#L19)

### ErrorRetryLater (interface)

Delayed retry policy with an optional minimum delay.
afterMs must be a finite non-negative integer when supplied.

**Example**

```ts
const retry: ErrorRetryLater = { kind: "later", afterMs: 500 };
```

**Signature**

```ts
export interface ErrorRetryLater {
  readonly kind: "later";
  readonly afterMs?: number;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/error-retry.types.ts#L10)

### NormalizedErrorRetry (interface)

Canonical immutable retry policy.
Normalization removes a delay when retry is never.

**Example**

```ts
const policy = normalizeErrorRetry("later", 500);
```

**Signature**

```ts
export interface NormalizedErrorRetry {
  readonly retry: ErrorRetry;
  readonly afterMs?: number;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/error-retry.types.ts#L25)

## `identity-bind.ts`

### bindDescriptorIdentity

Synchronous canonical identity binding adapter.

**Throws**

DescriptorIdentityError or TypeError for invalid identity.

**Example**

```ts
bindDescriptorIdentity(descriptor, "tasks.run");
```

**Signature**

```ts
declare const bindDescriptorIdentity: <T extends object>(descriptor: T, id: string) => T;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/identity-bind.ts#L47)

### bindDescriptorIdentityEffect

Binds a canonical descriptor identity without mutating the descriptor.

**Example**

```ts
Effect.runSync(bindDescriptorIdentityEffect(descriptor, "tasks.run"));
```

**Signature**

```ts
declare const bindDescriptorIdentityEffect: <T extends object>(
  descriptor: T,
  id: string,
) => Effect.Effect<T, import("./identity-state.js").DescriptorIdentityFailure>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/identity-bind.ts#L18)

### bindDescriptorServiceMembers

Synchronous service member binding adapter.

**Throws**

DescriptorIdentityError when a member belongs to another service.

**Example**

```ts
bindDescriptorServiceMembers([member], service);
```

**Signature**

```ts
declare const bindDescriptorServiceMembers: <T extends object>(
  descriptors: readonly T[],
  service: object & DescriptorIdentitySource,
) => readonly T[];
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/identity-bind.ts#L99)

### bindDescriptorServiceMembersEffect

Associates descriptor members with one service without changing them.

**Example**

```ts
Effect.runSync(bindDescriptorServiceMembersEffect([member], service));
```

**Signature**

```ts
declare const bindDescriptorServiceMembersEffect: <T extends object>(
  descriptors: readonly T[],
  service: object & DescriptorIdentitySource,
) => Effect.Effect<ReadonlyArray<T>, DescriptorIdentityFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/identity-bind.ts#L75)

### isDescriptorIdentityBound

Synchronous bound check adapter.

**Example**

```ts
isDescriptorIdentityBound(descriptor);
```

**Signature**

```ts
declare const isDescriptorIdentityBound: (descriptor: object) => boolean;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/identity-bind.ts#L65)

### isDescriptorIdentityBoundEffect

Checks if a descriptor has an explicit canonical binding.

**Example**

```ts
Effect.runSync(isDescriptorIdentityBoundEffect(descriptor));
```

**Signature**

```ts
declare const isDescriptorIdentityBoundEffect: (
  descriptor: object,
) => Effect.Effect<boolean, DescriptorIdentityFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/invocation/src/identity-bind.ts#L56)