@effect-uai/anthropic 0.2.0 → 0.4.0

package/dist/streamEvents.d.mts

@@ -0,0 +1,196 @@
+import { Accumulator } from "./codec.mjs";
+import { Schema } from "effect";
+
+//#region src/streamEvents.d.ts
+declare namespace streamEvents_d_exports {
+  export { KnownProviderEvent, ProviderEvent, applyEvent, isErrorEvent, isInputJsonDeltaEvent, isMessageStop, isTextDeltaEvent, isThinkingDeltaEvent, isToolUseStartEvent };
+}
+/**
+ * Internal: union of variants we actually know how to decode from the wire.
+ * Used as the decode target; failures are caught and re-emitted as `Unknown`.
+ */
+declare const KnownProviderEvent: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"message_start">;
+  readonly message: Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly usage: Schema.optional<Schema.Struct<{
+      readonly input_tokens: Schema.optional<Schema.Number>;
+      readonly output_tokens: Schema.optional<Schema.Number>;
+      readonly cache_creation_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+      readonly cache_read_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    }>>;
+  }>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"content_block_start">;
+  readonly index: Schema.Number;
+  readonly content_block: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool_use">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"thinking">;
+    readonly thinking: Schema.String;
+    readonly signature: Schema.optional<Schema.String>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"redacted_thinking">;
+    readonly data: Schema.String;
+  }>]>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"content_block_delta">;
+  readonly index: Schema.Number;
+  readonly delta: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text_delta">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_json_delta">;
+    readonly partial_json: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"thinking_delta">;
+    readonly thinking: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"signature_delta">;
+    readonly signature: Schema.String;
+  }>]>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"content_block_stop">;
+  readonly index: Schema.Number;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"message_delta">;
+  readonly delta: Schema.Struct<{
+    readonly stop_reason: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly stop_sequence: Schema.optional<Schema.NullOr<Schema.String>>;
+  }>;
+  readonly usage: Schema.optional<Schema.Struct<{
+    readonly input_tokens: Schema.optional<Schema.Number>;
+    readonly output_tokens: Schema.optional<Schema.Number>;
+    readonly cache_creation_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly cache_read_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+  }>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"message_stop">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"ping">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"error">;
+  readonly error: Schema.optional<Schema.Struct<{
+    readonly type: Schema.optional<Schema.String>;
+    readonly message: Schema.optional<Schema.String>;
+  }>>;
+}>]>;
+/**
+ * Public: every event the native stream can emit. Discriminated on `type`.
+ * The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`
+ * cannot silently miss a wire event we didn't model.
+ */
+declare const ProviderEvent: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"message_start">;
+  readonly message: Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly usage: Schema.optional<Schema.Struct<{
+      readonly input_tokens: Schema.optional<Schema.Number>;
+      readonly output_tokens: Schema.optional<Schema.Number>;
+      readonly cache_creation_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+      readonly cache_read_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    }>>;
+  }>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"content_block_start">;
+  readonly index: Schema.Number;
+  readonly content_block: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool_use">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"thinking">;
+    readonly thinking: Schema.String;
+    readonly signature: Schema.optional<Schema.String>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"redacted_thinking">;
+    readonly data: Schema.String;
+  }>]>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"content_block_delta">;
+  readonly index: Schema.Number;
+  readonly delta: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text_delta">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_json_delta">;
+    readonly partial_json: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"thinking_delta">;
+    readonly thinking: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"signature_delta">;
+    readonly signature: Schema.String;
+  }>]>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"content_block_stop">;
+  readonly index: Schema.Number;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"message_delta">;
+  readonly delta: Schema.Struct<{
+    readonly stop_reason: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly stop_sequence: Schema.optional<Schema.NullOr<Schema.String>>;
+  }>;
+  readonly usage: Schema.optional<Schema.Struct<{
+    readonly input_tokens: Schema.optional<Schema.Number>;
+    readonly output_tokens: Schema.optional<Schema.Number>;
+    readonly cache_creation_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly cache_read_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+  }>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"message_stop">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"ping">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"error">;
+  readonly error: Schema.optional<Schema.Struct<{
+    readonly type: Schema.optional<Schema.String>;
+    readonly message: Schema.optional<Schema.String>;
+  }>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"_unknown">;
+  readonly raw: Schema.Unknown;
+}>]>;
+type ProviderEvent = typeof ProviderEvent.Type;
+declare const applyEvent: (acc: Accumulator, event: ProviderEvent) => Accumulator;
+declare const isTextDeltaEvent: (event: ProviderEvent) => event is Extract<ProviderEvent, {
+  type: "content_block_delta";
+  delta: {
+    type: "text_delta";
+  };
+}>;
+declare const isThinkingDeltaEvent: (event: ProviderEvent) => event is Extract<ProviderEvent, {
+  type: "content_block_delta";
+  delta: {
+    type: "thinking_delta";
+  };
+}>;
+declare const isInputJsonDeltaEvent: (event: ProviderEvent) => event is Extract<ProviderEvent, {
+  type: "content_block_delta";
+  delta: {
+    type: "input_json_delta";
+  };
+}>;
+declare const isToolUseStartEvent: (event: ProviderEvent) => event is Extract<ProviderEvent, {
+  type: "content_block_start";
+  content_block: {
+    type: "tool_use";
+  };
+}>;
+declare const isMessageStop: (event: ProviderEvent) => boolean;
+declare const isErrorEvent: (event: ProviderEvent) => event is Extract<ProviderEvent, {
+  type: "error";
+}>;
+//#endregion
+export { KnownProviderEvent, ProviderEvent, applyEvent, isErrorEvent, isInputJsonDeltaEvent, isMessageStop, isTextDeltaEvent, isThinkingDeltaEvent, isToolUseStartEvent, streamEvents_d_exports as t };
+//# sourceMappingURL=streamEvents.d.mts.map

