effect 4.0.5 → 4.0.7

package/src/ai/DecisionModel.ts

@@ -2,15 +2,19 @@
  * Defines the provider-neutral service for structured decisions.
  * `decide` encodes one input as JSON, sends its named decisions in one provider
  * call, and validates the answers. Failures are reported as `AiError` values.
+ * `decideSettled` makes the same call but reports each decision separately, so
+ * valid answers survive when others are missing, refused, or invalid.
  * @stability unstable
  * @since 4.0.0
  */
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import * as Predicate from "../Predicate.ts"
+import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
 import * as AiError from "./AiError.ts"
 import type * as Decision from "./Decision.ts"
+import type * as Response from "./Response.ts"
 
 /**
  * Service key for answering decisions about an input. Create implementations
@@ -87,7 +91,17 @@ export interface Image {
 }
 
 /**
- * Answers for every decision in a definition together with usage metadata.
+ * Provider-specific response metadata keyed by provider name. Provider
+ * packages augment this interface.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.6
+ */
+export interface DecideResponseMetadata extends Response.ProviderMetadata {}
+
+/**
+ * Answers for every decision in a definition with usage and response metadata.
  *
  * @see {@link DecisionUsage} for token usage metadata
  *
@@ -98,6 +112,43 @@ export interface Image {
 export interface DecideResponse<Decisions extends Record<string, Decision.Any>> {
   readonly answers: Decision.Answers<Decisions>
   readonly usage: DecisionUsage
+  /**
+   * Response id reported by the provider.
+   *
+   * @since 4.0.6
+   */
+  readonly id?: string | undefined
+  /**
+   * Model that answered. Can differ from the requested model when the
+   * provider resolves an alias.
+   *
+   * @since 4.0.6
+   */
+  readonly modelId?: string | undefined
+  /**
+   * Provider-specific metadata, such as reported cost.
+   *
+   * @since 4.0.6
+   */
+  readonly metadata: DecideResponseMetadata
+}
+
+/**
+ * Per-decision outcomes, token usage, and response metadata for the whole
+ * request.
+ *
+ * @see {@link decideSettled} for producing this response
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.6
+ */
+export interface DecideSettledResponse<Decisions extends Record<string, Decision.Any>> {
+  readonly outcomes: Decision.Outcomes<Decisions>
+  readonly usage: DecisionUsage
+  readonly id?: string | undefined
+  readonly modelId?: string | undefined
+  readonly metadata: DecideResponseMetadata
 }
 
 /**
@@ -117,7 +168,7 @@ export interface ProviderOptions {
 }
 
 /**
- * Provider answer for a classify decision.
+ * Provider classify answer. Omit `probabilities` when no distribution is available.
  *
  * @stability unstable
  * @category models
@@ -126,14 +177,13 @@ export interface ProviderOptions {
 export interface ProviderClassifyAnswer {
   readonly _tag: "Classify"
   readonly label: string
-  readonly probabilities: Readonly<Record<string, number>>
+  readonly probabilities?: Readonly<Record<string, number>> | undefined
   readonly confidence?: number | undefined
 }
 
 /**
- * Provider answer for a rate decision.
- * The core derives the label from the highest probability, choosing the
- * first criteria entry on ties.
+ * Provider rate answer. The highest probability determines the label, with
+ * ties going to the first criterion. Omit `probabilities` when unavailable.
  *
  * @stability unstable
  * @category models
@@ -142,7 +192,7 @@ export interface ProviderClassifyAnswer {
 export interface ProviderRateAnswer {
   readonly _tag: "Rate"
   readonly rating: number
-  readonly probabilities: Readonly<Record<string, number>>
+  readonly probabilities?: Readonly<Record<string, number>> | undefined
   readonly confidence?: number | undefined
 }
 
@@ -158,6 +208,17 @@ export interface ProviderProbabilityAnswer {
   readonly probability: number
 }
 
+/**
+ * Provider refusal to answer a decision.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.6
+ */
+export interface ProviderRefusalAnswer {
+  readonly _tag: "Refusal"
+}
+
 /**
  * Provider answer for any decision kind.
  *
@@ -165,12 +226,18 @@ export interface ProviderProbabilityAnswer {
  * @category models
  * @since 4.0.0
  */
