@effect-uai/core 0.1.0 → 0.2.0

package/src/tool/Resolvers.ts

@@ -1,29 +1,52 @@
 /**
- * Ready-made `Resolver`s for the two transport flavors plus combinators
- * for layering policy on top.
+ * Approval helpers for the two transport flavors.
  *
- *   - `fromVerdictQueue` : long-lived channel (WebSocket / SSE).
- *   - `fromApprovalMap`  : request-shaped (HTTP chat).
- *   - `withPermissions`  : authz wrapper.
- *   - `withFallback`     : recovery wrapper.
- *
- * None of these know about the executor's stream shape; they just produce
- * `Effect<ToolDecision>`s a `Resolver` can return.
+ * These helpers only decide which calls are approved and which synthetic
+ * results must be returned to the model. Tool execution stays explicit at
+ * the recipe boundary via `Toolkit.executeAll`.
  */
 import { Deferred, Effect, Queue, Scope, Stream } from "effect"
 import type { FunctionCall } from "../domain/Items.js"
-import {
-  type ToolDecision,
-  type ToolResult,
-  cancelled,
-  denied,
-  execute,
-  reject,
-  rejected,
-} from "./Outcome.js"
-import type { Resolver } from "./Toolkit.js"
+import { type ToolResult, cancelled, denied } from "./Outcome.js"
 import type { ToolEvent } from "./ToolEvent.js"
 
+export interface ToolCallPlan {
+  readonly approved: ReadonlyArray<FunctionCall>
+  readonly rejected: ReadonlyArray<ToolResult>
+}
+
+export type ToolCallDecision =
+  | { readonly _tag: "Approved"; readonly call: FunctionCall }
+  | { readonly _tag: "Rejected"; readonly result: ToolResult }
+
+export const approve = (call: FunctionCall): ToolCallDecision => ({
+  _tag: "Approved",
+  call,
+})
+
+export const reject = (result: ToolResult): ToolCallDecision => ({
+  _tag: "Rejected",
+  result,
+})
+
+export const splitToolCallDecisions = (
+  decisions: ReadonlyArray<ToolCallDecision>,
+): ToolCallPlan =>
+  decisions.reduce<ToolCallPlan>(
+    (acc, decision) =>
+      decision._tag === "Approved"
+        ? { ...acc, approved: [...acc.approved, decision.call] }
+        : { ...acc, rejected: [...acc.rejected, decision.result] },
+    { approved: [], rejected: [] },
+  )
+
+export const approvalRequested = (call: FunctionCall): ToolEvent => ({
+  _tag: "ApprovalRequested",
+  call_id: call.call_id,
+  tool: call.name,
+  arguments: call.arguments,
+})
+
 // ---------------------------------------------------------------------------
 // Verdict queue (WebSocket-style transport).
 // ---------------------------------------------------------------------------
@@ -35,10 +58,9 @@ export interface Verdict {
 }
 
 /**
- * Queue-backed resolver. The router fiber drains verdicts and resolves
- * pre-registered Deferreds keyed by `call_id`. Returns the resolver and
- * a stream of `ApprovalRequested` events for the gated calls; the recipe
- * merges the announce stream into its consumer view.
+ * Queue-backed approval planner. Safe calls are returned immediately in
+ * `approved`; gated calls emit `ApprovalRequested` events and later produce
+ * one `ToolCallDecision` when their matching verdict arrives.
  */
 export const fromVerdictQueue =
   (
@@ -49,7 +71,8 @@ export const fromVerdictQueue =
     calls: ReadonlyArray<FunctionCall>,
   ): Effect.Effect<
     {
-      readonly resolve: Resolver
+      readonly approved: ReadonlyArray<FunctionCall>
+      readonly decisions: Stream.Stream<ToolCallDecision>
       readonly announce: Stream.Stream<ToolEvent>
     },
     never,
