@effect/ai 0.28.2 → 0.28.3

package/src/Chat.ts

@@ -54,11 +54,13 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type { ParseError } from "effect/ParseResult"
+import * as Predicate from "effect/Predicate"
 import * as Ref from "effect/Ref"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import type { NoExcessProperties } from "effect/Types"
 import * as AiError from "./AiError.js"
+import * as IdGenerator from "./IdGenerator.js"
 import * as LanguageModel from "./LanguageModel.js"
 import * as Prompt from "./Prompt.js"
 import type * as Response from "./Response.js"
@@ -651,6 +653,11 @@ export interface Persisted extends Service {
    * The identifier for the chat in the backing persistence store.
    */
   readonly id: string
+
+  /**
+   * Saves the current chat history into the backing persistence store.
+   */
+  readonly save: Effect.Effect<void, AiError.MalformedOutput | PersistenceBackingError>
 }
 
 /**
@@ -668,28 +675,77 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
   const persistence = yield* BackingPersistence
   const store = yield* persistence.make(options.storeId)
 
-  const toPersisted = (chatId: string, chat: Service): Persisted => {
-    const persistChat = chat.exportJson.pipe(
-      Effect.flatMap((history) => store.set(chatId, history, Option.none())),
-      Effect.orDie
+  const toPersisted = Effect.fnUntraced(function*(chatId: string, chat: Service) {
+    const idGenerator = yield* Effect.serviceOption(IdGenerator.IdGenerator).pipe(
+      Effect.map(Option.getOrElse(() => IdGenerator.defaultIdGenerator))
     )
-    return {
+
+    const saveChat = Effect.fnUntraced(
+      function*(prevHistory: Prompt.Prompt) {
+        // Get the current chat history
+        const history = yield* Ref.get(chat.history)
+        // Get the most recent message stored in the previous chat history
+        const lastMessage = prevHistory.content[prevHistory.content.length - 1]
+        // Determine the correct message identifier to use:
+        let messageId: string | undefined = undefined
+        // If the most recent message in the chat history is an assistant message,
+        // use the message identifer stored in that message
+        if (Predicate.isNotUndefined(lastMessage) && lastMessage.role === "assistant") {
+          messageId = lastMessage.options[Persistence.key]?.messageId as string | undefined
+        }
+        // If the chat history is empty or a message identifier did not exist on
+        // the most recent message in the chat history, generate a new identifier
+        if (Predicate.isUndefined(messageId)) {
+          messageId = yield* idGenerator.generateId()
+        }
+        // Mutate the new messages to add the generated message identifier
+        for (let i = prevHistory.content.length; i < history.content.length; i++) {
+          const message = history.content[i]
+          ;(message.options as any)[Persistence.key] = { messageId }
+        }
+        // Save the mutated history back to the ref
+        yield* Ref.set(chat.history, history)
+        // Export the chat to JSON
+        const json = yield* chat.exportJson
+        // Save the chat to the backing store
+        yield* store.set(chatId, json, Option.none())
+      },
+      Effect.catchTag("PersistenceError", (error) => {
+        // Should never happen because we are using the backing persistence
+        // store directly, and parse errors can only occur when using result
+        // persistence
+        if (error.reason === "ParseError") return Effect.die(error)
+        return Effect.fail(error)
+      })
+    )
+
+    const persisted: Persisted = {
       ...chat,
       id: chatId,
-      generateText: (options) =>
-        chat.generateText(options).pipe(
-          Effect.ensuring(persistChat)
-        ),
-      generateObject: (options) =>
-        chat.generateObject(options).pipe(
-          Effect.ensuring(persistChat)
-        ),
-      streamText: (options) =>
-        chat.streamText(options).pipe(
-          Stream.ensuring(persistChat)
+      save: Effect.flatMap(Ref.get(chat.history), saveChat),
+      generateText: Effect.fnUntraced(function*(options) {
+        const history = yield* Ref.get(chat.history)
+        return yield* chat.generateText(options).pipe(
+          Effect.ensuring(Effect.orDie(saveChat(history)))
+        )
+      }),
+      generateObject: Effect.fnUntraced(function*(options) {
+        const history = yield* Ref.get(chat.history)
+        return yield* chat.generateObject(options).pipe(
+          Effect.ensuring(Effect.orDie(saveChat(history)))
         )
+      }),
+      streamText: Effect.fnUntraced(function*(options) {
+        const history = yield* Ref.get(chat.history)
+        const stream = chat.streamText(options).pipe(
+          Stream.ensuring(Effect.orDie(saveChat(history)))
+        )
+        return stream
+      }, Stream.unwrap)
     }
-  }
+
+    return persisted
+  })
 
   const createChat = Effect.fnUntraced(
     function*(chatId: string) {
@@ -701,7 +757,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
       yield* store.set(chatId, history, Option.none())
 
       // Convert the chat to a persisted chat
-      return toPersisted(chatId, chat)
+      return yield* toPersisted(chatId, chat)
     },
     Effect.catchTag("PersistenceError", (error) => {
       // Should never happen because we are using the backing persistence
@@ -726,7 +782,7 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
       )
 
       // Convert the chat to a persisted chat
-      return toPersisted(chatId, chat)
+      return yield* toPersisted(chatId, chat)
     },
     Effect.catchTags({
       ParseError: (error) => Effect.die(error),

package/src/Prompt.ts

@@ -51,6 +51,7 @@
  *
  * @since 1.0.0
  */
