@llm4ts/core 2.54.1 → 3.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llm4ts/core",
-  "version": "2.54.1",
-  "description": "Effect-native LLM contracts, providers, tools, evaluation, and observability",
+  "version": "3.1.0",
+  "description": "Effect-native LLM contracts, providers, evaluation, and observability",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -22,8 +22,6 @@
     "./Connector": "./dist/Connector.js",
     "./ConnectorConfig": "./dist/ConnectorConfig.js",
     "./ConnectorRegistry": "./dist/ConnectorRegistry.js",
-    "./ContextManagement": "./dist/ContextManagement.js",
-    "./Conversation": "./dist/Conversation.js",
     "./Errors": "./dist/Errors.js",
     "./eval/Checks": "./dist/eval/Checks.js",
     "./eval/Eval": "./dist/eval/Eval.js",
@@ -39,12 +37,8 @@
     "./LabelScoring": "./dist/LabelScoring.js",
     "./LlmService": "./dist/LlmService.js",
     "./Models": "./dist/Models.js",
-    "./observability/Metrics": "./dist/observability/Metrics.js",
-    "./observability/MeteredLlmService": "./dist/observability/MeteredLlmService.js",
     "./observability/Redaction": "./dist/observability/Redaction.js",
     "./observability/StreamRecorder": "./dist/observability/StreamRecorder.js",
-    "./observability/StructuredLogger": "./dist/observability/StructuredLogger.js",
-    "./observability/Tracing": "./dist/observability/Tracing.js",
     "./ProcessExecutor": "./dist/ProcessExecutor.js",
     "./providers/AnthropicModels": "./dist/providers/AnthropicModels.js",
     "./providers/AnthropicProvider": "./dist/providers/AnthropicProvider.js",
@@ -71,16 +65,10 @@
     "./providers/OpenCodeCliConnector": "./dist/providers/OpenCodeCliConnector.js",
     "./providers/OllamaModels": "./dist/providers/OllamaModels.js",
     "./providers/OllamaProvider": "./dist/providers/OllamaProvider.js",
-    "./providers/OpenCodeModels": "./dist/providers/OpenCodeModels.js",
-    "./providers/OpenCodeProvider": "./dist/providers/OpenCodeProvider.js",
     "./providers/PiConnector": "./dist/providers/PiConnector.js",
-    "./RateLimiter": "./dist/RateLimiter.js",
     "./Streaming": "./dist/Streaming.js",
     "./StructuredOutput": "./dist/StructuredOutput.js",
     "./TemporaryFiles": "./dist/TemporaryFiles.js",
-    "./tools/Tool": "./dist/tools/Tool.js",
-    "./tools/ToolCallingExecutor": "./dist/tools/ToolCallingExecutor.js",
-    "./tools/ToolRegistry": "./dist/tools/ToolRegistry.js",
     "./UsageLimits": "./dist/UsageLimits.js",
     "./package.json": "./package.json"
   },

package/src/Capability.ts

