effect 4.0.0-beta.33 → 4.0.0-beta.34

package/src/TxHashSet.ts

@@ -10,7 +10,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import type { Predicate, Refinement } from "./Predicate.ts"
+import { hasProperty, type Predicate, type Refinement } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 import type { NoInfer } from "./Types.ts"
 
@@ -286,7 +286,7 @@ export const fromHashSet = <V>(hashSet: HashSet.HashSet<V>): Effect.Effect<TxHas
  * @since 2.0.0
  * @category guards
  */
-export const isTxHashSet = (u: unknown): u is TxHashSet<unknown> => typeof u === "object" && u !== null && TypeId in u
+export const isTxHashSet = (u: unknown): u is TxHashSet<unknown> => hasProperty(u, TypeId)
 
 /**
  * Adds a value to the TxHashSet. If the value already exists, the operation has no effect.

package/src/TxPriorityQueue.ts

@@ -16,7 +16,7 @@ import * as O from "./Option.ts"
 import type { Order } from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import type { Predicate } from "./Predicate.ts"
+import { hasProperty, type Predicate } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxPriorityQueue"
@@ -763,5 +763,4 @@ export const toArray = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>, ne
  * @since 4.0.0
  * @category guards
  */
-export const isTxPriorityQueue = (u: unknown): u is TxPriorityQueue<unknown> =>
-  typeof u === "object" && u !== null && TypeId in u
+export const isTxPriorityQueue = (u: unknown): u is TxPriorityQueue<unknown> => hasProperty(u, TypeId)

package/src/TxSemaphore.ts

@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Scope from "./Scope.ts"
 import * as TxRef from "./TxRef.ts"
 
@@ -738,4 +739,4 @@ export const withPermitScoped = (self: TxSemaphore): Effect.Effect<void, never,
  * @since 4.0.0
  * @category guards
  */
-export const isTxSemaphore = (u: unknown): u is TxSemaphore => typeof u === "object" && u !== null && TypeId in u
+export const isTxSemaphore = (u: unknown): u is TxSemaphore => hasProperty(u, TypeId)

package/src/internal/effect.ts

