effect 4.0.0-beta.10 → 4.0.0-beta.11

package/src/SchemaAST.ts

@@ -1455,7 +1455,8 @@ export class Arrays extends Base {
         // handle post rest elements
         // ---------------------------------------------
         for (let j = 0; j < tail.length; j++) {
-          if (len < i + 1) {
+          i += j
+          if (len < i) {
             continue
           } else {
             const tailj = tail[j]

package/src/Stream.ts

@@ -22,7 +22,7 @@ import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
 import * as Latch from "./Latch.ts"
 import type * as Layer from "./Layer.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { Severity } from "./LogLevel.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import * as MutableList from "./MutableList.ts"
 import * as Option from "./Option.ts"
@@ -8820,12 +8820,12 @@ export const orDie = <A, E, R>(self: Stream<A, E, R>): Stream<A, never, R> => fr
  */
 export const ignore: <
   Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 >(
   selfOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R>
   : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R> = dual(
@@ -8833,7 +8833,7 @@ export const ignore: <
     <A, E, R>(
       self: Stream<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel | undefined
+        readonly log?: boolean | Severity | undefined
       } | undefined
     ): Stream<A, never, R> => fromChannel(Channel.ignore(self.channel, options))
   )
@@ -8860,19 +8860,19 @@ export const ignore: <
  */
 export const ignoreCause: <
   Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 >(
   streamOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R>
   : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R> = dual(
     (args) => isStream(args[0]),
     <A, E, R>(
       self: Stream<A, E, R>,
-      options?: { readonly log?: boolean | LogLevel | undefined } | undefined
+      options?: { readonly log?: boolean | Severity | undefined } | undefined
     ): Stream<A, never, R> => fromChannel(Channel.ignoreCause(self.channel, options))
   )
 

package/src/index.ts

@@ -1119,6 +1119,11 @@ export * as Equal from "./Equal.ts"
  */
 export * as Equivalence from "./Equivalence.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as ErrorReporter from "./ErrorReporter.ts"
+
 /**
  * @since 3.16.0
  */

package/src/internal/effect.ts

@@ -5,6 +5,7 @@ import type * as Console from "../Console.ts"
 import * as Duration from "../Duration.ts"
 import type * as Effect from "../Effect.ts"
 import * as Equal from "../Equal.ts"
+import type { ErrorReporter } from "../ErrorReporter.ts"
 import type * as Exit from "../Exit.ts"
 import type * as Fiber from "../Fiber.ts"
 import * as Filter from "../Filter.ts"
@@ -341,7 +342,8 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
   return errors
 }
 
-const causePrettyError = (
+/** @internal */
+export const causePrettyError = (
   original: Record<string, unknown> | Error,
   annotations?: ReadonlyMap<string, unknown>
 ): Error => {
@@ -490,17 +492,33 @@ const fiberIdStore = { id: 0 }
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
 const keepAlive = (() => {
+  const start = (() => {
+    const setInterval = globalThis.setInterval
+    const clearInterval = globalThis.clearInterval
+    try {
+      const running = setInterval(constVoid, 2_147_483_647)
+      clearInterval(running)
+      return {
+        setInterval,
+        clearInterval
+      }
+    } catch {
+      return undefined
+    }
+  })()
   let count = 0
   let running: ReturnType<typeof globalThis.setInterval> | undefined = undefined
   return ({
     increment() {
       count++
-      running ??= globalThis.setInterval(constVoid, 2_147_483_647)
+      if (start !== undefined && running === undefined) {
+        running = start.setInterval(constVoid, 2_147_483_647)
+      }
     },
     decrement() {
       count--
-      if (count === 0 && running !== undefined) {
-        globalThis.clearInterval(running)
+      if (count === 0 && start !== undefined && running !== undefined) {
+        start.clearInterval(running)
         running = undefined
       }
     }
@@ -3093,14 +3111,14 @@ export const eventually = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect
 /** @internal */
 export const ignore: <
   Arg extends Effect.Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R> = dual(
@@ -3108,7 +3126,7 @@ export const ignore: <
     <A, E, R>(
       self: Effect.Effect<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel.LogLevel | undefined
+        readonly log?: boolean | LogLevel.Severity | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
@@ -3128,14 +3146,14 @@ export const ignore: <
 /** @internal */
 export const ignoreCause: <
   Arg extends Effect.Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R> = dual(
@@ -3143,7 +3161,7 @@ export const ignoreCause: <
     <A, E, R>(
       self: Effect.Effect<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel.LogLevel | undefined
+        readonly log?: boolean | LogLevel.Severity | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
@@ -4080,6 +4098,59 @@ export const partition: {
     )
 )
 
+/** @internal */
+export const validate: {
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): (elements: Iterable<A>) => Effect.Effect<void, Arr.NonEmptyArray<E>, R>
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): Effect.Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): Effect.Effect<void, Arr.NonEmptyArray<E>, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: boolean | undefined
+    } | undefined
+  ): Effect.Effect<Array<B> | void, Arr.NonEmptyArray<E>, R> =>
+    flatMap(
+      partition(elements, f, { concurrency: options?.concurrency }),
+      ([excluded, satisfying]) => {
+        if (Arr.isArrayNonEmpty(excluded)) {
+          return fail(excluded)
+        }
+        return options?.discard ? void_ : succeed(satisfying)
+      }
+    )
+)
+
 /** @internal */
 export const whileLoop: <A, E, R>(options: {
   readonly while: LazyArg<boolean>
@@ -5499,7 +5570,7 @@ const LoggerProto = {
 
 /** @internal */
 export const loggerMake = <Message, Output>(
-  log: (options: Logger.Logger.Options<Message>) => Output
+  log: (options: Logger.Options<Message>) => Output
 ): Logger.Logger<Message, Output> => {
   const self = Object.create(LoggerProto)
   self.log = log
@@ -5539,7 +5610,7 @@ export const structuredMessage = (u: unknown): unknown => {
 }
 
 /** @internal */
-export const logWithLevel = (level?: LogLevel.LogLevel) =>
+export const logWithLevel = (level?: LogLevel.Severity) =>
 (
   ...message: ReadonlyArray<any>
 ): Effect.Effect<void> => {
@@ -5830,3 +5901,55 @@ const undefined_ = succeed(undefined)
 
 /** @internal */
 export { undefined_ as undefined }
+
+// ----------------------------------------------------------------------------
+// ErrorReporter
+// ----------------------------------------------------------------------------
+
+/** @internal */
+export const CurrentErrorReporters = ServiceMap.Reference<
+  ReadonlySet<ErrorReporter>
+>("effect/ErrorReporter/CurrentErrorReporters", {
+  defaultValue: () => new Set()
+})
+
+/** @internal */
+export const withErrorReporting: <
+  Arg extends Effect.Effect<any, any, any> | {
+    readonly defectsOnly?: boolean | undefined
+  } | undefined = {
+    readonly defectsOnly?: boolean | undefined
+  }
+>(
+  effectOrOptions: Arg,
+  options?: {
+    readonly defectsOnly?: boolean | undefined
+  } | undefined
+) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Arg
+  : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> = dual(
+    (args) => isEffect(args[0]),
+    <A, E, R>(
+      self: Effect.Effect<A, E, R>,
+      options?: {
+        readonly defectsOnly?: boolean | undefined
+      } | undefined
+    ): Effect.Effect<A, E, R> =>
+      onError(self, (cause) =>
+        withFiber((fiber) => {
+          reportCauseUnsafe(fiber, cause, options?.defectsOnly)
+          return void_
+        }))
+  )
+
+/** @internal */
+export const reportCauseUnsafe = (
+  fiber: Fiber.Fiber<unknown, unknown>,
+  cause: Cause.Cause<unknown>,
+  defectsOnly?: boolean
+) => {
+  const reporters = fiber.getRef(CurrentErrorReporters)
+  if (reporters.size === 0) return
+  if (defectsOnly && !hasDies(cause)) return
+  const opts = { cause, fiber, timestamp: fiber.getRef(ClockRef).currentTimeNanosUnsafe() }
+  reporters.forEach((reporter) => reporter.report(opts))
+}

package/src/internal/hashMap.ts

@@ -83,7 +83,7 @@ function mergeLeaves<K, V>(
   }
 
   const bitmap = bit1 | bit2
-  const children: Array<Node<K, V>> = bit1 < bit2
+  const children: Array<Node<K, V>> = (bit1 >>> 0) < (bit2 >>> 0)
     ? [node1, node2]
     : [node2, node1]
 
@@ -248,7 +248,7 @@ class LeafNode<K, V> extends Node<K, V> {
     }
 
     const bitmap = newBit | existingBit
-    const nodes: Array<Node<K, V>> = newBit < existingBit
+    const nodes: Array<Node<K, V>> = (newBit >>> 0) < (existingBit >>> 0)
       ? [new LeafNode(edit, hash, key, value), this]
       : [this, new LeafNode(edit, hash, key, value)]
 

package/src/unstable/ai/LanguageModel.ts

@@ -984,6 +984,13 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
           toolMessage
         ])
       }
+
+      // Strip consumed approval artifacts so they don't reach the provider
+      providerOptions.prompt = stripResolvedApprovals(
+        providerOptions.prompt,
+        approved,
+        denied
+      )
     }
 
     const tools = typeof toolChoice === "object" && "oneOf" in toolChoice
@@ -1165,6 +1172,13 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
           toolMessage
         ])
       }
+
+      // Strip consumed approval artifacts so they don't reach the provider
+      providerOptions.prompt = stripResolvedApprovals(
+        providerOptions.prompt,
+        pendingApproved,
+        pendingDenied
+      )
     }
 
     const tools = typeof toolChoice === "object" && "oneOf" in toolChoice
@@ -1506,6 +1520,63 @@ const collectToolApprovals = (
   return { approved, denied }
 }
 
+/**
+ * Strip resolved approval artifacts from the prompt before sending to the
+ * provider. After pre-resolving approvals (executing approved tools and
+ * creating denial results), the original `tool-approval-request` parts in
+ * assistant messages and `tool-approval-response` parts in tool messages are
+ * no longer needed. Leaving them in causes provider-specific errors (e.g.
+ * OpenAI rejects `mcp_approval_response` items that reference approval
+ * requests it never issued).
+ */
+const stripResolvedApprovals = (
+  prompt: Prompt.Prompt,
+  approved: ReadonlyArray<ApprovalResult>,
+  denied: ReadonlyArray<ApprovalResult>
+): Prompt.Prompt => {
+  const resolvedApprovalIds = new Set<string>()
+  for (const a of approved) resolvedApprovalIds.add(a.approvalId)
+  for (const d of denied) resolvedApprovalIds.add(d.approvalId)
+
+  const cleanedMessages: Array<Prompt.Message> = []
+
+  for (const message of prompt.content) {
+    if (message.role === "assistant") {
+      const filteredContent = message.content.filter(
+        (part) =>
+          part.type !== "tool-approval-request" ||
+          !resolvedApprovalIds.has(part.approvalId)
+      )
+      if (filteredContent.length > 0) {
+        cleanedMessages.push(
+          Prompt.makeMessage("assistant", {
+            content: filteredContent,
+            options: message.options
+          })
+        )
+      }
+    } else if (message.role === "tool") {
+      const filteredContent = message.content.filter(
+        (part) =>
+          part.type !== "tool-approval-response" ||
+          !resolvedApprovalIds.has(part.approvalId)
+      )
+      if (filteredContent.length > 0) {
+        cleanedMessages.push(
+          Prompt.makeMessage("tool", {
+            content: filteredContent,
+            options: message.options
+          })
+        )
+      }
+    } else {
+      cleanedMessages.push(message)
+    }
+  }
+
+  return Prompt.fromMessages(cleanedMessages)
+}
+
 const isApprovalNeeded = Effect.fnUntraced(function*<T extends Tool.Any>(
   tool: T,
   toolCall: Response.ToolCallPartEncoded,

package/src/unstable/cli/CliOutput.ts

@@ -499,14 +499,53 @@ const formatHelpDocImpl = (doc: HelpDoc, colors: ColorFunctions): string => {
 
   // Subcommands section
   if (doc.subcommands && doc.subcommands.length > 0) {
-    sections.push(colors.bold("SUBCOMMANDS"))
+    const ungrouped = doc.subcommands.find((group) => group.group === undefined)
+
+    if (ungrouped) {
+      sections.push(colors.bold("SUBCOMMANDS"))
+      sections.push(renderTable(
+        ungrouped.commands.map((sub) => ({
+          left: colors.cyan(sub.name),
+          right: sub.shortDescription ?? sub.description
+        })),
+        20
+      ))
+      if (doc.subcommands.length > 1) {
+        sections.push("")
+      }
+    }
 
-    const subcommandRows: Array<Row> = doc.subcommands.map((sub) => ({
-      left: colors.cyan(sub.name),
-      right: sub.description
-    }))
+    for (const group of doc.subcommands) {
+      if (group.group === undefined) continue
+      sections.push(colors.bold(`${group.group}:`))
+      sections.push(renderTable(
+        group.commands.map((sub) => ({
+          left: colors.cyan(sub.name),
+          right: sub.shortDescription ?? sub.description
+        })),
+        20
+      ))
+      sections.push("")
+    }
+  }
 
-    sections.push(renderTable(subcommandRows, 20))
+  // Examples section
+  if (doc.examples && doc.examples.length > 0) {
+    sections.push(colors.bold("EXAMPLES"))
+
+    let first = true
+    let previousHadDescription = false
+    for (const example of doc.examples) {
+      if (example.description) {
+        if (!first) sections.push("")
+        sections.push(`  ${colors.dim(`# ${example.description}`)}`)
+      } else if (previousHadDescription) {
+        sections.push("")
+      }
+      sections.push(`  ${colors.cyan(example.command)}`)
+      first = false
+      previousHadDescription = !!example.description
+    }
     sections.push("")
   }