@diegoaltoworks/chatter 0.32.0 → 0.33.0

package/dist/images/index.mjs

@@ -0,0 +1,357 @@
+// src/images/cache.ts
+import { createHash } from "node:crypto";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function publicIdForRequest(prompt, images) {
+  const hash = createHash("sha256").update(prompt);
+  if (images?.baseImage) hash.update(images.baseImage.bytes);
+  for (const image of images?.inputImages ?? []) {
+    hash.update(image.bytes);
+  }
+  return hash.digest("hex");
+}
+function isCacheEntryFresh(entry, now) {
+  return now - entry.createdAt < CACHE_TTL_MS;
+}
+
+// src/images/cacheStore.ts
+var schemaReady = /* @__PURE__ */ new WeakMap();
+function ensureCacheSchema(client, tableName) {
+  let perTable = schemaReady.get(client);
+  if (!perTable) {
+    perTable = /* @__PURE__ */ new Map();
+    schemaReady.set(client, perTable);
+  }
+  const tables = perTable;
+  let ready = tables.get(tableName);
+  if (!ready) {
+    ready = client.execute(
+      `CREATE TABLE IF NOT EXISTS ${tableName} (
+          public_id TEXT PRIMARY KEY,
+          url TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        )`
+    ).catch((error) => {
+      tables.delete(tableName);
+      throw error;
+    });
+    tables.set(tableName, ready);
+  }
+  return ready;
+}
+var VALID_TABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function createTursoImageCacheStore(client, tableName) {
+  if (!VALID_TABLE_NAME.test(tableName)) {
+    throw new Error(`Invalid image cache table name: ${tableName}`);
+  }
+  return {
+    async get(key) {
+      await ensureCacheSchema(client, tableName);
+      const result = await client.execute({
+        sql: `SELECT url, created_at FROM ${tableName} WHERE public_id = ?`,
+        args: [key]
+      });
+      const row = result.rows[0];
+      if (!row) return null;
+      return { url: String(row.url), createdAt: Number(row.created_at) };
+    },
+    async set(key, entry) {
+      await ensureCacheSchema(client, tableName);
+      await client.execute({
+        sql: `INSERT INTO ${tableName} (public_id, url, created_at) VALUES (?, ?, ?)
+              ON CONFLICT(public_id) DO UPDATE SET url = excluded.url, created_at = excluded.created_at`,
+        args: [key, entry.url, entry.createdAt]
+      });
+    }
+  };
+}
+
+// src/images/captionComposer.ts
+var DEFAULT_TIMEOUT_MS = 8e3;
+var MAX_COMPOSED_LENGTH = 300;
+function createCaptionComposer(options) {
+  const { pool } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const random = options.random ?? Math.random;
+  function randomCaption(subject) {
+    if (pool.length === 0) return "";
+    const eligible = pool.filter((template2) => subject || !template2.includes("{subject}"));
+    const candidates = eligible.length > 0 ? eligible : pool;
+    const template = candidates[Math.floor(random() * candidates.length)] ?? candidates[0] ?? "";
+    return template.replaceAll("{subject}", subject ?? "");
+  }
+  return {
+    randomCaption,
+    async composeCaption(request) {
+      if (!options.compose) return randomCaption(request.subject);
+      let timer;
+      try {
+        const text = await Promise.race([
+          options.compose(request),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("caption compose timed out")), timeoutMs);
+          })
+        ]);
+        const trimmed = text.trim();
+        return trimmed.length > 0 && trimmed.length <= MAX_COMPOSED_LENGTH ? trimmed : randomCaption(request.subject);
+      } catch {
+        return randomCaption(request.subject);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
+// src/images/cloudinaryConfig.ts
+var DEFAULT_CLOUDINARY_FOLDER = "generated";
+function pick(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0);
+}
+function resolveCloudinaryConfig(env = {}, overrides = {}) {
+  return {
+    cloudName: pick(overrides.cloudName, env.CLOUDINARY_CLOUD_NAME),
+    apiKey: pick(overrides.apiKey, env.CLOUDINARY_API_KEY),
+    apiSecret: pick(overrides.apiSecret, env.CLOUDINARY_API_SECRET),
+    folder: pick(overrides.folder, env.CLOUDINARY_FOLDER, DEFAULT_CLOUDINARY_FOLDER) ?? DEFAULT_CLOUDINARY_FOLDER
+  };
+}
+function isCloudinaryConfigured(config) {
+  return Boolean(config.cloudName && config.apiKey && config.apiSecret);
+}
+
+// src/images/cloudinarySignature.ts
+import { createHash as createHash2 } from "node:crypto";
+function signCloudinaryParams(params, apiSecret) {
+  const toSign = Object.keys(params).sort().map((key) => `${key}=${params[key]}`).join("&");
+  return createHash2("sha1").update(`${toSign}${apiSecret}`).digest("hex");
+}
+
+// src/images/types.ts
+var ImageGenerationError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ImageGenerationError";
+    this.code = code;
+  }
+};
+
+// src/images/cloudinaryClient.ts
+function createCloudinaryUploadClient(config, fetchImpl = fetch) {
+  return {
+    async upload({ imageBytes, publicId, folder }) {
+      if (!isCloudinaryConfigured(config)) {
+        throw new ImageGenerationError("not_configured", "Image upload is not configured");
+      }
+      const timestamp = Math.floor(Date.now() / 1e3).toString();
+      const signature = signCloudinaryParams(
+        { folder, public_id: publicId, timestamp },
+        config.apiSecret
+      );
+      const form = new FormData();
+      form.set(
+        "file",
+        new Blob([Buffer.from(imageBytes)], { type: "image/png" }),
+        `${publicId}.png`
+      );
+      form.set("public_id", publicId);
+      form.set("folder", folder);
+      form.set("timestamp", timestamp);
+      form.set("api_key", config.apiKey);
+      form.set("signature", signature);
+      const response = await fetchImpl(
+        `https://api.cloudinary.com/v1_1/${config.cloudName}/image/upload`,
+        { method: "POST", body: form }
+      );
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new ImageGenerationError(
+          "api_error",
+          `Cloudinary upload failed: ${response.status} ${body}`
+        );
+      }
+      const data = await response.json();
+      if (!data.secure_url) {
+        throw new ImageGenerationError("api_error", "Cloudinary upload returned no secure_url");
+      }
+      return { secureUrl: data.secure_url };
+    }
+  };
+}
+
+// src/images/config.ts
+var DEFAULT_IMAGE_MODEL = "gpt-image-1";
+var DEFAULT_IMAGE_SIZE = "1024x1024";
+var DEFAULT_IMAGE_QUALITY = "medium";
+function pick2(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0) ?? "";
+}
+function resolveImageConfig(env = {}, overrides = {}) {
+  return {
+    apiKey: overrides.apiKey ?? env.OPENAI_API_KEY,
+    model: pick2(overrides.model, env.IMAGE_MODEL, DEFAULT_IMAGE_MODEL),
+    size: pick2(overrides.size, env.IMAGE_SIZE, DEFAULT_IMAGE_SIZE),
+    quality: pick2(overrides.quality, env.IMAGE_QUALITY, DEFAULT_IMAGE_QUALITY)
+  };
+}
+function isImageConfigured(config) {
+  return typeof config.apiKey === "string" && config.apiKey.length > 0;
+}
+
+// src/images/generator.ts
+var MODERATION_PATTERN = /moderation|safety system|content policy|rejected as a result/i;
+var DEFAULT_MIME_TYPE = "image/png";
+function extensionForMimeType(mimeType) {
+  const subtype = mimeType.split("/")[1];
+  return subtype === "jpeg" ? "jpg" : subtype || "png";
+}
+function toImageError(error) {
+  if (error instanceof ImageGenerationError) return error;
+  const code = error?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  if (code === "moderation_blocked" || MODERATION_PATTERN.test(message)) {
+    return new ImageGenerationError("moderation", message, { cause: error });
+  }
+  return new ImageGenerationError("api_error", message, { cause: error });
+}
+function createImageGenerator(config, deps) {
+  return {
+    isConfigured: () => isImageConfigured(config),
+    async generateImage(request) {
+      if (!isImageConfigured(config)) {
+        throw new ImageGenerationError("not_configured", "Image generation is not configured");
+      }
+      if (request.prompt.trim().length === 0) {
+        throw new ImageGenerationError("invalid_request", "Image request has an empty prompt");
+      }
+      let response;
+      try {
+        response = await deps.client.createImage({
+          model: config.model,
+          prompt: request.prompt,
+          size: config.size,
+          quality: config.quality,
+          n: 1,
+          baseImage: request.baseImage ? {
+            bytes: request.baseImage.bytes,
+            mimeType: request.baseImage.mimeType ?? DEFAULT_MIME_TYPE,
+            fileName: `base.${extensionForMimeType(request.baseImage.mimeType ?? DEFAULT_MIME_TYPE)}`
+          } : void 0,
+          inputImages: request.inputImages?.map((image, index) => ({
+            bytes: image.bytes,
+            mimeType: image.mimeType ?? DEFAULT_MIME_TYPE,
+            fileName: `photo-${index + 1}.${extensionForMimeType(image.mimeType ?? DEFAULT_MIME_TYPE)}`
+          }))
+        });
+      } catch (error) {
+        throw toImageError(error);
+      }
+      const b64 = response?.data?.[0]?.b64_json;
+      if (!b64) {
+        throw new ImageGenerationError("api_error", "Image API returned no image data");
+      }
+      return { b64, imageBytes: Uint8Array.from(Buffer.from(b64, "base64")) };
+    }
+  };
+}
+
+// src/images/openaiClient.ts
+import OpenAI, { toFile } from "openai";
+function isGptImageModel(model) {
+  return model.startsWith("gpt-image");
+}
+function createOpenAIImageClient(config, client = new OpenAI({ apiKey: config.apiKey })) {
+  return {
+    async createImage(params) {
+      const responseFormat = isGptImageModel(params.model) ? {} : { response_format: "b64_json" };
+      if (!params.baseImage && (!params.inputImages || params.inputImages.length === 0)) {
+        const response2 = await client.images.generate({
+          model: params.model,
+          prompt: params.prompt,
+          size: params.size,
+          quality: params.quality,
+          n: params.n,
+          ...responseFormat
+        });
+        return { data: response2.data };
+      }
+      const baseFile = params.baseImage ? await toFile(Buffer.from(params.baseImage.bytes), params.baseImage.fileName, {
+        type: params.baseImage.mimeType
+      }) : void 0;
+      const photoFiles = await Promise.all(
+        (params.inputImages ?? []).map(
+          (photo) => toFile(Buffer.from(photo.bytes), photo.fileName, { type: photo.mimeType })
+        )
+      );
+      const image = baseFile ? [...photoFiles, baseFile] : photoFiles;
+      const response = await client.images.edit({
+        model: params.model,
+        image,
+        prompt: params.prompt,
+        size: params.size,
+        quality: params.quality,
+        n: params.n,
+        ...responseFormat
+      });
+      return { data: response.data };
+    }
+  };
+}
+
+// src/images/uploader.ts
+function createImageUploader(config, deps) {
+  const now = deps.now ?? Date.now;
+  function cacheKey(request) {
+    if (!isCloudinaryConfigured(config)) {
+      throw new ImageGenerationError("not_configured", "Image upload is not configured");
+    }
+    return publicIdForRequest(request.prompt, request);
+  }
+  return {
+    // A cache hit never needs the generator, but a fresh upload does — both
+    // must be configured for this uploader to actually work end to end.
+    isConfigured: () => isCloudinaryConfigured(config) && deps.generator.isConfigured(),
+    async peekCached(request) {
+      const publicId = cacheKey(request);
+      const cached = await deps.cacheStore.get(publicId);
+      return !!cached && isCacheEntryFresh(cached, now());
+    },
+    async getOrCreateImage(request) {
+      const publicId = cacheKey(request);
+      const nowMs = now();
+      const cached = await deps.cacheStore.get(publicId);
+      if (cached && isCacheEntryFresh(cached, nowMs)) {
+        return { url: cached.url, cached: true };
+      }
+      const generated = await deps.generator.generateImage(request);
+      const uploaded = await deps.uploadClient.upload({
+        imageBytes: generated.imageBytes,
+        publicId,
+        folder: config.folder
+      });
+      await deps.cacheStore.set(publicId, { url: uploaded.secureUrl, createdAt: nowMs });
+      return { url: uploaded.secureUrl, cached: false };
+    }
+  };
+}
+export {
+  CACHE_TTL_MS,
+  DEFAULT_CLOUDINARY_FOLDER,
+  DEFAULT_IMAGE_MODEL,
+  DEFAULT_IMAGE_QUALITY,
+  DEFAULT_IMAGE_SIZE,
+  ImageGenerationError,
+  createCaptionComposer,
+  createCloudinaryUploadClient,
+  createImageGenerator,
+  createImageUploader,
+  createOpenAIImageClient,
+  createTursoImageCacheStore,
+  isCacheEntryFresh,
+  isCloudinaryConfigured,
+  isImageConfigured,
+  publicIdForRequest,
+  resolveCloudinaryConfig,
+  resolveImageConfig,
+  signCloudinaryParams
+};

