npm - @bike4mind/cli - Versions diffs - 0.1.0 - Mend

@bike4mind/cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/README.md +246 -0
package/bin/bike4mind-cli.mjs +66 -0
package/dist/artifactExtractor-QN34RFDM.js +181 -0
package/dist/chunk-BDQBOLYG.js +120 -0
package/dist/chunk-BPFEGDC7.js +192 -0
package/dist/chunk-CC67R4RB.js +345 -0
package/dist/chunk-CPNUKQQ3.js +110 -0
package/dist/chunk-ETEFNJEP.js +235 -0
package/dist/chunk-JVPB6BB5.js +10399 -0
package/dist/chunk-LM6ZFZT6.js +92 -0
package/dist/chunk-MKO2KCCS.js +6119 -0
package/dist/chunk-PDX44BCA.js +11 -0
package/dist/create-AYVZNCEH.js +13 -0
package/dist/formatConverter-I7EIUVDY.js +8 -0
package/dist/index.js +7614 -0
package/dist/llmMarkdownGenerator-JBDLN44A.js +372 -0
package/dist/markdownGenerator-MM5N3H5I.js +270 -0
package/dist/mementoService-N5HYIH4Y.js +13 -0
package/dist/notificationDeduplicator-LQAMED4L.js +10 -0
package/dist/src-GTQ5UBCP.js +255 -0
package/dist/src-OVEHYUVN.js +588 -0
package/dist/subtractCredits-22TZUVZX.js +13 -0
package/dist/utils-JPMDGUBL.js +32 -0
package/package.json +111 -0

