miragedev-sdk 0.2.0 → 0.3.0

package/README.md

@@ -267,6 +267,130 @@ function MyComponent() {
 }
 ```
 
+### AI Module
+
+```typescript
+import { chat, chatStream, useChat, setAIConfig } from 'miragedev-sdk/ai'
+```
+
+**Setup:**
+
+```typescript
+// lib/miragedev.init.ts or app setup
+import { initMirageDev } from 'miragedev-sdk'
+
+initMirageDev({
+  ai: {
+    provider: 'openai',
+    apiKey: process.env.OPENAI_API_KEY,
+    defaultModel: 'gpt-4-turbo-preview',
+    temperature: 0.7,
+  }
+})
+```
+
+**Server-Side Chat:**
+
+```typescript
+import { chat } from 'miragedev-sdk/ai'
+
+export async function POST(req: Request) {
+  const { message } = await req.json()
+  
+  const response = await chat({
+    messages: [
+      { role: 'system', content: 'You are a helpful assistant' },
+      { role: 'user', content: message }
+    ],
+    temperature: 0.7,
+  })
+  
+  return Response.json({ reply: response.content })
+}
+```
+
+**Streaming (Edge Runtime):**
+
+```typescript
+import { chatStream, createEdgeStreamResponse } from 'miragedev-sdk/ai'
+
+export const runtime = 'edge'
+
+export async function POST(req: Request) {
+  const { messages } = await req.json()
+  
+  return createEdgeStreamResponse(async (write) => {
+    await chatStream({ messages }, (chunk) => {
+      write(chunk.delta)
+    })
+  })
+}
+```
+
+**Client-Side Hook:**
+
+```typescript
+'use client'
+
+import { useChat } from 'miragedev-sdk/ai'
+
+export function ChatComponent() {
+  const { messages, sendMessage, isLoading, streamingMessage } = useChat({
+    stream: true,
+    initialMessages: [
+      { role: 'system', content: 'You are a helpful assistant' }
+    ],
+    onError: (error) => console.error(error)
+  })
+
+  return (
+    <div>
+      {messages.map((msg, i) => (
+        <div key={i}>
+          <strong>{msg.role}:</strong> {msg.content}
+        </div>
+      ))}
+      
+      {streamingMessage && (
+        <div>
+          <strong>assistant:</strong> {streamingMessage}
+        </div>
+      )}
+      
+      <button 
+        onClick={() => sendMessage('Hello!')}
+        disabled={isLoading}
+      >
+        Send Message
+      </button>
+    </div>
+  )
+}
+```
+
+**Embeddings:**
+
+```typescript
+import { createEmbeddings } from 'miragedev-sdk/ai'
+
+const response = await createEmbeddings({
+  input: 'Machine learning is fascinating',
+})
+
+console.log(response.embeddings[0]) // [0.123, -0.456, ...]
+```
+
+**Environment Variables:**
+
+```env
+OPENAI_API_KEY=sk-...
+```
+
+**Supported Providers:**
+- ✅ OpenAI (GPT-4, GPT-3.5, embeddings)
+- 🔜 Anthropic (Claude) - Coming soon
+```
+
 ## API Reference
 
 Full API documentation with examples for every function is available in the code via JSDoc. Your AI assistant can read these to help you build faster.

package/dist/ai/index.cjs

