@effect/ai 0.29.1 → 0.31.0

package/src/Tool.ts

@@ -27,7 +27,7 @@
  * @since 1.0.0
  */
 import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
+import type * as Effect from "effect/Effect"
 import { constFalse, constTrue, identity } from "effect/Function"
 import * as JsonSchema from "effect/JSONSchema"
 import * as Option from "effect/Option"
@@ -37,7 +37,7 @@ import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as AST from "effect/SchemaAST"
 import type { Covariant } from "effect/Types"
-import * as AiError from "./AiError.js"
+import type * as AiError from "./AiError.js"
 
 // =============================================================================
 // Type Ids
@@ -115,15 +115,13 @@ export interface Tool<
     readonly parameters: AnyStructSchema
     readonly success: Schema.Schema.Any
     readonly failure: Schema.Schema.All
-  } = {
-    readonly parameters: Schema.Struct<{}>
-    readonly success: typeof Schema.Void
-    readonly failure: typeof Schema.Never
+    readonly failureMode: FailureMode
   },
   Requirements = never
 > extends Tool.Variance<Requirements> {
   /**
-   * The tool identifier which is used to uniquely identify the tool. */
+   * The tool identifier which is used to uniquely identify the tool.
+   */
   readonly id: string
 
   /**
@@ -136,6 +134,19 @@ export interface Tool<
    */
   readonly description?: string | undefined
 
+  /**
+   * The strategy used for handling errors returned from tool call handler
+   * execution.
+   *
+   * If set to `"error"` (the default), errors that occur during tool call
+   * handler execution will be returned in the error channel of the calling
+   * effect.
+   *
+   * If set to `"return"`, errors that occur during tool call handler execution
+   * will be captured and returned as part of the tool call result.
+   */
+  readonly failureMode: FailureMode
+
   /**
    * A `Schema` representing the parameters that a tool must be called with.
    */
@@ -167,60 +178,76 @@ export interface Tool<
    * **MUST** be provided to each request to the large language model provider
    * instead of being provided when creating the tool call handler layer.
    */
-  addDependency<Identifier, Service>(tag: Context.Tag<Identifier, Service>): Tool<
-    Name,
-    Config,
-    Identifier | Requirements
-  >
+  addDependency<Identifier, Service>(
+    tag: Context.Tag<Identifier, Service>
+  ): Tool<Name, Config, Identifier | Requirements>
 
   /**
    * Set the schema to use to validate the result of a tool call when successful.
    */
-  setParameters<ParametersSchema extends Schema.Struct<any> | Schema.Struct.Fields>(
+  setParameters<
+    ParametersSchema extends Schema.Struct<any> | Schema.Struct.Fields
+  >(
     schema: ParametersSchema
-  ): Tool<Name, {
-    readonly parameters: ParametersSchema extends Schema.Struct<infer _> ? ParametersSchema
-      : ParametersSchema extends Schema.Struct.Fields ? Schema.Struct<ParametersSchema>
-      : never
-    readonly success: Config["success"]
-    readonly failure: Config["failure"]
-  }, Requirements>
+  ): Tool<
+    Name,
+    {
+      readonly parameters: ParametersSchema extends Schema.Struct<infer _> ? ParametersSchema
+        : ParametersSchema extends Schema.Struct.Fields ? Schema.Struct<ParametersSchema>
+        : never
+      readonly success: Config["success"]
+      readonly failure: Config["failure"]
+      readonly failureMode: Config["failureMode"]
+    },
+    Requirements
+  >
 
   /**
    * Set the schema to use to validate the result of a tool call when successful.
    */
-  setSuccess<SuccessSchema extends Schema.Schema.Any>(schema: SuccessSchema): Tool<Name, {
-    readonly parameters: Config["parameters"]
-    readonly success: SuccessSchema
-    readonly failure: Config["failure"]
-  }, Requirements>
+  setSuccess<SuccessSchema extends Schema.Schema.Any>(
+    schema: SuccessSchema
+  ): Tool<
+    Name,
+    {
+      readonly parameters: Config["parameters"]
+      readonly success: SuccessSchema
+      readonly failure: Config["failure"]
+      readonly failureMode: Config["failureMode"]
+    },
+    Requirements
+  >
 
   /**
    * Set the schema to use to validate the result of a tool call when it fails.
    */
-  setFailure<FailureSchema extends Schema.Schema.Any>(schema: FailureSchema): Tool<Name, {
-    readonly parameters: Config["parameters"]
-    readonly success: Config["success"]
-    readonly failure: FailureSchema
-  }, Requirements>
+  setFailure<FailureSchema extends Schema.Schema.Any>(
+    schema: FailureSchema
+  ): Tool<
+    Name,
+    {
+      readonly parameters: Config["parameters"]
+      readonly success: Config["success"]
+      readonly failure: FailureSchema
+      readonly failureMode: Config["failureMode"]
+    },
+    Requirements
+  >
 
   /**
    * Add an annotation to the tool.
    */
-  annotate<I, S>(tag: Context.Tag<I, S>, value: S): Tool<
-    Name,
-    Config,
-    Requirements
-  >
+  annotate<I, S>(
+    tag: Context.Tag<I, S>,
+    value: S
+  ): Tool<Name, Config, Requirements>
 
   /**
    * Add many annotations to the tool.
    */
-  annotateContext<I>(context: Context.Context<I>): Tool<
-    Name,
-    Config,
-    Requirements
-  >
+  annotateContext<I>(
+    context: Context.Context<I>
+  ): Tool<Name, Config, Requirements>
 }
 
 /**
@@ -264,21 +291,25 @@ export interface ProviderDefined<
     readonly parameters: AnyStructSchema
     readonly success: Schema.Schema.Any
     readonly failure: Schema.Schema.All
+    readonly failureMode: FailureMode
   } = {
     readonly args: Schema.Struct<{}>
     readonly parameters: Schema.Struct<{}>
     readonly success: typeof Schema.Void
     readonly failure: typeof Schema.Never
+    readonly failureMode: "error"
   },
   RequiresHandler extends boolean = false
 > extends
-  Tool<Name, {
-    readonly parameters: Config["parameters"]
-    success: RequiresHandler extends true ? Config["success"]
-      : Schema.Either<Config["success"], Config["failure"]>
-    failure: RequiresHandler extends true ? Config["failure"]
-      : typeof Schema.Never
-  }>,
+  Tool<
+    Name,
+    {
+      readonly parameters: Config["parameters"]
+      readonly success: Config["success"]
+      readonly failure: Config["failure"]
+      readonly failureMode: Config["failureMode"]
+    }
+  >,
   Tool.ProviderDefinedProto
 {
   /**
@@ -303,13 +334,23 @@ export interface ProviderDefined<
    * this tool into a `Layer`.
    */
   readonly requiresHandler: RequiresHandler
