@umituz/web-ai 0.0.0-stage → 1.0.1

package/dist/chat/index.cjs

@@ -0,0 +1,625 @@
+'use strict';
+
+// src/core/errors/ai-error-types.ts
+var AIErrorType = /* @__PURE__ */ ((AIErrorType2) => {
+  AIErrorType2["INVALID_API_KEY"] = "INVALID_API_KEY";
+  AIErrorType2["MISSING_CONFIG"] = "MISSING_CONFIG";
+  AIErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  AIErrorType2["ABORT_ERROR"] = "ABORT_ERROR";
+  AIErrorType2["RATE_LIMIT_ERROR"] = "RATE_LIMIT_ERROR";
+  AIErrorType2["SERVER_ERROR"] = "SERVER_ERROR";
+  AIErrorType2["CLIENT_ERROR"] = "CLIENT_ERROR";
+  AIErrorType2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return AIErrorType2;
+})(AIErrorType || {});
+
+// src/core/errors/ai-error.ts
+var KNOWN_ERROR_TYPES = new Set(Object.values(AIErrorType));
+function mapCodeToType(code) {
+  switch (code) {
+    case "VALIDATION_ERROR":
+    case "CLIENT_ERROR":
+      return "CLIENT_ERROR" /* CLIENT_ERROR */;
+    case "INVALID_API_KEY":
+      return "INVALID_API_KEY" /* INVALID_API_KEY */;
+    case "MISSING_CONFIG":
+    case "PROVIDER_UNAVAILABLE":
+      return "MISSING_CONFIG" /* MISSING_CONFIG */;
+    case "PROVIDER_QUOTA_EXHAUSTED":
+    case "RATE_LIMIT_ERROR":
+      return "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */;
+    case "NETWORK_ERROR":
+    case "TIMEOUT":
+      return "NETWORK_ERROR" /* NETWORK_ERROR */;
+    case "ABORT_ERROR":
+    case "ABORTED":
+      return "ABORT_ERROR" /* ABORT_ERROR */;
+    case "SERVER_ERROR":
+    case "PROVIDER_ERROR":
+    case "NO_RESULT":
+      return "SERVER_ERROR" /* SERVER_ERROR */;
+    default:
+      return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+}
+function mapMessageToCode(message, fallback = "UNKNOWN") {
+  const lower = message.toLowerCase();
+  if (lower.includes("validation")) return "VALIDATION_ERROR";
+  if (lower.includes("quota")) return "PROVIDER_QUOTA_EXHAUSTED";
+  if (lower.includes("unavailable")) return "PROVIDER_UNAVAILABLE";
+  if (lower.includes("timeout") || lower.includes("aborted")) {
+    return lower.includes("aborted") ? "ABORTED" : "TIMEOUT";
+  }
+  if (lower.includes("parse") || lower.includes("json")) return "PARSE_ERROR";
+  if (lower.includes("no result")) return "NO_RESULT";
+  if (lower.includes("network") || lower.includes("fetch")) return "NETWORK_ERROR";
+  return fallback;
+}
+var AIError = class _AIError extends Error {
+  type;
+  code;
+  cause;
+  metadata;
+  constructor(typeOrMessage, messageOrCode, cause, metadata = {}) {
+    let effectiveType;
+    let effectiveMessage;
+    let effectiveCode;
+    if (KNOWN_ERROR_TYPES.has(typeOrMessage)) {
+      effectiveType = typeOrMessage;
+      effectiveMessage = messageOrCode ?? "";
+      effectiveCode = effectiveType;
+    } else {
+      effectiveMessage = typeOrMessage;
+      effectiveCode = messageOrCode ?? "UNKNOWN";
+      effectiveType = mapCodeToType(effectiveCode);
+    }
+    super(effectiveMessage);
+    this.name = "AIError";
+    this.type = effectiveType;
+    this.code = effectiveCode;
+    this.cause = cause;
+    this.metadata = metadata;
+  }
+  static from(error, fallbackCode = "UNKNOWN") {
+    if (error instanceof _AIError) return error;
+    if (error instanceof Error) {
+      const code = mapMessageToCode(error.message, fallbackCode);
+      return new _AIError(error.message, code, error);
+    }
+    return new _AIError(String(error), fallbackCode, error);
+  }
+  toString() {
+    const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
+    return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      code: this.code,
+      message: this.message,
+      metadata: this.metadata
+    };
+  }
+};
+
+// src/providers/base/provider.types.ts
+function isTextProvider(provider) {
+  return provider.capabilities.includes("text");
+}
+
+// src/content/domain/limits/ProviderTimingConfig.ts
+var ProviderTimingConfig = {
+  HEALTH_CHECK_TTL_MS: 5 * 60 * 1e3};
+
+// src/providers/factory/provider.factory.ts
+var ProviderFactory = class {
+  providers = /* @__PURE__ */ new Map();
+  healthCache = /* @__PURE__ */ new Map();
+  priority;
+  fallbackEnabled;
+  defaultTier;
+  constructor(config = {}) {
+    this.priority = config.priority ?? [];
+    this.fallbackEnabled = config.fallbackEnabled ?? true;
+    this.defaultTier = config.defaultTier ?? "balanced";
+  }
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  getAllProviders() {
+    return Array.from(this.providers.values());
+  }
+  getByCapability(capability) {
+    return this.getAllProviders().filter(
+      (provider) => provider.capabilities.includes(capability)
+    );
+  }
+  getTextProviders() {
+    return this.getAllProviders().filter(isTextProvider);
+  }
+  hasTextProvider() {
+    return this.getByCapability("text").length > 0;
+  }
+  /* ---------- neutral text surface ---------- */
+  /**
+   * Single-chat entry point: resolves a healthy text provider by priority,
+   * injects the default tier when the request names neither model nor tier,
+   * and walks the fallback chain on failure. Providers map tiers onto their
+   * own models, so switching Groq→Anthropic is a config change.
+   */
+  async chat(request) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    return this.executeWithFallback(
+      "text",
+      (provider) => provider.generate(effective)
+    );
+  }
+  async chatStream(request, callbacks) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    let lastError;
+    const attemptCallbacks = {
+      onChunk: callbacks.onChunk,
+      onComplete: callbacks.onComplete
+    };
+    const providers = this.getByCapability("text");
+    if (providers.length === 0) {
+      throw this.noProviderError("text");
+    }
+    const ordered = this.orderByPriority(providers);
+    for (const provider of ordered) {
+      if (!this.isProviderHealthy(provider.id)) continue;
+      try {
+        return await provider.stream(effective, attemptCallbacks);
+      } catch (error) {
+        lastError = error;
+        this.markDegraded(provider.id);
+        if (!this.fallbackEnabled) {
+          callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+          throw error;
+        }
+      }
+    }
+    const failure = new AIError(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      `All providers failed for capability 'text'`,
+      lastError instanceof Error ? lastError : void 0
+    );
+    callbacks.onError?.(lastError instanceof Error ? lastError : failure);
+    throw failure;
+  }
+  /** AsyncGenerator adapter over chatStream — A's familiar consumption shape. */
+  async *streamText(request) {
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let failure;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    request.signal?.addEventListener("abort", onAbort);
+    const effectiveRequest = { ...request, signal: controller.signal };
+    const notify = () => {
+      const resolve = wake;
+      wake = null;
+      resolve?.();
+    };
+    const completion = this.chatStream(effectiveRequest, {
+      onChunk: (chunk) => {
+        queue.push(chunk);
+        notify();
+      }
+    }).then(
+      () => {
+        finished = true;
+        notify();
+      },
+      (error) => {
+        failure = error;
+        finished = true;
+        notify();
+      }
+    );
+    try {
+      while (!finished || queue.length > 0) {
+        if (queue.length === 0 && !finished) {
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        }
+        while (queue.length > 0) {
+          yield queue.shift();
+        }
+        if (failure) throw failure;
+      }
+      await completion;
+    } finally {
+      controller.abort();
+      request.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async generateJson(request) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    return this.executeWithFallback(
+      "text",
+      (provider) => provider.generateStructured(effective)
+    );
+  }
+  /* ---------- content-layer string facade (ITextGenerator) ---------- */
+  async generateText(prompt, options = {}) {
+    const result = await this.chat({
+      messages: [{ role: "user", content: prompt }],
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP
+    });
+    return result.text;
+  }
+  generateTextStream(prompt, options = {}) {
+    return this.streamText({
+      messages: [{ role: "user", content: prompt }],
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP
+    });
+  }
+  /* ---------- media surface ---------- */
+  async generateImage(request) {
+    return this.executeWithFallback(
+      "image",
+      (provider) => provider.generateImage(request)
+    );
+  }
+  async generateVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.generateVideo(request)
+    );
+  }
+  async imageToVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.imageToVideo(request)
+    );
+  }
+  async videoToVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.videoToVideo(request)
+    );
+  }
+  /* ---------- health ---------- */
+  async checkProviderHealth(providerId, forceRefresh = false) {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      return "unavailable";
+    }
+    const cached = this.healthCache.get(providerId);
+    const now = Date.now();
+    const ttl = ProviderTimingConfig.HEALTH_CHECK_TTL_MS;
+    if (!forceRefresh && cached && now - cached.timestamp < ttl) {
+      return cached.health;
+    }
+    try {
+      const health = await provider.healthCheck();
+      this.healthCache.set(providerId, { health, timestamp: now });
+      return health;
+    } catch {
+      this.healthCache.set(providerId, { health: "unavailable", timestamp: now });
+      return "unavailable";
+    }
+  }
+  isProviderHealthy(providerId) {
+    const cached = this.healthCache.get(providerId);
+    if (!cached) {
+      return true;
+    }
+    return cached.health === "healthy" || cached.health === "degraded";
+  }
+  async refreshAllHealth() {
+    await Promise.all(
+      Array.from(this.providers.keys()).map((id) => this.checkProviderHealth(id))
+    );
+  }
+  /* ---------- internals ---------- */
+  async executeWithFallback(capability, fn) {
+    const providers = this.getByCapability(capability);
+    if (providers.length === 0) {
+      throw this.noProviderError(capability);
+    }
+    let lastError;
+    for (const provider of this.orderByPriority(providers)) {
+      if (!this.isProviderHealthy(provider.id)) {
+        continue;
+      }
+      try {
+        return await fn(provider);
+      } catch (error) {
+        lastError = error;
+        this.markDegraded(provider.id);
+        if (!this.fallbackEnabled) {
+          throw error;
+        }
+      }
+    }
+    throw new AIError(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      `All providers failed for capability '${capability}'`,
+      lastError instanceof Error ? lastError : void 0
+    );
+  }
+  orderByPriority(providers) {
+    if (this.priority.length === 0) {
+      return providers;
+    }
+    const ordered = [];
+    for (const providerId of this.priority) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (provider) ordered.push(provider);
+    }
+    for (const provider of providers) {
+      if (!this.priority.includes(provider.id)) {
+        ordered.push(provider);
+      }
+    }
+    return ordered;
+  }
+  markDegraded(providerId) {
+    const cached = this.healthCache.get(providerId);
+    if (cached) {
+      this.healthCache.set(providerId, { health: "degraded", timestamp: cached.timestamp });
+    }
+  }
+  noProviderError(capability) {
+    return new AIError(
+      "MISSING_CONFIG" /* MISSING_CONFIG */,
+      `No provider registered for capability '${capability}' \u2014 create one with createAI() and include its config block`
+    );
+  }
+};
+
+// src/core/calculations/random-base36-suffix.ts
+var BASE_36_RADIX = 36;
+var DECIMAL_OFFSET = 2;
+function generateRandomBase36Suffix(length, random = Math.random) {
+  if (length <= 0) return "";
+  const raw = random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  if (raw.length >= length) return raw.slice(0, length);
+  let result = raw;
+  while (result.length < length) {
+    result += random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  }
+  return result.slice(0, length);
+}
+
+// src/core/constants/identifier.constants.ts
+var MESSAGE_ID_PREFIX = "msg-";
+var CHAT_MESSAGE_ID_SUFFIX_LENGTH = 9;
+var USER_ROLE = "user";
+var ASSISTANT_ROLE = "assistant";
+
+// src/chat/utils/chat-id-generator.ts
+var ID_PART_DELIMITER = "-";
+var ChatIdGenerator = class {
+  counter = 0;
+  randomLength;
+  constructor(randomLength = CHAT_MESSAGE_ID_SUFFIX_LENGTH) {
+    this.randomLength = randomLength;
+  }
+  next(sender) {
+    this.counter += 1;
+    const random = generateRandomBase36Suffix(this.randomLength);
+    return [
+      MESSAGE_ID_PREFIX,
+      Date.now(),
+      sender,
+      this.counter,
+      random
+    ].join(ID_PART_DELIMITER);
+  }
+};
+var chatIdGenerator = new ChatIdGenerator();
+
+// src/chat/utils/message-formatter.ts
+var MessageFormatter = class {
+  constructor(idGenerator = chatIdGenerator) {
+    this.idGenerator = idGenerator;
+  }
+  idGenerator;
+  /** Maps chat-domain history to neutral core messages; system senders are
+   *  dropped — the system prompt travels on the request's own slot. */
+  toCoreMessages(messages) {
+    const coreMessages = [];
+    for (const message of messages) {
+      if (message.sender === "system") continue;
+      coreMessages.push({
+        role: message.sender === "user" ? USER_ROLE : ASSISTANT_ROLE,
+        content: message.content
+      });
+    }
+    return coreMessages;
+  }
+  toChatMessage(content, sender) {
+    return {
+      id: this.idGenerator.next(sender),
+      sender,
+      content: content.trim(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "text"
+    };
+  }
+};
+var messageFormatter = new MessageFormatter();
+
+// src/chat/utils/prompt-strategy.ts
+var DEFAULT_PROMPT_STRATEGY = {
+  resolve: (config) => {
+    if (config.systemPrompt && config.systemPrompt.length > 0) {
+      return config.systemPrompt;
+    }
+    return void 0;
+  }
+};
+
+// src/chat/services/chat.service.ts
+var DEFAULT_CONFIG = {
+  temperature: 0.8,
+  maxTokens: 500
+};
+var ChatService = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  engine;
+  config = DEFAULT_CONFIG;
+  promptStrategy = DEFAULT_PROMPT_STRATEGY;
+  storage = null;
+  initialize(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setPromptStrategy(strategy) {
+    this.promptStrategy = strategy;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  async getConversation(conversationId) {
+    const storage = this.requireStorage();
+    const messages = await storage.getMessages(conversationId);
+    if (messages.length === 0) return null;
+    const last = messages[messages.length - 1];
+    const first = messages[0];
+    const companionId = String(first.metadata?.["companionId"] ?? "unknown");
+    const companionName = String(first.metadata?.["companionName"] ?? "Unknown");
+    return {
+      id: conversationId,
+      companionId,
+      companionName,
+      lastMessage: last,
+      messageCount: messages.length,
+      updatedAt: last.timestamp
+    };
+  }
+  async getConversations() {
+    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
+      return this.storage.getConversations();
+    }
+    return [];
+  }
+  async sendMessage(input, signal) {
+    const userMessage = {
+      ...messageFormatter.toChatMessage(input.text, "user"),
+      type: input.type ?? "text",
+      ...input.imageUrl !== void 0 ? { imageUrl: input.imageUrl } : {}
+    };
+    const aiResponse = await this.generateAIResponse(
+      input.companionId,
+      input.text,
+      [],
+      signal
+    );
+    return { userMessage, aiResponse };
+  }
+  async generateAIResponse(companionId, userMessage, context = [], signal) {
+    const result = await this.run({
+      ...this.buildRequest(userMessage, context, signal)
+    });
+    return {
+      ...messageFormatter.toChatMessage(result.text, "assistant"),
+      metadata: {
+        companionId,
+        model: result.model,
+        usage: {
+          input_tokens: result.usage?.inputTokens,
+          output_tokens: result.usage?.outputTokens,
+          total_tokens: result.usage?.totalTokens
+        },
+        finishReason: result.finishReason
+      }
+    };
+  }
+  async generateStreamingResponse(userMessage, context, onChunk, signal) {
+    const request = this.buildRequest(userMessage, context, signal);
+    const result = await this.runStream(request, { onChunk });
+    return result.text;
+  }
+  buildRequest(userMessage, context, signal) {
+    const messages = messageFormatter.toCoreMessages(context);
+    messages.push({ role: "user", content: userMessage });
+    return {
+      messages,
+      systemPrompt: this.resolveSystemPrompt(),
+      model: this.config.model,
+      tier: this.config.tier,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      ...signal !== void 0 ? { signal } : {}
+    };
+  }
+  resolveSystemPrompt() {
+    const prompt = this.promptStrategy.resolve(this.config);
+    return prompt && prompt.length > 0 ? prompt : void 0;
+  }
+  async run(request) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chat(request);
+    }
+    return this.engine.generate(request);
+  }
+  async runStream(request, callbacks) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chatStream(request, callbacks);
+    }
+    return this.engine.stream(request, callbacks);
+  }
+  requireStorage() {
+    if (!this.storage) {
+      throw new AIError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "ChatService.getConversation requires setStorage() to be called first."
+      );
+    }
+    return this.storage;
+  }
+};
+function extractTokenUsage(message) {
+  const meta = message.metadata;
+  if (!meta) return null;
+  const usage = meta["usage"];
+  if (!usage || typeof usage !== "object") return null;
+  const u = usage;
+  const inputTokens = readNumber(u, ["input_tokens", "prompt_tokens"]);
+  const outputTokens = readNumber(u, ["output_tokens", "completion_tokens"]);
+  const totalTokens = readNumber(u, ["total_tokens"]);
+  if (inputTokens === null || outputTokens === null || totalTokens === null) {
+    return null;
+  }
+  return {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens
+  };
+}
+function readNumber(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number") return value;
+  }
+  return null;
+}
+
+exports.ChatIdGenerator = ChatIdGenerator;
+exports.ChatService = ChatService;
+exports.DEFAULT_PROMPT_STRATEGY = DEFAULT_PROMPT_STRATEGY;
+exports.chatIdGenerator = chatIdGenerator;
+exports.extractTokenUsage = extractTokenUsage;
+exports.messageFormatter = messageFormatter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map