package/dist/streamEvents.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamEvents.d.mts","names":[],"sources":["../src/streamEvents.ts"],"mappings":";;;;;;;;;;;cAoHa,kBAAA,EAAkB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgBlB,aAAA,EAAa,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWd,aAAA,UAAuB,aAAA,CAAc,IAAA;AAAA,cAWpC,UAAA,GAAc,GAAA,EAAK,WAAA,EAAa,KAAA,EAAO,aAAA,KAAgB,WAAA;AAAA,cAoCvD,gBAAA,GACX,KAAA,EAAO,aAAA,KACN,KAAA,IAAS,OAAA,CACV,aAAA;EACE,IAAA;EAA6B,KAAA;IAAS,IAAA;EAAA;AAAA;AAAA,cAG7B,oBAAA,GACX,KAAA,EAAO,aAAA,KACN,KAAA,IAAS,OAAA,CACV,aAAA;EACE,IAAA;EAA6B,KAAA;IAAS,IAAA;EAAA;AAAA;AAAA,cAG7B,qBAAA,GACX,KAAA,EAAO,aAAA,KACN,KAAA,IAAS,OAAA,CACV,aAAA;EACE,IAAA;EAA6B,KAAA;IAAS,IAAA;EAAA;AAAA;AAAA,cAG7B,mBAAA,GACX,KAAA,EAAO,aAAA,KACN,KAAA,IAAS,OAAA,CACV,aAAA;EACE,IAAA;EAA6B,aAAA;IAAiB,IAAA;EAAA;AAAA;AAAA,cAGrC,aAAA,GAAiB,KAAA,EAAO,aAAA;AAAA,cAExB,YAAA,GACX,KAAA,EAAO,aAAA,KACN,KAAA,IAAS,OAAA,CAAQ,aAAA;EAAiB,IAAA;AAAA"}

package/dist/streamEvents.mjs