package/dist/chunk-BPFEGDC7.js ADDED Viewed

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// ../../b4m-core/packages/services/dist/src/notebookCurationService/formatConverter.js
+import { marked } from "marked";
+var FormatConverter = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Convert markdown content to specified format
+   */
+  async convert(markdownContent, format) {
+    this.logger?.info(`Converting markdown to ${format}`);
+    switch (format) {
+      case "markdown":
+        return this.convertToMarkdown(markdownContent);
+      case "txt":
+        return this.convertToTXT(markdownContent);
+      case "html":
+        return this.convertToHTML(markdownContent);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Markdown (no conversion needed)
+   */
+  convertToMarkdown(content) {
+    return {
+      content: Buffer.from(content, "utf-8"),
+      mimeType: "text/markdown",
+      extension: ".md"
+    };
+  }
+  /**
+   * Convert markdown to HTML
+   */
+  async convertToHTML(markdownContent) {
+    try {
+      const htmlBody = await marked.parse(markdownContent);
+      const fullHTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Curated Notebook</title>
+    <style>
+${this.getHTMLStylesheet()}
+    </style>
+</head>
+<body>
+    <div class="markdown-body">
+${htmlBody}
+    </div>
+</body>
+</html>`;
+      return {
+        content: Buffer.from(fullHTML, "utf-8"),
+        mimeType: "text/html",
+        extension: ".html"
+      };
+    } catch (error) {
+      this.logger?.error("HTML conversion failed:", error);
+      throw new Error(`HTML conversion failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Convert markdown to plain text
+   * Strips all markdown formatting and returns plain text
+   */
+  convertToTXT(markdownContent) {
+    let plainText = markdownContent;
+    plainText = plainText.replace(/^#{1,6}\s+/gm, "");
+    plainText = plainText.replace(/(\*\*|__)(.*?)\1/g, "$2");
+    plainText = plainText.replace(/(\*|_)(.*?)\1/g, "$2");
+    plainText = plainText.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    plainText = plainText.replace(/!\[([^\]]*)\]\([^)]+\)/g, "[Image: $1]");
+    plainText = plainText.replace(/`([^`]+)`/g, "$1");
+    plainText = plainText.replace(/```[\s\S]*?\n([\s\S]*?)```/g, "$1");
+    plainText = plainText.replace(/^[-*_]{3,}\s*$/gm, "");
+    plainText = plainText.replace(/^>\s+/gm, "");
+    plainText = plainText.replace(/<[^>]+>/g, "");
+    plainText = plainText.replace(/\n{3,}/g, "\n\n");
+    return {
+      content: Buffer.from(plainText, "utf-8"),
+      mimeType: "text/plain",
+      extension: ".txt"
+    };
+  }
+  /**
+   * Get HTML-specific CSS stylesheet
+   */
+  getHTMLStylesheet() {
+    return `
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+        font-size: 16px;
+        line-height: 1.6;
+        color: #24292e;
+        max-width: 980px;
+        margin: 0 auto;
+        padding: 45px;
+        background-color: #fff;
+      }
+      .markdown-body {
+        box-sizing: border-box;
+        min-width: 200px;
+        max-width: 980px;
+      }
+      h1, h2, h3, h4, h5, h6 {
+        margin-top: 24px;
+        margin-bottom: 16px;
+        font-weight: 600;
+        line-height: 1.25;
+      }
+      h1 { font-size: 2em; border-bottom: 1px solid #eaecef; padding-bottom: 0.3em; }
+      h2 { font-size: 1.5em; border-bottom: 1px solid #eaecef; padding-bottom: 0.3em; }
+      h3 { font-size: 1.25em; }
+      pre {
+        background-color: #f6f8fa;
+        border-radius: 6px;
+        padding: 16px;
+        overflow: auto;
+        font-size: 85%;
+        line-height: 1.45;
+      }
+      code {
+        background-color: rgba(27,31,35,0.05);
+        border-radius: 3px;
+        padding: 0.2em 0.4em;
+        font-family: 'SF Mono', Monaco, Menlo, Consolas, 'Liberation Mono', 'Courier New', monospace;
+        font-size: 85%;
+      }
+      pre code {
+        background-color: transparent;
+        padding: 0;
+        font-size: 100%;
+      }
+      blockquote {
+        padding: 0 1em;
+        color: #6a737d;
+        border-left: 0.25em solid #dfe2e5;
+        margin: 0 0 16px 0;
+      }
+      table {
+        border-collapse: collapse;
+        border-spacing: 0;
+        width: 100%;
+        margin-bottom: 16px;
+        overflow: auto;
+      }
+      table th {
+        font-weight: 600;
+        background-color: #f6f8fa;
+      }
+      table th, table td {
+        padding: 6px 13px;
+        border: 1px solid #dfe2e5;
+      }
+      table tr {
+        background-color: #fff;
+        border-top: 1px solid #c6cbd1;
+      }
+      table tr:nth-child(2n) {
+        background-color: #f6f8fa;
+      }
+      img {
+        max-width: 100%;
+        box-sizing: content-box;
+        background-color: #fff;
+      }
+      a {
+        color: #0366d6;
+        text-decoration: none;
+      }
+      a:hover {
+        text-decoration: underline;
+      }
+      hr {
+        height: 0.25em;
+        padding: 0;
+        margin: 24px 0;
+        background-color: #e1e4e8;
+        border: 0;
+      }
+    `;
+  }
+};
+export {
+  FormatConverter
+};

package/dist/chunk-CC67R4RB.js ADDED Viewed

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+// ../../b4m-core/packages/utils/dist/src/logger.js
+var Logger = class _Logger {
+  static globalInstance = new _Logger();
+  metadata = {};
+  logInJson;
+  constructor(options = {}) {
+    const { metadata = {}, logInJson = process.env.LOG_JSON === "true" || !(process.env.IS_LOCAL === "true" || process.env.NODE_ENV === "development") } = options;
+    this.metadata = metadata;
+    this.logInJson = logInJson;
+  }
+  resetMetadata() {
+    this.metadata = {};
+    return this;
+  }
+  withMetadata(metadata) {
+    return new _Logger({
+      metadata: {
+        ...this.metadata,
+        ...metadata
+      }
+    });
+  }
+  updateMetadata(metadata) {
+    this.metadata = {
+      ...this.metadata,
+      ...metadata
+    };
+    return this;
+  }
+  log(...args) {
+    return this.info(...args);
+  }
+  debug(...args) {
+    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+    if (this.logInJson) {
+      console.debug(JSON.stringify({ ...this.metadata, severity: "debug", message }));
+    } else {
+      console.debug(message);
+    }
+  }
+  info(...args) {
+    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+    if (this.logInJson) {
+      console.info(JSON.stringify({ ...this.metadata, severity: "info", message }));
+    } else {
+      console.info(message);
+    }
+  }
+  warn(...args) {
+    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+    if (this.logInJson) {
+      console.warn(JSON.stringify({ ...this.metadata, severity: "warn", message }));
+    } else {
+      console.warn(message);
+    }
+  }
+  error(...args) {
+    const message = args.map((a) => {
+      if (a instanceof Error) {
+        return a.stack || a.message;
+      }
+      return typeof a === "string" ? a : JSON.stringify(a);
+    }).join(" ");
+    if (this.logInJson) {
+      console.error(JSON.stringify({ ...this.metadata, severity: "error", message }));
+    } else {
+      console.error(message);
+    }
+  }
+  /*
+   * Global logger instance handling:
+   */
+  /** @deprecated: use Logger.log instance method instead */
+  static log(...args) {
+    return _Logger.globalInstance.log(...args);
+  }
+  /** @deprecated: use Logger.debug instance method instead */
+  static debug(...args) {
+    return _Logger.globalInstance.debug(...args);
+  }
+  /** @deprecated: use Logger.info instance method instead */
+  static info(...args) {
+    return _Logger.globalInstance.info(...args);
+  }
+  /** @deprecated: use Logger.warn instance method instead */
+  static warn(...args) {
+    return _Logger.globalInstance.warn(...args);
+  }
+  /** @deprecated: use Logger.error instance method instead */
+  static error(...args) {
+    return _Logger.globalInstance.error(...args);
+  }
+  /**
+   * Update tags for all log following log messages (until resetMetadata()):
+   * @deprecated: Use Logger.withMetadata() instead
+   */
+  static updateMetadata(metadata) {
+    return _Logger.globalInstance.updateMetadata(metadata);
+  }
+  /**
+   * Temporarily add tags for log messages descended from the returned handle:
+   * @deprecated: Use Logger.withMetadata() instead
+   */
+  static withMetadata(metadata) {
+    return _Logger.globalInstance.withMetadata(metadata);
+  }
+  /**
+   * Reset tags associated with the global logger instance:
+   * @deprecated: Don't use the global logger instance; use Logger injected from caller instead
+   */
+  static resetMetadata() {
+    return _Logger.globalInstance.resetMetadata();
+  }
+  static colorize = (...args) => ({
+    black: `\x1B[30m${args.join(" ")}\x1B[0m`,
+    red: `\x1B[31m${args.join(" ")}\x1B[0m`,
+    green: `\x1B[32m${args.join(" ")}\x1B[0m`,
+    yellow: `\x1B[33m${args.join(" ")}\x1B[0m`,
+    blue: `\x1B[34m${args.join(" ")}\x1B[0m`
+  });
+};
+// ../../b4m-core/packages/utils/dist/src/slack.js
+import axios, { isAxiosError } from "axios";
+import * as util from "util";
+import * as zlib from "zlib";
+var notifyEventLogsToSlack = async ({ event, stage, slackUrl, throttlingSlackUrl, enabledStages }) => {
+  const payload = Buffer.from(event.awslogs.data, "base64");
+  const decompressed = await util.promisify(zlib.gunzip)(payload);
+  const logData = JSON.parse(decompressed.toString("utf8"));
+  const allowedStages = enabledStages ?? ["production"];
+  if (!allowedStages.includes(stage))
+    return;
+  const logEvents = logData.logEvents;
+  const { notificationDeduplicator: notificationDeduplicator2 } = await import("./notificationDeduplicator-LQAMED4L.js");
+  for (const logEvent of logEvents) {
+    try {
+      let message;
+      let severity;
+      let metadata;
+      try {
+        const logEventData = JSON.parse(logEvent.message.split("	")[3]);
+        message = logEventData.message;
+        severity = logEventData.severity;
+        metadata = logEventData;
+      } catch (error) {
+        message = logEvent.message;
+        severity = "error";
+        metadata = { source: "AWS" };
+      }
+      const targetSlackUrl = message.includes("ThrottlingException: Rate exceeded") && throttlingSlackUrl ? throttlingSlackUrl : slackUrl;
+      await notificationDeduplicator2.handleErrorNotification(message, severity, metadata, logData, logEvent, stage, targetSlackUrl);
+    } catch (error) {
+      console.error(`Error: ${error}
+	Log Event: ${JSON.stringify(logEvent)}`);
+    }
+  }
+};
+async function postMessageToSlack(slackWebhookUrl, message) {
+  try {
+    if (!slackWebhookUrl) {
+      Logger.error("postMessageToSlack: Error posting message to Slack: slackWebhookUrl is not set");
+      return;
+    }
+    await axios.post(slackWebhookUrl, { text: message }, {
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    Logger.error("Error posting message to Slack:", error);
+  }
+}
+async function postLowCreditsNotificationToSlack(userId, username, email, currentCredits, organization, slackWebhookUrl) {
+  try {
+    if (!slackWebhookUrl) {
+      Logger.error("postLowCreditsNotificationToSlack: Error posting low credits notification to Slack: slackWebhookUrl not set");
+      Logger.error("User details:", { userId, username, email, currentCredits });
+      return;
+    }
+    const message = `\u26A0\uFE0F *Low Credits Alert*
+*User:* ${username} (${email})
+*User ID:* ${userId}
+*Current Credits:* ${currentCredits}
+${organization ? `*Organization:* ${organization.name} (${organization.id})` : ""}`;
+    Logger.info("Sending low credits notification to Slack:", { userId, username, currentCredits });
+    await axios.post(slackWebhookUrl, { text: message }, {
+      headers: { "Content-Type": "application/json" }
+    });
+    Logger.info("Successfully sent low credits notification to Slack");
+  } catch (error) {
+    let errorMessage = "Something went wrong";
+    if (isAxiosError(error)) {
+      errorMessage = error.response?.data.error;
+    } else if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    Logger.error("Failed notification details:", { userId, username, email, currentCredits, error: errorMessage });
+  }
+}
+// ../../b4m-core/packages/utils/dist/src/notificationDeduplicator.js
+var NotificationDeduplicator = class {
+  errorGroups = /* @__PURE__ */ new Map();
+  lowCreditTiers = {};
+  // Configuration
+  ERROR_GROUPING_WINDOW_MS = 5 * 60 * 1e3;
+  // 5 minutes
+  CLEANUP_INTERVAL_MS = 60 * 60 * 1e3;
+  // 1 hour
+  LOW_CREDIT_RESET_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  constructor() {
+    setInterval(() => this.cleanupOldEntries(), this.CLEANUP_INTERVAL_MS);
+  }
+  /**
+   * Handle low credit notifications with tiered thresholds
+   */
+  async handleLowCreditNotification(userId, username, email, currentCredits, organization, slackWebhookUrl) {
+    if (!slackWebhookUrl)
+      return;
+    if (!this.lowCreditTiers[userId]) {
+      this.lowCreditTiers[userId] = { tier1000: false, tier300: false, tier0: false };
+    }
+    const userTiers = this.lowCreditTiers[userId];
+    let shouldNotify = false;
+    let tierMessage = "";
+    if (currentCredits <= 0 && !userTiers.tier0) {
+      userTiers.tier0 = true;
+      shouldNotify = true;
+      tierMessage = "\u{1F6A8} *CRITICAL* - User has run out of credits!";
+    } else if (currentCredits <= 300 && !userTiers.tier300) {
+      userTiers.tier300 = true;
+      shouldNotify = true;
+      tierMessage = "\u26A0\uFE0F *WARNING* - User credits critically low (\u2264300)";
+    } else if (currentCredits <= 1e3 && !userTiers.tier1000) {
+      userTiers.tier1000 = true;
+      shouldNotify = true;
+      tierMessage = "\u26A0\uFE0F *Low Credits Alert* - User credits below 1000";
+    }
+    if (shouldNotify) {
+      const message = `${tierMessage}
+*User:* ${username} (${email})
+*User ID:* ${userId}
+*Current Credits:* ${currentCredits}${organization ? `
+*Organization:* ${organization.name} (${organization.id})` : ""}`;
+      await postMessageToSlack(slackWebhookUrl, message);
+      Logger.info(`Sent tiered low credit notification for user ${userId} at ${currentCredits} credits`);
+    }
+    if (currentCredits > 1e3) {
+      userTiers.tier1000 = false;
+      userTiers.tier300 = false;
+      userTiers.tier0 = false;
+    } else if (currentCredits > 300) {
+      userTiers.tier300 = false;
+      userTiers.tier0 = false;
+    } else if (currentCredits > 0) {
+      userTiers.tier0 = false;
+    }
+  }
+  /**
+   * Handle error notifications with deduplication and grouping
+   */
+  async handleErrorNotification(errorMessage, severity, metadata, logData, logEvent, stage, slackUrl) {
+    const normalizedError = this.normalizeErrorMessage(errorMessage);
+    const groupKey = `${severity}:${normalizedError}`;
+    const now = /* @__PURE__ */ new Date();
+    const existingEntry = this.errorGroups.get(groupKey);
+    if (!existingEntry) {
+      this.errorGroups.set(groupKey, {
+        count: 1,
+        firstOccurrence: now,
+        lastOccurrence: now,
+        lastNotificationSent: now
+      });
+      await this.sendErrorNotification(errorMessage, severity, metadata, logData, logEvent, stage, slackUrl, 1);
+    } else {
+      existingEntry.count++;
+      existingEntry.lastOccurrence = now;
+      const timeSinceLastNotification = now.getTime() - (existingEntry.lastNotificationSent?.getTime() || 0);
+      if (timeSinceLastNotification >= this.ERROR_GROUPING_WINDOW_MS) {
+        await this.sendErrorNotification(errorMessage, severity, metadata, logData, logEvent, stage, slackUrl, existingEntry.count, existingEntry.firstOccurrence, existingEntry.lastOccurrence);
+        existingEntry.lastNotificationSent = now;
+      }
+    }
+  }
+  async sendErrorNotification(message, severity, metadata, logData, logEvent, stage, slackUrl, count, firstOccurrence, lastOccurrence) {
+    const tags = Object.entries(metadata).map(([key, value]) => `\`${key}: ${value}\``).join(" ");
+    const group = encodeURIComponent(logData.logGroup);
+    const stream = encodeURIComponent(logData.logStream);
+    const url = `https://console.aws.amazon.com/cloudwatch/home?region=${process.env.AWS_REGION}#logEventViewer:group=${group};stream=${stream};start=${logEvent.timestamp};end=${logEvent.timestamp}`;
+    let slackMessage;
+    if (count === 1) {
+      slackMessage = `*${severity.toUpperCase()}* - ${message}
+\`env: ${stage}\` ${tags} [AWS](${url})`;
+    } else {
+      const duration = lastOccurrence && firstOccurrence ? this.formatDuration(lastOccurrence.getTime() - firstOccurrence.getTime()) : "";
+      slackMessage = `*${severity.toUpperCase()}* - ${message}
+\`count: ${count}\` \`duration: ${duration}\` \`env: ${stage}\` ${tags} [AWS](${url})`;
+    }
+    await postMessageToSlack(slackUrl, slackMessage);
+  }
+  normalizeErrorMessage(message) {
+    return message.replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/g, "[TIMESTAMP]").replace(/Request failed with status code \d+/g, "Request failed with status code [CODE]").replace(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/g, "[UUID]").replace(/\b\d+\.\d+\.\d+\.\d+\b/g, "[IP]").substring(0, 200);
+  }
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0)
+      return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+      return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+  }
+  cleanupOldEntries() {
+    const now = /* @__PURE__ */ new Date();
+    const cutoffTime = now.getTime() - this.CLEANUP_INTERVAL_MS;
+    for (const [key, entry] of Array.from(this.errorGroups.entries())) {
+      if (entry.lastOccurrence.getTime() < cutoffTime) {
+        this.errorGroups.delete(key);
+      }
+    }
+    Logger.info(`Cleaned up old notification entries: ${this.errorGroups.size} error groups remaining`);
+  }
+  /**
+   * Get current deduplication status (for monitoring)
+   */
+  getStatus() {
+    return {
+      errorGroupsCount: this.errorGroups.size,
+      lowCreditUsersTracked: Object.keys(this.lowCreditTiers).length
+    };
+  }
+};
+var notificationDeduplicator = new NotificationDeduplicator();
+export {
+  Logger,
+  NotificationDeduplicator,
+  notificationDeduplicator,
+  notifyEventLogsToSlack,
+  postMessageToSlack,
+  postLowCreditsNotificationToSlack
+};

package/dist/chunk-CPNUKQQ3.js ADDED Viewed

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import {
+  BadRequestError,
+  secureParameters
+} from "./chunk-JVPB6BB5.js";
+import {
+  GenericCreditDeductTransaction,
+  ImageEditUsageTransaction,
+  ImageGenerationUsageTransaction,
+  RealtimeVoiceUsageTransaction,
+  TextGenerationUsageTransaction,
+  TransferCreditTransaction
+} from "./chunk-MKO2KCCS.js";
+// ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
+import { z } from "zod";
+var SubtractCreditsSchema = z.discriminatedUnion("type", [
+  GenericCreditDeductTransaction.omit({ createdAt: true, updatedAt: true }),
+  TextGenerationUsageTransaction.omit({ createdAt: true, updatedAt: true }),
+  ImageGenerationUsageTransaction.omit({ createdAt: true, updatedAt: true }),
+  RealtimeVoiceUsageTransaction.omit({ createdAt: true, updatedAt: true }),
+  ImageEditUsageTransaction.omit({ createdAt: true, updatedAt: true }),
+  TransferCreditTransaction.omit({ createdAt: true, updatedAt: true })
+]);
+async function subtractCredits(parameters, { db, creditHolderMethods }) {
+  const params = secureParameters(parameters, SubtractCreditsSchema);
+  const { ownerId, ownerType, credits, type, description, metadata } = params;
+  const updatedEntity = await creditHolderMethods.incrementCredits(ownerId, -credits);
+  if (!updatedEntity) {
+    throw new BadRequestError("Failed to update credits");
+  }
+  if (type === "generic_deduct") {
+    await db.creditTransactions.createTransaction("generic_deduct", {
+      ownerId,
+      ownerType,
+      credits: -Math.abs(credits),
+      // Negative for usage
+      description: description || "Generic credit deduction",
+      metadata,
+      reason: params.reason,
+      // Backward compatibility
+      userId: params.userId
+    });
+  } else if (type === "text_generation_usage") {
+    await db.creditTransactions.createTransaction("text_generation_usage", {
+      ownerId,
+      ownerType,
+      credits: -Math.abs(credits),
+      // Negative for usage
+      description: description || "Text generation usage",
+      metadata,
+      model: params.model,
+      questId: params.questId,
+      sessionId: params.sessionId,
+      inputTokens: params.inputTokens,
+      outputTokens: params.outputTokens
+    });
+  } else if (type === "image_generation_usage") {
+    await db.creditTransactions.createTransaction("image_generation_usage", {
+      ownerId,
+      ownerType,
+      credits: -Math.abs(credits),
+      // Negative for usage
+      description: description || "Image generation usage",
+      metadata,
+      model: params.model,
+      questId: params.questId,
+      sessionId: params.sessionId
+    });
+  } else if (type === "image_edit_usage") {
+    await db.creditTransactions.createTransaction("image_edit_usage", {
+      ownerId,
+      ownerType,
+      credits: -Math.abs(credits),
+      // Negative for usage
+      description: description || "Image editing usage",
+      metadata,
+      model: params.model,
+      questId: params.questId,
+      sessionId: params.sessionId
+    });
+  } else if (type === "transfer_credit") {
+    await db.creditTransactions.createTransaction("transfer_credit", {
+      ownerId,
+      ownerType,
+      credits: -Math.abs(credits),
+      // Negative for usage
+      description: description || "Transfer credits",
+      recipientId: params.recipientId,
+      recipientType: params.recipientType
+    });
+  } else {
+    await db.creditTransactions.createTransaction("realtime_voice_usage", {
+      ownerId,
+      ownerType,
+      credits: -Math.abs(credits),
+      // Negative for usage
+      description: description || "Voice usage",
+      metadata,
+      model: params.model,
+      sessionId: params.sessionId
+    });
+  }
+  return updatedEntity;
+}
+export {
+  SubtractCreditsSchema,
+  subtractCredits
+};