-export type ProviderAnswer = ProviderClassifyAnswer | ProviderRateAnswer | ProviderProbabilityAnswer
+export type ProviderAnswer =
+  | ProviderClassifyAnswer
+  | ProviderRateAnswer
+  | ProviderProbabilityAnswer
+  | ProviderRefusalAnswer
 
 /**
  * Provider response for a decision request.
  * `answers` is keyed like the requested decisions. Each answer is validated
- * against its decision before it is returned to the caller.
+ * against its decision before it is returned to the caller. Omit the key of a
+ * decision the provider did not answer. `id`, `modelId` and `metadata` are
+ * passed through; `metadata` defaults to `{}`.
  *
  * @stability unstable
  * @category models
@@ -182,6 +249,9 @@ export interface ProviderResponse {
     readonly inputTokens: number | undefined
     readonly outputTokens: number | undefined
   }
+  readonly id?: string | undefined
+  readonly modelId?: string | undefined
+  readonly metadata?: DecideResponseMetadata | undefined
 }
 
 /**
@@ -197,14 +267,21 @@ export interface DecisionModel {
     definition: Decision.Definition<Input, Decisions>,
     options: DecideOptions<Input>
   ) => Effect.Effect<DecideResponse<Decisions>, AiError.AiError, Input["EncodingServices"]>
+  readonly decideSettled: <Input extends Schema.Constraint, Decisions extends Record<string, Decision.Any>>(
+    definition: Decision.Definition<Input, Decisions>,
+    options: DecideOptions<Input>
+  ) => Effect.Effect<DecideSettledResponse<Decisions>, AiError.AiError, Input["EncodingServices"]>
 }
 
-const invalidOutput = (description: string): AiError.AiError =>
-  AiError.make({
-    module: "DecisionModel",
-    method: "decide",
-    reason: new AiError.InvalidOutputError({ description })
-  })
+const unanswered = (
+  reason: Decision.Unanswered["reason"],
+  description: string
+): Result.Result<never, Decision.Unanswered> => Result.fail({ _tag: "Unanswered", reason, description })
+
+const invalid = (description: string) => unanswered("Invalid", description)
+
+const aiError = (method: "decide" | "decideSettled", reason: AiError.AiErrorReason): AiError.AiError =>
+  AiError.make({ module: "DecisionModel", method, reason })
 
 const isFiniteNumber = (value: unknown): value is number => Predicate.isNumber(value) && Number.isFinite(value)
 
@@ -222,41 +299,41 @@ const validateDistribution = (
   labels: ReadonlyArray<string>,
   answer: Record<string, unknown>,
   roundingError: number
-): Record<string, number> | AiError.AiError => {
+): Result.Result<Record<string, number>, Decision.Unanswered> => {
   const raw = answer.probabilities
   if (!Predicate.isObject(raw)) {
-    return invalidOutput(`Provider returned no probabilities for decision "${key}"`)
+    return unanswered("NoDistribution", `Provider returned no probabilities for decision "${key}"`)
   }
   const probabilities: Record<string, number> = Object.create(null)
   let total = 0
   for (const label of labels) {
     const value = raw[label]
     if (!isUnitInterval(value)) {
-      return invalidOutput(`Provider returned no probability for label "${label}" of decision "${key}"`)
+      return invalid(`Provider returned no probability for label "${label}" of decision "${key}"`)
     }
     probabilities[label] = value
     total += value
   }
   const drift = Math.abs(total - 1)
   if (total === 0 || drift > labels.length * roundingError + sumTolerance) {
-    return invalidOutput(`Provider returned probabilities that do not sum to 1 for decision "${key}"`)
+    return invalid(`Provider returned probabilities that do not sum to 1 for decision "${key}"`)
   }
   if (drift > sumTolerance) {
     for (const label of labels) probabilities[label] /= total
   }
-  return probabilities
+  return Result.succeed(probabilities)
 }
 
 const validateConfidence = (
   key: string,
   answer: Record<string, unknown>
-): number | undefined | AiError.AiError => {
+): Result.Result<number | undefined, Decision.Unanswered> => {
   if (answer.confidence === undefined) {
-    return undefined
+    return Result.succeed(undefined)
   }
   return isUnitInterval(answer.confidence)
-    ? answer.confidence
-    : invalidOutput(`Provider returned confidence outside [0, 1] for decision "${key}"`)
+    ? Result.succeed(answer.confidence)
+    : invalid(`Provider returned confidence outside [0, 1] for decision "${key}"`)
 }
 
 const validateAnswer = (
@@ -264,83 +341,105 @@ const validateAnswer = (
   decision: Decision.Any,
   answer: unknown,
   roundingError: number
-): Decision.Answer<Decision.Any> | AiError.AiError => {
+): Decision.Outcome<Decision.Any> => {
   if (!Predicate.isObject(answer)) {
-    return invalidOutput(`Provider returned no answer for decision "${key}"`)
+    return unanswered("Missing", `Provider returned no answer for decision "${key}"`)
+  }
+  if (answer._tag === "Refusal") {
+    return unanswered("Refused", `Provider refused to answer decision "${key}"`)
   }
   if (answer._tag !== decision._tag) {
-    return invalidOutput(
+    return invalid(
       `Provider returned a "${String(answer._tag)}" answer for decision "${key}", expected "${decision._tag}"`
     )
   }
   switch (decision._tag) {
     case "Classify": {
       const labels = Object.keys(decision.criteria)
-      if (!Predicate.isString(answer.label) || !labels.includes(answer.label)) {
-        return invalidOutput(`Provider returned an unknown label for decision "${key}"`)
-      }
-      const confidence = validateConfidence(key, answer)
-      if (AiError.isAiError(confidence)) {
-        return confidence
-      }
-      const probabilities = validateDistribution(key, labels, answer, roundingError)
-      if (AiError.isAiError(probabilities)) {
-        return probabilities
+      const label = answer.label
+      if (!Predicate.isString(label) || !labels.includes(label)) {
+        return invalid(`Provider returned an unknown label for decision "${key}"`)
       }
-      return { label: answer.label, probabilities, ...(confidence === undefined ? undefined : { confidence }) }
+      return Result.gen(function*() {
+        const confidence = yield* validateConfidence(key, answer)
+        const probabilities = yield* validateDistribution(key, labels, answer, roundingError)
+        return { label, probabilities, ...(confidence === undefined ? undefined : { confidence }) }
+      })
     }
     case "Rate": {
       const levels = decision.criteria.map((level) => level.label)
-      if (!isFiniteNumber(answer.rating) || answer.rating < 0 || answer.rating > levels.length - 1) {
-        return invalidOutput(`Provider returned a rating outside [0, ${levels.length - 1}] for decision "${key}"`)
+      const rating = answer.rating
+      if (!isFiniteNumber(rating) || rating < 0 || rating > levels.length - 1) {
+        return invalid(`Provider returned a rating outside [0, ${levels.length - 1}] for decision "${key}"`)
       }
-      const confidence = validateConfidence(key, answer)
-      if (AiError.isAiError(confidence)) {
-        return confidence
-      }
-      const probabilities = validateDistribution(key, levels, answer, roundingError)
-      if (AiError.isAiError(probabilities)) {
-        return probabilities
-      }
-      let label = levels[0]
-      for (let i = 1; i < levels.length; i++) {
-        if (probabilities[levels[i]] > probabilities[label]) {
-          label = levels[i]
+      return Result.gen(function*() {
+        const confidence = yield* validateConfidence(key, answer)
+        const probabilities = yield* validateDistribution(key, levels, answer, roundingError)
+        let label = levels[0]
+        for (let i = 1; i < levels.length; i++) {
+          if (probabilities[levels[i]] > probabilities[label]) {
+            label = levels[i]
+          }
         }
-      }
-      return { rating: answer.rating, label, probabilities, ...(confidence === undefined ? undefined : { confidence }) }
+        return { rating, label, probabilities, ...(confidence === undefined ? undefined : { confidence }) }
+      })
     }
     case "Probability": {
       if (!isUnitInterval(answer.probability)) {
-        return invalidOutput(`Provider returned a probability outside [0, 1] for decision "${key}"`)
+        return invalid(`Provider returned a probability outside [0, 1] for decision "${key}"`)
       }
-      return { probability: answer.probability }
+      return Result.succeed({ probability: answer.probability })
     }
   }
 }
 
-const validateAnswers = <Decisions extends Record<string, Decision.Any>>(
+const settleAnswers = <Decisions extends Record<string, Decision.Any>>(
   decisions: Decisions,
   answers: Readonly<Record<string, ProviderAnswer>>,
   roundingError: number
-): Effect.Effect<Decision.Answers<Decisions>, AiError.AiError> => {
-  const validated: Record<string, Decision.Answer<Decision.Any>> = Object.create(null)
+): Decision.Outcomes<Decisions> => {
+  const outcomes: Record<string, Decision.Outcome<Decision.Any>> = Object.create(null)
   for (const key of Object.keys(decisions)) {
-    const answer = validateAnswer(key, decisions[key], answers[key], roundingError)
-    if (AiError.isAiError(answer)) {
-      return Effect.fail(answer)
+    outcomes[key] = validateAnswer(key, decisions[key], answers[key], roundingError)
+  }
+  return outcomes as Decision.Outcomes<Decisions>
+}
+
+const requireAnswers = <Decisions extends Record<string, Decision.Any>>(
+  outcomes: Decision.Outcomes<Decisions>
+): Effect.Effect<Decision.Answers<Decisions>, AiError.AiError> => {
+  const answers: Record<string, Decision.Answer<Decision.Any>> = Object.create(null)
+  const refused: Array<string> = []
+  let firstUnanswered: Decision.Unanswered | undefined
+  for (const [key, outcome] of Object.entries(outcomes) as Array<[string, Decision.Outcome<Decision.Any>]>) {
+    if (Result.isSuccess(outcome)) {
+      answers[key] = outcome.success
+    } else if (outcome.failure.reason === "Refused") {
+      refused.push(`"${key}"`)
+    } else {
+      firstUnanswered ??= outcome.failure
     }
-    validated[key] = answer
   }
-  return Effect.succeed(validated as Decision.Answers<Decisions>)
+  if (refused.length > 0) {
+    return Effect.fail(aiError(
+      "decide",
+      new AiError.ContentPolicyError({ description: `Provider refused to answer decisions ${refused.join(", ")}` })
+    ))
+  }
+  if (firstUnanswered !== undefined) {
+    return Effect.fail(aiError("decide", new AiError.InvalidOutputError({ description: firstUnanswered.description })))
+  }
+  return Effect.succeed(answers as Decision.Answers<Decisions>)
 }
 
 /**
  * Creates a `DecisionModel` that encodes inputs as JSON and validates provider answers.
  * Answers must cover every decision and use its labels. Distributions must
  * sum to 1 within `1e-6`, optional confidence must be in `[0, 1]`, and ratings must be
- * in `[0, criteria.length - 1]`. Invalid answers fail with
- * `AiError.InvalidOutputError`; encoding failures use `AiError.InvalidUserInputError`.
+ * in `[0, criteria.length - 1]`. With `decide`, refused decisions fail with
+ * `AiError.ContentPolicyError` and other unanswered decisions fail with
+ * `AiError.InvalidOutputError`; `decideSettled` reports them per decision
+ * instead. Encoding failures use `AiError.InvalidUserInputError`.
  *
  * **Details**
  *
@@ -367,52 +466,52 @@ export const make = (params: {
 }): Effect.Effect<DecisionModel> =>
   Effect.sync(() => {
     const roundingError = params.probabilityPrecision === undefined ? 0 : 0.5 * 10 ** -params.probabilityPrecision
-    return DecisionModel.of({
-      [TypeId]: TypeId,
-      decide: <Input extends Schema.Constraint, Decisions extends Record<string, Decision.Any>>(
-        definition: Decision.Definition<Input, Decisions>,
-        options: DecideOptions<Input>
-      ): Effect.Effect<DecideResponse<Decisions>, AiError.AiError, Input["EncodingServices"]> =>
-        Schema.encodeEffect(Schema.toCodecJson(definition.input))(options.input).pipe(
-          Effect.mapError((error) =>
-            AiError.make({
-              module: "DecisionModel",
-              method: "decide",
-              reason: new AiError.InvalidUserInputError({ description: error.message })
-            })
-          ),
-          Effect.flatMap((state) => {
-            const images = options.images?.length ? options.images : undefined
-            if (images !== undefined && params.supportsImages !== true) {
-              return Effect.fail(
-                AiError.make({
-                  module: "DecisionModel",
-                  method: "decide",
-                  reason: new AiError.InvalidUserInputError({
-                    description: "This decision model does not accept images"
-                  })
-                })
+    const settle = <Input extends Schema.Constraint, Decisions extends Record<string, Decision.Any>>(
+      method: "decide" | "decideSettled",
+      definition: Decision.Definition<Input, Decisions>,
+      options: DecideOptions<Input>
+    ): Effect.Effect<DecideSettledResponse<Decisions>, AiError.AiError, Input["EncodingServices"]> =>
+      Schema.encodeEffect(Schema.toCodecJson(definition.input))(options.input).pipe(
+        Effect.mapError((error) => aiError(method, new AiError.InvalidUserInputError({ description: error.message }))),
+        Effect.flatMap((state) => {
+          const images = options.images?.length ? options.images : undefined
+          if (images !== undefined && params.supportsImages !== true) {
+            return Effect.fail(
+              aiError(
+                method,
+                new AiError.InvalidUserInputError({ description: "This decision model does not accept images" })
               )
-            }
-            return params.decide({
-              state,
-              decisions: definition.decisions,
-              ...(images === undefined ? undefined : { images })
-            })
-          }),
-          Effect.flatMap((response) =>
-            Effect.map(
-              validateAnswers(definition.decisions, response.answers, roundingError),
-              (answers): DecideResponse<Decisions> => ({
-                answers,
-                usage: new DecisionUsage({
-                  inputTokens: response.usage.inputTokens,
-                  outputTokens: response.usage.outputTokens
-                })
-              })
             )
+          }
+          return params.decide({
+            state,
+            decisions: definition.decisions,
+            ...(images === undefined ? undefined : { images })
+          })
+        }),
+        Effect.map((response): DecideSettledResponse<Decisions> => ({
+          outcomes: settleAnswers(definition.decisions, response.answers, roundingError),
+          usage: new DecisionUsage({
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens
+          }),
+          ...(response.id === undefined ? undefined : { id: response.id }),
+          ...(response.modelId === undefined ? undefined : { modelId: response.modelId }),
+          metadata: response.metadata ?? {}
+        }))
+      )
+    return DecisionModel.of({
+      [TypeId]: TypeId,
+      decide: (definition, options) =>
+        settle("decide", definition, options).pipe(
+          Effect.flatMap(({ outcomes, ...response }) =>
+            Effect.map(requireAnswers(outcomes), (answers) => ({ answers, ...response }))
           ),
           (effect) => Effect.withSpan(effect, "DecisionModel.decide", { captureStackTrace: false })
+        ),
+      decideSettled: (definition, options) =>
+        settle("decideSettled", definition, options).pipe(
+          (effect) => Effect.withSpan(effect, "DecisionModel.decideSettled", { captureStackTrace: false })
         )
     })
   })
@@ -423,6 +522,9 @@ export const make = (params: {
  * Explicit `undefined` fields become `null`; absent fields stay absent.
  * Custom declarations need a JSON codec annotation or encoding fails.
  * Returned answers and probability dictionaries have null prototypes.
+ * Fails with `AiError.ContentPolicyError` if the provider refuses any decision,
+ * and otherwise with `AiError.InvalidOutputError` for the first unanswered
+ * decision in definition order.
  *
  * **Example** (Triaging a ticket)
  *
@@ -449,6 +551,7 @@ export const make = (params: {
  * ```
  *
  * @see {@link DecisionModel} for the service this function requires
+ * @see {@link decideSettled} for keeping valid answers when others fail
  *
  * @stability unstable
  * @category decisions
@@ -459,3 +562,56 @@ export const decide = <Input extends Schema.Constraint, Decisions extends Record
   options: DecideOptions<Input>
 ): Effect.Effect<DecideResponse<Decisions>, AiError.AiError, DecisionModel | Input["EncodingServices"]> =>
   DecisionModel.use((model) => model.decide(definition, options))
+
+/**
+ * Answers each decision with a `Result` containing a validated answer or a
+ * `Decision.Unanswered` reason. Input encoding and provider failures still
+ * fail the effect. Token usage covers the whole call.
+ *
+ * **Details**
+ *
+ * Provider response decoding errors fail the whole call. Per-decision reasons
+ * reflect the first failed validation check; `"NoDistribution"` requires an
+ * otherwise valid answer.
+ *
+ * **Example** (Falling back for unanswered decisions)
+ *
+ * ```ts
+ * import { Effect, Result, Schema } from "effect"
+ * import { Decision, DecisionModel } from "effect/ai"
+ *
+ * const TicketTriage = Decision.make({
+ *   input: Schema.String,
+ *   decisions: {
+ *     department: Decision.classify({
+ *       instructions: "Which team should handle this",
+ *       criteria: { billing: "payments", technical: "bugs" }
+ *     }),
+ *     urgent: Decision.probability({ instructions: "The message is time-sensitive" })
+ *   }
+ * })
+ *
+ * const program = Effect.gen(function*() {
+ *   const { outcomes } = yield* DecisionModel.decideSettled(TicketTriage, {
+ *     input: "My card was charged twice, please fix this today"
+ *   })
+ *   const department = Result.isSuccess(outcomes.department) &&
+ *       outcomes.department.success.probabilities.billing >= 0.8
+ *     ? "billing"
+ *     : "needs review"
+ *   const urgent = Result.isSuccess(outcomes.urgent) ? outcomes.urgent.success.probability : undefined
+ *   return { department, urgent }
+ * })
+ * ```
+ *
+ * @see {@link decide} for failing unless every decision is answered
+ *
+ * @stability unstable
+ * @category decisions
+ * @since 4.0.6
+ */
+export const decideSettled = <Input extends Schema.Constraint, Decisions extends Record<string, Decision.Any>>(
+  definition: Decision.Definition<Input, Decisions>,
+  options: DecideOptions<Input>
+): Effect.Effect<DecideSettledResponse<Decisions>, AiError.AiError, DecisionModel | Input["EncodingServices"]> =>
+  DecisionModel.use((model) => model.decideSettled(definition, options))