package/dist/images/openaiClient.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The real image client, backed by the OpenAI Images API.
+ *
+ * This is the only file in the module that talks to a paid API. `client` is
+ * injectable (defaulting to a real `OpenAI` instance), so tests substitute a
+ * mock and never reach it. A request with no base/input images calls
+ * `images.generate` (pure text-to-image); a request with either calls
+ * `images.edit`.
+ */
+import OpenAI from "openai";
+import type { ImageModuleConfig } from "./config";
+import type { ImageClient } from "./types";
+export declare function createOpenAIImageClient(config: ImageModuleConfig, client?: OpenAI): ImageClient;
+//# sourceMappingURL=openaiClient.d.ts.map

package/dist/images/openaiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openaiClient.d.ts","sourceRoot":"","sources":["../../src/images/openaiClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,MAAkB,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAA2C,MAAM,SAAS,CAAC;AAcpF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,EACzB,MAAM,GAAE,MAA8C,GACrD,WAAW,CA+Cb"}

package/dist/images/openaiClient.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=openaiClient.test.d.ts.map

package/dist/images/openaiClient.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openaiClient.test.d.ts","sourceRoot":"","sources":["../../src/images/openaiClient.test.ts"],"names":[],"mappings":""}

package/dist/images/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Image generation - public types.
+ *
+ * Framework-free: this file (and everything else in src/images/) must not import
+ * from chatter's core, routes or channels. The module is self-contained and
+ * carries no persona or bot-specific content - prompts arrive fully composed
+ * from the caller.
+ */
+/** Every failure mode the module reports, so callers can pick a reply per case. */
+export type ImageErrorCode = "not_configured" | "invalid_request" | "moderation" | "api_error";
+/** Typed error - callers switch on `code`, never on message text. */
+export declare class ImageGenerationError extends Error {
+    readonly code: ImageErrorCode;
+    constructor(code: ImageErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Image bytes plus the MIME type they were encoded with. Defaults to PNG when omitted. */
+export interface ImageInput {
+    bytes: Uint8Array;
+    mimeType?: string;
+}
+/**
+ * A request for a generated image.
+ *
+ * `prompt` is fully composed by the caller - this module has no prompt
+ * templates or character content of its own. `baseImage` and `inputImages`
+ * are both optional: omit both for a pure text-to-image generate call, or
+ * supply them to edit/composite against existing pictures.
+ */
+export interface ImageRequest {
+    prompt: string;
+    /** Image to edit. Omit for a pure generate call. */
+    baseImage?: ImageInput;
+    /** Additional reference photos, sent alongside `baseImage`. */
+    inputImages?: ImageInput[];
+}
+/** A generated picture, ready to be uploaded or attached. */
+export interface GeneratedImage {
+    /** Raw PNG bytes. */
+    imageBytes: Uint8Array;
+    /** The same bytes, base64-encoded, as returned by the image API. */
+    b64: string;
+}
+/**
+ * The slice of the image API this module depends on.
+ *
+ * Declared structurally so tests can inject a mock and no real (paid) call is
+ * ever made from the suite, and so the module does not hard-depend on one SDK
+ * version.
+ */
+export interface ImageClient {
+    createImage(params: ImageClientRequest): Promise<ImageClientResponse>;
+}
+export interface ImageClientRequest {
+    model: string;
+    prompt: string;
+    size: string;
+    quality: string;
+    n: number;
+    baseImage?: {
+        bytes: Uint8Array;
+        fileName: string;
+        mimeType: string;
+    };
+    inputImages?: Array<{
+        bytes: Uint8Array;
+        fileName: string;
+        mimeType: string;
+    }>;
+}
+export interface ImageClientResponse {
+    data?: Array<{
+        b64_json?: string | null;
+    }> | null;
+}
+/**
+ * The slice of the Cloudinary upload API this module depends on.
+ *
+ * Declared structurally, same reasoning as {@link ImageClient}: tests inject a
+ * mock and no real (paid) upload is ever made from the suite.
+ */
+export interface CloudinaryUploadClient {
+    upload(request: CloudinaryUploadRequest): Promise<CloudinaryUploadResponse>;
+}
+export interface CloudinaryUploadRequest {
+    /** PNG bytes to upload. */
+    imageBytes: Uint8Array;
+    /** Deterministic id derived from the request - see `publicIdForRequest`. */
+    publicId: string;
+    folder: string;
+}
+export interface CloudinaryUploadResponse {
+    secureUrl: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/images/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/images/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,mFAAmF;AACnF,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,YAAY,GAAG,WAAW,CAAC;AAE/F,qEAAqE;AACrE,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAE9B,YAAY,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAI/E;CACF;AAED,2FAA2F;AAC3F,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,6DAA6D;AAC7D,MAAM,WAAW,cAAc;IAC7B,qBAAqB;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChF;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,KAAK,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;CACnD;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,uBAAuB;IACtC,2BAA2B;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/images/uploader.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Generate-or-serve-from-cache orchestration.
+ *
+ * The request is hashed into a deterministic key before anything paid
+ * happens, and checked against the cache first - only a miss or an expired
+ * entry reaches the image generator and Cloudinary.
+ */
+import { type ImageCacheStore } from "./cache";
+import type { CloudinaryModuleConfig } from "./cloudinaryConfig";
+import type { ImageGenerator } from "./generator";
+import { type CloudinaryUploadClient, type ImageRequest } from "./types";
+export interface ImageUploaderDeps {
+    generator: ImageGenerator;
+    uploadClient: CloudinaryUploadClient;
+    cacheStore: ImageCacheStore;
+    /** Clock, injectable so cache-freshness tests don't depend on real time. */
+    now?: () => number;
+}
+export interface UploadedImage {
+    url: string;
+    /** True when served from cache without generating or uploading anything new. */
+    cached: boolean;
+}
+export interface ImageUploader {
+    isConfigured(): boolean;
+    /**
+     * True when `request` already has a fresh cached upload.
+     *
+     * Lets a caller decide whether to spend a spend-guard unit *before* calling
+     * `getOrCreateImage` - a cache hit costs nothing, so it must not touch a
+     * daily cap. Throws the same `not_configured` error `getOrCreateImage`
+     * would, so a caller that checks this first sees a consistent error no
+     * matter which method it called.
+     */
+    peekCached(request: ImageRequest): Promise<boolean>;
+    getOrCreateImage(request: ImageRequest): Promise<UploadedImage>;
+}
+export declare function createImageUploader(config: CloudinaryModuleConfig, deps: ImageUploaderDeps): ImageUploader;
+//# sourceMappingURL=uploader.d.ts.map

package/dist/images/uploader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploader.d.ts","sourceRoot":"","sources":["../../src/images/uploader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,eAAe,EAAyC,MAAM,SAAS,CAAC;AACtF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,KAAK,sBAAsB,EAAwB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAE/F,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,EAAE,sBAAsB,CAAC;IACrC,UAAU,EAAE,eAAe,CAAC;IAC5B,4EAA4E;IAC5E,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,gFAAgF;IAChF,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,IAAI,OAAO,CAAC;IACxB;;;;;;;;OAQG;IACH,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpD,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACjE;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,iBAAiB,GACtB,aAAa,CA0Cf"}

package/dist/images/uploader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uploader.test.d.ts.map

package/dist/images/uploader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploader.test.d.ts","sourceRoot":"","sources":["../../src/images/uploader.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegoaltoworks/chatter",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Embeddable AI chatbot framework with RAG, authentication, and customizable widgets",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -54,6 +54,11 @@
       "types": "./dist/channels/whatsapp/index.d.ts",
       "import": "./dist/channels/whatsapp/index.mjs",
       "require": "./dist/channels/whatsapp/index.js"
+    },
+    "./images": {
+      "types": "./dist/images/index.d.ts",
+      "import": "./dist/images/index.mjs",
+      "require": "./dist/images/index.js"
     }
   },
   "files": [
@@ -63,7 +68,7 @@
   ],
   "scripts": {
     "dev": "bun --watch src/index.ts",
-    "build": "bun run build:clean && bun run build:types && bun run build:esm && bun run build:cjs && bun run build:mcp && bun run build:usage && bun run build:personas && bun run build:channels && bun run build:whatsapp && bun run build:flows && bun run build:bin && bun run build:client && bun run build:copy-client",
+    "build": "bun run build:clean && bun run build:types && bun run build:esm && bun run build:cjs && bun run build:mcp && bun run build:usage && bun run build:personas && bun run build:channels && bun run build:whatsapp && bun run build:flows && bun run build:images && bun run build:bin && bun run build:client && bun run build:copy-client",
     "build:clean": "rm -rf dist",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
     "build:esm": "esbuild src/index.ts --bundle --format=esm --outfile=dist/index.mjs --external:hono --external:openai --external:@libsql/client --external:jose --platform=node --target=node24",
@@ -74,6 +79,7 @@
     "build:channels": "esbuild src/channels/index.ts --bundle --format=esm --outfile=dist/channels/index.mjs --external:hono --external:openai --external:@libsql/client --platform=node --target=node24 && esbuild src/channels/index.ts --bundle --format=cjs --outfile=dist/channels/index.js --external:hono --external:openai --external:@libsql/client --platform=node --target=node24",
     "build:whatsapp": "esbuild src/channels/whatsapp/index.ts --bundle --format=esm --outfile=dist/channels/whatsapp/index.mjs --external:@libsql/client --external:@whiskeysockets/baileys --platform=node --target=node24 && esbuild src/channels/whatsapp/index.ts --bundle --format=cjs --outfile=dist/channels/whatsapp/index.js --external:@libsql/client --external:@whiskeysockets/baileys --platform=node --target=node24",
     "build:flows": "esbuild src/flows/index.ts --bundle --format=esm --outfile=dist/flows/index.mjs --external:@libsql/client --external:openai --platform=node --target=node24 && esbuild src/flows/index.ts --bundle --format=cjs --outfile=dist/flows/index.js --external:@libsql/client --external:openai --platform=node --target=node24",
+    "build:images": "esbuild src/images/index.ts --bundle --format=esm --outfile=dist/images/index.mjs --external:@libsql/client --external:openai --platform=node --target=node24 && esbuild src/images/index.ts --bundle --format=cjs --outfile=dist/images/index.js --external:@libsql/client --external:openai --platform=node --target=node24",
     "build:bin": "esbuild bin/create-apikey.ts --bundle --format=cjs --outfile=dist/bin/create-apikey.js --external:jose --platform=node --target=node18 --banner:js='#!/usr/bin/env node' && esbuild bin/wa-pair.ts --bundle --format=cjs --outfile=dist/bin/wa-pair.js --external:@libsql/client --external:@whiskeysockets/baileys --external:qrcode-terminal --platform=node --target=node18 --banner:js='#!/usr/bin/env node'",
     "build:client": "cd src/client && bun run build",
     "build:copy-client": "mkdir -p dist/static && cp src/client/dist/chatter.js src/client/dist/chatter.css dist/static/",