@@ -0,0 +1,383 @@
+'use strict';
+
+var chunkTALL2IL5_cjs = require('../chunk-TALL2IL5.cjs');
+var chunkBW4BLEIM_cjs = require('../chunk-BW4BLEIM.cjs');
+require('../chunk-75ZPJI57.cjs');
+var OpenAI = require('openai');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
+
+var OpenAIProvider = class {
+  client;
+  config;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_CONFIG_INVALID",
+        "OpenAI API key is required"
+      );
+    }
+    this.config = config;
+    this.client = new OpenAI__default.default({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+      organization: config.organization,
+      timeout: config.timeout,
+      dangerouslyAllowBrowser: true
+      // Allow in tests and edge runtime
+    });
+  }
+  /**
+   * Convert our message format to OpenAI message format
+   */
+  convertMessages(messages) {
+    return messages.map((msg) => {
+      if (msg.role === "system") {
+        const systemMessage = {
+          role: "system",
+          content: msg.content
+        };
+        if (msg.name) {
+          systemMessage.name = msg.name;
+        }
+        return systemMessage;
+      }
+      if (msg.role === "user") {
+        const userMessage = {
+          role: "user",
+          content: msg.content
+        };
+        if (msg.name) {
+          userMessage.name = msg.name;
+        }
+        return userMessage;
+      }
+      if (msg.role === "assistant") {
+        const assistantMessage = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.name) {
+          assistantMessage.name = msg.name;
+        }
+        if (msg.functionCall) {
+          assistantMessage.function_call = {
+            name: msg.functionCall.name,
+            arguments: msg.functionCall.arguments
+          };
+        }
+        return assistantMessage;
+      }
+      const functionMessage = {
+        role: "function",
+        content: msg.content,
+        name: msg.name || ""
+      };
+      return functionMessage;
+    });
+  }
+  /**
+   * Send a chat completion request
+   */
+  async chat(options) {
+    try {
+      if (!options.messages || options.messages.length === 0) {
+        throw new chunkBW4BLEIM_cjs.MirageDevError(
+          "AI_CONFIG_INVALID",
+          "Messages array cannot be empty"
+        );
+      }
+      const model = options.model || this.config.defaultModel || "gpt-4o-mini";
+      const temperature = options.temperature ?? this.config.temperature;
+      const maxTokens = options.maxTokens ?? this.config.maxTokens;
+      const params = {
+        model,
+        messages: this.convertMessages(options.messages)
+      };
+      if (temperature !== void 0) {
+        params.temperature = temperature;
+      }
+      if (maxTokens !== void 0) {
+        params.max_tokens = maxTokens;
+      }
+      if (options.functions) {
+        params.functions = options.functions.map((fn) => ({
+          name: fn.name,
+          description: fn.description,
+          parameters: fn.parameters
+        }));
+      }
+      const response = await this.client.chat.completions.create(params);
+      const choice = response.choices[0];
+      if (!choice) {
+        throw new chunkBW4BLEIM_cjs.MirageDevError(
+          "AI_API_ERROR",
+          "No response choices returned from OpenAI"
+        );
+      }
+      const result = {
+        content: choice.message.content || "",
+        role: choice.message.role,
+        finishReason: this.mapFinishReason(choice.finish_reason)
+      };
+      if (choice.message.function_call) {
+        try {
+          result.functionCall = {
+            name: choice.message.function_call.name,
+            arguments: JSON.parse(choice.message.function_call.arguments || "{}")
+          };
+        } catch (error) {
+          throw new chunkBW4BLEIM_cjs.MirageDevError(
+            "AI_API_ERROR",
+            `Failed to parse function call arguments: ${error instanceof Error ? error.message : "Invalid JSON"}`,
+            error
+          );
+        }
+      }
+      if (response.usage) {
+        result.usage = {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        };
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof chunkBW4BLEIM_cjs.MirageDevError) {
+        throw error;
+      }
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_API_ERROR",
+        error instanceof Error ? error.message : "Unknown error occurred",
+        error
+      );
+    }
+  }
+  /**
+   * Send a streaming chat completion request
+   */
+  async chatStream(options, onChunk) {
+    try {
+      const model = options.model || this.config.defaultModel || "gpt-4o-mini";
+      const temperature = options.temperature ?? this.config.temperature;
+      const maxTokens = options.maxTokens ?? this.config.maxTokens;
+      const params = {
+        model,
+        messages: this.convertMessages(options.messages),
+        stream: true
+      };
+      if (temperature !== void 0) {
+        params.temperature = temperature;
+      }
+      if (maxTokens !== void 0) {
+        params.max_tokens = maxTokens;
+      }
+      if (options.functions) {
+        params.functions = options.functions.map((fn) => ({
+          name: fn.name,
+          description: fn.description,
+          parameters: fn.parameters
+        }));
+      }
+      const stream = await this.client.chat.completions.create(params);
+      let content = "";
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content || "";
+        const finishReason = chunk.choices[0]?.finish_reason;
+        if (delta) {
+          content += delta;
+        }
+        onChunk({
+          content,
+          delta,
+          isComplete: finishReason !== null
+        });
+      }
+    } catch (error) {
+      if (error instanceof chunkBW4BLEIM_cjs.MirageDevError) {
+        throw error;
+      }
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_API_ERROR",
+        error instanceof Error ? error.message : "Unknown error occurred",
+        error
+      );
+    }
+  }
+  /**
+   * Create embeddings for text input(s)
+   */
+  async createEmbeddings(options) {
+    try {
+      const model = options.model || "text-embedding-ada-002";
+      const input = Array.isArray(options.input) ? options.input : [options.input];
+      const response = await this.client.embeddings.create({
+        model,
+        input
+      });
+      const result = {
+        embeddings: response.data.map((item) => item.embedding)
+      };
+      if (response.usage) {
+        result.usage = {
+          promptTokens: response.usage.prompt_tokens,
+          totalTokens: response.usage.total_tokens
+        };
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof chunkBW4BLEIM_cjs.MirageDevError) {
+        throw error;
+      }
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_API_ERROR",
+        error instanceof Error ? error.message : "Unknown error occurred",
+        error
+      );
+    }
+  }
+  /**
+   * Map OpenAI finish reason to our format
+   */
+  mapFinishReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "stop";
+      case "length":
+        return "length";
+      case "function_call":
+        return "function_call";
+      case "content_filter":
+        return "content_filter";
+      default:
+        return "stop";
+    }
+  }
+};
+
+// src/ai/factory.ts
+var providerInstance = null;
+function getAIProvider() {
+  const config = chunkTALL2IL5_cjs.getAIConfig();
+  if (providerInstance) {
+    return providerInstance;
+  }
+  if (!config.apiKey) {
+    throw new chunkBW4BLEIM_cjs.MirageDevError(
+      "AI_CONFIG_INVALID",
+      "API key required for AI provider"
+    );
+  }
+  switch (config.provider) {
+    case "openai":
+      providerInstance = new OpenAIProvider({
+        apiKey: config.apiKey,
+        baseURL: config.baseURL,
+        defaultModel: config.defaultModel,
+        maxTokens: config.maxTokens,
+        temperature: config.temperature
+      });
+      break;
+    case "anthropic":
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_PROVIDER_ERROR",
+        "Anthropic provider not yet supported. Coming soon!"
+      );
+    case "custom":
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_PROVIDER_ERROR",
+        "Custom provider requires implementation"
+      );
+    default:
+      throw new chunkBW4BLEIM_cjs.MirageDevError(
+        "AI_PROVIDER_ERROR",
+        `Unknown AI provider: ${config.provider}`
+      );
+  }
+  return providerInstance;
+}
+
+// src/ai/edge.ts
+function createEdgeStreamResponse(callback) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const write = async (data) => {
+        controller.enqueue(encoder.encode(data));
+      };
+      try {
+        await callback(write);
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+}
+function createSSEStream(callback) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = async (event, data) => {
+        const message = `event: ${event}
+data: ${data}
+
+`;
+        controller.enqueue(encoder.encode(message));
+      };
+      try {
+        await callback(send);
+      } catch (error) {
+        await send("error", JSON.stringify({ error: String(error) }));
+        controller.error(error);
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+}
+
+// src/ai/index.ts
+async function chat(options) {
+  const provider = getAIProvider();
+  return provider.chat(options);
+}
+async function chatStream(options, onChunk) {
+  const provider = getAIProvider();
+  return provider.chatStream(options, onChunk);
+}
+async function createEmbeddings(options) {
+  const provider = getAIProvider();
+  return provider.createEmbeddings(options);
+}
+
+Object.defineProperty(exports, "getAIConfig", {
+  enumerable: true,
+  get: function () { return chunkTALL2IL5_cjs.getAIConfig; }
+});
+Object.defineProperty(exports, "setAIConfig", {
+  enumerable: true,
+  get: function () { return chunkTALL2IL5_cjs.setAIConfig; }
+});
+exports.chat = chat;
+exports.chatStream = chatStream;
+exports.createEdgeStreamResponse = createEdgeStreamResponse;
+exports.createEmbeddings = createEmbeddings;
+exports.createSSEStream = createSSEStream;