package/src/ai/EmbeddingModel.ts

@@ -209,8 +209,17 @@ const invalidProviderResponse = (description: string): AiError.AiError =>
  * provider, while `embedMany([])` returns an empty response without calling the
  * provider.
  *
+ * Concurrent `embed` calls share one `embedMany` call when `batchKey` returns
+ * equal keys under `Equal.equals`. The batch runs with the first caller's
+ * context, so return every value `embedMany` reads from that context. Without
+ * `batchKey`, all callers share one batch.
+ *
  * **Gotchas**
  *
+ * Context that `batchKey` does not return is not isolated. Per-call
+ * `FetchHttpClient.RequestInit`, or any service read by an injected HTTP
+ * client, takes the first caller's value for the whole batch.
+ *
  * Provider responses are interpreted positionally and must contain exactly one
  * result for each requested input. If the provider returns a different number
  * of results, `embed` and `embedMany` fail with `AiError.InvalidOutputError`.
@@ -225,20 +234,23 @@ const invalidProviderResponse = (description: string): AiError.AiError =>
  */
 export const make: (params: {
   readonly embedMany: (options: ProviderOptions) => Effect.Effect<ProviderResponse, AiError.AiError>
+  readonly batchKey?: ((context: Context.Context<never>) => unknown) | undefined
 }) => Effect.Effect<EmbeddingModel> = 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(
+  const resolver = RequestResolver.makeGrouped<EmbeddingRequest, unknown>({
+    key: ({ context }) => params.batchKey?.(context),
+    resolver: (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")
   )
 

package/src/ai/LanguageModel.ts

@@ -1553,6 +1553,7 @@ export const make: (params: {
             preliminary: false,
             result: r.encodedResult,
             encodedResult: r.encodedResult,
+            ...modelOutputField(r.modelOutput),
             isFailure: r.isFailure
           }) as Response.StreamPart<Tools>
         )
@@ -1680,6 +1681,7 @@ export const make: (params: {
             providerExecuted: false,
             result: result.result,
             encodedResult: result.encodedResult,
+            ...modelOutputField(result.modelOutput),
             isFailure: result.isFailure,
             preliminary: result.preliminary
           }) as Response.StreamPart<Tools>
@@ -2268,6 +2270,7 @@ const executeApprovedToolCalls = <Tools extends Record<string, Tool.Any>>(
       name: toolCall.name,
       result: terminalResult.result,
       encodedResult: terminalResult.encodedResult,
+      ...modelOutputField(terminalResult.modelOutput),
       isFailure: terminalResult.isFailure,
       preliminary: terminalResult.preliminary,
       providerExecuted: false
@@ -2347,6 +2350,10 @@ const makeInterruptedToolResult = (
   })
 }
 
+// Omits the key entirely so unmapped tool result parts keep their shape.
+const modelOutputField = (modelOutput: ReadonlyArray<Prompt.ToolModelOutputPart> | undefined) =>
+  modelOutput === undefined ? undefined : { modelOutput }
+
 type ToolResolutionResult<Tools extends Record<string, Tool.Any>> =
   | Response.ToolResultPart<
     Tool.Name<Tools[keyof Tools]>,
@@ -2417,6 +2424,7 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
                 providerExecuted: false,
                 result: result.result,
                 encodedResult: result.encodedResult,
+                ...modelOutputField(result.modelOutput),
                 isFailure: result.isFailure,
                 preliminary: result.preliminary
               }) as ToolResolutionResult<Tools>
@@ -2446,6 +2454,7 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
               providerExecuted: false,
               result: result.result,
               encodedResult: result.encodedResult,
+              ...modelOutputField(result.modelOutput),
               isFailure: result.isFailure,
               preliminary: result.preliminary
             }) as ToolResolutionResult<Tools>