effect 4.0.0-beta.40 → 4.0.0-beta.42

package/src/TxSubscriptionRef.ts

@@ -92,7 +92,7 @@ const TxSubscriptionRefProto: Omit<TxSubscriptionRef<any>, typeof TypeId | "ref"
  * @since 4.0.0
  * @category constructors
  */
-export const make = <A>(value: A): Effect.Effect<TxSubscriptionRef<A>, never, Effect.Transaction> =>
+export const make = <A>(value: A): Effect.Effect<TxSubscriptionRef<A>> =>
   Effect.gen(function*() {
     const ref = yield* TxRef.make(value)
     const pubsub = yield* TxPubSub.unbounded<A>()
@@ -101,7 +101,7 @@ export const make = <A>(value: A): Effect.Effect<TxSubscriptionRef<A>, never, Ef
     self.ref = ref
     self.pubsub = pubsub
     return self
-  })
+  }).pipe(Effect.tx)
 
 // =============================================================================
 // Getters
@@ -124,7 +124,7 @@ export const make = <A>(value: A): Effect.Effect<TxSubscriptionRef<A>, never, Ef
  * @since 4.0.0
  * @category getters
  */
-export const get = <A>(self: TxSubscriptionRef<A>): Effect.Effect<A, never, Effect.Transaction> => TxRef.get(self.ref)
+export const get = <A>(self: TxSubscriptionRef<A>): Effect.Effect<A> => TxRef.get(self.ref)
 
 // =============================================================================
 // Mutations
