@sixb/core 0.1.8 → 0.1.9

package/dist/chunk-h1gfhhbh.js

@@ -0,0 +1,602 @@
+// @bun
+import {
+  createSixbError2,
+  isSixbError2
+} from "./chunk-f4w3yp4f.js";
+import {
+  AiLimitStorageError2
+} from "./chunk-jgwb25gc.js";
+import {
+  aiLimitSubjectsFromAttribution2,
+  applicableAiLimitPolicies2,
+  aiUsageLimitExceededError2,
+  aiUsageLimitUnavailableError2
+} from "./chunk-0y39rgsb.js";
+import {
+  defineLanguageModel2,
+  ModelCatalogUnavailableError2
+} from "./chunk-e0d1rzef.js";
+import {
+  AiUsageStorageError2,
+  normalizeAiModelCallCostRecord2,
+  aiModelCallCostMatchesUsage2
+} from "./chunk-g53f0e4j.js";
+import {
+  AiCostStorageError2
+} from "./chunk-mjbk2djy.js";
+import {
+  normalizeAiModelCallRecord2
+} from "./chunk-s3csryxe.js";
+import {
+  assertJsonObject2
+} from "./chunk-wy0qdqfm.js";
+
+// src/models/execution/model-call-limits.ts
+function createAiModelCallLimitController2(input) {
+  const subjects = aiLimitSubjectsFromAttribution2(input.requestedBy, input.requesterGroupIds);
+  return {
+    beforeModelCall: async (admission) => {
+      let applicable;
+      try {
+        const policies = await input.storage.aiLimits.listPolicies({
+          projectId: input.projectId
+        });
+        applicable = applicableAiLimitPolicies2(policies, subjects);
+      } catch (error) {
+        throw limitStorageUnavailable(error);
+      }
+      if (applicable.length === 0)
+        return { reservation: "none" };
+      const estimates = reservationEstimates(admission, applicable.some((policy) => policy.limit.meter === "cost.catalogEstimated"));
+      if (estimates.length === 0) {
+        throw aiUsageLimitUnavailableError2(["missingEstimate"]);
+      }
+      let result;
+      try {
+        result = await input.storage.aiLimits.reserveModelCall({
+          ...reservationIdentity(admission),
+          subjects,
+          estimates
+        });
+      } catch (error) {
+        throw limitStorageUnavailable(error);
+      }
+      switch (result.status) {
+        case "reserved":
+          return { reservation: "active" };
+        case "notRequired":
+          return { reservation: "none" };
+        case "denied":
+          throw aiUsageLimitExceededError2(result.resetAt);
+        case "unavailable":
+          throw aiUsageLimitUnavailableError2(result.reasons);
+        case "terminal":
+          throw aiUsageLimitUnavailableError2(["terminalReservationReplay"]);
+      }
+    },
+    markModelCallUnknown: async (identity) => {
+      try {
+        await input.storage.aiLimits.markReservationUnknown(identity);
+      } catch (error) {
+        throw limitStorageUnavailable(error);
+      }
+    }
+  };
+}
+function reservationEstimates(input, needsCost) {
+  if (input.inputTokens.status !== "estimated" || input.estimatedTotalTokens === undefined) {
+    return [];
+  }
+  const estimates = [
+    { meter: "tokens.total", amount: input.estimatedTotalTokens }
+  ];
+  if (needsCost) {
+    try {
+      const money = input.costEstimator?.estimateReservation?.({
+        inputTokens: input.inputTokens.tokens,
+        outputTokens: input.outputTokenAllowance
+      });
+      if (money)
+        estimates.push({ meter: "cost.catalogEstimated", amount: money });
+    } catch {
+      return estimates;
+    }
+  }
+  return estimates;
+}
+function reservationIdentity(input) {
+  return {
+    projectId: input.projectId,
+    executionId: input.executionId,
+    attempt: input.attempt,
+    callId: input.callId
+  };
+}
+function limitStorageUnavailable(error) {
+  if (isSixbError2(error) && (error.code === "ai.usage_limit_exceeded" || error.code === "ai.usage_limit_unavailable")) {
+    return error;
+  }
+  return aiUsageLimitUnavailableError2(["limitStorageUnavailable"]);
+}
+
+// src/models/execution/errors.ts
+class ModelUsageRecordingError2 extends Error {
+  executionId;
+  callId;
+  recoveryScheduled;
+  name = "ModelUsageRecordingError";
+  constructor(executionId, callId, recoveryScheduled, options) {
+    super(recoveryScheduled ? `[SixbModels] AI usage for call '${callId}' in execution '${executionId}' was deferred to durable recovery.` : `[SixbModels] Could not preserve AI usage for call '${callId}' in execution '${executionId}'.`, options);
+    this.executionId = executionId;
+    this.callId = callId;
+    this.recoveryScheduled = recoveryScheduled;
+  }
+}
+
+// src/models/execution/model-call-accounting.ts
+import { createHash } from "crypto";
+async function recordAiModelCallAccounting(input) {
+  return input.storage.transaction(async (tx) => {
+    const { aiUsage, aiCosts, aiLimits } = requireAccountingCapabilities(tx);
+    const usage = await aiUsage.recordModelCall(input.usage);
+    const canonical = normalizeModelCallAccounting({
+      ...input,
+      usage: usage.record,
+      ratedAt: usage.record.recordedAt
+    });
+    const record = modelCostRecord(canonical, usage.record.id);
+    const estimate = canonical.cost.status !== "reported" || canonical.estimate === undefined ? undefined : modelCostRecord({ ...canonical, cost: canonical.estimate }, usage.record.id);
+    await aiCosts.recordModelCallCost({
+      ...record,
+      ...estimate === undefined ? {} : {
+        estimate: estimate.status === "rated" ? { status: "rated", money: estimate.money, components: estimate.components } : {
+          status: "unpriceable",
+          reason: estimate.reason,
+          ...estimate.missingMeters === undefined ? {} : { missingMeters: estimate.missingMeters }
+        }
+      }
+    });
+    if (usage.created) {
+      await aiLimits.recordModelCallActuals({
+        projectId: usage.record.projectId,
+        usageRecordId: usage.record.id,
+        recordedAt: input.ratedAt
+      });
+    }
+    if (input.reconcileLimitReservation) {
+      await aiLimits.reconcileModelCall({
+        projectId: usage.record.projectId,
+        executionId: usage.record.executionId,
+        attempt: usage.record.attempt,
+        callId: usage.record.callId,
+        usageRecordId: usage.record.id,
+        reconciledAt: input.ratedAt
+      });
+    }
+    return usage;
+  });
+}
+function normalizeModelCallAccounting(input) {
+  const usage = normalizeAiModelCallRecord2(input.usage);
+  return {
+    ...input,
+    cost: input.cost.status === "reported" ? input.cost : validatedEstimate(input.cost, input, usage),
+    ...input.estimate === undefined ? {} : { estimate: validatedEstimate(input.estimate, input, usage) }
+  };
+}
+function validatedEstimate(cost, input, usage) {
+  try {
+    assertJsonObject2(cost, "model cost estimate");
+    const record = normalizeAiModelCallCostRecord2(modelCostRecord({ ...input, cost }, usage.id));
+    if (!aiModelCallCostMatchesUsage2(record, usage)) {
+      throw new TypeError("Estimate quantities do not match recorded usage.");
+    }
+    return structuredClone(cost);
+  } catch {
+    console.warn("[SixbModels] Invalid model cost estimate; preserving call usage and provider cost.");
+    return { status: "unpriceable", reason: "inconsistent-usage" };
+  }
+}
+function modelCostRecord(input, usageRecordId) {
+  const billingIdentity = {
+    providerId: input.usage.providerId,
+    modelId: input.usage.requestedModelId
+  };
+  const pricingContext = {
+    ...input.route?.providerId === undefined ? {} : { routedProviderId: input.route.providerId },
+    ...input.route?.modelId === undefined ? {} : { routedModelId: input.route.modelId }
+  };
+  if (input.cost.status === "reported" || input.cost.status === "rated") {
+    return {
+      projectId: input.usage.projectId,
+      usageRecordId,
+      status: "rated",
+      billingIdentity,
+      pricingContext,
+      priceSource: costPriceSource(input.usage, input.cost),
+      money: input.cost.money,
+      components: input.cost.status === "rated" ? input.cost.components : [],
+      ratedAt: new Date(input.ratedAt)
+    };
+  }
+  const reason = input.cost.reason === "missing-rate-card" ? "missingRateCard" : input.cost.reason === "missing-usage" ? "missingUsageMeter" : "invalidUsageForFormula";
+  const missingMeters = reason === "missingUsageMeter" ? normalizeMissingMeters(input.cost.missingMeters) : undefined;
+  return {
+    projectId: input.usage.projectId,
+    usageRecordId,
+    status: "unpriceable",
+    billingIdentity,
+    pricingContext,
+    reason,
+    ...missingMeters === undefined ? {} : { missingMeters },
+    ratedAt: new Date(input.ratedAt)
+  };
+}
+function costPriceSource(usage, cost) {
+  if (cost.status === "reported") {
+    return {
+      sourceId: "provider-reported",
+      sourceEntryId: `${usage.providerId}/${usage.responseId}`,
+      sourceVersion: "response-v1",
+      observedAt: new Date(usage.occurredAt)
+    };
+  }
+  const rates = cost.components.map(({ meter, rateAmountNanosPerMillion }) => ({
+    meter,
+    rateAmountNanosPerMillion
+  }));
+  const version = createHash("sha256").update(JSON.stringify(rates)).digest("hex");
+  return {
+    sourceId: "model-rate-card",
+    sourceEntryId: `${usage.providerId}/${usage.requestedModelId}`,
+    sourceVersion: `sha256:${version}`,
+    observedAt: new Date(usage.occurredAt)
+  };
+}
+function normalizeMissingMeters(meters) {
+  const fallback = ["tokens.input.total", "tokens.output.total"];
+  return [...new Set(meters ?? fallback)];
+}
+function requireAccountingCapabilities(storage) {
+  if (!storage.aiUsage || !storage.aiCosts || !storage.aiLimits) {
+    throw new Error("[SixbModels] AI model-call accounting requires storage.aiUsage, storage.aiCosts, and storage.aiLimits.");
+  }
+  return { aiUsage: storage.aiUsage, aiCosts: storage.aiCosts, aiLimits: storage.aiLimits };
+}
+
+// src/models/execution/usage.ts
+function aiModelCallUsageFromModel(usage) {
+  return {
+    ...usage.inputTokens === undefined ? {} : { inputTokens: usage.inputTokens },
+    ...usage.outputTokens === undefined ? {} : { outputTokens: usage.outputTokens },
+    ...usage.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: usage.uncachedInputTokens },
+    ...usage.cacheReadInputTokens === undefined ? {} : { cacheReadInputTokens: usage.cacheReadInputTokens },
+    ...usage.cacheWriteInputTokens === undefined ? {} : { cacheWriteInputTokens: usage.cacheWriteInputTokens },
+    ...usage.textOutputTokens === undefined ? {} : { textOutputTokens: usage.textOutputTokens },
+    ...usage.reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens: usage.reasoningOutputTokens }
+  };
+}
+
+// src/models/execution/model-call-recovery.ts
+class InvalidAiUsageRecoveryJobError extends Error {
+  name = "InvalidAiUsageRecoveryJobError";
+  constructor(message, options) {
+    super(`[SixbModels] ${message}`, options);
+  }
+}
+function modelCallRecoveryPayload(input) {
+  normalizeAiModelCallRecord2(input.usage);
+  return {
+    record: toQueuePayload(input.usage),
+    accounting: toAccountingPayload(input)
+  };
+}
+async function recordRecoveredAiModelCall2(storage, job) {
+  const usage = fromQueuePayload(job);
+  const accounting = accountingFromQueuePayload(job);
+  return recordAiModelCallAccounting({ storage, usage, ...accounting });
+}
+function isPermanentAiUsageRecoveryError2(error) {
+  return error instanceof InvalidAiUsageRecoveryJobError || error instanceof TypeError || error instanceof AiUsageStorageError2 && (error.code === "duplicate_id" || error.code === "missing_execution") || error instanceof AiCostStorageError2 && (error.code === "missing_usage" || error.code === "cost_mismatch") || error instanceof AiLimitStorageError2 && (error.code === "missing_execution" || error.code === "missing_reservation" || error.code === "missing_usage_record" || error.code === "usage_mismatch" || error.code === "reservation_conflict" || error.code === "reconciliation_conflict" || error.code === "invalid_reservation_state");
+}
+function toQueuePayload(record) {
+  return {
+    id: record.id,
+    executionId: record.executionId,
+    attempt: record.attempt,
+    callId: record.callId,
+    requesterGroupIds: [...record.requesterGroupIds],
+    providerId: record.providerId,
+    ...record.providerIds === undefined ? {} : { providerIds: structuredClone(record.providerIds) },
+    requestedModelId: record.requestedModelId,
+    ...record.requestedReasoning === undefined ? {} : { requestedReasoning: structuredClone(record.requestedReasoning) },
+    ...record.responseModelId === undefined ? {} : { responseModelId: record.responseModelId },
+    responseId: record.responseId,
+    usage: aiModelCallUsageFromModel(record.usage),
+    ...record.rawUsage === undefined ? {} : { rawUsage: structuredClone(record.rawUsage) },
+    occurredAt: record.occurredAt.toISOString()
+  };
+}
+function toAccountingPayload(input) {
+  return {
+    cost: structuredClone(input.cost),
+    ...input.estimate === undefined ? {} : { estimate: structuredClone(input.estimate) },
+    ...input.route === undefined ? {} : { route: structuredClone(input.route) },
+    ratedAt: input.ratedAt.toISOString(),
+    ...input.reconcileLimitReservation ? { reconcileLimitReservation: true } : {}
+  };
+}
+function fromQueuePayload(job) {
+  const occurredAt = parseDate(job.payload.record.occurredAt, job.id, "occurredAt");
+  return { ...job.payload.record, projectId: job.projectId, occurredAt };
+}
+function accountingFromQueuePayload(job) {
+  const accounting = job.payload.accounting;
+  return {
+    cost: structuredClone(accounting.cost),
+    ...accounting.estimate === undefined ? {} : { estimate: structuredClone(accounting.estimate) },
+    ...accounting.route === undefined ? {} : { route: structuredClone(accounting.route) },
+    ratedAt: parseDate(accounting.ratedAt, job.id, "ratedAt"),
+    reconcileLimitReservation: accounting.reconcileLimitReservation === true
+  };
+}
+function parseDate(value, jobId, field) {
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) {
+    throw new InvalidAiUsageRecoveryJobError(`AI usage recovery job '${jobId}' has an invalid ${field} timestamp.`);
+  }
+  return date;
+}
+
+// src/models/execution/model-call-recorder.ts
+import { randomUUID } from "crypto";
+
+// src/models/execution/model-call-admission.ts
+var AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE = 4096;
+function estimateAiModelCallInputTokens(input) {
+  if (containsNonTextInput(input.prompt)) {
+    return { status: "unavailable", reason: "nonTextInput" };
+  }
+  let serialized;
+  try {
+    serialized = JSON.stringify(input);
+  } catch {
+    return { status: "unavailable", reason: "unserializableInput" };
+  }
+  if (serialized === undefined) {
+    return { status: "unavailable", reason: "unserializableInput" };
+  }
+  const bytes = new TextEncoder().encode(serialized).byteLength;
+  return {
+    status: "estimated",
+    tokens: Math.ceil(bytes / 4),
+    method: "utf8BytesDividedByFour"
+  };
+}
+function aiModelCallOutputTokenAllowance(maxOutputTokens) {
+  if (maxOutputTokens === undefined)
+    return AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE;
+  if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) {
+    throw new TypeError("[SixbModels] AI model-call maxOutputTokens must be a positive safe integer.");
+  }
+  return maxOutputTokens;
+}
+function estimatedAiModelCallTotalTokens(inputTokens, outputTokenAllowance) {
+  if (inputTokens.status !== "estimated")
+    return;
+  const total = inputTokens.tokens + outputTokenAllowance;
+  if (!Number.isSafeInteger(total)) {
+    throw new TypeError("[SixbModels] AI model-call token estimate exceeds the safe range.");
+  }
+  return total;
+}
+function containsNonTextInput(value, seen = new WeakSet) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (value instanceof URL || value instanceof ArrayBuffer || ArrayBuffer.isView(value) || typeof Blob !== "undefined" && value instanceof Blob) {
+    return true;
+  }
+  if (seen.has(value))
+    return false;
+  seen.add(value);
+  if (!Array.isArray(value)) {
+    const type = Reflect.get(value, "type");
+    if (type === "image" || type === "file" || type === "reasoning-file" || type === "custom" || type === "provider-state") {
+      return true;
+    }
+  }
+  return Object.values(value).some((entry) => containsNonTextInput(entry, seen));
+}
+
+// src/models/execution/model-call-recorder.ts
+var STORAGE_RETRY_DELAYS_MS = [50, 200, 600];
+
+class AiModelCallRecorder2 {
+  input;
+  generateId;
+  now;
+  retryDelaysMs;
+  sleep;
+  recordAccounting;
+  reservations = new Set;
+  admissionError;
+  recordingError;
+  constructor(input, internals = {}) {
+    this.input = input;
+    requireAccountingCapabilities(input.storage);
+    this.generateId = internals.generateId ?? (() => `ai_usage_${randomUUID()}`);
+    this.now = internals.now ?? (() => new Date);
+    this.retryDelaysMs = internals.retryDelaysMs ?? STORAGE_RETRY_DELAYS_MS;
+    this.sleep = internals.sleep ?? sleep;
+    this.recordAccounting = internals.recordAccounting ?? (async (recovery) => {
+      await recordAiModelCallAccounting({ storage: this.input.storage, ...recovery });
+    });
+  }
+  wrapModel(model) {
+    return {
+      providerId: model.providerId,
+      modelId: model.modelId,
+      definition: model.definition,
+      costEstimator: model.costEstimator,
+      ...model.validateResponseFormat === undefined ? {} : { validateResponseFormat: model.validateResponseFormat.bind(model) },
+      stream: async (request) => {
+        this.assertHealthy();
+        const inputTokens = estimateAiModelCallInputTokens({
+          prompt: request.messages,
+          tools: request.tools,
+          responseFormat: request.responseFormat
+        });
+        const outputTokenAllowance = aiModelCallOutputTokenAllowance(request.maxOutputTokens);
+        let decision;
+        try {
+          decision = await this.input.limits.beforeModelCall({
+            ...this.identity(request),
+            requesterGroupIds: this.input.requesterGroupIds,
+            providerId: model.providerId,
+            modelId: model.modelId,
+            costEstimator: model.costEstimator,
+            inputTokens,
+            outputTokenAllowance,
+            estimatedTotalTokens: estimatedAiModelCallTotalTokens(inputTokens, outputTokenAllowance)
+          });
+        } catch (error) {
+          this.admissionError = error;
+          throw error;
+        }
+        if (decision.reservation === "active")
+          this.reservations.add(request.callId);
+        try {
+          return await model.stream(request);
+        } catch (error) {
+          if (this.reservations.has(request.callId)) {
+            await this.input.limits.markModelCallUnknown(this.identity(request));
+          }
+          throw error;
+        }
+      }
+    };
+  }
+  identity(request) {
+    return {
+      projectId: this.input.projectId,
+      executionId: this.input.executionId,
+      attempt: this.input.attempt,
+      callId: request.callId
+    };
+  }
+  onModelCallEnd = async (event) => {
+    try {
+      const occurredAt = this.now();
+      const record = {
+        id: this.generateId(),
+        projectId: this.input.projectId,
+        executionId: this.input.executionId,
+        attempt: this.input.attempt,
+        callId: event.callId,
+        requesterGroupIds: this.input.requesterGroupIds,
+        providerId: event.providerId,
+        ...event.providerIds === undefined ? {} : { providerIds: event.providerIds },
+        requestedModelId: event.modelId,
+        ...event.requestedReasoning === undefined ? {} : { requestedReasoning: event.requestedReasoning },
+        ...event.responseModelId === undefined ? {} : { responseModelId: event.responseModelId },
+        responseId: event.responseId,
+        usage: aiModelCallUsageFromModel(event.usage),
+        ...event.usage.raw === undefined ? {} : { rawUsage: rawUsage(event.usage) },
+        occurredAt
+      };
+      const recoveryInput = normalizeModelCallAccounting({
+        usage: record,
+        cost: event.cost,
+        ...event.estimate === undefined ? {} : { estimate: event.estimate },
+        ...event.route === undefined ? {} : { route: event.route },
+        ratedAt: new Date(occurredAt),
+        ...this.reservations.has(event.callId) ? { reconcileLimitReservation: true } : {}
+      });
+      try {
+        await retryOperation(() => this.recordAccounting(recoveryInput), this.retryDelaysMs, this.sleep, (error) => !isPermanentAiUsageRecoveryError2(error));
+      } catch (storageError) {
+        if (isPermanentAiUsageRecoveryError2(storageError))
+          throw storageError;
+        try {
+          await retryOperation(() => this.input.recoverAiModelCall(recoveryInput), this.retryDelaysMs, this.sleep, (error) => !isPermanentAiUsageRecoveryError2(error));
+        } catch (recoveryError) {
+          throw new AggregateError([storageError, recoveryError], "Direct AI accounting and durable recovery both failed.");
+        }
+        throw new ModelUsageRecordingError2(this.input.executionId, event.callId, true, {
+          cause: storageError
+        });
+      }
+    } catch (error) {
+      const recordingError = error instanceof ModelUsageRecordingError2 ? error : new ModelUsageRecordingError2(this.input.executionId, event.callId, false, {
+        cause: error
+      });
+      this.recordingError ??= recordingError;
+      throw recordingError;
+    }
+  };
+  assertHealthy() {
+    if (this.admissionError !== undefined)
+      throw this.admissionError;
+    if (this.recordingError)
+      throw this.recordingError;
+  }
+}
+function rawUsage(usage) {
+  return structuredClone(usage.raw ?? {});
+}
+async function retryOperation(operation, retryDelaysMs, wait, shouldRetry) {
+  for (let attempt = 0;; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!shouldRetry(error))
+        throw error;
+      const delay = retryDelaysMs[attempt];
+      if (delay === undefined)
+        throw error;
+      await wait(delay);
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/models/execution/recovery-queue.ts
+function agentAiUsageRecoveryJobId(recordId) {
+  return `agt_usage_job_${recordId}`;
+}
+async function enqueueAiModelCallRecovery2(queue, input) {
+  const payload = modelCallRecoveryPayload(input);
+  const record = input.usage;
+  const jobId = agentAiUsageRecoveryJobId(record.id);
+  const [job] = await queue.enqueue({
+    projectId: record.projectId,
+    jobs: [{ id: jobId, type: "agent.ai-usage.record.requested", payload }]
+  });
+  if (job?.id !== jobId || job.type !== "agent.ai-usage.record.requested") {
+    throw createSixbError2("internal.unexpected", `[SixbModels] Agent queue did not confirm AI usage recovery job '${jobId}'.`, { details: { jobId } });
+  }
+}
+
+// src/models/resolve.ts
+async function resolveLanguageModel2(binding) {
+  const offline = binding.definition.contextWindow !== undefined || binding.definition.maxInputTokens !== undefined;
+  let model;
+  try {
+    model = await binding.resolve?.({ offline }) ?? binding;
+  } catch (cause) {
+    if (offline || !(cause instanceof ModelCatalogUnavailableError2))
+      throw cause;
+    model = await binding.resolve?.({ offline: true }) ?? binding;
+  }
+  const definition = defineLanguageModel2(model.definition);
+  if (definition.providerId !== binding.providerId || definition.modelId !== binding.modelId || model.providerId !== binding.providerId || model.modelId !== binding.modelId) {
+    throw new TypeError("[SixbModels] Resolved model identity does not match the selected model.");
+  }
+  return model;
+}
+
+export { requireAccountingCapabilities, aiModelCallOutputTokenAllowance, createAiModelCallLimitController2, ModelUsageRecordingError2, recordRecoveredAiModelCall2, isPermanentAiUsageRecoveryError2, AiModelCallRecorder2, enqueueAiModelCallRecovery2, resolveLanguageModel2 };
+
+//# debugId=CC3C37B45A645F1264756E2164756E21