@effect/ai 0.29.1 → 0.31.0

package/src/Toolkit.ts

@@ -45,6 +45,7 @@ import type { Inspectable } from "effect/Inspectable"
 import { BaseProto as InspectableProto } from "effect/Inspectable"
 import * as Layer from "effect/Layer"
 import type { ParseError } from "effect/ParseResult"
+import * as ParseResult from "effect/ParseResult"
 import { type Pipeable, pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
@@ -226,10 +227,7 @@ export interface WithHandler<in out Tools extends Record<string, Tool.Any>> {
      */
     params: Tool.Parameters<Tools[Name]>
   ) => Effect.Effect<
-    {
-      readonly result: Tool.Success<Tools[Name]>
-      readonly encodedResult: unknown
-    },
+    Tool.HandlerResult<Tools[Name]>,
     Tool.Failure<Tools[Name]>,
     Tool.Requirements<Tools[Name]>
   >
@@ -267,26 +265,24 @@ const Proto = {
       const schemasCache = new WeakMap<any, {
         readonly context: Context.Context<never>
         readonly handler: (params: any) => Effect.Effect<any, any>
-        readonly encodeSuccess: (u: unknown) => Effect.Effect<unknown, ParseError>
-        readonly encodeFailure: (u: unknown) => Effect.Effect<unknown, ParseError>
-        readonly decodeFailure: (u: unknown) => Effect.Effect<Tool.Failure<any>, ParseError>
         readonly decodeParameters: (u: unknown) => Effect.Effect<Tool.Parameters<any>, ParseError>
+        readonly validateResult: (u: unknown) => Effect.Effect<unknown, ParseError>
+        readonly encodeResult: (u: unknown) => Effect.Effect<unknown, ParseError>
       }>()
       const getSchemas = (tool: Tool.Any) => {
         let schemas = schemasCache.get(tool)
         if (Predicate.isUndefined(schemas)) {
           const handler = context.unsafeMap.get(tool.id)! as Tool.Handler<any>
-          const encodeSuccess = Schema.encodeUnknown(tool.successSchema) as any
-          const encodeFailure = Schema.encodeUnknown(tool.failureSchema as any) as any
-          const decodeFailure = Schema.decodeUnknown(tool.failureSchema as any) as any
           const decodeParameters = Schema.decodeUnknown(tool.parametersSchema) as any
+          const resultSchema = Schema.Union(tool.successSchema, tool.failureSchema)
+          const validateResult = Schema.validate(resultSchema) as any
+          const encodeResult = Schema.encodeUnknown(resultSchema) as any
           schemas = {
             context: handler.context,
             handler: handler.handler,
-            encodeSuccess,
-            encodeFailure,
-            decodeFailure,
-            decodeParameters
+            decodeParameters,
+            validateResult,
+            encodeResult
           }
           schemasCache.set(tool, schemas)
         }
@@ -317,24 +313,30 @@ const Proto = {
                 cause
               })
           )
-          const result = yield* schemas.handler(decodedParams).pipe(
-            Effect.mapInputContext((input) => Context.merge(schemas.context, input)),
+          const { isFailure, result } = yield* schemas.handler(decodedParams).pipe(
+            Effect.map((result) => ({ result, isFailure: false })),
             Effect.catchAll((error) =>
-              schemas.decodeFailure(error).pipe(
-                Effect.mapError((cause) =>
-                  new AiError.MalformedInput({
-                    module: "Toolkit",
-                    method: `${name}.handle`,
-                    description: `Failed to decode tool call failure for tool '${name}'`,
-                    cause
-                  })
-                ),
-                Effect.flatMap(Effect.fail)
-              )
+              // If the tool handler failed, check the tool's failure mode to
+              // determine how the result should be returned to the end user
+              tool.failureMode === "error"
+                ? Effect.fail(error)
+                : Effect.succeed({ result: error, isFailure: true })
+            ),
+            Effect.tap(({ result }) => schemas.validateResult(result)),
+            Effect.mapInputContext((input) => Context.merge(schemas.context, input)),
+            Effect.mapError((cause) =>
+              ParseResult.isParseError(cause)
+                ? new AiError.MalformedInput({
+                  module: "Toolkit",
+                  method: `${name}.handle`,
+                  description: `Failed to validate tool call result for tool '${name}'`,
+                  cause
+                })
+                : cause
             )
           )
           const encodedResult = yield* Effect.mapError(
-            schemas.encodeSuccess(result),
+            schemas.encodeResult(result),
             (cause) =>
               new AiError.MalformedInput({
                 module: "Toolkit",
@@ -344,6 +346,7 @@ const Proto = {
               })
           )
           return {
+            isFailure,
             result,
             encodedResult
           } satisfies Tool.HandlerResult<any>