@@ -0,0 +1,152 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { WireContentBlock, appendInputJsonDelta, appendSignatureDelta, appendTextDelta, appendThinkingDelta, mergeUsage, setStopReason, startBlock } from "./codec.mjs";
+import { Match, Schema } from "effect";
+//#region src/streamEvents.ts
+var streamEvents_exports = /* @__PURE__ */ __exportAll({
+	KnownProviderEvent: () => KnownProviderEvent,
+	ProviderEvent: () => ProviderEvent,
+	applyEvent: () => applyEvent,
+	isErrorEvent: () => isErrorEvent,
+	isInputJsonDeltaEvent: () => isInputJsonDeltaEvent,
+	isMessageStop: () => isMessageStop,
+	isTextDeltaEvent: () => isTextDeltaEvent,
+	isThinkingDeltaEvent: () => isThinkingDeltaEvent,
+	isToolUseStartEvent: () => isToolUseStartEvent
+});
+const WireMessageStartUsage = Schema.Struct({
+	input_tokens: Schema.optional(Schema.Number),
+	output_tokens: Schema.optional(Schema.Number),
+	cache_creation_input_tokens: Schema.optional(Schema.NullOr(Schema.Number)),
+	cache_read_input_tokens: Schema.optional(Schema.NullOr(Schema.Number))
+});
+const MessageStart = Schema.Struct({
+	type: Schema.Literal("message_start"),
+	message: Schema.Struct({
+		id: Schema.optional(Schema.String),
+		usage: Schema.optional(WireMessageStartUsage)
+	})
+});
+const ContentBlockStart = Schema.Struct({
+	type: Schema.Literal("content_block_start"),
+	index: Schema.Number,
+	content_block: WireContentBlock
+});
+const TextDelta = Schema.Struct({
+	type: Schema.Literal("text_delta"),
+	text: Schema.String
+});
+const InputJsonDelta = Schema.Struct({
+	type: Schema.Literal("input_json_delta"),
+	partial_json: Schema.String
+});
+const ThinkingDelta = Schema.Struct({
+	type: Schema.Literal("thinking_delta"),
+	thinking: Schema.String
+});
+const SignatureDelta = Schema.Struct({
+	type: Schema.Literal("signature_delta"),
+	signature: Schema.String
+});
+const Delta = Schema.Union([
+	TextDelta,
+	InputJsonDelta,
+	ThinkingDelta,
+	SignatureDelta
+]);
+const ContentBlockDelta = Schema.Struct({
+	type: Schema.Literal("content_block_delta"),
+	index: Schema.Number,
+	delta: Delta
+});
+const ContentBlockStop = Schema.Struct({
+	type: Schema.Literal("content_block_stop"),
+	index: Schema.Number
+});
+const MessageDelta = Schema.Struct({
+	type: Schema.Literal("message_delta"),
+	delta: Schema.Struct({
+		stop_reason: Schema.optional(Schema.NullOr(Schema.String)),
+		stop_sequence: Schema.optional(Schema.NullOr(Schema.String))
+	}),
+	usage: Schema.optional(WireMessageStartUsage)
+});
+const MessageStop = Schema.Struct({ type: Schema.Literal("message_stop") });
+const Ping = Schema.Struct({ type: Schema.Literal("ping") });
+const ErrorEvent = Schema.Struct({
+	type: Schema.Literal("error"),
+	error: Schema.optional(Schema.Struct({
+		type: Schema.optional(Schema.String),
+		message: Schema.optional(Schema.String)
+	}))
+});
+/**
+* Catch-all variant for wire events that fail to decode against any known
+* schema, plus events that fail to JSON-parse. The decoder never produces
+* this directly - it's synthesized by `sseEventToProviderEvent` when
+* `decodeKnown` fails.
+*/
+const Unknown = Schema.Struct({
+	type: Schema.Literal("_unknown"),
+	raw: Schema.Unknown
+});
+/**
+* Internal: union of variants we actually know how to decode from the wire.
+* Used as the decode target; failures are caught and re-emitted as `Unknown`.
+*/
+const KnownProviderEvent = Schema.Union([
+	MessageStart,
+	ContentBlockStart,
+	ContentBlockDelta,
+	ContentBlockStop,
+	MessageDelta,
+	MessageStop,
+	Ping,
+	ErrorEvent
+]);
+/**
+* Public: every event the native stream can emit. Discriminated on `type`.
+* The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`
+* cannot silently miss a wire event we didn't model.
+*/
+const ProviderEvent = Schema.Union([
+	MessageStart,
+	ContentBlockStart,
+	ContentBlockDelta,
+	ContentBlockStop,
+	MessageDelta,
+	MessageStop,
+	Ping,
+	ErrorEvent,
+	Unknown
+]);
+const mergeOptionalUsage = (acc, wire) => wire === void 0 ? acc : mergeUsage(acc, wire);
+const applyEvent = (acc, event) => Match.value(event).pipe(Match.discriminatorsExhaustive("type")({
+	message_start: (e) => mergeOptionalUsage(acc, e.message.usage),
+	content_block_start: (e) => startBlock(acc, e.index, e.content_block),
+	content_block_delta: (e) => Match.value(e.delta).pipe(Match.discriminatorsExhaustive("type")({
+		text_delta: (d) => appendTextDelta(acc, e.index, d.text),
+		input_json_delta: (d) => appendInputJsonDelta(acc, e.index, d.partial_json),
+		thinking_delta: (d) => appendThinkingDelta(acc, e.index, d.thinking),
+		signature_delta: (d) => appendSignatureDelta(acc, e.index, d.signature)
+	})),
+	content_block_stop: () => acc,
+	message_delta: (e) => {
+		const withUsage = mergeOptionalUsage(acc, e.usage);
+		const reason = e.delta.stop_reason;
+		return reason === void 0 || reason === null ? withUsage : setStopReason(withUsage, reason);
+	},
+	message_stop: () => acc,
+	ping: () => acc,
+	error: () => acc,
+	_unknown: () => acc
+}));
+const isTextDeltaEvent = (event) => event.type === "content_block_delta" && event.delta.type === "text_delta";
+const isThinkingDeltaEvent = (event) => event.type === "content_block_delta" && event.delta.type === "thinking_delta";
+const isInputJsonDeltaEvent = (event) => event.type === "content_block_delta" && event.delta.type === "input_json_delta";
+const isToolUseStartEvent = (event) => event.type === "content_block_start" && event.content_block.type === "tool_use";
+const isMessageStop = (event) => event.type === "message_stop";
+const isErrorEvent = (event) => event.type === "error";
+//#endregion
+export { KnownProviderEvent, ProviderEvent, applyEvent, isErrorEvent, isInputJsonDeltaEvent, isMessageStop, isTextDeltaEvent, isThinkingDeltaEvent, isToolUseStartEvent, streamEvents_exports as t };
+
+//# sourceMappingURL=streamEvents.mjs.map

