@effect/ai 0.8.0 → 0.8.2

package/dist/esm/index.js

@@ -18,6 +18,10 @@ export * as AiResponse from "./AiResponse.js";
  * @since 1.0.0
  */
 export * as AiRole from "./AiRole.js";
+/**
+ * @since 1.0.0
+ */
+export * as AiTelemetry from "./AiTelemetry.js";
 /**
  * @since 1.0.0
  */
@@ -26,6 +30,10 @@ export * as AiToolkit from "./AiToolkit.js";
  * @since 1.0.0
  */
 export * as Completions from "./Completions.js";
+/**
+ * @since 1.0.0
+ */
+export * as Embeddings from "./Embeddings.js";
 /**
  * @since 1.0.0
  */

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["AiChat","AiError","AiInput","AiResponse","AiRole","AiToolkit","Completions","Tokenizer"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;AAGA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB","ignoreList":[]}
+{"version":3,"file":"index.js","names":["AiChat","AiError","AiInput","AiResponse","AiRole","AiTelemetry","AiToolkit","Completions","Embeddings","Tokenizer"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,MAAM,MAAM,aAAa;AAErC;;;AAGA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;AAGA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,SAAS,MAAM,gBAAgB","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/ai",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Effect modules for working with AI apis",
   "license": "MIT",
   "repository": {
@@ -11,8 +11,9 @@
   "sideEffects": [],
   "dependencies": {},
   "peerDependencies": {
-    "@effect/platform": "^0.75.0",
-    "effect": "^3.12.6"
+    "@effect/experimental": "^0.39.2",
+    "@effect/platform": "^0.75.2",
+    "effect": "^3.12.8"
   },
   "publishConfig": {
     "provenance": true
@@ -52,6 +53,11 @@
       "import": "./dist/esm/AiRole.js",
       "default": "./dist/cjs/AiRole.js"
     },
+    "./AiTelemetry": {
+      "types": "./dist/dts/AiTelemetry.d.ts",
+      "import": "./dist/esm/AiTelemetry.js",
+      "default": "./dist/cjs/AiTelemetry.js"
+    },
     "./AiToolkit": {
       "types": "./dist/dts/AiToolkit.d.ts",
       "import": "./dist/esm/AiToolkit.js",
@@ -62,6 +68,11 @@
       "import": "./dist/esm/Completions.js",
       "default": "./dist/cjs/Completions.js"
     },
+    "./Embeddings": {
+      "types": "./dist/dts/Embeddings.d.ts",
+      "import": "./dist/esm/Embeddings.js",
+      "default": "./dist/cjs/Embeddings.js"
+    },
     "./Tokenizer": {
       "types": "./dist/dts/Tokenizer.d.ts",
       "import": "./dist/esm/Tokenizer.js",
@@ -85,12 +96,18 @@
       "AiRole": [
         "./dist/dts/AiRole.d.ts"
       ],
+      "AiTelemetry": [
+        "./dist/dts/AiTelemetry.d.ts"
+      ],
       "AiToolkit": [
         "./dist/dts/AiToolkit.d.ts"
       ],
       "Completions": [
         "./dist/dts/Completions.d.ts"
       ],
+      "Embeddings": [
+        "./dist/dts/Embeddings.d.ts"
+      ],
       "Tokenizer": [
         "./dist/dts/Tokenizer.d.ts"
       ]

package/src/AiChat.ts

@@ -39,10 +39,17 @@ export declare namespace AiChat {
     readonly exportJson: Effect.Effect<string>
     readonly send: (input: AiInput.Input) => Effect.Effect<AiResponse, AiError>
     readonly stream: (input: AiInput.Input) => Stream.Stream<AiResponse, AiError>
-    readonly structured: <A, I, R>(
-      tool: Completions.StructuredSchema<A, I, R>,
-      input: AiInput.Input
-    ) => Effect.Effect<A, AiError, R>
+    readonly structured: {
+      <A, I, R>(options: {
+        readonly input: AiInput.Input
+        readonly schema: Completions.StructuredSchema<A, I, R>
+      }): Effect.Effect<A, AiError, R>
+      <A, I, R>(options: {
+        readonly input: AiInput.Input
+        readonly schema: Schema.Schema<A, I, R>
+        readonly toolCallId: string
+      }): Effect.Effect<A, AiError, R>
+    }
     readonly toolkit: <Tools extends AiToolkit.Tool.AnySchema>(
       options: {
         readonly input: AiInput.Input
@@ -74,180 +81,164 @@ export declare namespace AiChat {
  * @since 1.0.0
  * @category constructors
  */
-export const fromInput = (input: AiInput.Input): Effect.Effect<AiChat.Service, never, Completions> =>
-  Ref.make(AiInput.make(input)).pipe(
-    Effect.bindTo("historyRef"),
-    Effect.bind("completions", () => Completions),
-    Effect.map(({ completions, historyRef }) => new AiChatImpl(historyRef, completions))
-  )
-
-class AiChatImpl implements AiChat.Service {
-  readonly semaphore = Effect.unsafeMakeSemaphore(1)
-
-  constructor(
-    readonly historyRef: Ref.Ref<AiInput.AiInput>,
-    readonly completions: Completions.Service
-  ) {}
-
-  get history() {
-    return Ref.get(this.historyRef)
-  }
+export const fromInput = Effect.fnUntraced(
+  function*(input: AiInput.Input) {
+    const completions = yield* Completions
+    const history = yield* Ref.make(AiInput.make(input))
+    const semaphore = yield* Effect.makeSemaphore(1)
 
-  get export() {
-    return Ref.get(this.historyRef).pipe(
-      Effect.flatMap(Schema.encode(AiInput.Schema)),
-      Effect.orDie
-    )
-  }
-
-  get exportJson() {
-    return Ref.get(this.historyRef).pipe(
-      Effect.flatMap(Schema.encode(AiInput.SchemaJson)),
-      Effect.orDie
-    )
-  }
-
-  send(input: AiInput.Input) {
-    const newParts = AiInput.make(input)
-    return Ref.get(this.historyRef).pipe(
-      Effect.flatMap((parts) => {
-        const allParts = Chunk.appendAll(parts, newParts)
-        return this.completions.create(allParts).pipe(
-          Effect.tap((response) => {
-            const responseParts = AiInput.make(response)
-            return Ref.set(this.historyRef, Chunk.appendAll(allParts, responseParts))
+    return AiChat.of({
+      history: Ref.get(history),
+      export: Ref.get(history).pipe(
+        Effect.flatMap(Schema.encode(AiInput.Schema)),
+        Effect.orDie
+      ),
+      exportJson: Ref.get(history).pipe(
+        Effect.flatMap(Schema.encode(AiInput.SchemaJson)),
+        Effect.orDie
+      ),
+      send(input) {
+        const newParts = AiInput.make(input)
+        return Ref.get(history).pipe(
+          Effect.flatMap((parts) => {
+            const allParts = Chunk.appendAll(parts, newParts)
+            return completions.create(allParts).pipe(
+              Effect.tap((response) => {
+                const responseParts = AiInput.make(response)
+                return Ref.set(history, Chunk.appendAll(allParts, responseParts))
+              })
+            )
+          }),
+          semaphore.withPermits(1),
+          Effect.withSpan("AiChat.send", {
+            attributes: { input },
+            captureStackTrace: false
           })
         )
-      }),
-      this.semaphore.withPermits(1),
-      Effect.withSpan("AiChat.send", { attributes: { input }, captureStackTrace: false })
-    )
-  }
-
-  stream(input: AiInput.Input) {
-    return Stream.suspend(() => {
-      let combined = AiResponse.empty
-      return Stream.fromChannel(Channel.acquireUseRelease(
-        this.semaphore.take(1).pipe(
-          Effect.zipRight(Ref.get(this.historyRef)),
-          Effect.map(Chunk.appendAll(AiInput.make(input)))
-        ),
-        (parts) =>
-          this.completions.stream(parts).pipe(
-            Stream.map((chunk) => {
-              combined = combined.concat(chunk)
-              return chunk
-            }),
-            Stream.toChannel
-          ),
-        (parts) =>
-          Effect.zipRight(
-            Ref.set(this.historyRef, Chunk.appendAll(parts, AiInput.make(combined))),
-            this.semaphore.release(1)
-          )
-      ))
-    }).pipe(Stream.withSpan("AiChat.stream", { attributes: { input }, captureStackTrace: false }))
-  }
-
-  structured<A, I, R>(
-    schema: Completions.StructuredSchema<A, I, R>,
-    input: AiInput.Input
-  ): Effect.Effect<A, AiError, R> {
-    const newParts = AiInput.make(input)
-    return Ref.get(this.historyRef).pipe(
-      Effect.flatMap((parts) => {
-        const allParts = Chunk.appendAll(parts, newParts)
-        return this.completions.structured({
-          input: allParts,
-          schema
-        }).pipe(
-          Effect.flatMap((response) => {
-            const responseParts = AiInput.make(response)
-            return Effect.as(
-              Ref.set(this.historyRef, Chunk.appendAll(allParts, responseParts)),
-              response.unsafeValue
+      },
+      stream(input) {
+        return Stream.suspend(() => {
+          let combined = AiResponse.empty
+          return Stream.fromChannel(Channel.acquireUseRelease(
+            semaphore.take(1).pipe(
+              Effect.zipRight(Ref.get(history)),
+              Effect.map(Chunk.appendAll(AiInput.make(input)))
+            ),
+            (parts) =>
+              completions.stream(parts).pipe(
+                Stream.map((chunk) => {
+                  combined = combined.concat(chunk)
+                  return chunk
+                }),
+                Stream.toChannel
+              ),
+            (parts) =>
+              Effect.zipRight(
+                Ref.set(history, Chunk.appendAll(parts, AiInput.make(combined))),
+                semaphore.release(1)
+              )
+          ))
+        }).pipe(Stream.withSpan("AiChat.stream", {
+          attributes: { input },
+          captureStackTrace: false
+        }))
+      },
+      structured(options) {
+        const newParts = AiInput.make(options.input)
+        return Ref.get(history).pipe(
+          Effect.flatMap((parts) => {
+            const allParts = Chunk.appendAll(parts, newParts)
+            return completions.structured({
+              ...options,
+              input: allParts
+            } as any).pipe(
+              Effect.flatMap((response) => {
+                const responseParts = AiInput.make(response)
+                return Effect.as(
+                  Ref.set(history, Chunk.appendAll(allParts, responseParts)),
+                  response.unsafeValue
+                )
+              })
             )
+          }),
+          semaphore.withPermits(1),
+          Effect.withSpan("AiChat.structured", {
+            attributes: {
+              input: options.input,
+              schema: "toolCallId" in options
+                ? options.toolCallId
+                : "_tag" in options.schema
+                ? options.schema._tag
+                : options.schema.identifier
+            },
+            captureStackTrace: false
           })
         )
-      }),
-      this.semaphore.withPermits(1),
-      Effect.withSpan("AiChat.structured", {
-        attributes: { input, schema: schema._tag ?? schema.identifier },
-        captureStackTrace: false
-      })
-    )
-  }
-
-  toolkit<Tools extends AiToolkit.Tool.AnySchema>(
-    options: {
-      readonly input: AiInput.Input
-      readonly tools: AiToolkit.Handlers<Tools>
-      readonly required?: Tools["_tag"] | boolean | undefined
-      readonly concurrency?: Concurrency | undefined
-    }
-  ): Effect.Effect<
-    WithResolved<AiToolkit.Tool.Success<Tools>>,
-    AiError | AiToolkit.Tool.Failure<Tools>,
-    AiToolkit.Tool.Context<Tools>
-  > {
-    const newParts = AiInput.make(options.input)
-    return Ref.get(this.historyRef).pipe(
-      Effect.flatMap((parts) => {
-        const allParts = Chunk.appendAll(parts, newParts)
-        return this.completions.toolkit({
-          ...options,
-          input: allParts
-        }).pipe(
-          Effect.tap((response) => {
-            const responseParts = AiInput.make(response)
-            return Ref.set(this.historyRef, Chunk.appendAll(allParts, responseParts))
+      },
+      toolkit(options) {
+        const newParts = AiInput.make(options.input)
+        return Ref.get(history).pipe(
+          Effect.flatMap((parts) => {
+            const allParts = Chunk.appendAll(parts, newParts)
+            return completions.toolkit({
+              ...options,
+              input: allParts
+            }).pipe(
+              Effect.tap((response) => {
+                const responseParts = AiInput.make(response)
+                return Ref.set(history, Chunk.appendAll(allParts, responseParts))
+              })
+            )
+          }),
+          semaphore.withPermits(1),
+          Effect.withSpan("AiChat.toolkit", {
+            attributes: { input: options.input },
+            captureStackTrace: false
           })
         )
-      }),
-      this.semaphore.withPermits(1),
-      Effect.withSpan("AiChat.toolkit", { attributes: { input: options.input }, captureStackTrace: false })
-    )
-  }
-
-  toolkitStream<Tools extends AiToolkit.Tool.AnySchema>(
-    options: {
-      readonly input: AiInput.Input
-      readonly tools: AiToolkit.Handlers<Tools>
-      readonly required?: Tools["_tag"] | boolean | undefined
-      readonly concurrency?: Concurrency | undefined
-    }
-  ): Stream.Stream<
-    WithResolved<AiToolkit.Tool.Success<Tools>>,
-    AiError | AiToolkit.Tool.Failure<Tools>,
-    AiToolkit.Tool.Context<Tools>
-  > {
-    return Stream.suspend(() => {
-      let combined = WithResolved.empty as WithResolved<AiToolkit.Tool.Success<Tools>>
-      return Stream.fromChannel(Channel.acquireUseRelease(
-        this.semaphore.take(1).pipe(
-          Effect.zipRight(Ref.get(this.historyRef)),
-          Effect.map(Chunk.appendAll(AiInput.make(options.input)))
-        ),
-        (parts) =>
-          this.completions.toolkitStream({
-            ...options,
-            input: parts
-          }).pipe(
-            Stream.map((chunk) => {
-              combined = combined.concat(chunk)
-              return chunk
-            }),
-            Stream.toChannel
-          ),
-        (parts) =>
-          Effect.zipRight(
-            Ref.set(this.historyRef, Chunk.appendAll(parts, AiInput.make(combined))),
-            this.semaphore.release(1)
-          )
-      ))
-    }).pipe(Stream.withSpan("AiChat.toolkitStream", { attributes: { input: options.input }, captureStackTrace: false }))
+      },
+      toolkitStream<Tools extends AiToolkit.Tool.AnySchema>(options: {
+        readonly input: AiInput.Input
+        readonly tools: AiToolkit.Handlers<Tools>
+        readonly required?: Tools["_tag"] | boolean | undefined
+        readonly concurrency?: Concurrency | undefined
+      }): Stream.Stream<
+        WithResolved<AiToolkit.Tool.Success<Tools>>,
+        AiError | AiToolkit.Tool.Failure<Tools>,
+        AiToolkit.Tool.Context<Tools>
+      > {
+        return Stream.suspend(() => {
+          let combined = WithResolved.empty as WithResolved<AiToolkit.Tool.Success<Tools>>
+          return Stream.fromChannel(Channel.acquireUseRelease(
+            semaphore.take(1).pipe(
+              Effect.zipRight(Ref.get(history)),
+              Effect.map(Chunk.appendAll(AiInput.make(options.input)))
+            ),
+            (parts) =>
+              completions.toolkitStream({
+                ...options,
+                input: parts
+              }).pipe(
+                Stream.map((chunk) => {
+                  combined = combined.concat(chunk)
+                  return chunk
+                }),
+                Stream.toChannel
+              ),
+            (parts) =>
+              Effect.zipRight(
+                Ref.set(history, Chunk.appendAll(parts, AiInput.make(combined))),
+                semaphore.release(1)
+              )
+          ))
+        }).pipe(Stream.withSpan("AiChat.toolkitStream", {
+          attributes: { input: options.input },
+          captureStackTrace: false
+        }))
+      }
+    })
   }
-}
+)
 
 /**
  * @since 1.0.0