GLM-4.5 vs Claude Opus: The Price Gap That Feels Illegal

Claude 4.1 Opus (Cursor)
- Total tokens: 10,506,082
- Total output: 49,692
- Cost: $34.49
 
GLM-4.5 (OpenRouter, one morning run)
- Total tokens: ~989,447
- Total cost: $0.0304
- Avg per request: ~49,472 tokens for $0.00152

# app/services/user_management_service.rb
class UserManagementService
  include ActiveModel::Model
  include ActiveModel::Attributes
 
  attribute :user_id, :integer
  attribute :action, :string
  attribute :metadata, :hash, default: {}
 
  validates :user_id, presence: true
  validates :action, presence: true, inclusion: { in: %w[activate deactivate suspend upgrade] }
 
  def initialize(user_id, action, metadata = {})
    @user_id = user_id
    @action = action
    @metadata = metadata
    @errors = ActiveModel::Errors.new(self)
  end
 
  def call
    return { success: false, errors: errors.full_messages } unless valid?
 
    User.transaction do
      user = User.find_by(id: user_id)
      return { success: false, errors: ["User not found"] } unless user
 
      case action
      when 'activate'
        result = activate_user(user)
      when 'deactivate'
        result = deactivate_user(user)
      when 'suspend'
        result = suspend_user(user)
      when 'upgrade'
        result = upgrade_user(user)
      end
 
      log_action(user, result)
      send_notification(user, action) if result[:success]
 
      result
    end
  rescue StandardError => e
    Rails.logger.error "UserManagementService failed: #{e.message}"
    { success: false, errors: [e.message] }
  end
 
  private
 
  def activate_user(user)
    return { success: false, errors: ["User already active"] } if user.active?
 
    user.update!(
      status: 'active',
      activated_at: Time.current,
      activation_token: nil
    )
 
    { success: true, message: "User activated successfully", user: user }
  end
 
  def deactivate_user(user)
    return { success: false, errors: ["User already inactive"] } unless user.active?
 
    user.update!(
      status: 'inactive',
      deactivated_at: Time.current
    )
 
    { success: true, message: "User deactivated successfully", user: user }
  end
 
  def suspend_user(user)
    return { success: false, errors: ["User already suspended"] } if user.suspended?
 
    user.update!(
      status: 'suspended',
      suspended_at: Time.current,
      suspension_reason: metadata[:reason]
    )
 
    { success: true, message: "User suspended successfully", user: user }
  end
 
  def upgrade_user(user)
    plan = metadata[:plan]
    return { success: false, errors: ["Plan is required"] } unless plan
 
    user.update!(
      plan: plan,
      upgraded_at: Time.current,
      previous_plan: user.plan
    )
 
    { success: true, message: "User upgraded to #{plan}", user: user }
  end
 
  def log_action(user, result)
    AuditLog.create!(
      user_id: user.id,
      action: action,
      metadata: metadata.merge(result: result[:success]),
      ip_address: metadata[:ip_address]
    )
  end
 
  def send_notification(user, action)
    UserMailer.send(
      "#{action}_notification",
      user: user,
      metadata: metadata
    ).deliver_later
  end
end

// services/UserManagementService.js
const { User, AuditLog } = require("../models");
const { sendEmail } = require("../utils/email");
const logger = require("../utils/logger");
const { ValidationError } = require("../utils/errors");
 
class UserManagementService {
  constructor(userId, action, metadata = {}) {
    this.userId = userId;
    this.action = action;
    this.metadata = metadata;
    this.errors = [];
  }
 
  async call() {
    try {
      if (!this.isValid()) {
        return { success: false, errors: this.errors };
      }
 
      const result = await User.transaction(async (transaction) => {
        const user = await User.findByPk(this.userId, { transaction });
        if (!user) {
          return { success: false, errors: ["User not found"] };
        }
 
        let actionResult;
        switch (this.action) {
          case "activate":
            actionResult = await this.activateUser(user, transaction);
            break;
          case "deactivate":
            actionResult = await this.deactivateUser(user, transaction);
            break;
          case "suspend":
            actionResult = await this.suspendUser(user, transaction);
            break;
          case "upgrade":
            actionResult = await this.upgradeUser(user, transaction);
            break;
          default:
            throw new Error(`Invalid action: ${this.action}`);
        }
 
        await this.logAction(user, actionResult, transaction);
 
        if (actionResult.success) {
          await this.sendNotification(user, this.action);
        }
 
        return actionResult;
      });
 
      return result;
    } catch (error) {
      logger.error(`UserManagementService failed: ${error.message}`);
      return { success: false, errors: [error.message] };
    }
  }
 
  isValid() {
    if (!this.userId) {
      this.errors.push("User ID is required");
    }
 
    if (!this.action) {
      this.errors.push("Action is required");
    } else if (!["activate", "deactivate", "suspend", "upgrade"].includes(this.action)) {
      this.errors.push("Invalid action");
    }
 
    return this.errors.length === 0;
  }
 
  async activateUser(user, transaction) {
    if (user.status === "active") {
      return { success: false, errors: ["User already active"] };
    }
 
    await user.update(
      {
        status: "active",
        activatedAt: new Date(),
        activationToken: null,
      },
      { transaction }
    );
 
    return {
      success: true,
      message: "User activated successfully",
      user: user.toJSON(),
    };
  }
 
  async deactivateUser(user, transaction) {
    if (user.status !== "active") {
      return { success: false, errors: ["User already inactive"] };
    }
 
    await user.update(
      {
        status: "inactive",
        deactivatedAt: new Date(),
      },
      { transaction }
    );
 
    return {
      success: true,
      message: "User deactivated successfully",
      user: user.toJSON(),
    };
  }
 
  async suspendUser(user, transaction) {
    if (user.status === "suspended") {
      return { success: false, errors: ["User already suspended"] };
    }
 
    await user.update(
      {
        status: "suspended",
        suspendedAt: new Date(),
        suspensionReason: this.metadata.reason,
      },
      { transaction }
    );
 
    return {
      success: true,
      message: "User suspended successfully",
      user: user.toJSON(),
    };
  }
 
  async upgradeUser(user, transaction) {
    const plan = this.metadata.plan;
    if (!plan) {
      return { success: false, errors: ["Plan is required"] };
    }
 
    await user.update(
      {
        plan: plan,
        upgradedAt: new Date(),
        previousPlan: user.plan,
      },
      { transaction }
    );
 
    return {
      success: true,
      message: `User upgraded to ${plan}`,
      user: user.toJSON(),
    };
  }
 
  async logAction(user, result, transaction) {
    await AuditLog.create(
      {
        userId: user.id,
        action: this.action,
        metadata: {
          ...this.metadata,
          result: result.success,
        },
        ipAddress: this.metadata.ipAddress,
      },
      { transaction }
    );
  }
 
  async sendNotification(user, action) {
    try {
      await sendEmail({
        template: `${action}Notification`,
        to: user.email,
        data: {
          user: user.toJSON(),
          metadata: this.metadata,
        },
      });
    } catch (error) {
      logger.error(`Failed to send notification: ${error.message}`);
    }
  }
}
 
module.exports = UserManagementService;