@@ -57,6 +80,7 @@ export const fromVerdictQueue =
   > =>
     Effect.gen(function* () {
       const gated = calls.filter(predicate)
+      const approved = calls.filter((call) => !predicate(call))
 
       const entries = yield* Effect.forEach(gated, (call) =>
         Deferred.make<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),
@@ -76,26 +100,25 @@ export const fromVerdictQueue =
         ),
       )
 
-      const resolve: Resolver = (call) => {
-        if (!predicate(call)) return Effect.succeed(execute)
-        const d = deferreds.get(call.call_id)!
-        return Deferred.await(d).pipe(
-          Effect.map((v) =>
-            v.decision === "approve" ? execute : reject(denied(call, v.reason)),
-          ),
-        )
-      }
-
-      const announce = Stream.fromIterable<ToolEvent>(
-        gated.map((call) => ({
-          _tag: "ApprovalRequested",
-          call_id: call.call_id,
-          tool: call.name,
-          arguments: call.arguments,
-        })),
+      const decisions = Stream.fromIterable(gated).pipe(
+        Stream.flatMap(
+          (call) => {
+            const d = deferreds.get(call.call_id)!
+            return Stream.fromEffect(
+              Deferred.await(d).pipe(
+                Effect.map((v) =>
+                  v.decision === "approve" ? approve(call) : reject(denied(call, v.reason)),
+                ),
+              ),
+            )
+          },
+          { concurrency: "unbounded" },
+        ),
       )
 
-      return { resolve, announce }
+      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))
+
+      return { approved, decisions, announce }
     })
 
 // ---------------------------------------------------------------------------
@@ -111,56 +134,14 @@ export const fromApprovalMap =
   (
     predicate: (call: FunctionCall) => boolean,
     approvals: ReadonlyMap<string, ApprovalMapEntry>,
-  ): Resolver =>
-  (call) => {
-    if (!predicate(call)) return Effect.succeed(execute)
-    const v = approvals.get(call.call_id)
-    if (v === undefined) return Effect.succeed(reject(cancelled(call)))
-    return Effect.succeed(
-      v.decision === "approve" ? execute : reject(denied(call, v.reason)),
-    )
-  }
-
-// ---------------------------------------------------------------------------
-// Combinators - compose policy onto an inner resolver.
-// ---------------------------------------------------------------------------
-
-/**
- * Authz gate. `canApprove` runs BEFORE the inner resolver; failures
- * short-circuit to a `permission_denied` rejection. Override `onForbidden`
- * if your audit format wants a different kind or reason.
- */
-export const withPermissions =
-  (
-    inner: Resolver,
-    canApprove: (call: FunctionCall) => Effect.Effect<boolean>,
-    onForbidden: (call: FunctionCall) => ToolResult = (call) =>
-      rejected(call, "permission_denied", "missing permissions"),
-  ): Resolver =>
-  (call) =>
-    canApprove(call).pipe(
-      Effect.flatMap((allowed) =>
-        allowed ? inner(call) : Effect.succeed(reject(onForbidden(call))),
-      ),
-    )
-
-/**
- * Fallback gate. If `inner` returns a Reject whose result matches the
- * `recoverable` predicate, run `fallback(call)` instead and use that
- * decision. Otherwise pass the original Reject through.
- */
-export const withFallback =
-  (
-    inner: Resolver,
-    recoverable: (result: ToolResult) => boolean,
-    fallback: (call: FunctionCall) => Effect.Effect<ToolDecision>,
-  ): Resolver =>
-  (call) =>
-    inner(call).pipe(
-      Effect.flatMap((decision) =>
-        decision._tag === "Reject" && recoverable(decision.result)
-          ? fallback(call)
-          : Effect.succeed(decision),
-      ),
+  ) =>
+  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>
+    splitToolCallDecisions(
+      calls.map((call) => {
+        if (!predicate(call)) return approve(call)
+        const v = approvals.get(call.call_id)
+        if (v === undefined) return reject(cancelled(call))
+        return v.decision === "approve" ? approve(call) : reject(denied(call, v.reason))
+      }),
     )
 