+import * as Arbitrary from "effect/Arbitrary"
 import * as Arr from "effect/Array"
 import { constFalse, dual } from "effect/Function"
 import * as ParseResult from "effect/ParseResult"
@@ -225,10 +226,10 @@ export const makePart = <const Type extends Part["type"]>(
   }
 ): Extract<Part, { type: Type }> =>
   (({
-   ...params,
-   [PartTypeId]: PartTypeId,
-   type,
-   options: params.options ?? {}
+    ...params,
+    [PartTypeId]: PartTypeId,
+    type,
+    options: params.options ?? {}
   }) as any)
 
 // =============================================================================
@@ -724,10 +725,10 @@ export const makeMessage = <const Role extends Message["role"]>(
   }
 ): Extract<Message, { role: Role }> =>
   (({
-   ...params,
-   [MessageTypeId]: MessageTypeId,
-   role,
-   options: params.options ?? {}
+    ...params,
+    [MessageTypeId]: MessageTypeId,
+    role,
+    options: params.options ?? {}
   }) as any)
 
 /**
@@ -1214,7 +1215,11 @@ export class PromptFromSelf extends Schema.declare(
   (u) => isPrompt(u),
   {
     identifier: "PromptFromSelf",
-    description: "a Prompt instance"
+    description: "a Prompt instance",
+    arbitrary: (): Arbitrary.LazyArbitrary<Prompt> => (fc) =>
+      fc.array(
+        Arbitrary.makeLazy(Message)(fc)
+      ).map(makePrompt)
   }
 ) {}
 
@@ -1467,14 +1472,15 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
     return empty
   }
 
-  const content: Array<AssistantMessagePart> = []
+  const assistantParts: Array<AssistantMessagePart> = []
+  const toolParts: Array<ToolMessagePart> = []
 
   const textDeltas: Array<string> = []
   function flushTextDeltas() {
     if (textDeltas.length > 0) {
       const text = textDeltas.join("")
       if (text.length > 0) {
-        content.push(makePart("text", { text }))
+        assistantParts.push(makePart("text", { text }))
       }
       textDeltas.length = 0
     }
@@ -1485,7 +1491,7 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
     if (reasoningDeltas.length > 0) {
       const text = reasoningDeltas.join("")
       if (text.length > 0) {
-        content.push(makePart("reasoning", { text }))
+        assistantParts.push(makePart("reasoning", { text }))
       }
       reasoningDeltas.length = 0
     }
@@ -1501,7 +1507,7 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
       switch (part.type) {
         case "text": {
           flushDeltas()
-          content.push(makePart("text", { text: part.text }))
+          assistantParts.push(makePart("text", { text: part.text }))
           break
         }
         case "text-delta": {
@@ -1511,7 +1517,7 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
         }
         case "reasoning": {
           flushDeltas()
-          content.push(makePart("reasoning", { text: part.text }))
+          assistantParts.push(makePart("reasoning", { text: part.text }))
           break
         }
         case "reasoning-delta": {
@@ -1521,7 +1527,7 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
         }
         case "tool-call": {
           flushDeltas()
-          content.push(makePart("tool-call", {
+          assistantParts.push(makePart("tool-call", {
             id: part.id,
             name: part.providerName ?? part.name,
             params: part.params,
@@ -1531,7 +1537,7 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
         }
         case "tool-result": {
           flushDeltas()
-          content.push(makePart("tool-result", {
+          toolParts.push(makePart("tool-result", {
             id: part.id,
             name: part.providerName ?? part.name,
             result: part.encodedResult
@@ -1544,9 +1550,18 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
 
   flushDeltas()
 
-  const message = makeMessage("assistant", { content })
+  if (assistantParts.length === 0 && toolParts.length === 0) {
+    return empty
+  }
 
-  return makePrompt([message])
+  const messages: Array<Message> = []
+  if (assistantParts.length > 0) {
+    messages.push(makeMessage("assistant", { content: assistantParts }))
+  }
+  if (toolParts.length > 0) {
+    messages.push(makeMessage("tool", { content: toolParts }))
+  }
+  return makePrompt(messages)
 }
 
 // =============================================================================
@@ -1600,7 +1615,7 @@ export const merge: {
    * @since 1.0.0
    * @category Combinators
    */
-  (other: RawInput): (self: Prompt) => Prompt
+  (input: RawInput): (self: Prompt) => Prompt
   // =============================================================================
   // Merging Prompts
   // =============================================================================
@@ -1626,12 +1641,17 @@ export const merge: {
    * @since 1.0.0
    * @category Combinators
    */
-  (self: Prompt, other: RawInput): Prompt
-} = dual(2, (self: Prompt, other: RawInput): Prompt =>
-  fromMessages([
-    ...self.content,
-    ...make(other).content
-  ]))
+  (self: Prompt, input: RawInput): Prompt
+} = dual(2, (self: Prompt, input: RawInput): Prompt => {
+  const other = make(input)
+  if (self.content.length === 0) {
+    return other
+  }
+  if (other.content.length === 0) {
+    return self
+  }
+  return fromMessages([...self.content, ...other.content])
+})
 
 // =============================================================================
 // Manipulating Prompts

package/src/Response.ts

@@ -542,7 +542,7 @@ export const makePart = <const Type extends AnyPart["type"]>(
    ...params,
    [PartTypeId]: PartTypeId,
    type,
-   metadata: params.metadata
+   metadata: params.metadata ?? {}
   }) as any)
 
 // =============================================================================