v0.5.2

@effect-uai/core

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

effect-uai

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/anthropic

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/elevenlabs

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/google

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/inworld

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/jina

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/openai

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }

@effect-uai/responses

Patch Changes

• 1509883: Two related refactors. Both are breaking but mechanical — a one-line
  rewrite per affected call site.

  Retry is its own module

  LanguageModel.retry and LanguageModel.Retryable were not
  LanguageModel-specific — the implementation was a generic AiError
  combinator. Hoisted out into @effect-uai/core/Retry, with two
  carriers so it covers every model surface:

  • Retry.stream(schedule) — for Stream<A, AiError, R> (streamTurn,
    streamSynthesis, streamTranscriptionFrom).
  • Retry.effect(schedule) — for Effect<A, AiError, R> (turn,
    embed, embedMany, synthesize, transcribe).

  Both gate on the RateLimited | Unavailable | Timeout subset; other
  AiErrors propagate unchanged. The namespace deliberately doesn't
  shadow Effect's own Stream.retry / Effect.retry.

  // Before
  import { retry } from "@effect-uai/core/LanguageModel";
  streamTurn(req).pipe(retry(schedule));
  
  // After
  import * as Retry from "@effect-uai/core/Retry";
  streamTurn(req).pipe(Retry.stream(schedule));
  embed(req).pipe(Retry.effect(schedule));

  Retryable and isRetryable move to the same module.

  turn is now on LanguageModelService

  turn(request): Effect<Turn, AiError> is now a method on the service
  alongside streamTurn. Providers without a native non-streaming
  endpoint derive it from streamTurn via the new
  LanguageModel.turnFromStream(streamTurn) helper; providers with a
  native complete endpoint can override.

  The top-level LanguageModel.turn(request) helper is unchanged at
  call sites — it now delegates to the service method instead of
  draining streamTurn inline.

  Hand-rolled LanguageModelService values (most commonly in tests)
  must now supply a turn field. Use turnFromStream:

  // Before
  const service: LanguageModelService = {
    streamTurn: () => Stream.fromIterable([...]),
  }
  
  // After
  import { turnFromStream } from "@effect-uai/core/LanguageModel"
  const streamTurn: LanguageModelService["streamTurn"] = () => Stream.fromIterable([...])
  const service: LanguageModelService = { streamTurn, turn: turnFromStream(streamTurn) }