package/src/tool/ToolEvent.ts

@@ -1,7 +1,7 @@
 /**
- * The event type emitted by `Toolkit.executeAllWithResolver`.
+ * The event type emitted while handling tool calls.
  *
- *   - ApprovalRequested : gated calls before resolver returns
+ *   - ApprovalRequested : gated calls waiting for approval
  *   - Intermediate      : per-element passthrough from a streaming tool's run
  *   - Output            : terminal result (carries a structured ToolResult)
  *

package/src/tool/Toolkit.ts

@@ -1,4 +1,4 @@
-import { Array as Arr, Effect, Match, Ref, Stream } from "effect"
+import { Array as Arr, Effect, Ref, Stream } from "effect"
 import * as Loop from "../loop/Loop.js"
 import type { FunctionCall } from "../domain/Items.js"
 import {
@@ -10,9 +10,7 @@ import {
   type ToolDescriptor,
 } from "./Tool.js"
 import {
-  type ToolDecision,
   type ToolResult,
-  execute as executeDecision,
   executionError,
   rejected,
 } from "./Outcome.js"
@@ -50,56 +48,32 @@ export const toDescriptors = <Tools extends ReadonlyArray<AnyTool>>(
   })
 
 // ---------------------------------------------------------------------------
-// Resolver-based executor. Streams `ToolEvent`s in real time, dispatches
-// streaming and plain tools uniformly, and lets the caller decide what
-// happens to each call (Execute or Reject) before execution.
-//
-// `executeAllWithResolver` is the general primitive. `executeAllStream` is
-// the no-resolver shortcut.
+// Tool executor. Streams `ToolEvent`s in real time and dispatches streaming
+// and plain tools uniformly. Policy stays outside this module: callers pass
+// only the calls they have already decided should run.
 // ---------------------------------------------------------------------------
 
-export type Resolver = (call: FunctionCall) => Effect.Effect<ToolDecision>
-
 export interface ExecuteOptions {
   readonly concurrency?: number | "unbounded"
 }
 
-export const executeAllWithResolver = (
+/** Execute every provided call. Approval/rejection policy belongs upstream. */
+export const executeAll = (
   tools: ReadonlyArray<AnyKindTool>,
   calls: ReadonlyArray<FunctionCall>,
-  resolve: Resolver,
   options?: ExecuteOptions,
 ): Stream.Stream<ToolEvent> =>
   Stream.fromIterable(calls).pipe(
-    Stream.flatMap(
-      (call) =>
-        Stream.unwrap(
-          resolve(call).pipe(Effect.map((decision) => dispatch(tools, call, decision))),
-        ),
-      { concurrency: options?.concurrency ?? "unbounded" },
-    ),
+    Stream.flatMap((call) => runOne(tools, call), {
+      concurrency: options?.concurrency ?? "unbounded",
+    }),
   )
 
-/** No-resolver shortcut: every call gets `Execute`. */
-export const executeAll = (
-  tools: ReadonlyArray<AnyKindTool>,
-  calls: ReadonlyArray<FunctionCall>,
-  options?: ExecuteOptions,
-): Stream.Stream<ToolEvent> =>
-  executeAllWithResolver(tools, calls, () => Effect.succeed(executeDecision), options)
+export const outputEvent = (result: ToolResult): ToolEvent => ({ _tag: "Output", result })
 