@@ -173,7 +173,7 @@ export const modify: {
    * @since 4.0.0
    * @category mutations
    */
-  <A, B>(f: (current: A) => [returnValue: B, newValue: A]): (self: TxSubscriptionRef<A>) => Effect.Effect<B, never, Effect.Transaction>
+  <A, B>(f: (current: A) => [returnValue: B, newValue: A]): (self: TxSubscriptionRef<A>) => Effect.Effect<B>
   // =============================================================================
   // Mutations
   // =============================================================================
@@ -200,20 +200,20 @@ export const modify: {
   <A, B>(
     self: TxSubscriptionRef<A>,
     f: (current: A) => [returnValue: B, newValue: A]
-  ): Effect.Effect<B, never, Effect.Transaction>
+  ): Effect.Effect<B>
 } = dual(
   2,
   <A, B>(
     self: TxSubscriptionRef<A>,
     f: (current: A) => [returnValue: B, newValue: A]
-  ): Effect.Effect<B, never, Effect.Transaction> =>
+  ): Effect.Effect<B> =>
     Effect.gen(function*() {
       const current = yield* TxRef.get(self.ref)
       const [returnValue, newValue] = f(current)
       yield* TxRef.set(self.ref, newValue)
       yield* TxPubSub.publish(self.pubsub, newValue)
       return returnValue
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -251,7 +251,7 @@ export const set: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(value: A): (self: TxSubscriptionRef<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(value: A): (self: TxSubscriptionRef<A>) => Effect.Effect<void>
   /**
    * Sets the value of the TxSubscriptionRef and publishes the new value to all subscribers.
    *
@@ -269,11 +269,10 @@ export const set: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<void, never, Effect.Transaction> =>
-    modify(self, () => [void 0, value])
+  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<void> => modify(self, () => [void 0, value])
 )
 
 /**
@@ -313,7 +312,7 @@ export const update: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(f: (current: A) => A): (self: TxSubscriptionRef<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(f: (current: A) => A): (self: TxSubscriptionRef<A>) => Effect.Effect<void>
   /**
    * Updates the value of the TxSubscriptionRef using a function and publishes the new
    * value to all subscribers.
@@ -332,10 +331,10 @@ export const update: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<void> =>
     modify(self, (current) => [void 0, f(current)])
 )
 
@@ -378,7 +377,7 @@ export const getAndSet: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(value: A): (self: TxSubscriptionRef<A>) => Effect.Effect<A, never, Effect.Transaction>
+  <A>(value: A): (self: TxSubscriptionRef<A>) => Effect.Effect<A>
   /**
    * Gets the current value and sets a new value atomically. Publishes the new value
    * to all subscribers.
@@ -398,11 +397,10 @@ export const getAndSet: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<A, never, Effect.Transaction>
+  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<A>
 } = dual(
   2,
-  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<A, never, Effect.Transaction> =>
-    modify(self, (current) => [current, value])
+  <A>(self: TxSubscriptionRef<A>, value: A): Effect.Effect<A> => modify(self, (current) => [current, value])
 )
 
 /**
@@ -444,7 +442,7 @@ export const getAndUpdate: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(f: (current: A) => A): (self: TxSubscriptionRef<A>) => Effect.Effect<A, never, Effect.Transaction>
+  <A>(f: (current: A) => A): (self: TxSubscriptionRef<A>) => Effect.Effect<A>
   /**
    * Gets the current value and updates it using a function atomically. Publishes
    * the new value to all subscribers.
@@ -464,10 +462,10 @@ export const getAndUpdate: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A, never, Effect.Transaction>
+  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A>
 } = dual(
   2,
-  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A, never, Effect.Transaction> =>
+  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A> =>
     modify(self, (current) => [current, f(current)])
 )
 
@@ -508,7 +506,7 @@ export const updateAndGet: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(f: (current: A) => A): (self: TxSubscriptionRef<A>) => Effect.Effect<A, never, Effect.Transaction>
+  <A>(f: (current: A) => A): (self: TxSubscriptionRef<A>) => Effect.Effect<A>
   /**
    * Updates the value using a function and returns the new value. Publishes the
    * new value to all subscribers.
@@ -527,10 +525,10 @@ export const updateAndGet: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A, never, Effect.Transaction>
+  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A>
 } = dual(
   2,
-  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A, never, Effect.Transaction> =>
+  <A>(self: TxSubscriptionRef<A>, f: (current: A) => A): Effect.Effect<A> =>
     modify(self, (current) => {
       const newValue = f(current)
       return [newValue, newValue]
@@ -573,7 +571,7 @@ export const changes = <A>(
   self: TxSubscriptionRef<A>
 ): Effect.Effect<TxQueue.TxQueue<A>, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.transaction(
+    Effect.tx(
       Effect.gen(function*() {
         const sub = yield* TxPubSub.acquireSubscriber(self.pubsub)
         const current = yield* TxRef.get(self.ref)
@@ -581,7 +579,7 @@ export const changes = <A>(
         return sub
       })
     ),
-    (queue) => Effect.transaction(TxPubSub.releaseSubscriber(self.pubsub, queue))
+    (queue) => Effect.tx(TxPubSub.releaseSubscriber(self.pubsub, queue))
   )
 
 /**
@@ -611,7 +609,7 @@ export const changesStream = <A>(self: TxSubscriptionRef<A>): Stream.Stream<A, n
   Stream.unwrap(
     Effect.map(
       changes(self),
-      (sub) => Stream.fromEffectRepeat(Effect.transaction(TxQueue.take(sub)))
+      (sub) => Stream.fromEffectRepeat(Effect.tx(TxQueue.take(sub)))
     )
   )
 

package/src/index.ts

@@ -1086,7 +1086,7 @@ export * as Equal from "./Equal.ts"
  * - Using strict equality (`===`) → {@link strictEqual}
  * - Combining multiple equivalences (AND logic) → {@link combine}, {@link combineAll}
  * - Transforming input before comparison → {@link mapInput}
- * - Creating equivalences for structured types → {@link Struct}, {@link Tuple}, {@link Array}, {@link Record}
+ * - Creating equivalences for structured types → {@link Struct}, {@link Tuple}, {@link Array_}, {@link Record}
  *
  * ## Gotchas
  *
@@ -1114,7 +1114,7 @@ export * as Equal from "./Equal.ts"
  * ## See also
  *
  * - {@link Equal} - For structural equality (can convert to Equivalence)
- * - {@link Array.dedupeWith} - Remove duplicates using an equivalence
+ * - {@link Array_.dedupeWith} - Remove duplicates using an equivalence
  * - {@link Chunk} - Collections that use equivalences for operations
  *
  * @since 2.0.0
@@ -3270,7 +3270,7 @@ export * as Scheduler from "./Scheduler.ts"
  *
  * - Define a struct: {@link Struct}
  * - Define a union: {@link Union}, {@link TaggedUnion}, {@link Literals}
- * - Define an array: {@link Array}, {@link NonEmptyArray}
+ * - Define an array: {@link ArraySchema}, {@link NonEmptyArray}
  * - Define a record: {@link Record}
  * - Define a tuple: {@link Tuple}, {@link TupleWithRest}
  * - Validate unknown data synchronously: {@link decodeUnknownSync}
@@ -4039,7 +4039,7 @@ export * as Tuple from "./Tuple.ts"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @since 4.0.0
  */
@@ -4089,7 +4089,7 @@ export * as TxPubSub from "./TxPubSub.ts"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxQueue values change.
+ * calls `Effect.txRetry` and any of the accessed TxQueue values change.
  *
  * @since 4.0.0
  */
@@ -4110,7 +4110,7 @@ export * as TxReentrantLock from "./TxReentrantLock.ts"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and in order to
  * track changes, a transaction will retry whenever a conflict is detected or whenever the
- * transaction explicitely calls to `Effect.retryTransaction` and any of the accessed TxRef values
+ * transaction explicitely calls to `Effect.txRetry` and any of the accessed TxRef values
  * change.
  *
  * @since 4.0.0

package/src/internal/effect.ts

@@ -5025,6 +5025,9 @@ export const runForkWith = <R>(services: ServiceMap.ServiceMap<R>) =>
       fiber.addObserver(() => options.signal!.removeEventListener("abort", abort))
     }
   }
+  if (options?.onFiberStart) {
+    options.onFiberStart(fiber)
+  }
   return fiber
 }
 