package/dist/ai/index.d.cts

@@ -0,0 +1,14 @@
+import { A as AIConfig, C as ChatOptions, e as ChatResponse, S as StreamChunk, E as EmbeddingOptions, f as EmbeddingResponse } from '../ai-DTlWq4Xf.cjs';
+export { d as AIFunction, c as AIMessage, a as AIProvider, b as AIRole } from '../ai-DTlWq4Xf.cjs';
+
+declare function setAIConfig(config: Partial<AIConfig>): void;
+declare function getAIConfig(): AIConfig;
+
+declare function createEdgeStreamResponse(callback: (write: (data: string) => Promise<void>) => Promise<void>): Response;
+declare function createSSEStream(callback: (send: (event: string, data: string) => Promise<void>) => Promise<void>): Response;
+
+declare function chat(options: ChatOptions): Promise<ChatResponse>;
+declare function chatStream(options: ChatOptions, onChunk: (chunk: StreamChunk) => void): Promise<void>;
+declare function createEmbeddings(options: EmbeddingOptions): Promise<EmbeddingResponse>;
+
+export { AIConfig, ChatOptions, ChatResponse, EmbeddingOptions, EmbeddingResponse, StreamChunk, chat, chatStream, createEdgeStreamResponse, createEmbeddings, createSSEStream, getAIConfig, setAIConfig };

package/dist/ai/index.d.ts

@@ -0,0 +1,14 @@
+import { A as AIConfig, C as ChatOptions, e as ChatResponse, S as StreamChunk, E as EmbeddingOptions, f as EmbeddingResponse } from '../ai-DTlWq4Xf.js';
+export { d as AIFunction, c as AIMessage, a as AIProvider, b as AIRole } from '../ai-DTlWq4Xf.js';
+
+declare function setAIConfig(config: Partial<AIConfig>): void;
+declare function getAIConfig(): AIConfig;
+
+declare function createEdgeStreamResponse(callback: (write: (data: string) => Promise<void>) => Promise<void>): Response;
+declare function createSSEStream(callback: (send: (event: string, data: string) => Promise<void>) => Promise<void>): Response;
+
+declare function chat(options: ChatOptions): Promise<ChatResponse>;
+declare function chatStream(options: ChatOptions, onChunk: (chunk: StreamChunk) => void): Promise<void>;
+declare function createEmbeddings(options: EmbeddingOptions): Promise<EmbeddingResponse>;
+
+export { AIConfig, ChatOptions, ChatResponse, EmbeddingOptions, EmbeddingResponse, StreamChunk, chat, chatStream, createEdgeStreamResponse, createEmbeddings, createSSEStream, getAIConfig, setAIConfig };