-
-  /**
-   * Decodes the result received after the provider-defined tool is called.
-   */
-  decodeResult(args: unknown): Effect.Effect<Config["success"]["Type"], AiError.AiError>
 }
 
+/**
+ * The strategy used for handling errors returned from tool call handler
+ * execution.
+ *
+ * If set to `"error"` (the default), errors that occur during tool call handler
+ * execution will be returned in the error channel of the calling effect.
+ *
+ * If set to `"return"`, errors that occur during tool call handler execution
+ * will be captured and returned as part of the tool call result.
+ *
+ * @since 1.0.0
+ * @category Models
+ */
+export type FailureMode = "error" | "return"
+
 /**
  * @since 1.0.0
  */
@@ -431,8 +472,9 @@ export const isUserDefined = (u: unknown): u is Tool<string, any, any> =>
  * @since 1.0.0
  * @category Guards
  */
-export const isProviderDefined = (u: unknown): u is ProviderDefined<string, any> =>
-  Predicate.hasProperty(u, ProviderDefinedTypeId)
+export const isProviderDefined = (
+  u: unknown
+): u is ProviderDefined<string, any> => Predicate.hasProperty(u, ProviderDefinedTypeId)
 
 // =============================================================================
 // Utility Types
@@ -454,6 +496,7 @@ export interface Any extends Pipeable {
   readonly parametersSchema: AnyStructSchema
   readonly successSchema: Schema.Schema.Any
   readonly failureSchema: Schema.Schema.All
+  readonly failureMode: FailureMode
   readonly annotations: Context.Context<never>
 }
 