-const dispatch = (
-  tools: ReadonlyArray<AnyKindTool>,
-  call: FunctionCall,
-  decision: ToolDecision,
-): Stream.Stream<ToolEvent> =>
-  Match.value(decision).pipe(
-    Match.tag("Execute", () => runOne(tools, call)),
-    Match.tag("Reject", (d) =>
-      Stream.succeed<ToolEvent>({ _tag: "Output", result: d.result }),
-    ),
-    Match.exhaustive,
-  )
+export const outputEvents = (
+  results: ReadonlyArray<ToolResult>,
+): Stream.Stream<ToolEvent> => Stream.fromIterable(results.map(outputEvent))
 
 const valueResult = (call: FunctionCall, tool: string, value: unknown): ToolResult => ({
   _tag: "Value",

package/dist/Loop-CzSJo1h8.d.mts

@@ -1,87 +0,0 @@
-import { l as IncompleteTurn } from "./AiError-CqmYjXyx.mjs";
-import { a as TurnEvent, i as Turn } from "./Turn-rlTfuHaQ.mjs";
-import { Data, Effect, Stream } from "effect";
-
-//#region src/loop/Loop.d.ts
-declare namespace Loop_d_exports {
-  export { Event, loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, value };
-}
-/**
- * The tagged union a body emits per pull. `Value` carries a payload that
- * flows downstream. `Next` ends the current iteration and continues with a
- * new state. `Stop` ends the loop entirely.
- */
-type Event<A, S> = Data.TaggedEnum<{
-  Value: {
-    readonly value: A;
-  };
-  Next: {
-    readonly state: S;
-  };
-  Stop: {};
-}>;
-/** Wrap a value so it flows through the loop to downstream consumers. */
-declare const value: <A>(a: A) => Event<A, never>;
-/** End the current iteration and continue with a new state. */
-declare const next: <S>(state: S) => Event<never, S>;
-/** The terminal `Stop` event. Use `stop` (the Stream) to end a loop body. */
-declare const stopEvent: Event<never, never>;
-/**
- * A single-element stream that ends the loop. Return this from a body when
- * there's nothing else to emit; equivalent to `stopAfter(Stream.empty)` but
- * named for the common case.
- */
-declare const stop: Stream.Stream<Event<never, never>>;
-/**
- * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
- * iteration with `next(state)`. Common shape for "stream this turn's
- * deltas, then continue with updated history."
- */
-declare const nextAfter: <S, A, E, R>(stream: Stream.Stream<A, E, R>, state: S) => Stream.Stream<Event<A, S>, E, R>;
-/**
- * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
- * loop. Common shape for "stream this turn's deltas, then we're done."
- */
-declare const stopAfter: <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<Event<A, never>, E, R>;
-/**
- * General `nextAfter` variant: drain `stream` to the consumer, fold elements
- * into an accumulator, and at end-of-stream emit one `next(build(finalAcc))`.
- *
- * Subsumes `nextAfter` when state is constant (`reduce: (s, _) => s`,
- * `build: (s) => s`). Used by `Toolkit.nextStateFrom` to collect tool
- * results and build next state without exposing a Ref to recipes.
- */
-declare const nextAfterFold: <A, B, S, E, R>(stream: Stream.Stream<A, E, R>, initial: B, reduce: (acc: B, a: A) => B, build: (b: B) => S) => Stream.Stream<Event<A, S>, E, R>;
-/**
- * Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Event<TurnEvent | A, S>>`.
- * Each delta passes through as `value(delta)` (including the terminal
- * `turn_complete`, so the consumer sees turn boundaries naturally). Once
- * the terminal arrives, `then(turn)` runs and its returned stream of loop
- * events (typically tool outputs followed by `next(state)` or `stop`) is
- * concatenated.
- *
- * Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on
- * the raw delta stream cover anything an `emit`-style callback would do.
- *
- * If the upstream ends without a `turn_complete`, the resulting stream
- * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if
- * you want to recover.
- */
-declare const streamUntilComplete: <S, A, E2 = never, R2 = never>(then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>) => <E, R>(deltas: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>;
-type LoopBody<S, A, E, R> = (state: S) => Stream.Stream<Event<A, S>, E, R> | Effect.Effect<Stream.Stream<Event<A, S>, E, R>, E, R>;
-/**
- * Drive a state-threaded loop body. Each iteration runs `body(state)` to get
- * a `Stream<Event<A, S>>`; values flow downstream, `next(s)` continues with
- * a new state, `stop` ends the loop. See the file header for the full
- * pull-based execution model.
- *
- * Dual: data-first `loop(initial, body)` and data-last `loop(body)(initial)`
- * (or `pipe(initial, loop(body))`) both work.
- */
-declare const loop: {
-  <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>;
-  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>;
-};
-//#endregion
-export { nextAfter as a, stopAfter as c, value as d, next as i, stopEvent as l, Loop_d_exports as n, nextAfterFold as o, loop as r, stop as s, Event as t, streamUntilComplete as u };
-//# sourceMappingURL=Loop-CzSJo1h8.d.mts.map

package/dist/Loop-CzSJo1h8.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Loop-CzSJo1h8.d.mts","names":[],"sources":["../src/loop/Loop.ts"],"mappings":";;;;;;;;;;;;;KAgCY,KAAA,SAAc,IAAA,CAAK,UAAA;EAC7B,KAAA;IAAA,SAAkB,KAAA,EAAO,CAAA;EAAA;EACzB,IAAA;IAAA,SAAiB,KAAA,EAAO,CAAA;EAAA;EACxB,IAAA;AAAA;;cAUW,KAAA,MAAY,CAAA,EAAG,CAAA,KAAI,KAAA,CAAM,CAAA;;cAGzB,IAAA,MAAW,KAAA,EAAO,CAAA,KAAI,KAAA,QAAa,CAAA;;cAGnC,SAAA,EAAW,KAAA;;;;;;cAOX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,KAAA;;;;;;cAOpB,SAAA,eACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,GAC5B,KAAA,EAAO,CAAA,KACN,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;AApBjC;;;;AAAA,cA2Ba,SAAA,YACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,MAC3B,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,UAAW,CAAA,EAAG,CAAA;;;;;;;;;cAWxB,aAAA,kBACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,GAC5B,OAAA,EAAS,CAAA,EACT,MAAA,GAAS,GAAA,EAAK,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,CAAA,EAC1B,KAAA,GAAQ,CAAA,EAAG,CAAA,KAAM,CAAA,KAChB,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;;AA1CjC;;;;;AAOA;;;;;;;;;cAqEa,mBAAA,iCAET,IAAA,GAAO,IAAA,EAAM,IAAA,KAAS,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,EAAA,EAAI,EAAA,GAAK,EAAA,EAAI,EAAA,aAG5E,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,SAAA,GAAY,CAAA,EAAG,CAAA,GAAI,CAAA,GAAI,EAAA,GAAK,cAAA,EAAgB,CAAA,GAAI,EAAA;AAAA,KAkEpE,QAAA,gBACH,KAAA,EAAO,CAAA,KACJ,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA;;;;;;;;;;cAW9E,IAAA;EAAA,aACE,IAAA,EAAM,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,KAAM,OAAA,EAAS,CAAA,KAAM,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA,aACjE,OAAA,EAAS,CAAA,EAAG,IAAA,EAAM,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA"}

package/dist/Outcome-C2JYknCu.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Outcome-C2JYknCu.d.mts","names":[],"sources":["../src/tool/Outcome.ts"],"mappings":";;;KAsBY,UAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;AAAA;AAAA,cAGF,OAAA,GAAW,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAGtD,SAAA,GAAa,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,KAOzD,YAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAAyB,MAAA,EAAQ,UAAA;AAAA;AAAA,cAEnC,OAAA,EAAS,YAAA;AAAA,cAET,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,YAAA;AAAA,cAO/B,QAAA,GACX,IAAA,EAAM,YAAA,EACN,IAAA,UACA,MAAA,cACC,UAAA;;cASU,MAAA,GAAU,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAIhD,SAAA,GAAa,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAInD,cAAA,GAAkB,IAAA,EAAM,YAAA,EAAc,MAAA,aAAiB,UAAA;AAAA,cAOvD,oBAAA,GAAwB,CAAA,EAAG,UAAA,KAAa,kBAAA"}