@@ -71,9 +71,6 @@ const levelRank = (level: GrantLevel): number => {
 const minLevel = (first: GrantLevel, second: GrantLevel): GrantLevel =>
   levelRank(first) <= levelRank(second) ? first : second
 
-const maxLevel = (first: GrantLevel, second: GrantLevel): GrantLevel =>
-  levelRank(first) >= levelRank(second) ? first : second
-
 export class ExecDenied extends Schema.TaggedClass<ExecDenied>()("Denied", {}) {}
 export class ExecAllow extends Schema.TaggedClass<ExecAllow>()("Allow", {
   commands: Schema.ReadonlySet(Schema.String)
@@ -104,19 +101,6 @@ const intersectExec = (first: ExecGrant, second: ExecGrant): ExecGrant => {
   return allowExec([...first.commands].filter((command) => second.commands.has(command)))
 }
 
-const unionExec = (first: ExecGrant, second: ExecGrant): ExecGrant => {
-  if (first._tag === "All" || second._tag === "All") {
-    return ExecGrants.All
-  }
-  if (first._tag === "Denied") {
-    return second
-  }
-  if (second._tag === "Denied") {
-    return first
-  }
-  return allowExec(new Set([...first.commands, ...second.commands]))
-}
-
 export class Grants extends Schema.Class<Grants>("Grants")({
   git: GrantLevel,
   gh: GrantLevel,
@@ -164,18 +148,6 @@ export const intersectGrants = (first: Grants, second: Grants): Grants =>
     declassify: first.declassify && second.declassify
   })
 
-export const unionGrants = (first: Grants, second: Grants): Grants =>
-  new Grants({
-    git: maxLevel(first.git, second.git),
-    gh: maxLevel(first.gh, second.gh),
-    ado: maxLevel(first.ado, second.ado),
-    basecamp: maxLevel(first.basecamp, second.basecamp),
-    exec: unionExec(first.exec, second.exec),
-    coder: first.coder || second.coder,
-    reasoning: first.reasoning || second.reasoning,
-    declassify: first.declassify || second.declassify
-  })
-
 const execAllows = (grant: ExecGrant, command: string): boolean => {
   switch (grant._tag) {
     case "Denied":
@@ -230,25 +202,3 @@ export const restricted =
     Effect.flatMap(CurrentGrants, (current) =>
       Effect.provideService(effect, CurrentGrants, intersectGrants(current, grants))
     )
-
-export class CapabilityDenied extends Schema.TaggedError<CapabilityDenied>()("CapabilityDenied", {
-  required: Schema.Array(Capability),
-  granted: Grants
-}) {
-  get message(): string {
-    const names = this.required.map((capability) =>
-      capability._tag === "Exec" ? `Exec(${capability.command})` : capability._tag
-    )
-    return `missing required capabilities: ${names.join(", ")}`
-  }
-}
-
-export const requireCapabilities =
-  (required: ReadonlyArray<Capability>) =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | CapabilityDenied, R> =>
-    Effect.flatMap(CurrentGrants, (granted): Effect.Effect<A, E | CapabilityDenied, R> => {
-      const missing = required.filter((capability) => !allows(granted, capability))
-      return missing.length === 0
-        ? effect
-        : Effect.fail(new CapabilityDenied({ required: missing, granted }))
-    })

package/src/Connector.ts

@@ -4,7 +4,7 @@ import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import type * as Stream from "effect/Stream"
 import { CliSandbox } from "./ConnectorConfig.ts"
-import { InvalidRequestError, type LlmError } from "./Errors.ts"
+import type { LlmError } from "./Errors.ts"
 import { verbalizedScoreLabels } from "./LabelScoring.ts"
 import type { LlmServiceShape, StructuredResult } from "./LlmService.ts"
 import {
@@ -16,9 +16,7 @@ import {
   type InteractionSupport,
   type JsonSchema,
   type LlmChunk,
-  type Message,
-  type ToolCallResponse,
-  type ToolDefinition
+  type Message
 } from "./Models.ts"
 import type { ProcessExecutorShape, ProcessResult } from "./ProcessExecutor.ts"
 import { parseFromText, withSchemaHint } from "./StructuredOutput.ts"
@@ -77,10 +75,6 @@ export interface ApiConnectorPrimitives {
   readonly executeStreamWithHistory: (
     messages: ReadonlyArray<Message>
   ) => Stream.Stream<LlmChunk, LlmError>
-  readonly executeWithTools: (
-    prompt: string,
-    tools: ReadonlyArray<ToolDefinition>
-  ) => Effect.Effect<ToolCallResponse, LlmError>
   readonly executeStructuredWithUsage: <A, E, RD, RE>(
     prompt: string,
     schema: Schema.ConstraintCodec<A, E, RD, RE>,
@@ -204,17 +198,6 @@ export interface CliConnectorPrimitives {
   readonly capabilities?: ConnectorCapabilities
 }
 
-const unsupportedTools = (
-  id: ConnectorId,
-  _prompt: string,
-  _tools: ReadonlyArray<ToolDefinition>
-): Effect.Effect<ToolCallResponse, LlmError> =>
-  Effect.fail(
-    InvalidRequestError.make({
-      message: `CLI connector ${id.value} does not support tool calling`
-    })
-  )
-
 export const makeCliConnector = (primitives: CliConnectorPrimitives): CliConnectorShape => {
   const executeStructured = <A, E, RD, RE>(
     prompt: string,
@@ -258,7 +241,6 @@ export const makeCliConnector = (primitives: CliConnectorPrimitives): CliConnect
     isAvailable,
     executeStream: primitives.completeStream,
     executeStreamWithHistory: (messages) => primitives.completeStream(flattenHistory(messages)),
-    executeWithTools: (prompt, tools) => unsupportedTools(primitives.id, prompt, tools),
     executeStructured,
     executeStructuredWithUsage,
     scoreLabels: verbalizedScoreLabels(executeStructuredWithUsage)

package/src/ConnectorRegistry.ts

@@ -170,18 +170,3 @@ export const makeConnectorRegistry = (
     healthCheckAll
   }
 }
-
-export const resolveConnector = (
-  config: ConnectorConfig
-): Effect.Effect<ConnectorShape, LlmError, ConnectorRegistry> =>
-  Effect.flatMap(ConnectorRegistry, (registry) => registry.resolve(config))
-
-export const resolveApiConnector = (
-  config: ApiConnectorConfig
-): Effect.Effect<ApiConnectorShape, LlmError, ConnectorRegistry> =>
-  Effect.flatMap(ConnectorRegistry, (registry) => registry.resolveApi(config))
-
-export const resolveCliConnector = (
-  config: CliConnectorConfig
-): Effect.Effect<CliConnectorShape, LlmError, ConnectorRegistry> =>
-  Effect.flatMap(ConnectorRegistry, (registry) => registry.resolveCli(config))

package/src/HttpClient.ts

@@ -185,18 +185,3 @@ export const makeRecordingHttpClient = Effect.fn("@llm4ts/core/HttpClient.makeRe
     }
   }
 )
-
-export const httpGet = (
-  url: string,
-  headers: Readonly<Record<string, string>> = emptyHeaders,
-  timeout: Duration.Duration
-): Effect.Effect<string, LlmError, HttpClient> =>
-  Effect.flatMap(HttpClient, (client) => client.get(url, headers, timeout))
-
-export const httpPostJson = (
-  url: string,
-  body: string,
-  headers: Readonly<Record<string, string>> = emptyHeaders,
-  timeout: Duration.Duration
-): Effect.Effect<string, LlmError, HttpClient> =>
-  Effect.flatMap(HttpClient, (client) => client.postJson(url, body, headers, timeout))

package/src/LlmService.ts

@@ -4,15 +4,7 @@ import type * as Stream from "effect/Stream"
 import type * as Schema from "effect/Schema"
 import type * as Result from "effect/Result"
 import type { LlmError, ParseError } from "./Errors.ts"
-import type {
-  JsonSchema,
-  LabelDistribution,
-  LlmChunk,
-  Message,
-  TokenUsage,
-  ToolCallResponse,
-  ToolDefinition
-} from "./Models.ts"
+import type { JsonSchema, LabelDistribution, LlmChunk, Message, TokenUsage } from "./Models.ts"
 
 export type StructuredResult<A> = readonly [
   value: A,
@@ -25,10 +17,6 @@ export interface LlmServiceShape {
   readonly executeStreamWithHistory: (
     messages: ReadonlyArray<Message>
   ) => Stream.Stream<LlmChunk, LlmError>
-  readonly executeWithTools: (
-    prompt: string,
-    tools: ReadonlyArray<ToolDefinition>
-  ) => Effect.Effect<ToolCallResponse, LlmError>
   readonly executeStructured: <A, E, RD, RE>(
     prompt: string,
     schema: Schema.ConstraintCodec<A, E, RD, RE>,

package/src/Models.ts

@@ -223,31 +223,9 @@ export const withConfigDefaults = (config: LlmConfig): LlmConfig => {
   return baseUrl === undefined ? config : new LlmConfig({ ...config, baseUrl })
 }
 
-export class ToolCall extends Schema.Class<ToolCall>("ToolCall")({
-  id: Schema.String,
-  name: Schema.String,
-  arguments: Schema.String
-}) {}
-
-const emptyToolCalls: ReadonlyArray<ToolCall> = Object.freeze([])
-
-export class ToolCallResponse extends Schema.Class<ToolCallResponse>("ToolCallResponse")({
-  content: Schema.optionalKey(Schema.String),
-  toolCalls: Schema.Array(ToolCall).pipe(
-    Schema.withConstructorDefault(Effect.succeed(emptyToolCalls))
-  ),
-  finishReason: Schema.String
-}) {}
-
 export const JsonSchema = Schema.Record(Schema.String, Schema.Json)
 export type JsonSchema = typeof JsonSchema.Type
 
-export class ToolDefinition extends Schema.Class<ToolDefinition>("ToolDefinition")({
-  name: Schema.String,
-  description: Schema.String,
-  parameters: JsonSchema
-}) {}
-
 export const Availability = Schema.Literals(["Healthy", "Degraded", "Unhealthy", "Unknown"])
 export type Availability = typeof Availability.Type
 

package/src/Streaming.ts

@@ -1,11 +1,10 @@
 import * as Clock from "effect/Clock"
-import * as Deferred from "effect/Deferred"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
-import { ParseError, TimeoutError, type LlmError } from "./Errors.ts"
-import { LlmChunk, LlmResponse, StreamProgress } from "./Models.ts"
+import { TimeoutError, type LlmError } from "./Errors.ts"
+import type { LlmChunk } from "./Models.ts"
+import { LlmResponse, StreamProgress } from "./Models.ts"
 
 const appendChunk = (response: LlmResponse, chunk: LlmChunk): LlmResponse => {
   const usage = chunk.usage ?? response.usage
@@ -65,25 +64,6 @@ export const trackProgress = <R, R2>(
     )
   )
 
-export const parsePartialJson = <A, E, RD, RE, R>(
-  stream: Stream.Stream<string, LlmError, R>,
-  schema: Schema.ConstraintCodec<A, E, RD, RE>
-): Stream.Stream<A, LlmError, R | RD> =>
-  stream.pipe(
-    Stream.mapAccumEffect(
-      () => "",
-      (accumulated, chunk) => {
-        const next = accumulated + chunk
-        return Schema.decodeUnknownEffect(Schema.fromJsonString(schema))(next).pipe(
-          Effect.match({
-            onFailure: () => [next, []] as const,
-            onSuccess: (value) => [next, [value]] as const
-          })
-        )
-      }
-    )
-  )
-
 const timeoutError = (duration: Duration.Input): TimeoutError =>
   TimeoutError.make({ duration: Duration.fromInputUnsafe(duration) })
 
@@ -95,79 +75,3 @@ export const withTimeout = <R>(
     duration,
     orElse: () => Stream.fail(timeoutError(duration))
   })
-
-export const cancellable = <R>(
-  stream: Stream.Stream<LlmChunk, LlmError, R>
-): Effect.Effect<
-  readonly [stream: Stream.Stream<LlmChunk, LlmError, R>, cancel: Effect.Effect<void>]
-> =>
-  Effect.map(Deferred.make<void>(), (deferred) => [
-    Stream.interruptWhen(stream, Deferred.await(deferred)),
-    Deferred.succeed(deferred, undefined).pipe(Effect.asVoid)
-  ])
-
-export const withSnapshots = <R>(
-  stream: Stream.Stream<LlmChunk, LlmError, R>,
-  snapshotInterval: Duration.Input = "500 millis"
-): Stream.Stream<string, LlmError, R> =>
-  stream.pipe(
-    Stream.scan(
-      () => "",
-      (content, chunk) => content + chunk.delta
-    ),
-    Stream.debounce(snapshotInterval)
-  )
-
-const chunkJson = Schema.fromJsonString(Schema.toCodecJson(LlmChunk))
-
-export const toSSE = <R>(
-  stream: Stream.Stream<LlmChunk, LlmError, R>
-): Stream.Stream<string, LlmError, R> =>
-  Stream.mapEffect(stream, (chunk) =>
-    Schema.encodeEffect(chunkJson)(chunk).pipe(
-      Effect.map((encoded) => `data: ${encoded}\n\n`),
-      Effect.mapError((error) =>
-        ParseError.make({
-          message: `Failed to encode SSE chunk: ${String(error)}`,
-          raw: chunk.delta
-        })
-      )
-    )
-  )
-
-export const fromSSE = <R>(
-  stream: Stream.Stream<string, LlmError, R>
-): Stream.Stream<LlmChunk, LlmError, R> =>
-  stream.pipe(
-    Stream.filter((line) => line.startsWith("data: ")),
-    Stream.map((line) => line.slice("data: ".length).trim()),
-    Stream.filter((payload) => payload.length > 0 && payload !== "[DONE]"),
-    Stream.mapEffect((payload) =>
-      Schema.decodeUnknownEffect(chunkJson)(payload).pipe(
-        Effect.mapError((error) =>
-          ParseError.make({
-            message: `Failed to parse SSE chunk: ${String(error)}`,
-            raw: payload
-          })
-        )
-      )
-    )
-  )
-
-export const withHeartbeat = <R>(
-  stream: Stream.Stream<LlmChunk, LlmError, R>,
-  heartbeatTimeout: Duration.Input
-): Stream.Stream<LlmChunk, LlmError, R> =>
-  withTimeout(stream, heartbeatTimeout).pipe(Stream.rechunk(1))
-
-export const parallelStream = <A, B, R>(
-  inputs: Iterable<A>,
-  parallelism: number,
-  f: (input: A) => Stream.Stream<B, LlmError, R>
-): Stream.Stream<B, LlmError, R> =>
-  Stream.fromIterable(inputs).pipe(
-    Stream.mapEffect((input) => Stream.runCollect(f(input)), {
-      concurrency: parallelism
-    }),
-    Stream.flatMap(Stream.fromIterable)
-  )

package/src/providers/AnthropicModels.ts

@@ -1,5 +1,4 @@
 import * as Schema from "effect/Schema"
-import { JsonSchema } from "../Models.ts"
 
 /** A prompt-cache breakpoint (ADR 0029): the prefix up to this block is cached. */
 export class AnthropicCacheControl extends Schema.Class<AnthropicCacheControl>(
@@ -58,52 +57,6 @@ export class AnthropicResponse extends Schema.Class<AnthropicResponse>("Anthropi
   stop_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
 }) {}
 
-export class AnthropicToolInputSchema extends Schema.Class<AnthropicToolInputSchema>(
-  "AnthropicToolInputSchema"
-)({
-  type: Schema.String,
-  properties: JsonSchema,
-  required: Schema.optionalKey(Schema.Array(Schema.String))
-}) {}
-
-export class AnthropicTool extends Schema.Class<AnthropicTool>("AnthropicTool")({
-  name: Schema.String,
-  description: Schema.String,
-  input_schema: AnthropicToolInputSchema
-}) {}
-
-export class AnthropicContentBlockFull extends Schema.Class<AnthropicContentBlockFull>(
-  "AnthropicContentBlockFull"
-)({
-  type: Schema.String,
-  text: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  id: Schema.optionalKey(Schema.String),
-  name: Schema.optionalKey(Schema.String),
-  input: Schema.optionalKey(Schema.Json)
-}) {}
-
-export class AnthropicRequestWithTools extends Schema.Class<AnthropicRequestWithTools>(
-  "AnthropicRequestWithTools"
-)({
-  model: Schema.String,
-  max_tokens: Schema.Int,
-  messages: Schema.Array(AnthropicMessage),
-  tools: Schema.Array(AnthropicTool),
-  temperature: Schema.optionalKey(Schema.Number),
-  system: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(AnthropicTextBlock)])),
-  output_config: Schema.optionalKey(AnthropicOutputConfig)
-}) {}
-
-export class AnthropicResponseWithTools extends Schema.Class<AnthropicResponseWithTools>(
-  "AnthropicResponseWithTools"
-)({
-  id: Schema.optionalKey(Schema.String),
-  content: Schema.Array(AnthropicContentBlockFull),
-  model: Schema.optionalKey(Schema.String),
-  usage: Schema.optionalKey(AnthropicUsage),
-  stop_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
-}) {}
-
 export class AnthropicStreamChunkDelta extends Schema.Class<AnthropicStreamChunkDelta>(
   "AnthropicStreamChunkDelta"
 )({

package/src/providers/AnthropicProvider.ts

@@ -12,28 +12,20 @@ import {
   ConnectorIds,
   LlmChunk,
   TokenUsage,
-  ToolCall,
-  ToolCallResponse,
   type JsonSchema,
   type LlmConfig,
-  type Message,
-  type ToolDefinition
+  type Message
 } from "../Models.ts"
 import { collect } from "../Streaming.ts"
 import { parseFromText } from "../StructuredOutput.ts"
-import type { AnthropicContentBlockFull } from "./AnthropicModels.ts"
 import {
   AnthropicCacheControl,
   AnthropicMessage,
   AnthropicOutputConfig,
   AnthropicRequest,
-  AnthropicRequestWithTools,
   AnthropicResponse,
-  AnthropicResponseWithTools,
   AnthropicStreamChunk,
   AnthropicTextBlock,
-  AnthropicTool,
-  AnthropicToolInputSchema,
   AnthropicUsage
 } from "./AnthropicModels.ts"
 
@@ -54,16 +46,6 @@ const decodeResponse = (raw: string): Effect.Effect<AnthropicResponse, ParseErro
     )
   )
 
-const decodeToolResponse = (raw: string): Effect.Effect<AnthropicResponseWithTools, ParseError> =>
-  Schema.decodeUnknownEffect(Schema.fromJsonString(AnthropicResponseWithTools))(raw).pipe(
-    Effect.mapError((error) =>
-      ParseError.make({
-        message: `Failed to decode Anthropic tool response: ${String(error)}`,
-        raw
-      })
-    )
-  )
-
 const decodeStreamChunk = (raw: string): Effect.Effect<AnthropicStreamChunk, ParseError> =>
   Schema.decodeUnknownEffect(Schema.fromJsonString(AnthropicStreamChunk))(raw).pipe(
     Effect.mapError((error) =>
@@ -162,36 +144,6 @@ export const anthropicTokenUsage = (usage: AnthropicUsage): TokenUsage => {
   })
 }
 
-export const buildAnthropicToolRequest = (
-  config: LlmConfig,
-  prompt: string,
-  tools: ReadonlyArray<ToolDefinition>
-): AnthropicRequestWithTools =>
-  AnthropicRequestWithTools.make({
-    model: config.model,
-    max_tokens: config.maxTokens ?? 4096,
-    messages: [
-      AnthropicMessage.make({
-        role: "user",
-        content: prompt
-      })
-    ],
-    tools: tools.map((tool) =>
-      AnthropicTool.make({
-        name: tool.name,
-        description: tool.description,
-        input_schema: AnthropicToolInputSchema.make({
-          type: "object",
-          properties: tool.parameters
-        })
-      })
-    ),
-    ...(config.temperature === undefined ? {} : { temperature: config.temperature }),
-    ...(config.effort === undefined
-      ? {}
-      : { output_config: AnthropicOutputConfig.make({ effort: config.effort }) })
-  })
-
 const contentFromResponse = (
   response: AnthropicResponse,
   raw: string
@@ -207,8 +159,6 @@ const contentFromResponse = (
     : Effect.succeed(content)
 }
 
-const jsonString = (value: typeof Schema.Json.Type): string => JSON.stringify(value) ?? "{}"
-
 export const makeAnthropicProvider = (
   config: LlmConfig,
   httpClient: HttpClientShape
@@ -352,41 +302,6 @@ export const makeAnthropicProvider = (
       return result
     })
 
-  const executeWithTools = (
-    prompt: string,
-    tools: ReadonlyArray<ToolDefinition>
-  ): Effect.Effect<ToolCallResponse, LlmError> =>
-    Effect.gen(function* () {
-      const { apiKey, baseUrl } = yield* requiredConfig
-      const request = buildAnthropicToolRequest(config, prompt, tools)
-      const raw = yield* httpClient.postJson(
-        `${baseUrl}/messages`,
-        JSON.stringify(request),
-        authHeaders(apiKey),
-        config.timeout
-      )
-      const response = yield* decodeToolResponse(raw)
-      const toolCalls = response.content
-        .filter((block) => block.type === "tool_use")
-        .map((block) =>
-          ToolCall.make({
-            id: block.id ?? "",
-            name: block.name ?? "",
-            arguments: block.input === undefined ? "{}" : jsonString(block.input)
-          })
-        )
-      const content = response.content.find(
-        (block): block is AnthropicContentBlockFull =>
-          block.type === "text" && block.text !== undefined && block.text !== null
-      )?.text
-
-      return ToolCallResponse.make({
-        toolCalls,
-        finishReason: response.stop_reason ?? "stop",
-        ...(content === undefined || content === null ? {} : { content })
-      })
-    })
-
   const executeStream = (prompt: string): Stream.Stream<LlmChunk, LlmError> =>
     executeStreamRequest([
       AnthropicMessage.make({
@@ -409,7 +324,6 @@ export const makeAnthropicProvider = (
       const history = anthropicHistory(messages)
       return executeStreamRequest(history.messages, history.system)
     },
-    executeWithTools,
     executeStructuredWithUsage,
     isAvailable,
     capabilities: ConnectorCapabilities.make({ readOnlyEnforcement: "enforced", effort: "mapped" })