@@ -468,7 +511,9 @@ export interface AnyProviderDefined extends Any {
   readonly argsSchema: AnyStructSchema
   readonly requiresHandler: boolean
   readonly providerName: string
-  readonly decodeResult: (result: unknown) => Effect.Effect<any, AiError.AiError>
+  readonly decodeResult: (
+    result: unknown
+  ) => Effect.Effect<any, AiError.AiError>
 }
 
 /**
@@ -509,6 +554,7 @@ export interface FromTaggedRequest<S extends AnyTaggedRequestSchema> extends
       readonly parameters: S
       readonly success: S["success"]
       readonly failure: S["failure"]
+      readonly failureMode: "error"
     }
   >
 {}
@@ -523,8 +569,8 @@ export type Name<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Name :
-  never
+> ? _Name
+  : never
 
 /**
  * A utility type to extract the type of the tool call parameters.
@@ -536,8 +582,8 @@ export type Parameters<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? Schema.Struct.Type<_Config["parameters"]["fields"]> :
-  never
+> ? Schema.Struct.Type<_Config["parameters"]["fields"]>
+  : never
 
 /**
  * A utility type to extract the encoded type of the tool call parameters.
@@ -549,8 +595,8 @@ export type ParametersEncoded<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? Schema.Schema.Encoded<_Config["parameters"]> :
-  never
+> ? Schema.Schema.Encoded<_Config["parameters"]>
+  : never
 
 /**
  * A utility type to extract the schema for the parameters which an `Tool`
@@ -563,8 +609,8 @@ export type ParametersSchema<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Config["parameters"] :
-  never
+> ? _Config["parameters"]
+  : never
 
 /**
  * A utility type to extract the type of the tool call result when it succeeds.
@@ -576,8 +622,8 @@ export type Success<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? Schema.Schema.Type<_Config["success"]> :
-  never
+> ? Schema.Schema.Type<_Config["success"]>
+  : never
 
 /**
  * A utility type to extract the encoded type of the tool call result when
@@ -590,8 +636,8 @@ export type SuccessEncoded<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? Schema.Schema.Encoded<_Config["success"]> :
-  never
+> ? Schema.Schema.Encoded<_Config["success"]>
+  : never
 
 /**
  * A utility type to extract the schema for the return type of a tool call when
@@ -604,8 +650,8 @@ export type SuccessSchema<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Config["success"] :
-  never
+> ? _Config["success"]
+  : never
 
 /**
  * A utility type to extract the type of the tool call result when it fails.
@@ -617,8 +663,8 @@ export type Failure<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? Schema.Schema.Type<_Config["failure"]> :
-  never
+> ? Schema.Schema.Type<_Config["failure"]>
+  : never
 
 /**
  * A utility type to extract the encoded type of the tool call result when
@@ -631,8 +677,36 @@ export type FailureEncoded<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? Schema.Schema.Encoded<_Config["failure"]> :
-  never
+> ? Schema.Schema.Encoded<_Config["failure"]>
+  : never
+
+/**
+ * A utility type to extract the type of the tool call result whether it
+ * succeeds or fails.
+ *
+ * @since 1.0.0
+ * @category Utility Types
+ */
+export type Result<T> = T extends Tool<
+  infer _Name,
+  infer _Config,
+  infer _Requirements
+> ? Success<T> | Failure<T>
+  : never
+
+/**
+ * A utility type to extract the encoded type of the tool call result whether
+ * it succeeds or fails.
+ *
+ * @since 1.0.0
+ * @category Utility Types
+ */
+export type ResultEncoded<T> = T extends Tool<
+  infer _Name,
+  infer _Config,
+  infer _Requirements
+> ? SuccessEncoded<T> | FailureEncoded<T>
+  : never
 
 /**
  * A utility type to extract the requirements of an `Tool`.
@@ -644,8 +718,12 @@ export type Requirements<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Config["parameters"]["Context"] | _Config["success"]["Context"] | _Config["failure"]["Context"] | _Requirements :
-  never
+> ?
+    | _Config["parameters"]["Context"]
+    | _Config["success"]["Context"]
+    | _Config["failure"]["Context"]
+    | _Requirements
+  : never
 
 /**
  * Represents an `Tool` that has been implemented within the application.
@@ -667,10 +745,14 @@ export interface Handler<Name extends string> {
  * @category Models
  */
 export interface HandlerResult<Tool extends Any> {
+  /**
+   * Whether the result of executing the tool call handler was an error or not.
+   */
+  readonly isFailure: boolean
   /**
    * The result of executing the handler for a particular tool.
    */
-  readonly result: Success<Tool>
+  readonly result: Result<Tool>
   /**
    * The pre-encoded tool call result of executing the handler for a particular
    * tool as a JSON-serializable value. The encoded result can be incorporated
@@ -679,6 +761,21 @@ export interface HandlerResult<Tool extends Any> {
   readonly encodedResult: unknown
 }
 
+/**
+ * A utility type which represents the possible errors that can be raised by
+ * a tool call's handler.
+ *
+ * @since 1.0.0
+ * @category Utility Types
+ */
+export type HandlerError<T> = T extends Tool<
+  infer _Name,
+  infer _Config,
+  infer _Requirements
+> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"]
+  : never
+  : never
+
 /**
  * A utility type to create a union of `Handler` types for all tools in a
  * record.
@@ -698,8 +795,12 @@ export type HandlersFor<Tools extends Record<string, Any>> = {
  * @since 1.0.0
  * @category Utility Types
  */
-export type RequiresHandler<Tool extends Any> = Tool extends
-  ProviderDefined<infer _Name, infer _Config, infer _RequiresHandler> ? _RequiresHandler : true
+export type RequiresHandler<Tool extends Any> = Tool extends ProviderDefined<
+  infer _Name,
+  infer _Config,
+  infer _RequiresHandler
+> ? _RequiresHandler
+  : true
 
 // =============================================================================
 // Constructors
@@ -713,11 +814,14 @@ const Proto = {
   addDependency(this: Any) {
     return userDefinedProto({ ...this })
   },
-  setParameters(this: Any, parametersSchema: Schema.Struct<any> | Schema.Struct.Fields) {
+  setParameters(
+    this: Any,
+    parametersSchema: Schema.Struct<any> | Schema.Struct.Fields
+  ) {
     return userDefinedProto({
       ...this,
       parametersSchema: Schema.isSchema(parametersSchema)
-        ? parametersSchema as any
+        ? (parametersSchema as any)
         : Schema.Struct(parametersSchema as any)
     })
   },
@@ -749,27 +853,15 @@ const Proto = {
 
 const ProviderDefinedProto = {
   ...Proto,
-  [ProviderDefinedTypeId]: ProviderDefinedTypeId,
-  decodeResult(this: AnyProviderDefined, result: unknown) {
-    return Schema.decodeUnknown(this.successSchema)(result).pipe(
-      Effect.orElse(() => Schema.decodeUnknown(this.failureSchema as any)(result)),
-      Effect.mapError((cause) =>
-        new AiError.MalformedOutput({
-          module: "Tool",
-          method: "ProviderDefined.decodeResult",
-          description: `Failed to decode the result of provider-defined tool '${this.name}'`,
-          cause
-        })
-      )
-    )
-  }
+  [ProviderDefinedTypeId]: ProviderDefinedTypeId
 }
 
 const userDefinedProto = <
   const Name extends string,
   Parameters extends AnyStructSchema,
   Success extends Schema.Schema.Any,
-  Failure extends Schema.Schema.All
+  Failure extends Schema.Schema.All,
+  Mode extends FailureMode
 >(options: {
   readonly name: Name
   readonly description?: string | undefined
@@ -777,12 +869,14 @@ const userDefinedProto = <
   readonly successSchema: Success
   readonly failureSchema: Failure
   readonly annotations: Context.Context<never>
+  readonly failureMode: Mode
 }): Tool<
   Name,
   {
     readonly parameters: Parameters
     readonly success: Success
     readonly failure: Failure
+    readonly failureMode: Mode
   }
 > => {
   const self = Object.assign(Object.create(Proto), options)
@@ -796,7 +890,8 @@ const providerDefinedProto = <
   Parameters extends AnyStructSchema,
   Success extends Schema.Schema.Any,
   Failure extends Schema.Schema.All,
-  RequiresHandler extends boolean
+  RequiresHandler extends boolean,
+  Mode extends FailureMode
 >(options: {
   readonly id: string
   readonly name: Name
@@ -807,6 +902,7 @@ const providerDefinedProto = <
   readonly parametersSchema: Parameters
   readonly successSchema: Success
   readonly failureSchema: Failure
+  readonly failureMode: FailureMode
 }): ProviderDefined<
   Name,
   {
@@ -814,6 +910,7 @@ const providerDefinedProto = <
     readonly parameters: Parameters
     readonly success: Success
     readonly failure: Failure
+    readonly failureMode: Mode
   },
   RequiresHandler
 > => Object.assign(Object.create(ProviderDefinedProto), options)
@@ -847,6 +944,7 @@ export const make = <
   Parameters extends Schema.Struct.Fields = {},
   Success extends Schema.Schema.Any = typeof Schema.Void,
   Failure extends Schema.Schema.All = typeof Schema.Never,
+  Mode extends FailureMode | undefined = undefined,
   Dependencies extends Array<Context.Tag<any, any>> = []
 >(
   /**
@@ -870,6 +968,17 @@ export const make = <
      * Schema for tool execution failures.
      */
     readonly failure?: Failure | undefined
+    /**
+     * The strategy used for handling errors returned from tool call handler
+     * execution.
+     *
+     * If set to `"error"` (the default), errors that occur during tool call handler
+     * execution will be returned in the error channel of the calling effect.
+     *
+     * If set to `"return"`, errors that occur during tool call handler execution
+     * will be captured and returned as part of the tool call result.
+     */
+    readonly failureMode?: Mode
     /**
      * Service dependencies required by the tool handler.
      */
@@ -881,6 +990,7 @@ export const make = <
     readonly parameters: Schema.Struct<Parameters>
     readonly success: Success
     readonly failure: Failure
+    readonly failureMode: Mode extends undefined ? "error" : Mode
   },
   Context.Tag.Identifier<Dependencies[number]>
 > => {
@@ -894,6 +1004,7 @@ export const make = <
       : constEmptyStruct,
     successSchema,
     failureSchema,
+    failureMode: options?.failureMode ?? "error",
     annotations: Context.empty()
   }) as any
 }
@@ -973,19 +1084,37 @@ export const providerDefined = <
    */
   readonly failure?: Failure | undefined
 }) =>
-(args: Schema.Simplify<Schema.Struct.Encoded<Args>>): ProviderDefined<
+<Mode extends FailureMode | undefined = undefined>(
+  args: RequiresHandler extends true ? Schema.Simplify<
+      Schema.Struct.Encoded<Args> & {
+        /**
+         * The strategy used for handling errors returned from tool call handler
+         * execution.
+         *
+         * If set to `"error"` (the default), errors that occur during tool call handler
+         * execution will be returned in the error channel of the calling effect.
+         *
+         * If set to `"return"`, errors that occur during tool call handler execution
+         * will be captured and returned as part of the tool call result.
+         */
+        readonly failureMode?: Mode
+      }
+    >
+    : Schema.Simplify<Schema.Struct.Encoded<Args>>
+): ProviderDefined<
   Name,
   {
     readonly args: Schema.Struct<Args>
     readonly parameters: Schema.Struct<Parameters>
     readonly success: Success
     readonly failure: Failure
+    readonly failureMode: Mode extends undefined ? "error" : Mode
   },
   RequiresHandler
 > => {
+  const failureMode = "failureMode" in args ? args.failureMode : undefined
   const successSchema = options?.success ?? Schema.Void
   const failureSchema = options?.failure ?? Schema.Never
-  const resultSchema = Schema.EitherFromUnion({ right: successSchema, left: failureSchema })
   return providerDefinedProto({
     id: options.id,
     name: options.toolkitName,
@@ -996,8 +1125,9 @@ export const providerDefined = <
     parametersSchema: options?.parameters
       ? Schema.Struct(options?.parameters as any)
       : constEmptyStruct,
-    successSchema: options.requiresHandler === true ? successSchema : resultSchema,
-    failureSchema: options.requiresHandler === true ? failureSchema : Schema.Never
+    successSchema,
+    failureSchema,
+    failureMode: failureMode ?? "error"
   }) as any
 }
 
@@ -1041,10 +1171,13 @@ export const fromTaggedRequest = <S extends AnyTaggedRequestSchema>(
 ): FromTaggedRequest<S> =>
   userDefinedProto({
     name: schema._tag,
-    description: Option.getOrUndefined(AST.getDescriptionAnnotation((schema.ast as any).to)),
+    description: Option.getOrUndefined(
+      AST.getDescriptionAnnotation((schema.ast as any).to)
+    ),
     parametersSchema: schema,
     successSchema: schema.success,
     failureSchema: schema.failure,
+    failureMode: "error",
     annotations: Context.empty()
   }) as any
 
@@ -1079,6 +1212,7 @@ export const getDescription = <
     readonly parameters: AnyStructSchema
     readonly success: Schema.Schema.Any
     readonly failure: Schema.Schema.All
+    readonly failureMode: FailureMode
   }
 >(
   /**
@@ -1096,16 +1230,18 @@ export const getDescription = <
  * @since 1.0.0
  * @category Utilities
  */
-export const getDescriptionFromSchemaAst = (ast: AST.AST): string | undefined => {
-  const annotations = ast._tag === "Transformation" ?
-    {
+export const getDescriptionFromSchemaAst = (
+  ast: AST.AST
+): string | undefined => {
+  const annotations = ast._tag === "Transformation"
+    ? {
       ...ast.to.annotations,
       ...ast.annotations
-    } :
-    ast.annotations
+    }
+    : ast.annotations
   return AST.DescriptionAnnotationId in annotations
-    ? annotations[AST.DescriptionAnnotationId] as string :
-    undefined
+    ? (annotations[AST.DescriptionAnnotationId] as string)
+    : undefined
 }
 
 /**
@@ -1148,14 +1284,19 @@ export const getJsonSchema = <
     readonly parameters: AnyStructSchema
     readonly success: Schema.Schema.Any
     readonly failure: Schema.Schema.All
+    readonly failureMode: FailureMode
   }
->(tool: Tool<Name, Config>): JsonSchema.JsonSchema7 => getJsonSchemaFromSchemaAst(tool.parametersSchema.ast)
+>(
+  tool: Tool<Name, Config>
+): JsonSchema.JsonSchema7 => getJsonSchemaFromSchemaAst(tool.parametersSchema.ast)
 
 /**
  * @since 1.0.0
  * @category Utilities
  */
-export const getJsonSchemaFromSchemaAst = (ast: AST.AST): JsonSchema.JsonSchema7 => {
+export const getJsonSchemaFromSchemaAst = (
+  ast: AST.AST
+): JsonSchema.JsonSchema7 => {
   const props = AST.getPropertySignatures(ast)
   if (props.length === 0) {
     return {
@@ -1193,7 +1334,10 @@ export const getJsonSchemaFromSchemaAst = (ast: AST.AST): JsonSchema.JsonSchema7
  * @since 1.0.0
  * @category Annotations
  */
-export class Title extends Context.Tag("@effect/ai/Tool/Title")<Title, string>() {}
+export class Title extends Context.Tag("@effect/ai/Tool/Title")<
+  Title,
+  string
+>() {}
 
 /**
  * Annotation indicating whether a tool only reads data without making changes.
@@ -1209,9 +1353,12 @@ export class Title extends Context.Tag("@effect/ai/Tool/Title")<Title, string>()
  * @since 1.0.0
  * @category Annotations
  */
-export class Readonly extends Context.Reference<Readonly>()("@effect/ai/Tool/Readonly", {
-  defaultValue: constFalse
-}) {}
+export class Readonly extends Context.Reference<Readonly>()(
+  "@effect/ai/Tool/Readonly",
+  {
+    defaultValue: constFalse
+  }
+) {}
 
 /**
  * Annotation indicating whether a tool performs destructive operations.
@@ -1227,9 +1374,12 @@ export class Readonly extends Context.Reference<Readonly>()("@effect/ai/Tool/Rea
  * @since 1.0.0
  * @category Annotations
  */
-export class Destructive extends Context.Reference<Destructive>()("@effect/ai/Tool/Destructive", {
-  defaultValue: constTrue
-}) {}
+export class Destructive extends Context.Reference<Destructive>()(
+  "@effect/ai/Tool/Destructive",
+  {
+    defaultValue: constTrue
+  }
+) {}
 
 /**
  * Annotation indicating whether a tool can be called multiple times safely.
@@ -1245,9 +1395,12 @@ export class Destructive extends Context.Reference<Destructive>()("@effect/ai/To
  * @since 1.0.0
  * @category Annotations
  */
-export class Idempotent extends Context.Reference<Idempotent>()("@effect/ai/Tool/Idempotent", {
-  defaultValue: constFalse
-}) {}
+export class Idempotent extends Context.Reference<Idempotent>()(
+  "@effect/ai/Tool/Idempotent",
+  {
+    defaultValue: constFalse
+  }
+) {}
 
 /**
  * Annotation indicating whether a tool can handle arbitrary external data.
@@ -1263,9 +1416,12 @@ export class Idempotent extends Context.Reference<Idempotent>()("@effect/ai/Tool
  * @since 1.0.0
  * @category Annotations
  */
-export class OpenWorld extends Context.Reference<OpenWorld>()("@effect/ai/Tool/OpenWorld", {
-  defaultValue: constTrue
-}) {}
+export class OpenWorld extends Context.Reference<OpenWorld>()(
+  "@effect/ai/Tool/OpenWorld",
+  {
+    defaultValue: constTrue
+  }
+) {}
 
 // Licensed under BSD-3-Clause (below code only)
 // Code adapted from https://github.com/fastify/secure-json-parse/blob/783fcb1b5434709466759847cec974381939673a/index.js