@effect-uai/anthropic 0.17.0 → 0.19.0-dev-20261109183959

package/dist/{rolldown-runtime-D7D4PA-g.mjs → rolldown-runtime-EAsCxrDo.mjs}

@@ -1,5 +1,6 @@
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -10,4 +11,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll as t };
+export { __exportAll as n, __commonJSMin as t };

package/dist/streamEvents.mjs

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as __exportAll } from "./rolldown-runtime-EAsCxrDo.mjs";
 import { WireContentBlock, appendInputJsonDelta, appendSignatureDelta, appendTextDelta, appendThinkingDelta, mergeUsage, setStopReason, startBlock } from "./codec.mjs";
 import { Match, Schema } from "effect";
 //#region src/streamEvents.ts

package/dist/usage.test.mjs

@@ -1,6 +1,6 @@
 import { emptyAccumulator, mergeUsage } from "./codec.mjs";
 import { applyEvent } from "./streamEvents.mjs";
-import { n as describe, r as it, t as globalExpect } from "./test.DNmyFkvJ-N3QqMRwZ.mjs";
+import { n as describe, r as it, t as globalExpect } from "./index.C4tKZ0yW-xEu55bU4.mjs";
 //#region src/usage.test.ts
 const wire = {
 	input_tokens: 94,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/anthropic",
-  "version": "0.17.0",
+  "version": "0.19.0-dev-20261109183959",
   "description": "Anthropic Messages API provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -43,13 +43,13 @@
     "access": "public"
   },
   "devDependencies": {
-    "effect": "4.0.0-rc.111",
+    "effect": "4.1.2",
     "typescript": "^7.0.2",
-    "@effect-uai/core": "0.17.0"
+    "@effect-uai/core": "0.19.0-dev-20261109183959"
   },
   "peerDependencies": {
-    "@effect-uai/core": ">=0.2.0 <1",
-    "effect": ">=4.0.0-rc.111 <5.0.0"
+    "@effect-uai/core": "0.19.0-dev-20261109183959",
+    "effect": ">=4.0.1 <5.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/Anthropic.ts

@@ -10,7 +10,7 @@ import {
   Stream,
   pipe,
 } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import * as Capabilities from "@effect-uai/core/Capabilities"
 import {

package/src/anthropicTools.test.ts

@@ -10,6 +10,7 @@ const localTool = Tool.make({
   name: "get_weather",
   description: "Look up the weather.",
   inputSchema: Tool.fromEffectSchema(Schema.Struct({ city: Schema.String })),
+  outputSchema: Schema.String,
   run: ({ city }) => Effect.succeed(`sunny in ${city}`),
 })
 

package/src/codec.test.ts

@@ -0,0 +1,78 @@
+import { fileBase64, fileUrl } from "@effect-uai/core/File"
+import { imageBytes } from "@effect-uai/core/Image"
+import * as Items from "@effect-uai/core/Items"
+import { Option, Result } from "effect"
+import { describe, expect, it } from "vitest"
+import { buildRequestBody } from "./codec.js"
+
+const toolResultFor = (output: Items.ToolCallOutput) => {
+  const body = Result.getOrThrow(
+    buildRequestBody({
+      model: "claude-sonnet-4-5",
+      history: [
+        Items.userText("go"),
+        { type: "function_call", call_id: "c1", name: "shot", arguments: "{}" },
+        output,
+      ],
+      maxTokens: 1024,
+      temperature: Option.none(),
+      topP: Option.none(),
+      topK: Option.none(),
+      stopSequences: Option.none(),
+      thinking: Option.none(),
+      tools: Option.none(),
+      toolChoice: Option.none(),
+      userId: Option.none(),
+      outputConfig: Option.none(),
+      cacheControl: Option.none(),
+    }),
+  )
+  return body.messages.at(-1)?.content
+}
+
+const outputOf = (output: Items.ToolCallOutput["output"], isError?: boolean) =>
+  toolResultFor({
+    type: "function_call_output",
+    call_id: "c1",
+    output,
+    ...(isError !== undefined && { isError }),
+  })
+
+describe("tool_result", () => {
+  it("sends text and JSON as one string and flags failures with is_error", () => {
+    expect(outputOf([Items.json({ _tag: "CityNotFound", city: "Atlantis" })], true)).toEqual([
+      {
+        type: "tool_result",
+        tool_use_id: "c1",
+        content: '{"_tag":"CityNotFound","city":"Atlantis"}',
+        is_error: true,
+      },
+    ])
+  })
+
+  it("sends media as image and document blocks, the filename as the document title", () => {
+    expect(
+      outputOf([
+        Items.text("Home"),
+        Items.image(imageBytes(new Uint8Array([1, 2, 3]), "image/png")),
+        Items.file(fileBase64("JVBE", "application/pdf"), "report.pdf"),
+        Items.file(fileUrl("https://x/a.pdf")),
+      ]),
+    ).toEqual([
+      {
+        type: "tool_result",
+        tool_use_id: "c1",
+        content: [
+          { type: "text", text: "Home" },
+          { type: "image", source: { type: "base64", media_type: "image/png", data: "AQID" } },
+          {
+            type: "document",
+            source: { type: "base64", media_type: "application/pdf", data: "JVBE" },
+            title: "report.pdf",
+          },
+          { type: "document", source: { type: "url", url: "https://x/a.pdf" } },
+        ],
+      },
+    ])
+  })
+})

package/src/codec.ts

@@ -1,6 +1,8 @@
-import { Array as Arr, Encoding, Match, Option, Order, Result, Schema, pipe } from "effect"
+import { Array as Arr, Match, Option, Order, Result, Schema, pipe } from "effect"
+import { Base64 } from "effect/encoding"
 import * as Items from "@effect-uai/core/Items"
 import { JsonParseError } from "@effect-uai/core/JSONL"
+import * as ToolOutput from "@effect-uai/core/ToolOutput"
 import type { Turn } from "@effect-uai/core/Turn"
 
 // ---------------------------------------------------------------------------
@@ -59,9 +61,20 @@ type RequestTextContent = {
 type RequestToolResultContent = {
   readonly type: "tool_result"
   readonly tool_use_id: string
-  readonly content: string
+  readonly content: string | ReadonlyArray<RequestToolResultBlock>
+  readonly is_error?: boolean
 }
 
+type RequestDocumentContent = {
+  readonly type: "document"
+  readonly source:
+    | { readonly type: "url"; readonly url: string }
+    | { readonly type: "base64"; readonly media_type: string; readonly data: string }
+  readonly title?: string
+}
+
+type RequestToolResultBlock = RequestTextContent | RequestImageContent | RequestDocumentContent
+
 type RequestToolUseContent = {
   readonly type: "tool_use"
   readonly id: string
@@ -129,11 +142,50 @@ const imageSourceToWire = Match.type<Items.InputImage["source"]>().pipe(
   Match.tag("bytes", (s): RequestImageContent["source"] => ({
     type: "base64",
     media_type: s.mimeType,
-    data: Encoding.encodeBase64(s.bytes),
+    data: Base64.encode(s.bytes),
+  })),
+  Match.exhaustive,
+)
+
+const fileSourceToWire = Match.type<Items.InputFile["source"]>().pipe(
+  Match.tag("url", (s): RequestDocumentContent["source"] => ({ type: "url", url: s.url })),
+  Match.tag("base64", (s): RequestDocumentContent["source"] => ({
+    type: "base64",
+    media_type: s.mimeType,
+    data: s.base64,
+  })),
+  Match.tag("bytes", (s): RequestDocumentContent["source"] => ({
+    type: "base64",
+    media_type: s.mimeType,
+    data: Base64.encode(s.bytes),
   })),
   Match.exhaustive,
 )
 
+const toolResultBlock = Match.type<Items.ToolOutputContent>().pipe(
+  Match.discriminatorsExhaustive("type")({
+    input_text: (p): RequestToolResultBlock => ({ type: "text", text: ToolOutput.partText(p) }),
+    input_json: (p): RequestToolResultBlock => ({ type: "text", text: ToolOutput.partText(p) }),
+    input_image: (p): RequestToolResultBlock => ({
+      type: "image",
+      source: imageSourceToWire(p.source),
+    }),
+    input_file: (p): RequestToolResultBlock => ({
+      type: "document",
+      source: fileSourceToWire(p.source),
+      ...(p.filename !== undefined && { title: p.filename }),
+    }),
+  }),
+)
+
+// Text and JSON only: one string. With media: image and document blocks.
+const toolResult = (o: Items.ToolCallOutput): RequestToolResultContent => ({
+  type: "tool_result",
+  tool_use_id: o.call_id,
+  content: Option.getOrElse(ToolOutput.text(o.output), () => o.output.map(toolResultBlock)),
+  ...(o.isError === true && { is_error: true }),
+})
+
 const userContentBlock = (
   block: Items.ContentBlock,
 ): Result.Result<RequestUserContentBlock, void> =>
@@ -178,9 +230,7 @@ const itemToUserBlocks = (item: Items.HistoryItem): ReadonlyArray<RequestUserCon
       message: (m): ReadonlyArray<RequestUserContentBlock> =>
         m.role === "user" ? pipe(m.content, Arr.filterMap(userContentBlock)) : [],
       function_call: (): ReadonlyArray<RequestUserContentBlock> => [],
-      function_call_output: (o): ReadonlyArray<RequestUserContentBlock> => [
-        { type: "tool_result", tool_use_id: o.call_id, content: o.output },
-      ],
+      function_call_output: (o): ReadonlyArray<RequestUserContentBlock> => [toolResult(o)],
       reasoning: (): ReadonlyArray<RequestUserContentBlock> => [],
     }),
   )