package/dist/streamEvents.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamEvents.mjs","names":[],"sources":["../src/streamEvents.ts"],"sourcesContent":["import { Match, Schema } from \"effect\"\nimport {\n  type Accumulator,\n  WireContentBlock,\n  type WireUsage,\n  appendInputJsonDelta,\n  appendSignatureDelta,\n  appendTextDelta,\n  appendThinkingDelta,\n  mergeUsage,\n  setStopReason,\n  startBlock,\n} from \"./codec.js\"\n\n// ---------------------------------------------------------------------------\n// Wire schemas for the SSE events we map onto our `Accumulator`. Anthropic's\n// streaming protocol uses named SSE events; we match on the inner JSON\n// `type` field which mirrors the event name.\n// ---------------------------------------------------------------------------\n\nconst WireMessageStartUsage = Schema.Struct({\n  input_tokens: Schema.optional(Schema.Number),\n  output_tokens: Schema.optional(Schema.Number),\n  cache_creation_input_tokens: Schema.optional(Schema.NullOr(Schema.Number)),\n  cache_read_input_tokens: Schema.optional(Schema.NullOr(Schema.Number)),\n})\n\nconst MessageStart = Schema.Struct({\n  type: Schema.Literal(\"message_start\"),\n  message: Schema.Struct({\n    id: Schema.optional(Schema.String),\n    usage: Schema.optional(WireMessageStartUsage),\n  }),\n})\n\nconst ContentBlockStart = Schema.Struct({\n  type: Schema.Literal(\"content_block_start\"),\n  index: Schema.Number,\n  content_block: WireContentBlock,\n})\n\nconst TextDelta = Schema.Struct({\n  type: Schema.Literal(\"text_delta\"),\n  text: Schema.String,\n})\n\nconst InputJsonDelta = Schema.Struct({\n  type: Schema.Literal(\"input_json_delta\"),\n  partial_json: Schema.String,\n})\n\nconst ThinkingDelta = Schema.Struct({\n  type: Schema.Literal(\"thinking_delta\"),\n  thinking: Schema.String,\n})\n\nconst SignatureDelta = Schema.Struct({\n  type: Schema.Literal(\"signature_delta\"),\n  signature: Schema.String,\n})\n\nconst Delta = Schema.Union([TextDelta, InputJsonDelta, ThinkingDelta, SignatureDelta])\n\nconst ContentBlockDelta = Schema.Struct({\n  type: Schema.Literal(\"content_block_delta\"),\n  index: Schema.Number,\n  delta: Delta,\n})\n\nconst ContentBlockStop = Schema.Struct({\n  type: Schema.Literal(\"content_block_stop\"),\n  index: Schema.Number,\n})\n\nconst MessageDelta = Schema.Struct({\n  type: Schema.Literal(\"message_delta\"),\n  delta: Schema.Struct({\n    stop_reason: Schema.optional(Schema.NullOr(Schema.String)),\n    stop_sequence: Schema.optional(Schema.NullOr(Schema.String)),\n  }),\n  usage: Schema.optional(WireMessageStartUsage),\n})\n\nconst MessageStop = Schema.Struct({\n  type: Schema.Literal(\"message_stop\"),\n})\n\nconst Ping = Schema.Struct({\n  type: Schema.Literal(\"ping\"),\n})\n\nconst ErrorEvent = Schema.Struct({\n  type: Schema.Literal(\"error\"),\n  error: Schema.optional(\n    Schema.Struct({\n      type: Schema.optional(Schema.String),\n      message: Schema.optional(Schema.String),\n    }),\n  ),\n})\n\n/**\n * Catch-all variant for wire events that fail to decode against any known\n * schema, plus events that fail to JSON-parse. The decoder never produces\n * this directly - it's synthesized by `sseEventToProviderEvent` when\n * `decodeKnown` fails.\n */\nconst Unknown = Schema.Struct({\n  type: Schema.Literal(\"_unknown\"),\n  raw: Schema.Unknown,\n})\n\n/**\n * Internal: union of variants we actually know how to decode from the wire.\n * Used as the decode target; failures are caught and re-emitted as `Unknown`.\n */\nexport const KnownProviderEvent = Schema.Union([\n  MessageStart,\n  ContentBlockStart,\n  ContentBlockDelta,\n  ContentBlockStop,\n  MessageDelta,\n  MessageStop,\n  Ping,\n  ErrorEvent,\n])\n\n/**\n * Public: every event the native stream can emit. Discriminated on `type`.\n * The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`\n * cannot silently miss a wire event we didn't model.\n */\nexport const ProviderEvent = Schema.Union([\n  MessageStart,\n  ContentBlockStart,\n  ContentBlockDelta,\n  ContentBlockStop,\n  MessageDelta,\n  MessageStop,\n  Ping,\n  ErrorEvent,\n  Unknown,\n])\nexport type ProviderEvent = typeof ProviderEvent.Type\n\n// ---------------------------------------------------------------------------\n// Apply event → Accumulator. Pure: the mapping never fails. Caller wires\n// this into `Stream.mapAccum` and emits text/turn_complete deltas based on\n// the diff.\n// ---------------------------------------------------------------------------\n\nconst mergeOptionalUsage = (acc: Accumulator, wire: WireUsage | undefined): Accumulator =>\n  wire === undefined ? acc : mergeUsage(acc, wire)\n\nexport const applyEvent = (acc: Accumulator, event: ProviderEvent): Accumulator =>\n  Match.value(event).pipe(\n    Match.discriminatorsExhaustive(\"type\")({\n      message_start: (e) => mergeOptionalUsage(acc, e.message.usage),\n      content_block_start: (e) => startBlock(acc, e.index, e.content_block),\n      content_block_delta: (e) =>\n        Match.value(e.delta).pipe(\n          Match.discriminatorsExhaustive(\"type\")({\n            text_delta: (d) => appendTextDelta(acc, e.index, d.text),\n            input_json_delta: (d) => appendInputJsonDelta(acc, e.index, d.partial_json),\n            thinking_delta: (d) => appendThinkingDelta(acc, e.index, d.thinking),\n            signature_delta: (d) => appendSignatureDelta(acc, e.index, d.signature),\n          }),\n        ),\n      content_block_stop: () => acc,\n      message_delta: (e) => {\n        const withUsage = mergeOptionalUsage(acc, e.usage)\n        const reason = e.delta.stop_reason\n        return reason === undefined || reason === null\n          ? withUsage\n          : setStopReason(withUsage, reason)\n      },\n      message_stop: () => acc,\n      ping: () => acc,\n      error: () => acc,\n      // No silent drops: unknown wire events flow through `streamNative` but\n      // produce no accumulator change. Step 3 (canonical `other` event) will\n      // also forward them to `TurnEvent`.\n      _unknown: () => acc,\n    }),\n  )\n\n// ---------------------------------------------------------------------------\n// Helpers for producing TurnEvent from a step.\n// ---------------------------------------------------------------------------\n\nexport const isTextDeltaEvent = (\n  event: ProviderEvent,\n): event is Extract<\n  ProviderEvent,\n  { type: \"content_block_delta\"; delta: { type: \"text_delta\" } }\n> => event.type === \"content_block_delta\" && event.delta.type === \"text_delta\"\n\nexport const isThinkingDeltaEvent = (\n  event: ProviderEvent,\n): event is Extract<\n  ProviderEvent,\n  { type: \"content_block_delta\"; delta: { type: \"thinking_delta\" } }\n> => event.type === \"content_block_delta\" && event.delta.type === \"thinking_delta\"\n\nexport const isInputJsonDeltaEvent = (\n  event: ProviderEvent,\n): event is Extract<\n  ProviderEvent,\n  { type: \"content_block_delta\"; delta: { type: \"input_json_delta\" } }\n> => event.type === \"content_block_delta\" && event.delta.type === \"input_json_delta\"\n\nexport const isToolUseStartEvent = (\n  event: ProviderEvent,\n): event is Extract<\n  ProviderEvent,\n  { type: \"content_block_start\"; content_block: { type: \"tool_use\" } }\n> => event.type === \"content_block_start\" && event.content_block.type === \"tool_use\"\n\nexport const isMessageStop = (event: ProviderEvent): boolean => event.type === \"message_stop\"\n\nexport const isErrorEvent = (\n  event: ProviderEvent,\n): event is Extract<ProviderEvent, { type: \"error\" }> => event.type === \"error\"\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/anthropic",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Anthropic Messages API provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -20,6 +20,12 @@
     "url": "https://github.com/betalyra/effect-uai",
     "directory": "packages/providers/anthropic"
   },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "type": "module",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -27,25 +33,23 @@
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./Anthropic": {
+      "types": "./dist/Anthropic.d.mts",
+      "import": "./dist/Anthropic.mjs"
     }
   },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
   "publishConfig": {
     "access": "public"
   },