package/src/internal/schema/representation.ts

@@ -527,11 +527,39 @@ export function toJsonSchemaMultiDocument(
           // anyOf MUST be a non-empty array
           return { not: {} }
         }
+        if (types.length > 1) {
+          const compacted = compactEnums(types)
+          if (compacted) return compacted
+        }
         return schema.mode === "anyOf" ? { anyOf: types } : { oneOf: types }
       }
     }
   }
 
+  // Collapses [{type:"string",enum:["a"]},{type:"string",enum:["b"]}] into {type:"string",enum:["a","b"]}.
+  // Returns undefined if members have different types, extra keys (e.g. title), or empty enums.
+  function compactEnums(
+    types: ReadonlyArray<JsonSchema.JsonSchema>
+  ): JsonSchema.JsonSchema | undefined {
+    let sharedType: string | undefined
+    const values: Array<unknown> = []
+    for (const t of types) {
+      const keys = Object.keys(t)
+      if (keys.length !== 2 || t.type === undefined || !Array.isArray(t.enum) || t.enum.length === 0) {
+        return undefined
+      }
+      if (sharedType === undefined) {
+        sharedType = t.type as string
+      } else if (t.type !== sharedType) {
+        return undefined
+      }
+      for (const v of t.enum) {
+        values.push(v)
+      }
+    }
+    return { type: sharedType, enum: values }
+  }
+
   function collectJsonSchemaAnnotations(
     annotations: Schema.Annotations.Annotations | undefined
   ): JsonSchema.JsonSchema | undefined {

package/src/unstable/ai/Chat.ts

@@ -64,6 +64,7 @@ import * as IdGenerator from "./IdGenerator.ts"
 import * as LanguageModel from "./LanguageModel.ts"
 import * as Prompt from "./Prompt.ts"
 import type * as Response from "./Response.ts"
+import type * as Tool from "./Tool.ts"
 
 /**
  * The `Chat` service tag for dependency injection.
@@ -198,13 +199,43 @@ export interface Service {
    * })
    * ```
    */
-  readonly generateText: <
-    Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>
-  >(options: Options & LanguageModel.GenerateTextOptions<LanguageModel.ExtractTools<Options>>) => Effect.Effect<
-    LanguageModel.GenerateTextResponse<LanguageModel.ExtractTools<Options>>,
-    LanguageModel.ExtractError<Options>,
-    LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
-  >
+  readonly generateText: {
+    <Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<{}>, Options>>(
+      options: Options & { readonly toolkit?: undefined } & LanguageModel.GenerateTextOptions<{}>
+    ): Effect.Effect<
+      LanguageModel.GenerateTextResponse<{}>,
+      LanguageModel.ExtractError<Options>,
+      LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
+    >
+    <
+      Tools extends Record<string, Tool.Any>,
+      Options extends NoExcessProperties<
+        LanguageModel.GenerateTextOptions<Tools> & { readonly toolkit: LanguageModel.ToolkitInput<Tools> },
+        Options
+      >
+    >(
+      options: Options & LanguageModel.GenerateTextOptions<Tools> & {
+        readonly toolkit: LanguageModel.ToolkitInput<Tools>
+      }
+    ): Effect.Effect<
+      LanguageModel.GenerateTextResponse<Tools>,
+      LanguageModel.ExtractError<Options>,
+      LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
+    >
+    <
+      Options extends {
+        readonly toolkit: LanguageModel.ToolkitOption<any>
+      } & NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>
+    >(
+      options: Options & LanguageModel.GenerateTextOptions<LanguageModel.ExtractTools<Options>> & {
+        readonly toolkit: Options["toolkit"]
+      }
+    ): Effect.Effect<
+      LanguageModel.GenerateTextResponse<LanguageModel.ExtractTools<Options>>,
+      LanguageModel.ExtractError<Options>,
+      LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
+    >
+  }
 
   /**
    * Generate text using a language model with streaming output.
@@ -231,13 +262,43 @@ export interface Service {
    * })
    * ```
    */
-  readonly streamText: <
-    Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>
-  >(options: Options & LanguageModel.GenerateTextOptions<LanguageModel.ExtractTools<Options>>) => Stream.Stream<
-    Response.StreamPart<LanguageModel.ExtractTools<Options>>,
-    LanguageModel.ExtractError<Options>,
-    LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
-  >
+  readonly streamText: {
+    <Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<{}>, Options>>(
+      options: Options & { readonly toolkit?: undefined } & LanguageModel.GenerateTextOptions<{}>
+    ): Stream.Stream<
+      Response.StreamPart<{}>,
+      LanguageModel.ExtractError<Options>,
+      LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
+    >
+    <
+      Tools extends Record<string, Tool.Any>,
+      Options extends NoExcessProperties<
+        LanguageModel.GenerateTextOptions<Tools> & { readonly toolkit: LanguageModel.ToolkitInput<Tools> },
+        Options
+      >
+    >(
+      options: Options & LanguageModel.GenerateTextOptions<Tools> & {
+        readonly toolkit: LanguageModel.ToolkitInput<Tools>
+      }
+    ): Stream.Stream<
+      Response.StreamPart<Tools>,
+      LanguageModel.ExtractError<Options>,
+      LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
+    >
+    <
+      Options extends {
+        readonly toolkit: LanguageModel.ToolkitOption<any>
+      } & NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>
+    >(
+      options: Options & LanguageModel.GenerateTextOptions<LanguageModel.ExtractTools<Options>> & {
+        readonly toolkit: Options["toolkit"]
+      }
+    ): Stream.Stream<
+      Response.StreamPart<LanguageModel.ExtractTools<Options>>,
+      LanguageModel.ExtractError<Options>,
+      LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
+    >
+  }
 
   /**
    * Generate a structured object using a language model and schema.
@@ -334,7 +395,7 @@ const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
       },
       semaphore.withPermits(1),
       (effect) => Effect.withSpan(effect, "Chat.generateText", { captureStackTrace: false })
-    ),
+    ) as Service["generateText"],
     streamText: Effect.fnUntraced(
       function*(options) {
         let parts = Chunk.empty<Response.AnyPart>()
@@ -366,7 +427,7 @@ const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
         )
       },
       Stream.unwrap
-    ),
+    ) as Service["streamText"],
     generateObject: Effect.fnUntraced(
       function*(options) {
         const newPrompt = Prompt.make(options.prompt)
@@ -713,7 +774,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
           return yield* chat.generateText(options).pipe(
             Effect.ensuring(Effect.orDie(saveChat(history)))
           )
-        }),
+        }) as Service["generateText"],
         generateObject: Effect.fnUntraced(function*(options) {
           const history = yield* Ref.get(chat.history)
           return yield* chat.generateObject(options).pipe(
@@ -726,7 +787,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
             Stream.ensuring(Effect.orDie(saveChat(history)))
           )
           return stream
-        }, Stream.unwrap)
+        }, Stream.unwrap) as Service["streamText"]
       }
 
       return persisted