@effect/ai 0.26.0 → 0.27.0

package/dist/dts/Chat.d.ts

@@ -0,0 +1,356 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { ParseError } from "effect/ParseResult";
+import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
+import type { NoExcessProperties } from "effect/Types";
+import * as LanguageModel from "./LanguageModel.js";
+import * as Prompt from "./Prompt.js";
+import type * as Response from "./Response.js";
+import type * as Tool from "./Tool.js";
+declare const Chat_base: Context.TagClass<Chat, "@effect/ai/Chat", Service>;
+/**
+ * The `Chat` service tag for dependency injection.
+ *
+ * This tag provides access to chat functionality throughout your application,
+ * enabling persistent conversational AI interactions with full context
+ * management.
+ *
+ * @example
+ * ```ts
+ * import { Chat } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const useChat = Effect.gen(function* () {
+ *   const chat = yield* Chat
+ *   const response = yield* chat.generateText({
+ *     prompt: "Explain quantum computing in simple terms"
+ *   })
+ *   return response.content
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Context
+ */
+export declare class Chat extends Chat_base {
+}
+/**
+ * Represents the interface that the `Chat` service provides.
+ *
+ * @since 1.0.0
+ * @category Models
+ */
+export interface Service {
+    /**
+     * Reference to the chat history.
+     *
+     * Provides direct access to the conversation history for advanced use cases
+     * like custom history manipulation or inspection.
+     *
+     * @example
+     * ```ts
+     * import { Chat } from "@effect/ai"
+     * import { Effect, Ref } from "effect"
+     *
+     * const inspectHistory = Effect.gen(function* () {
+     *   const chat = yield* Chat.empty
+     *   const currentHistory = yield* Ref.get(chat.history)
+     *   console.log("Current conversation:", currentHistory)
+     *   return currentHistory
+     * })
+     * ```
+     */
+    readonly history: Ref.Ref<Prompt.Prompt>;
+    /**
+     * Exports the chat history into a structured format.
+     *
+     * Returns the complete conversation history as a structured object
+     * that can be stored, transmitted, or processed by other systems.
+     *
+     * @example
+     * ```ts
+     * import { Chat } from "@effect/ai"
+     * import { Effect } from "effect"
+     *
+     * const saveChat = Effect.gen(function* () {
+     *   const chat = yield* Chat.empty
+     *   yield* chat.generateText({ prompt: "Hello!" })
+     *
+     *   const exportedData = yield* chat.export
+     *
+     *   // Save to database or file system
+     *   return exportedData
+     * })
+     * ```
+     */
+    readonly export: Effect.Effect<unknown>;
+    /**
+     * Exports the chat history as a JSON string.
+     *
+     * Provides a convenient way to serialize the entire conversation
+     * for storage or transmission in JSON format.
+     *
+     * @example
+     * ```ts
+     * import { Chat } from "@effect/ai"
+     * import { Effect } from "effect"
+     *
+     * const backupChat = Effect.gen(function* () {
+     *   const chat = yield* Chat.empty
+     *   yield* chat.generateText({ prompt: "Explain photosynthesis" })
+     *
+     *   const jsonBackup = yield* chat.exportJson
+     *
+     *   yield* Effect.sync(() =>
+     *     localStorage.setItem("chat-backup", jsonBackup)
+     *   )
+     *
+     *   return jsonBackup
+     * })
+     * ```
+     */
+    readonly exportJson: Effect.Effect<string>;
+    /**
+     * Generate text using a language model for the specified prompt.
+     *
+     * If a toolkit is specified, the language model will have access to tools
+     * for function calling and enhanced capabilities. Both input and output
+     * messages are automatically added to the chat history.
+     *
+     * @example
+     * ```ts
+     * import { Chat } from "@effect/ai"
+     * import { Effect } from "effect"
+     *
+     * const chatWithAI = Effect.gen(function* () {
+     *   const chat = yield* Chat.empty
+     *
+     *   const response1 = yield* chat.generateText({
+     *     prompt: "What is the capital of France?"
+     *   })
+     *
+     *   const response2 = yield* chat.generateText({
+     *     prompt: "What's the population of that city?",
+     *   })
+     *
+     *   return [response1.content, response2.content]
+     * })
+     * ```
+     */
+    readonly generateText: <Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>, Tools extends Record<string, Tool.Any> = {}>(options: Options & LanguageModel.GenerateTextOptions<Tools>) => Effect.Effect<LanguageModel.GenerateTextResponse<Tools>, LanguageModel.ExtractError<Options>, LanguageModel.ExtractContext<Options>>;
+    /**
+     * Generate text using a language model with streaming output.
+     *
+     * Returns a stream of response parts that are emitted as soon as they're
+     * available from the model. Supports tool calling and maintains chat history.
+     *
+     * @example
+     * ```ts
+     * import { Chat } from "@effect/ai"
+     * import { Effect, Stream, Console } from "effect"
+     *
+     * const streamingChat = Effect.gen(function* () {
+     *   const chat = yield* Chat.empty
+     *
+     *   const stream = yield* chat.streamText({
+     *     prompt: "Write a short story about space exploration"
+     *   })
+     *
+     *   yield* Stream.runForEach(stream, (part) =>
+     *     part.type === "text-delta"
+     *       ? Effect.sync(() => process.stdout.write(part.delta))
+     *       : Effect.void
+     *   )
+     * })
+     * ```
+     */
+    readonly streamText: <Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>, Tools extends Record<string, Tool.Any> = {}>(options: Options & LanguageModel.GenerateTextOptions<Tools>) => Stream.Stream<Response.StreamPart<Tools>, LanguageModel.ExtractError<Options>, LanguageModel.ExtractContext<Options>>;
+    /**
+     * Generate a structured object using a language model and schema.
+     *
+     * Forces the model to return data that conforms to the specified schema,
+     * enabling structured data extraction and type-safe responses. The
+     * conversation history is maintained across calls.
+     *
+     * @example
+     * ```ts
+     * import { Chat } from "@effect/ai"
+     * import { Effect, Schema } from "effect"
+     *
+     * const ContactSchema = Schema.Struct({
+     *   name: Schema.String,
+     *   email: Schema.String,
+     *   phone: Schema.optional(Schema.String)
+     * })
+     *
+     * const extractContact = Effect.gen(function* () {
+     *   const chat = yield* Chat.empty
+     *
+     *   const contact = yield* chat.generateObject({
+     *     prompt: "Extract contact info: John Doe, john@example.com, 555-1234",
+     *     schema: ContactSchema
+     *   })
+     *
+     *   console.log(contact.object)
+     *   // { name: "John Doe", email: "john@example.com", phone: "555-1234" }
+     *
+     *   return contact.object
+     * })
+     * ```
+     */
+    readonly generateObject: <A, I extends Record<string, unknown>, R, Options extends NoExcessProperties<LanguageModel.GenerateObjectOptions<any, A, I, R>, Options>, Tools extends Record<string, Tool.Any> = {}>(options: Options & LanguageModel.GenerateObjectOptions<Tools, A, I, R>) => Effect.Effect<LanguageModel.GenerateObjectResponse<Tools, A>, LanguageModel.ExtractError<Options>, LanguageModel.LanguageModel | R | LanguageModel.ExtractContext<Options>>;
+}
+/**
+ * Creates a new Chat service from an initial prompt.
+ *
+ * This is the primary constructor for creating chat instances. It initializes
+ * a new conversation with the provided prompt as the starting context.
+ *
+ * @example
+ * ```ts
+ * import { Chat, Prompt } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const chatWithSystemPrompt = Effect.gen(function* () {
+ *   const chat = yield* Chat.fromPrompt([{
+ *     role: "system",
+ *     content: "You are a helpful assistant specialized in mathematics."
+ *   }])
+ *
+ *   const response = yield* chat.generateText({
+ *     prompt: "What is 2+2?"
+ *   })
+ *
+ *   return response.content
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Chat, Prompt } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * // Initialize with conversation history
+ * const existingChat = Effect.gen(function* () {
+ *   const chat = yield* Chat.fromPrompt([
+ *     { role: "user", content: [{ type: "text", text: "What's the weather like?" }] },
+ *     { role: "assistant", content: [{ type: "text", text: "I don't have access to weather data." }] },
+ *     { role: "user", content: [{ type: "text", text: "Can you help me with coding?" }] }
+ *   ])
+ *
+ *   const response = yield* chat.generateText({
+ *     prompt: "I need help with TypeScript"
+ *   })
+ *
+ *   return response
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export declare const fromPrompt: (prompt: Prompt.RawInput) => Effect.Effect<Service, never, LanguageModel.LanguageModel>;
+/**
+ * Creates a new Chat service with empty conversation history.
+ *
+ * This is the most common way to start a fresh chat session without
+ * any initial context or system prompts.
+ *
+ * @example
+ * ```ts
+ * import { Chat } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const freshChat = Effect.gen(function* () {
+ *   const chat = yield* Chat.empty
+ *
+ *   const response = yield* chat.generateText({
+ *     prompt: "Hello! Can you introduce yourself?"
+ *   })
+ *
+ *   console.log(response.content)
+ *
+ *   return chat
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export declare const empty: Effect.Effect<Service, never, LanguageModel.LanguageModel>;
+/**
+ * Creates a Chat service from previously exported chat data.
+ *
+ * Restores a chat session from structured data that was previously exported
+ * using the `export` method. Useful for persisting and restoring conversation
+ * state.
+ *
+ * @example
+ * ```ts
+ * import { Chat } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * declare const loadFromDatabase: (sessionId: string) => Effect.Effect<unknown>
+ *
+ * const restoreChat = Effect.gen(function* () {
+ *   // Assume we have previously exported data
+ *   const savedData = yield* loadFromDatabase("chat-session-123")
+ *
+ *   const restoredChat = yield* Chat.fromExport(savedData)
+ *
+ *   // Continue the conversation from where it left off
+ *   const response = yield* restoredChat.generateText({
+ *     prompt: "Let's continue our discussion"
+ *   })
+ * }).pipe(
+ *   Effect.catchTag("ParseError", (error) => {
+ *     console.log("Failed to restore chat:", error.message)
+ *     return Effect.void
+ *   })
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export declare const fromExport: (data: unknown) => Effect.Effect<Service, ParseError, LanguageModel.LanguageModel>;
+/**
+ * Creates a Chat service from previously exported JSON chat data.
+ *
+ * Restores a chat session from JSON string that was previously exported
+ * using the `exportJson` method. This is the most convenient way to
+ * persist and restore chat sessions to/from storage systems.
+ *
+ * @example
+ * ```ts
+ * import { Chat } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const restoreFromJson = Effect.gen(function* () {
+ *   // Load JSON from localStorage or file system
+ *   const jsonData = localStorage.getItem("my-chat-backup")
+ *   if (!jsonData) return yield* Chat.empty
+ *
+ *   const restoredChat = yield* Chat.fromJson(jsonData)
+ *
+ *   // Chat history is now restored
+ *   const response = yield* restoredChat.generateText({
+ *     prompt: "What were we talking about?"
+ *   })
+ *
+ *   return response
+ * }).pipe(
+ *   Effect.catchTag("ParseError", (error) => {
+ *     console.log("Invalid JSON format:", error.message)
+ *     return Chat.empty // Fallback to empty chat
+ *   })
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export declare const fromJson: (data: string) => Effect.Effect<Service, ParseError, LanguageModel.LanguageModel>;
+export {};
+//# sourceMappingURL=Chat.d.ts.map

package/dist/dts/Chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../src/Chat.ts"],"names":[],"mappings":"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"}

package/dist/dts/EmbeddingModel.d.ts

@@ -0,0 +1,153 @@
+import * as Context from "effect/Context";
+import type * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import type * as Types from "effect/Types";
+import * as AiError from "./AiError.js";
+declare const EmbeddingModel_base: Context.TagClass<EmbeddingModel, "@effect/ai/EmbeddingModel", Service>;
+/**
+ * The `EmbeddingModel` service tag for dependency injection.
+ *
+ * This tag provides access to vector embedding functionality throughout your application,
+ * enabling conversion of text to high-dimensional vectors for semantic analysis.
+ *
+ * @example
+ * ```ts
+ * import { EmbeddingModel } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const useEmbeddings = Effect.gen(function* () {
+ *   const embedder = yield* EmbeddingModel
+ *
+ *   const documentVector = yield* embedder.embed("This is a sample document")
+ *   const queryVector = yield* embedder.embed("sample query")
+ *
+ *   const similarity = cosineSimilarity(documentVector, queryVector)
+ *   return similarity
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Context
+ */
+export declare class EmbeddingModel extends EmbeddingModel_base {
+}
+/**
+ * The service interface for vector embedding operations.
+ *
+ * Defines the contract that all embedding model implementations must fulfill.
+ * The service provides text-to-vector conversion functionality.
+ *
+ * @since 1.0.0
+ * @category Models
+ */
+export interface Service {
+    /**
+     * Converts a text string into a vector embedding.
+     */
+    readonly embed: (input: string) => Effect.Effect<Array<number>, AiError.AiError>;
+    /**
+     * Converts a batch of text strings into a chunk of vector embeddings.
+     */
+    readonly embedMany: (input: ReadonlyArray<string>, options?: {
+        /**
+         * The concurrency level to use while batching requests.
+         */
+        readonly concurrency?: Types.Concurrency | undefined;
+    }) => Effect.Effect<Array<Array<number>>, AiError.AiError>;
+}
+/**
+ * Represents the result of a batch embedding operation.
+ *
+ * Used internally by the batching system to associate embeddings with their
+ * original request positions in the batch.
+ *
+ * @example
+ * ```ts
+ * import { EmbeddingModel } from "@effect/ai"
+ *
+ * const batchResults: EmbeddingModel.Result[] = [
+ *   { index: 0, embeddings: [0.1, 0.2, 0.3] },
+ *   { index: 1, embeddings: [0.4, 0.5, 0.6] },
+ *   { index: 2, embeddings: [0.7, 0.8, 0.9] }
+ * ]
+ *
+ * // Results correspond to input texts at positions 0, 1, 2
+ * ```
+ *
+ * @since 1.0.0
+ * @category Models
+ */
+export interface Result {
+    /**
+     * The position index of this result in the original batch request.
+     */
+    readonly index: number;
+    /**
+     * The vector embedding for the text at this index.
+     */
+    readonly embeddings: Array<number>;
+}
+/**
+ * Creates an EmbeddingModel service with batching and caching capabilities.
+ *
+ * This is the primary constructor for creating embedding services. It supports
+ * automatic batching of requests for efficiency and optional caching to reduce
+ * redundant API calls.
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export declare const make: (options: {
+    /**
+     * A method which processes a batch of text inputs and returns embedding
+     * results.
+     */
+    readonly embedMany: (input: ReadonlyArray<string>) => Effect.Effect<Array<Result>, AiError.AiError>;
+    /**
+     * Optional maximum number of text inputs to process in one batch.
+     */
+    readonly maxBatchSize?: number;
+    /**
+     * Optional configuration to control how batch request results are cached.
+     */
+    readonly cache?: {
+        /**
+         * The capacity of the cache.
+         */
+        readonly capacity: number;
+        /**
+         * The time-to-live for items in the cache.
+         */
+        readonly timeToLive: Duration.DurationInput;
+    };
+}) => Effect.Effect<Service, never, never>;
+/**
+ * Creates an EmbeddingModel service with time-window based batching.
+ *
+ * This constructor creates a service that uses a data loader pattern to batch
+ * embedding requests within a specified time window. This is optimal for
+ * high-throughput scenarios where you want to automatically batch requests that
+ * arrive within a short time period.
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export declare const makeDataLoader: (options: {
+    /**
+     * A method which processes a batch of text inputs and returns embedding
+     * results.
+     */
+    readonly embedMany: (input: ReadonlyArray<string>) => Effect.Effect<Array<Result>, AiError.AiError>;
+    /**
+     * The duration between batch requests during which requests are collected and
+     * added to the current batch.
+     */
+    readonly window: Duration.DurationInput;
+    /**
+     * Optional maximum number of requests to add to the batch before a batch
+     * request must be sent.
+     */
+    readonly maxBatchSize?: number;
+}) => Effect.Effect<Service, never, import("effect/Scope").Scope>;
+export {};
+//# sourceMappingURL=EmbeddingModel.d.ts.map

package/dist/dts/EmbeddingModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddingModel.d.ts","sourceRoot":"","sources":["../../src/EmbeddingModel.ts"],"names":[],"mappings":"AAmDA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAe,SAAQ,mBAGjC;CAAG;AAEN;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IAChF;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE;QAC3D;;WAEG;QACH,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAA;KACrD,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAC3D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IAEtB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CACnC;AAgCD;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IACnG;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf;;WAEG;QACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;QACzB;;WAEG;QACH,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAA;KAC5C,CAAA;CACF,yCAyCG,CAAA;AAEJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS;IACtC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IACnG;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAA;IACvC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAC/B,gEA0BG,CAAA"}