-  "peerDependencies": {
-    "effect": "4.0.0-beta.57",
-    "@effect-uai/core": "^0.2.0"
-  },
   "devDependencies": {
     "effect": "4.0.0-beta.57",
     "typescript": "^6.0.3",
-    "@effect-uai/core": "0.2.0"
+    "@effect-uai/core": "0.4.0"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": ">=0.2.0 <1",
+    "effect": "4.0.0-beta.57"
   },
   "scripts": {
     "build": "tsdown",

package/src/Anthropic.ts

@@ -17,7 +17,6 @@ import {
   LanguageModel,
   type LanguageModelService,
 } from "@effect-uai/core/LanguageModel"
-import { matchType } from "@effect-uai/core/Match"
 import * as SSE from "@effect-uai/core/SSE"
 import type { TurnEvent } from "@effect-uai/core/Turn"
 import {
@@ -34,7 +33,7 @@ import { KnownProviderEvent, ProviderEvent, applyEvent } from "./streamEvents.js
 // Public types
 // ---------------------------------------------------------------------------
 
-export interface AnthropicRequest extends Omit<CommonRequest, "model"> {
+export type AnthropicRequest = Omit<CommonRequest, "model"> & {
   /**
    * Narrows `CommonRequest.model` (`string`) to the typed `AnthropicModel`
    * literal union for autocomplete.
@@ -59,7 +58,7 @@ export interface AnthropicRequest extends Omit<CommonRequest, "model"> {
   readonly user?: string
 }
 
-export interface AnthropicService {
+export type AnthropicService = {
   /**
    * Stream the provider's native event vocabulary (post-SSE-decode).
    * Use this when you need full vendor fidelity (e.g. `signature_delta` for
@@ -93,7 +92,7 @@ export class Anthropic extends Context.Service<Anthropic, AnthropicService>()(
   "@betalyra/effect-uai/providers/anthropic/Anthropic",
 ) {}
 
-export interface Config {
+export type Config = {
   readonly apiKey: Redacted.Redacted
   readonly baseUrl?: string
   /**
@@ -182,57 +181,53 @@ const sseEventToProviderEvent = (ev: SSE.Event): Effect.Effect<ProviderEvent> =>
 
 const deltasFromEvent = (next: Accumulator, event: ProviderEvent): ReadonlyArray<TurnEvent> =>
   Match.value(event).pipe(
-    matchType("content_block_start", (e) =>
-      e.content_block.type === "tool_use"
-        ? [
-            {
-              type: "tool_call_start" as const,
-              call_id: e.content_block.id,
-              name: e.content_block.name,
+    Match.discriminatorsExhaustive("type")({
+      content_block_start: (e) =>
+        e.content_block.type === "tool_use"
+          ? [
+              {
+                type: "tool_call_start" as const,
+                call_id: e.content_block.id,
+                name: e.content_block.name,
+              },
+            ]
+          : [],
+      content_block_delta: (e) =>
+        Match.value(e.delta).pipe(
+          Match.discriminatorsExhaustive("type")({
+            text_delta: (d) => [{ type: "text_delta" as const, text: d.text }],
+            thinking_delta: (d) => [
+              { type: "reasoning_delta" as const, text: d.thinking, kind: "trace" as const },
+            ],
+            input_json_delta: (d) => {
+              const block = next.blocks[e.index]
+              if (block === undefined) return []
+              const callId = Option.getOrElse(block.id, () => "")
+              return callId.length === 0
+                ? []
+                : [
+                    {
+                      type: "tool_call_args_delta" as const,
+                      call_id: callId,
+                      delta: d.partial_json,
+                    },
+                  ]
             },
-          ]
-        : [],
-    ),
-    matchType("content_block_delta", (e) =>
-      Match.value(e.delta).pipe(
-        matchType("text_delta", (d) => [{ type: "text_delta" as const, text: d.text }]),
-        matchType("thinking_delta", (d) => [
-          { type: "reasoning_delta" as const, text: d.thinking, kind: "trace" as const },
-        ]),
-        matchType("input_json_delta", (d) => {
-          const block = next.blocks[e.index]
-          if (block === undefined) return []
-          const callId = Option.getOrElse(block.id, () => "")
-          return callId.length === 0
-            ? []
-            : [
-                {
-                  type: "tool_call_args_delta" as const,
-                  call_id: callId,
-                  delta: d.partial_json,
-                },
-              ]
-        }),
-        // Encrypted reasoning state - flows through `streamNative` but has
-        // no canonical representation.
-        matchType("signature_delta", () => []),
-        Match.exhaustive,
-      ),
-    ),
-    matchType("message_start", (e) =>
-      e.message.usage === undefined ? [] : [{ type: "usage_update" as const, usage: next.usage }],
-    ),
-    matchType("message_delta", (e) =>
-      e.usage === undefined ? [] : [{ type: "usage_update" as const, usage: next.usage }],
-    ),
-    matchType("message_stop", () => [
-      { type: "turn_complete" as const, turn: accumulatorToTurn(next) },
-    ]),
-    matchType("content_block_stop", () => []),
-    matchType("ping", () => []),
-    matchType("error", () => []),
-    matchType("_unknown", () => []),
-    Match.exhaustive,
+            // Encrypted reasoning state - flows through `streamNative` but has
+            // no canonical representation.
+            signature_delta: () => [],
+          }),
+        ),
+      message_start: (e) =>
+        e.message.usage === undefined ? [] : [{ type: "usage_update" as const, usage: next.usage }],
+      message_delta: (e) =>
+        e.usage === undefined ? [] : [{ type: "usage_update" as const, usage: next.usage }],
+      message_stop: () => [{ type: "turn_complete" as const, turn: accumulatorToTurn(next) }],
+      content_block_stop: () => [],
+      ping: () => [],
+      error: () => [],
+      _unknown: () => [],
+    }),
   )
 
 // ---------------------------------------------------------------------------