effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/internal/tracer.ts

@@ -1,6 +1,7 @@
 import type * as Tracer from "../Tracer.ts"
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
 
+/** @internal */
 export interface ErrorWithStackTraceLimit {
   stackTraceLimit?: number | undefined
 }
@@ -15,6 +16,9 @@ export const addSpanStackTrace = <A extends Tracer.TraceOptions>(
     return options
   }
   const limit = getStackTraceLimit()
+  if (limit === 0 && options?.captureStackTrace !== true) {
+    return { ...options, captureStackTrace: false } as A
+  }
   setStackTraceLimit(3)
   const traceError = new Error()
   setStackTraceLimit(limit)

package/src/internal/trie.ts

@@ -12,7 +12,7 @@ import type * as TR from "../Trie.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
-export const TrieTypeId = "~effect/collections/Trie"
+export const TrieTypeId = "~effect/Trie"
 
 type TraversalMap<K, V, A> = (k: K, v: V) => A
 
@@ -516,7 +516,10 @@ export const remove = dual<
       const n2 = nStack[s]
       const d = dStack[s]
       const child = nStack[s + 1]
-      const nc = child.left === undefined && child.mid === undefined && child.right === undefined ? undefined : child
+      const nc =
+        child.value === undefined && child.left === undefined && child.mid === undefined && child.right === undefined
+          ? undefined
+          : child
       if (d === -1) {
         // left
         nStack[s] = {

package/src/internal/uuid.ts

@@ -17,7 +17,9 @@ const randomBytes = (): Uint8Array<ArrayBuffer> => globalThis.crypto.getRandomVa
 
 /** @internal */
 export function v4Bytes(): Uint8Array<ArrayBuffer>
+/** @internal */
 export function v4Bytes<A extends ArrayBufferLike>(bytes: Uint8Array<A>): Uint8Array<A>
+/** @internal */
 export function v4Bytes(bytes: Uint8Array = randomBytes()): Uint8Array {
   bytes[6] = (bytes[6] & 0x0f) | 0x40
   bytes[8] = (bytes[8] & 0x3f) | 0x80
@@ -31,7 +33,9 @@ const maxV7Timestamp = 2 ** 48 - 1
 
 /** @internal */
 export function v7Bytes(timestampMillis: number): Uint8Array<ArrayBuffer>
+/** @internal */
 export function v7Bytes<A extends ArrayBufferLike>(timestampMillis: number, bytes: Uint8Array<A>): Uint8Array<A>
+/** @internal */
 export function v7Bytes(timestampMillis: number, bytes: Uint8Array = randomBytes()): Uint8Array {
   const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxV7Timestamp)
 

package/src/testing/TestSchema.ts

@@ -10,16 +10,21 @@
  * @since 4.0.0
  */
 import * as assert from "node:assert"
+import { isDeepStrictEqual } from "node:util"
 import type * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import { pipe } from "../Function.ts"
-import * as Record from "../Record.ts"
 import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
 import * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaIssue from "../SchemaIssue.ts"
 import * as SchemaParser from "../SchemaParser.ts"
-import * as FastCheck from "../testing/FastCheck.ts"
+import * as Arbitrary from "../unstable/arbitrary/Arbitrary.ts"
+
+function assertPropertyPassed<A, E>(result: Arbitrary.CheckResult<A, E>): void {
+  const failure = Arbitrary.formatCheckFailure(result)
+  if (failure !== undefined) assert.fail(failure)
+}
 
 /**
  * Provides schema test assertions for decoding, encoding, make, arbitrary generation, and round-trip verification.
@@ -76,7 +81,10 @@ export class Asserts<S extends Schema.Constraint> {
   static ast = {
     fields: {
       equals: (a: Schema.Struct.Fields, b: Schema.Struct.Fields) => {
-        assert.deepStrictEqual(Record.map(a, SchemaAST.getAST), Record.map(b, SchemaAST.getAST))
+        assert.deepStrictEqual(
+          Object.fromEntries(Reflect.ownKeys(a).map((key) => [key, SchemaAST.getAST(a[key])])),
+          Object.fromEntries(Reflect.ownKeys(b).map((key) => [key, SchemaAST.getAST(b[key])]))
+        )
       }
     },
     elements: {
@@ -153,7 +161,8 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Details**
    *
-   * FastCheck generates arbitrary values matching the schema's `Type`. The assertion fails if any generated value does not round-trip. Pass `options.params` to control FastCheck parameters such as `numRuns`.
+   * The native Schema arbitrary generates values matching the schema's `Type`. The assertion fails with the minimized
+   * shrunk input and replay token if any generated value does not round-trip.
    *
    * **Example** (Verifying round trips)
    *
@@ -162,30 +171,29 @@ export class Asserts<S extends Schema.Constraint> {
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.String)
-   * await asserts.verifyLosslessTransformation({ params: { seed: 1, numRuns: 20 } }) // => undefined
+   * await asserts.verifyLosslessTransformation({ seed: 1, runs: 20 }) // => undefined
    * ```
    *
    * @see {@link arbitrary} for checking that generated values satisfy the schema
    */
-  verifyLosslessTransformation<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>, options?: {
-    readonly params?: FastCheck.Parameters<[S["Type"]]>
-  }) {
+  verifyLosslessTransformation<S extends Schema.ConstraintCodec<unknown, unknown>>(
+    this: Asserts<S>,
+    options?: Arbitrary.CheckOptions
+  ): Promise<void> {
     const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
     const encodeEffect = SchemaParser.encodeEffect(this.schema)
-    const arbitrary = Schema.toArbitrary(this.schema)(FastCheck)
-    return FastCheck.assert(
-      FastCheck.asyncProperty(arbitrary, async (t) => {
-        const r = await Effect.runPromise(
-          encodeEffect(t).pipe(
-            Effect.flatMapEager((e) => decodeUnknownEffect(e)),
-            Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-            Effect.result
-          )
-        )
-        assert.deepStrictEqual(r, Result.succeed(t))
-      }),
-      options?.params
-    )
+    const arbitrary = Arbitrary.schema(this.schema)
+    return Effect.runPromise(Arbitrary.checkEffect(
+      arbitrary,
+      (value) =>
+        encodeEffect(value).pipe(
+          Effect.flatMapEager((encoded) => decodeUnknownEffect(encoded)),
+          Effect.mapErrorEager(SchemaIssue.defaultFormatter),
+          Effect.result,
+          Effect.mapEager((result) => isDeepStrictEqual(result, Result.succeed(value)))
+        ),
+      options
+    )).then(assertPropertyPassed)
   }
   /**
    * Returns a {@link Decoding} instance for this schema with helpers for decoding assertions.
@@ -258,7 +266,8 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Details**
    *
-   * `verifyGeneration()` generates arbitrary values and asserts each value satisfies the schema's `is` predicate. It defaults to 20 runs. Pass `options.params` to override FastCheck parameters.
+   * `verifyGeneration()` generates arbitrary values and asserts each value satisfies the schema's `is` predicate. It
+   * defaults to 20 runs. Native checking options can control generation, shrinking, bounded discards, and replay.
    *
    * **Example** (Verifying arbitrary generation)
    *
@@ -267,7 +276,7 @@ export class Asserts<S extends Schema.Constraint> {
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.String)
-   * asserts.arbitrary().verifyGeneration({ params: { seed: 1, numRuns: 20 } }) // => undefined
+   * asserts.arbitrary().verifyGeneration({ seed: 1, runs: 20 }) // => undefined
    * ```
    *
    * @see {@link verifyLosslessTransformation} for property-based round-trip checks
@@ -275,13 +284,10 @@ export class Asserts<S extends Schema.Constraint> {
   arbitrary<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>) {
     const schema = this.schema
     return {
-      verifyGeneration(options?: {
-        readonly params?: FastCheck.Parameters<[S["Type"]]> | undefined
-      }) {
-        const params = options?.params
+      verifyGeneration(options?: Arbitrary.CheckOptions): void {
         const is = Schema.is(schema)
-        const arb = Schema.toArbitrary(schema)(FastCheck)
-        FastCheck.assert(FastCheck.property(arb, (a) => is(a)), { numRuns: 20, ...params })
+        const arbitrary = Arbitrary.schema(schema)
+        assertPropertyPassed(Effect.runSync(Arbitrary.checkEffect(arbitrary, is, { runs: 20, ...options })))
       }
     }
   }

package/src/testing/index.ts

@@ -4,11 +4,6 @@
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
-/**
- * @since 3.10.0
- */
-export * as FastCheck from "./FastCheck.ts"
-
 /**
  * @since 2.0.0
  */

package/src/unstable/ai/AiError.ts

@@ -20,9 +20,75 @@ import { redact } from "../../Redactable.ts"
 import * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
 import type * as HttpClientError from "../http/HttpClientError.ts"
-import { HttpRequestDetails, HttpResponseDetails } from "./Response.ts"
 
-const ReasonTypeId = "~effect/unstable/ai/AiError/Reason" as const
+/**
+ * Schema for HTTP requests to an AI provider.
+ *
+ * **Example** (Describing an HTTP request)
+ *
+ * ```ts import.meta.vitest
+ * import type { AiError } from "effect/unstable/ai"
+ *
+ * const requestDetails: typeof AiError.HttpRequestDetails.Type = {
+ *   method: "POST",
+ *   url: "https://api.openai.com/v1/responses",
+ *   urlParams: [],
+ *   hash: undefined,
+ *   headers: { "Content-Type": "application/json" }
+ * }
+ * const result = [requestDetails.method, requestDetails.urlParams] // => ["POST", []]
+ * ```
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HttpRequestDetails = Schema.Struct({
+  method: Schema.Literals(["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD", "OPTIONS", "TRACE"]),
+  url: Schema.String,
+  urlParams: Schema.Array(Schema.Tuple([Schema.String, Schema.String])),
+  hash: Schema.optional(Schema.String),
+  headers: Schema.Record(
+    Schema.String,
+    Schema.Union([
+      Schema.String,
+      Schema.Redacted(Schema.String)
+    ])
+  )
+}).annotate({ identifier: "HttpRequestDetails" })
+
+/**
+ * Schema for HTTP responses from an AI provider.
+ *
+ * **Example** (Describing an HTTP response)
+ *
+ * ```ts import.meta.vitest
+ * import type { AiError } from "effect/unstable/ai"
+ *
+ * const responseDetails: typeof AiError.HttpResponseDetails.Type = {
+ *   status: 200,
+ *   headers: {
+ *     "Content-Type": "application/json",
+ *     "X-Request-Id": "req_abc123"
+ *   }
+ * }
+ * const result = [responseDetails.status, responseDetails.headers["X-Request-Id"]] // => [200, "req_abc123"]
+ * ```
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HttpResponseDetails = Schema.Struct({
+  status: Schema.Int,
+  headers: Schema.Record(
+    Schema.String,
+    Schema.Union([
+      Schema.String,
+      Schema.Redacted(Schema.String)
+    ])
+  )
+}).annotate({ identifier: "HttpResponseDetails" })
+
+const ReasonTypeId = "~effect/ai/AiError/Reason" as const
 
 const providerMetadataWithDefaults = <Metadata extends ProviderMetadata>() =>
   (ProviderMetadata as unknown as typeof ProviderMetadata & Schema.Schema<Metadata>).pipe(
@@ -341,6 +407,52 @@ export const HttpContext = Schema.Struct({
   body: Schema.optional(Schema.String)
 }).annotate({ identifier: "HttpContext" })
 
+/**
+ * Builds a description for an HTTP error returned by an AI provider.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const buildErrorDescription = (params: {
+  readonly status: number
+  readonly message: string | undefined
+  readonly method: string
+  readonly url: string
+  readonly errorCode?: string | number | null | undefined
+  readonly errorType?: string | null | undefined
+  readonly requestId?: string | null | undefined
+  readonly body: string | undefined
+}): string => {
+  const parts: Array<string> = []
+
+  if (params.message) {
+    parts.push(params.message)
+  } else {
+    parts.push(`HTTP ${params.status}`)
+  }
+
+  parts.push(`(${params.method} ${params.url})`)
+
+  if (params.errorCode) {
+    parts.push(`[code: ${params.errorCode}]`)
+  } else if (params.errorType) {
+    parts.push(`[type: ${params.errorType}]`)
+  }
+
+  if (params.requestId) {
+    parts.push(`[requestId: ${params.requestId}]`)
+  }
+
+  if (!params.message && params.body) {
+    const truncated = params.body.length > 200
+      ? params.body.slice(0, 200) + "..."
+      : params.body
+    parts.push(`Response: ${truncated}`)
+  }
+
+  return parts.join(" ")
+}
+
 // =============================================================================
 // Reason Classes
 // =============================================================================
@@ -468,6 +580,13 @@ export class QuotaExhaustedError extends Schema.Error<QuotaExhaustedError>(
  * })
  *
  * const result = [authError.kind, authError.isRetryable] // => ["InvalidKey", false]
+ *
+ * const detailed = new AiError.AuthenticationError({
+ *   kind: "InsufficientPermissions",
+ *   description: "Token expired"
+ * })
+ *
+ * detailed.message // => "InsufficientPermissions: Your API key lacks required permissions. Token expired"
  * ```
  *
  * @category errors
@@ -478,6 +597,7 @@ export class AuthenticationError extends Schema.Error<AuthenticationError>(
 )({
   _tag: Schema.tag("AuthenticationError"),
   kind: Schema.Literals(["InvalidKey", "ExpiredKey", "MissingKey", "InsufficientPermissions", "Unknown"]),
+  description: Schema.optional(Schema.String),
   metadata: providerMetadataWithDefaults<AuthenticationErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
@@ -505,7 +625,9 @@ export class AuthenticationError extends Schema.Error<AuthenticationError>(
       InsufficientPermissions: "Your API key lacks required permissions",
       Unknown: "Authentication failed. Check your credentials"
     }
-    return `${this.kind}: ${suggestions[this.kind]}`
+    let msg = `${this.kind}: ${suggestions[this.kind]}`
+    if (this.description) msg += `. ${this.description}`
+    return msg
   }
 }
 
@@ -999,7 +1121,6 @@ export class ToolNotFoundError extends Schema.Error<ToolNotFoundError>(
  *
  * const error = new AiError.ToolParameterValidationError({
  *   toolName: "GetWeather",
- *   toolParams: { location: 123 },
  *   description: "Expected string, got number"
  * })
  *
@@ -1014,7 +1135,6 @@ export class ToolParameterValidationError extends Schema.Error<ToolParameterVali
 )({
   _tag: Schema.tag("ToolParameterValidationError"),
   toolName: Schema.String,
-  toolParams: Schema.Json,
   description: Schema.String
 }) {
   /**
@@ -1396,7 +1516,7 @@ export const AiErrorReason: Schema.Union<[
 // Top-Level AiError
 // =============================================================================
 
-const TypeId = "~effect/unstable/ai/AiError/AiError" as const
+const TypeId = "~effect/ai/AiError" as const
 
 /**
  * Schema for the top-level AI error wrapper using the `reason` pattern.

package/src/unstable/ai/AnthropicStructuredOutput.ts

@@ -9,7 +9,7 @@
  *
  * @since 4.0.0
  */
-import * as JsonSchema from "../../JsonSchema.ts"
+import type * as JsonSchema from "../../JsonSchema.ts"
 import * as Rec from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
 import * as InternalStructuredOutput from "./internal/structured-output.ts"
@@ -58,11 +58,14 @@ export function toCodecAnthropic<T, E, RD, RE>(
   readonly jsonSchema: JsonSchema.JsonSchema
 } {
   const codec = InternalStructuredOutput.toCodec(schema)
-  const unresolvedDocument = Schema.toJsonSchemaDocument(codec, { generateDescriptions: true })
+  const unresolvedDocument = Schema.toJsonSchemaDocument(codec, {
+    generateDescriptions: true,
+    onExcessProperty: "error"
+  })
   if (hasReferenceCycle(unresolvedDocument.schema, unresolvedDocument.definitions)) {
     throw new Error("AnthropicStructuredOutput: Recursive schemas are not supported")
   }
-  const document = JsonSchema.resolveTopLevel$ref(unresolvedDocument)
+  const document = InternalStructuredOutput.resolveTopLevelReference(unresolvedDocument)
   const jsonSchema = rewriteAnthropic(document.schema)
   if (Object.keys(document.definitions).length > 0) {
     jsonSchema.$defs = Rec.map(document.definitions, rewriteAnthropic)
@@ -85,8 +88,8 @@ function hasReferenceCycle(
     let cycle = false
     InternalStructuredOutput.walkJsonSchema(schema, (node) => {
       if (!cycle && typeof node.$ref === "string") {
-        const target = node.$ref === "#" ? root : JsonSchema.resolve$ref(node.$ref, definitions)
-        if (target !== undefined && visit(target)) cycle = true
+        const target = node.$ref === "#" ? root : InternalStructuredOutput.resolveReference(node.$ref, definitions)
+        if (visit(target)) cycle = true
       }
       return node
     })

package/src/unstable/ai/Chat.ts

@@ -33,18 +33,7 @@ import type * as Response from "./Response.ts"
 import type * as Tool from "./Tool.ts"
 
 /**
- * Service tag for stateful AI conversation sessions.
- *
- * **When to use**
- *
- * Use to access or provide conversational AI sessions through the Effect
- * context.
- *
- * **Details**
- *
- * This tag provides access to chat functionality throughout your application,
- * enabling persistent conversational AI interactions with full context
- * management.
+ * Service key for stateful AI conversations.
  *
  * **Example** (Accessing the Chat service)
  *
@@ -82,26 +71,35 @@ import type * as Tool from "./Tool.ts"
  * @category services
  * @since 4.0.0
  */
-export class Chat extends Context.Service<Chat, Service>()(
-  "effect/ai/Chat"
-) {}
+export const Chat: Context.Service<Chat, Chat> = Context.Service("effect/ai/Chat")
 
 /**
- * Represents the interface that the `Chat` service provides.
+ * Brand type for `Chat`.
  *
- * **When to use**
+ * @category type IDs
+ * @since 4.0.0
+ */
+export type TypeId = "~effect/ai/Chat"
+
+/**
+ * Brand for `Chat` implementations.
  *
- * Use as the service contract for code that receives or constructs a stateful
- * chat session and needs history, export, text generation, streaming, and
- * structured-output operations.
+ * @category type IDs
+ * @since 4.0.0
+ */
+export const TypeId: TypeId = "~effect/ai/Chat"
+
+/**
+ * Chat session with history, export, and generation operations.
  *
- * @see {@link Chat} for the context tag that provides this service
  * @see {@link Persisted} for the persistence-backed extension
  *
  * @category models
  * @since 4.0.0
  */
-export interface Service {
+export interface Chat {
+  readonly [TypeId]: TypeId
+
   /**
    * Reference to the chat history.
    *
@@ -240,7 +238,7 @@ export interface Service {
         readonly toolkit: LanguageModel.ToolkitInput<Tools>
       }
     ): Effect.Effect<
-      LanguageModel.GenerateTextResponse<Tools, LanguageModel.ExtractEncodedToolParameters<Options>>,
+      LanguageModel.GenerateTextResponse<Tools, LanguageModel.ExtractToolParametersMode<Options>>,
       LanguageModel.ExtractError<Options>,
       LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
     >
@@ -255,7 +253,7 @@ export interface Service {
     ): Effect.Effect<
       LanguageModel.GenerateTextResponse<
         LanguageModel.ExtractTools<Options>,
-        LanguageModel.ExtractEncodedToolParameters<Options>
+        LanguageModel.ExtractToolParametersMode<Options>
       >,
       LanguageModel.ExtractError<Options>,
       LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
@@ -322,7 +320,7 @@ export interface Service {
         readonly toolkit: LanguageModel.ToolkitInput<Tools>
       }
     ): Stream.Stream<
-      Response.StreamPart<Tools, LanguageModel.ExtractEncodedToolParameters<Options>>,
+      Response.StreamPart<Tools, LanguageModel.ExtractToolParametersMode<Options>>,
       LanguageModel.ExtractError<Options>,
       LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
     >
@@ -337,7 +335,7 @@ export interface Service {
     ): Stream.Stream<
       Response.StreamPart<
         LanguageModel.ExtractTools<Options>,
-        LanguageModel.ExtractEncodedToolParameters<Options>
+        LanguageModel.ExtractToolParametersMode<Options>
       >,
       LanguageModel.ExtractError<Options>,
       LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
@@ -399,7 +397,7 @@ export interface Service {
     LanguageModel.GenerateObjectResponse<
       LanguageModel.ExtractTools<Options>,
       ObjectSchema["Type"],
-      LanguageModel.ExtractEncodedToolParameters<Options>
+      LanguageModel.ExtractToolParametersMode<Options>
     >,
     LanguageModel.ExtractError<Options>,
     LanguageModel.ExtractServices<Options> | ObjectSchema["DecodingServices"] | LanguageModel.LanguageModel
@@ -419,6 +417,7 @@ const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
   const semaphore = Semaphore.makeUnsafe(1)
 
   return Chat.of({
+    [TypeId]: TypeId,
     history,
     export: Ref.get(history).pipe(
       Effect.flatMap(encodeHistory),
@@ -455,7 +454,7 @@ const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
       },
       semaphore.withPermits(1),
       (effect) => Effect.withSpan(effect, "Chat.generateText", { captureStackTrace: false })
-    ) as Service["generateText"],
+    ) as Chat["generateText"],
     streamText: Effect.fnUntraced(
       function*(options) {
         let parts = Chunk.empty<Response.AnyPart>()
@@ -487,7 +486,7 @@ const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
         )
       },
       Stream.unwrap
-    ) as Service["streamText"],
+    ) as Chat["streamText"],
     generateObject: Effect.fnUntraced(
       function*(options) {
         const newPrompt = Prompt.make(options.prompt)
@@ -539,7 +538,7 @@ const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
  * @category constructors
  * @since 4.0.0
  */
-export const empty: Effect.Effect<Service> = Effect.sync(() => makeUnsafe(Ref.makeUnsafe(Prompt.empty)))
+export const empty: Effect.Effect<Chat> = Effect.sync(() => makeUnsafe(Ref.makeUnsafe(Prompt.empty)))
 
 /**
  * Creates a new Chat service from an initial prompt.
@@ -655,7 +654,7 @@ export const fromPrompt = (prompt: Prompt.RawInput) =>
  * @since 4.0.0
  */
 export const fromExport = (data: unknown): Effect.Effect<
-  Service,
+  Chat,
   Schema.SchemaError
 > => Effect.flatMap(decodeHistory(data), fromPrompt)
 
@@ -689,7 +688,7 @@ export const fromExport = (data: unknown): Effect.Effect<
  * @since 4.0.0
  */
 export const fromJson = (data: string): Effect.Effect<
-  Service,
+  Chat,
   Schema.SchemaError
 > => Effect.flatMap(decodeHistoryJson(data), fromPrompt)
 
@@ -779,7 +778,7 @@ export declare namespace Persistence {
  * @category models
  * @since 4.0.0
  */
-export interface Persisted extends Service {
+export interface Persisted extends Chat {
   /**
    * The identifier for the chat in the backing persistence store.
    */
@@ -816,7 +815,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
   const store = yield* persistence.make(options.storeId)
 
   const toPersisted = Effect.fnUntraced(
-    function*(chatId: string, chat: Service, ttl: Duration.Input | undefined) {
+    function*(chatId: string, chat: Chat, ttl: Duration.Input | undefined) {
       const idGenerator = yield* Effect.serviceOption(IdGenerator.IdGenerator).pipe(
         Effect.map(Option.getOrElse(() => IdGenerator.defaultIdGenerator))
       )
@@ -865,7 +864,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
           return yield* chat.generateText(options).pipe(
             Effect.ensuring(Effect.orDie(saveChat(history)))
           )
-        }) as Service["generateText"],
+        }) as Chat["generateText"],
         generateObject: Effect.fnUntraced(function*(options) {
           const history = yield* Ref.get(chat.history)
           return yield* chat.generateObject(options).pipe(
@@ -878,7 +877,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
             Stream.ensuring(Effect.orDie(saveChat(history)))
           )
           return stream
-        }, Stream.unwrap) as Service["streamText"]
+        }, Stream.unwrap) as Chat["streamText"]
       }
 
       return persisted