@@ -3794,11 +3794,18 @@ export const scopedWith = <A, E, R>(
 /** @internal */
 export const acquireRelease = <A, E, R>(
   acquire: Effect.Effect<A, E, R>,
-  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown>
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown>,
+  options?: { readonly interruptible?: boolean }
 ): Effect.Effect<A, E, R | Scope.Scope> =>
-  uninterruptible(
-    flatMap(scope, (scope) =>
-      tap(acquire, (a) => scopeAddFinalizerExit(scope, (exit) => internalCall(() => release(a, exit)))))
+  uninterruptibleMask((restore) =>
+    flatMap(
+      scope,
+      (scope) =>
+        tap(
+          options?.interruptible ? restore(acquire) : acquire,
+          (a) => scopeAddFinalizerExit(scope, (exit) => release(a, exit))
+        )
+    )
   )
 
 /** @internal */

package/src/unstable/ai/AiError.ts

@@ -1396,10 +1396,8 @@ export class AiError extends Schema.ErrorClass<AiError>(
   method: Schema.String,
   reason: AiErrorReason
 }) {
-  /**
-   * @since 1.0.0
-   */
   readonly [TypeId] = TypeId
+  override readonly cause = this.reason
 
   /**
    * Delegates to the underlying reason's `isRetryable` getter.

package/src/unstable/ai/EmbeddingModel.ts

@@ -0,0 +1,209 @@
+/**
+ * The `EmbeddingModel` module provides provider-agnostic text embedding capabilities.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { EmbeddingModel } from "effect/unstable/ai"
+ *
+ * const program = Effect.gen(function*() {
+ *   const model = yield* EmbeddingModel.EmbeddingModel
+ *   return yield* model.embed("hello world")
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ */
+import * as Effect from "../../Effect.ts"
+import * as Exit from "../../Exit.ts"
+import * as Request from "../../Request.ts"
+import * as RequestResolver from "../../RequestResolver.ts"
+import * as Schema from "../../Schema.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
+import * as AiError from "./AiError.ts"
+
+/**
+ * Service tag for embedding model operations.
+ *
+ * @since 4.0.0
+ * @category services
+ */
+export class EmbeddingModel extends ServiceMap.Service<EmbeddingModel, Service>()(
+  "effect/unstable/ai/EmbeddingModel"
+) {}
+
+/**
+ * Service tag that provides the current embedding dimensions.
+ *
+ * @since 4.0.0
+ * @category services
+ */
+export class Dimensions extends ServiceMap.Service<Dimensions, number>()(
+  "effect/unstable/ai/EmbeddingModel/Dimensions"
+) {}
+
+/**
+ * Token usage metadata for embedding operations.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export class EmbeddingUsage extends Schema.Class<EmbeddingUsage>(
+  "effect/ai/EmbeddingModel/EmbeddingUsage"
+)({
+  inputTokens: Schema.UndefinedOr(Schema.Finite)
+}) {}
+
+/**
+ * Response for a single embedding request.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export class EmbedResponse extends Schema.Class<EmbedResponse>(
+  "effect/ai/EmbeddingModel/EmbedResponse"
+)({
+  vector: Schema.Array(Schema.Finite)
+}) {}
+
+/**
+ * Response for multiple embeddings.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export class EmbedManyResponse extends Schema.Class<EmbedManyResponse>(
+  "effect/ai/EmbeddingModel/EmbedManyResponse"
+)({
+  embeddings: Schema.Array(EmbedResponse),
+  usage: EmbeddingUsage
+}) {}
+
+/**
+ * Provider input options for embedding requests.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface ProviderOptions {
+  readonly inputs: ReadonlyArray<string>
+}
+
+/**
+ * Provider response for batch embedding requests.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface ProviderResponse {
+  readonly results: Array<Array<number>>
+  readonly usage: {
+    readonly inputTokens: number | undefined
+  }
+}
+
+/**
+ * Tagged request used by request resolvers for embedding operations.
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export class EmbeddingRequest extends Request.TaggedClass("EmbeddingRequest")<
+  { readonly input: string },
+  EmbedResponse,
+  AiError.AiError
+> {}
+
+/**
+ * Service interface for embedding operations.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface Service {
+  readonly resolver: RequestResolver.RequestResolver<EmbeddingRequest>
+  readonly embed: (input: string) => Effect.Effect<EmbedResponse, AiError.AiError>
+  readonly embedMany: (input: ReadonlyArray<string>) => Effect.Effect<EmbedManyResponse, AiError.AiError>
+}
+
+const invalidProviderResponse = (description: string): AiError.AiError =>
+  AiError.make({
+    module: "EmbeddingModel",
+    method: "embedMany",
+    reason: new AiError.InvalidOutputError({ description })
+  })
+
+/**
+ * Creates an EmbeddingModel service from a provider embedMany implementation.
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make: (params: {
+  readonly embedMany: (options: ProviderOptions) => Effect.Effect<ProviderResponse, AiError.AiError>
+}) => Effect.Effect<Service> = Effect.fnUntraced(function*(params) {
+  const resolver = RequestResolver.make<EmbeddingRequest>((entries) =>
+    Effect.flatMap(
+      params.embedMany({
+        inputs: entries.map((entry) => entry.request.input)
+      }),
+      (response) =>
+        Effect.map(mapProviderResults(entries.length, response.results), (embeddings) => {
+          for (let i = 0; i < entries.length; i++) {
+            entries[i].completeUnsafe(Exit.succeed(embeddings[i]))
+          }
+        })
+    )
+  ).pipe(
+    RequestResolver.withSpan("EmbeddingModel.resolver")
+  )
+
+  return EmbeddingModel.of({
+    resolver,
+    embed: (input) =>
+      Effect.request(new EmbeddingRequest({ input }), resolver).pipe(
+        Effect.withSpan("EmbeddingModel.embed")
+      ),
+    embedMany: (input) =>
+      (input.length === 0
+        ? Effect.succeed(
+          new EmbedManyResponse({
+            embeddings: [],
+            usage: new EmbeddingUsage({ inputTokens: undefined })
+          })
+        )
+        : params.embedMany({ inputs: input }).pipe(
+          Effect.flatMap((response) =>
+            mapProviderResults(input.length, response.results).pipe(
+              Effect.map((embeddings) =>
+                new EmbedManyResponse({
+                  embeddings,
+                  usage: new EmbeddingUsage({
+                    inputTokens: response.usage.inputTokens
+                  })
+                })
+              )
+            )
+          )
+        )).pipe(Effect.withSpan("EmbeddingModel.embedMany"))
+  })
+})
+
+const mapProviderResults = (
+  inputLength: number,
+  results: Array<Array<number>>
+): Effect.Effect<Array<EmbedResponse>, AiError.AiError> => {
+  const embeddings = new Array<EmbedResponse>(inputLength)
+  if (results.length !== inputLength) {
+    return Effect.fail(
+      invalidProviderResponse(
+        `Provider returned ${results.length} embeddings but expected ${inputLength}`
+      )
+    )
+  }
+  for (let i = 0; i < results.length; i++) {
+    const vector = results[i]
+    embeddings[i] = new EmbedResponse({ vector })
+  }
+  return Effect.succeed(embeddings)
+}

package/src/unstable/ai/LanguageModel.ts

@@ -937,6 +937,20 @@ export const make: (params: {
     const tracker = Option.getOrUndefined(yield* Effect.serviceOption(ResponseIdTracker.ResponseIdTracker))
     const toolChoice = options.toolChoice ?? "auto"
 
+    const withNonIncrementalFallback = <R>(
+      effect: Effect.Effect<Array<Response.PartEncoded>, AiError.AiError, R>
+    ): Effect.Effect<Array<Response.PartEncoded>, AiError.AiError, R | IdGenerator> =>
+      providerOptions.incrementalPrompt ?
+        effect.pipe(
+          Effect.catchReason("AiError", "InvalidRequestError", (_) =>
+            params.generateText({
+              ...providerOptions,
+              incrementalPrompt: undefined,
+              previousResponseId: undefined
+            }))
+        ) :
+        effect
+
     // Check for pending approvals that need resolution
     const { approved, denied } = collectToolApprovals(
       providerOptions.prompt.content,
@@ -968,7 +982,7 @@ export const make: (params: {
       const ResponseSchema = Schema.mutable(
         Schema.Array(Response.Part(Toolkit.empty))
       )
-      const rawContent = yield* params.generateText(providerOptions)
+      const rawContent = yield* withNonIncrementalFallback(params.generateText(providerOptions))
       const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent)
       if (tracker) {
         const responseMetadata = content.find((part) => part.type === "response-metadata")
@@ -1006,7 +1020,7 @@ export const make: (params: {
       const ResponseSchema = Schema.mutable(
         Schema.Array(Response.Part(Toolkit.empty))
       )
-      const rawContent = yield* params.generateText(providerOptions)
+      const rawContent = yield* withNonIncrementalFallback(params.generateText(providerOptions))
       const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent)
       if (tracker) {
         const responseMetadata = content.find((part) => part.type === "response-metadata")
@@ -1085,7 +1099,7 @@ export const make: (params: {
     // If tool call resolution is disabled, return the response without
     // resolving the tool calls that were generated
     if (options.disableToolCallResolution === true) {
-      const rawContent = yield* params.generateText(providerOptions)
+      const rawContent = yield* withNonIncrementalFallback(params.generateText(providerOptions))
       const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent)
       if (tracker) {
         const responseMetadata = content.find((part) => part.type === "response-metadata")
@@ -1096,7 +1110,7 @@ export const make: (params: {
       return content as Array<Response.Part<Tools>>
     }
 
-    const rawContent = yield* params.generateText(providerOptions)
+    const rawContent = yield* withNonIncrementalFallback(params.generateText(providerOptions))
 
     // Resolve the generated tool calls
     const toolResults = yield* resolveToolCalls(
@@ -1154,6 +1168,20 @@ export const make: (params: {
     const tracker = Option.getOrUndefined(yield* Effect.serviceOption(ResponseIdTracker.ResponseIdTracker))
     const toolChoice = options.toolChoice ?? "auto"
 
+    const withNonIncrementalFallback = <R>(
+      stream: Stream.Stream<Response.StreamPartEncoded, AiError.AiError, R>
+    ): Stream.Stream<Response.StreamPartEncoded, AiError.AiError, R | IdGenerator> =>
+      providerOptions.incrementalPrompt ?
+        stream.pipe(
+          Stream.catchReason("AiError", "InvalidRequestError", (_) =>
+            params.streamText({
+              ...providerOptions,
+              incrementalPrompt: undefined,
+              previousResponseId: undefined
+            }))
+        ) :
+        stream
+
     // Check for pending approvals that need resolution
     const { approved: pendingApproved, denied: pendingDenied } = collectToolApprovals(providerOptions.prompt.content, {
       excludeResolved: true
@@ -1185,6 +1213,7 @@ export const make: (params: {
       const decodeParts = Schema.decodeEffect(schema)
       return pipe(
         params.streamText(providerOptions),
+        withNonIncrementalFallback,
         Stream.mapArrayEffect((parts) =>
           decodeParts(parts).pipe(
             tracker ?
@@ -1234,6 +1263,7 @@ export const make: (params: {
       const decodeParts = Schema.decodeEffect(schema)
       return pipe(
         params.streamText(providerOptions),
+        withNonIncrementalFallback,
         Stream.mapArrayEffect((parts) =>
           decodeParts(parts).pipe(
             tracker ?
@@ -1340,6 +1370,7 @@ export const make: (params: {
       const schema = Schema.NonEmptyArray(Response.StreamPart(toolkit))
       const decodeParts = Schema.decodeEffect(schema)
       return params.streamText(providerOptions).pipe(
+        withNonIncrementalFallback,
         Stream.mapArrayEffect((parts) =>
           decodeParts(parts).pipe(
             tracker ?
@@ -1419,6 +1450,7 @@ export const make: (params: {
     })
 
     yield* params.streamText(providerOptions).pipe(
+      withNonIncrementalFallback,
       Stream.runForEachArray(
         Effect.fnUntraced(function*(chunk) {
           const parts = yield* decodeParts(chunk)

package/src/unstable/ai/ResponseIdTracker.ts

@@ -38,16 +38,16 @@ export class ResponseIdTracker
  * @category constructors
  */
 export const make: Effect.Effect<Service> = Effect.sync(() => {
-  let sentParts = new WeakMap<object, string>()
+  const sentParts = new Map<object, string>()
 
   const none = () => {
-    sentParts = new WeakMap<object, string>()
+    sentParts.clear()
     return Option.none<PrepareResult>()
   }
 
   return {
     clearUnsafe() {
-      sentParts = new WeakMap<object, string>()
+      sentParts.clear()
     },
     markParts(parts, responseId) {
       for (let i = 0; i < parts.length; i++) {

package/src/unstable/ai/Tool.ts

@@ -1149,7 +1149,7 @@ const dynamicProto = <
  */
 export const make = <
   const Name extends string,
-  Parameters extends Schema.Top = typeof Schema.Void,
+  Parameters extends Schema.Top = typeof EmptyParams,
   Success extends Schema.Top = typeof Schema.Void,
   Failure extends Schema.Top = typeof Schema.Never,
   Mode extends FailureMode | undefined = undefined,
@@ -1210,7 +1210,7 @@ export const make = <
   return userDefinedProto({
     name,
     description: options?.description,
-    parametersSchema: options?.parameters ?? Schema.Void,
+    parametersSchema: options?.parameters ?? EmptyParams,
     successSchema,
     failureSchema,
     failureMode: options?.failureMode ?? "error",

package/src/unstable/ai/index.ts

@@ -153,6 +153,24 @@ export * as AnthropicStructuredOutput from "./AnthropicStructuredOutput.ts"
  */
 export * as Chat from "./Chat.ts"
 
+/**
+ * The `EmbeddingModel` module provides provider-agnostic text embedding capabilities.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { EmbeddingModel } from "effect/unstable/ai"
+ *
+ * const program = Effect.gen(function*() {
+ *   const model = yield* EmbeddingModel.EmbeddingModel
+ *   return yield* model.embed("hello world")
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ */
+export * as EmbeddingModel from "./EmbeddingModel.ts"
+
 /**
  * The `IdGenerator` module provides a pluggable system for generating unique identifiers
  * for tool calls and other items in the Effect AI SDKs.