@elizaos/plugin-finances 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/db/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":"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"}

package/dist/db/schema.js

@@ -0,0 +1,133 @@
+import {
+  boolean,
+  integer,
+  pgSchema,
+  real,
+  text,
+  unique
+} from "drizzle-orm/pg-core";
+const financesSchema = pgSchema("app_finances");
+const lifeSubscriptionAudits = financesSchema.table(
+  "life_subscription_audits",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    source: text("source").notNull().default("gmail"),
+    queryWindowDays: integer("query_window_days").notNull().default(180),
+    status: text("status").notNull().default("completed"),
+    totalCandidates: integer("total_candidates").notNull().default(0),
+    activeCandidates: integer("active_candidates").notNull().default(0),
+    canceledCandidates: integer("canceled_candidates").notNull().default(0),
+    uncertainCandidates: integer("uncertain_candidates").notNull().default(0),
+    summary: text("summary").notNull().default(""),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeSubscriptionCandidates = financesSchema.table(
+  "life_subscription_candidates",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    auditId: text("audit_id").notNull(),
+    serviceSlug: text("service_slug").notNull(),
+    serviceName: text("service_name").notNull(),
+    provider: text("provider").notNull().default("unknown"),
+    cadence: text("cadence").notNull().default("unknown"),
+    state: text("state").notNull().default("uncertain"),
+    confidence: real("confidence").notNull().default(0),
+    annualCostEstimateUsd: real("annual_cost_estimate_usd"),
+    managementUrl: text("management_url"),
+    latestEvidenceAt: text("latest_evidence_at"),
+    evidenceJson: text("evidence_json").notNull().default("[]"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.auditId, t.serviceSlug)]
+);
+const lifeSubscriptionCancellations = financesSchema.table(
+  "life_subscription_cancellations",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    auditId: text("audit_id"),
+    candidateId: text("candidate_id"),
+    serviceSlug: text("service_slug").notNull(),
+    serviceName: text("service_name").notNull(),
+    executor: text("executor").notNull().default("agent_browser"),
+    status: text("status").notNull().default("draft"),
+    confirmed: boolean("confirmed").notNull().default(false),
+    currentStep: text("current_step"),
+    browserSessionId: text("browser_session_id"),
+    evidenceSummary: text("evidence_summary"),
+    artifactCount: integer("artifact_count").notNull().default(0),
+    managementUrl: text("management_url"),
+    error: text("error"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    finishedAt: text("finished_at")
+  }
+);
+const lifePaymentSources = financesSchema.table("life_payment_sources", {
+  id: text("id").primaryKey(),
+  agentId: text("agent_id").notNull(),
+  kind: text("kind").notNull().default("manual"),
+  label: text("label").notNull().default(""),
+  institution: text("institution"),
+  accountMask: text("account_mask"),
+  status: text("status").notNull().default("active"),
+  lastSyncedAt: text("last_synced_at"),
+  transactionCount: integer("transaction_count").notNull().default(0),
+  metadataJson: text("metadata_json").notNull().default("{}"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+const lifePaymentTransactions = financesSchema.table(
+  "life_payment_transactions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    sourceId: text("source_id").notNull(),
+    externalId: text("external_id"),
+    postedAt: text("posted_at").notNull(),
+    // Legacy LifeOps-compatible storage; convert to minor units at API/UI edges.
+    amountUsd: real("amount_usd").notNull().default(0),
+    direction: text("direction").notNull().default("debit"),
+    merchantRaw: text("merchant_raw").notNull().default(""),
+    merchantNormalized: text("merchant_normalized").notNull().default(""),
+    description: text("description"),
+    category: text("category"),
+    currency: text("currency").notNull().default("USD"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => [
+    unique().on(
+      t.agentId,
+      t.sourceId,
+      t.postedAt,
+      t.amountUsd,
+      t.merchantNormalized
+    )
+  ]
+);
+const financesDbSchema = {
+  lifeSubscriptionAudits,
+  lifeSubscriptionCandidates,
+  lifeSubscriptionCancellations,
+  lifePaymentSources,
+  lifePaymentTransactions
+};
+export {
+  financesDbSchema,
+  financesSchema,
+  lifePaymentSources,
+  lifePaymentTransactions,
+  lifeSubscriptionAudits,
+  lifeSubscriptionCancellations,
+  lifeSubscriptionCandidates
+};
+//# sourceMappingURL=schema.js.map

package/dist/db/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/schema.ts"],"sourcesContent":["/**\n * Drizzle schema for @elizaos/plugin-finances.\n *\n * Tables live in their own pgSchema(\"app_finances\") namespace. The five\n * finance tables below were carved out of @elizaos/plugin-personal-assistant\n * (formerly in app_lifeops); table NAMES are preserved verbatim\n * (life_payment_*, life_subscription_*) so a non-destructive copy migration can\n * move existing rows across schemas. All raw SQL that targets these tables must\n * qualify them with the `app_finances.` prefix.\n */\n\nimport {\n  boolean,\n  integer,\n  pgSchema,\n  real,\n  text,\n  unique,\n} from \"drizzle-orm/pg-core\";\n\nexport const financesSchema = pgSchema(\"app_finances\");\n\nexport const lifeSubscriptionAudits = financesSchema.table(\n  \"life_subscription_audits\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    source: text(\"source\").notNull().default(\"gmail\"),\n    queryWindowDays: integer(\"query_window_days\").notNull().default(180),\n    status: text(\"status\").notNull().default(\"completed\"),\n    totalCandidates: integer(\"total_candidates\").notNull().default(0),\n    activeCandidates: integer(\"active_candidates\").notNull().default(0),\n    canceledCandidates: integer(\"canceled_candidates\").notNull().default(0),\n    uncertainCandidates: integer(\"uncertain_candidates\").notNull().default(0),\n    summary: text(\"summary\").notNull().default(\"\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n    updatedAt: text(\"updated_at\").notNull(),\n  },\n);\n\nexport const lifeSubscriptionCandidates = financesSchema.table(\n  \"life_subscription_candidates\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    auditId: text(\"audit_id\").notNull(),\n    serviceSlug: text(\"service_slug\").notNull(),\n    serviceName: text(\"service_name\").notNull(),\n    provider: text(\"provider\").notNull().default(\"unknown\"),\n    cadence: text(\"cadence\").notNull().default(\"unknown\"),\n    state: text(\"state\").notNull().default(\"uncertain\"),\n    confidence: real(\"confidence\").notNull().default(0),\n    annualCostEstimateUsd: real(\"annual_cost_estimate_usd\"),\n    managementUrl: text(\"management_url\"),\n    latestEvidenceAt: text(\"latest_evidence_at\"),\n    evidenceJson: text(\"evidence_json\").notNull().default(\"[]\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n    updatedAt: text(\"updated_at\").notNull(),\n  },\n  (t) => [unique().on(t.agentId, t.auditId, t.serviceSlug)],\n);\n\nexport const lifeSubscriptionCancellations = financesSchema.table(\n  \"life_subscription_cancellations\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    auditId: text(\"audit_id\"),\n    candidateId: text(\"candidate_id\"),\n    serviceSlug: text(\"service_slug\").notNull(),\n    serviceName: text(\"service_name\").notNull(),\n    executor: text(\"executor\").notNull().default(\"agent_browser\"),\n    status: text(\"status\").notNull().default(\"draft\"),\n    confirmed: boolean(\"confirmed\").notNull().default(false),\n    currentStep: text(\"current_step\"),\n    browserSessionId: text(\"browser_session_id\"),\n    evidenceSummary: text(\"evidence_summary\"),\n    artifactCount: integer(\"artifact_count\").notNull().default(0),\n    managementUrl: text(\"management_url\"),\n    error: text(\"error\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n    updatedAt: text(\"updated_at\").notNull(),\n    finishedAt: text(\"finished_at\"),\n  },\n);\n\nexport const lifePaymentSources = financesSchema.table(\"life_payment_sources\", {\n  id: text(\"id\").primaryKey(),\n  agentId: text(\"agent_id\").notNull(),\n  kind: text(\"kind\").notNull().default(\"manual\"),\n  label: text(\"label\").notNull().default(\"\"),\n  institution: text(\"institution\"),\n  accountMask: text(\"account_mask\"),\n  status: text(\"status\").notNull().default(\"active\"),\n  lastSyncedAt: text(\"last_synced_at\"),\n  transactionCount: integer(\"transaction_count\").notNull().default(0),\n  metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n  createdAt: text(\"created_at\").notNull(),\n  updatedAt: text(\"updated_at\").notNull(),\n});\n\nexport const lifePaymentTransactions = financesSchema.table(\n  \"life_payment_transactions\",\n  {\n    id: text(\"id\").primaryKey(),\n    agentId: text(\"agent_id\").notNull(),\n    sourceId: text(\"source_id\").notNull(),\n    externalId: text(\"external_id\"),\n    postedAt: text(\"posted_at\").notNull(),\n    // Legacy LifeOps-compatible storage; convert to minor units at API/UI edges.\n    amountUsd: real(\"amount_usd\").notNull().default(0),\n    direction: text(\"direction\").notNull().default(\"debit\"),\n    merchantRaw: text(\"merchant_raw\").notNull().default(\"\"),\n    merchantNormalized: text(\"merchant_normalized\").notNull().default(\"\"),\n    description: text(\"description\"),\n    category: text(\"category\"),\n    currency: text(\"currency\").notNull().default(\"USD\"),\n    metadataJson: text(\"metadata_json\").notNull().default(\"{}\"),\n    createdAt: text(\"created_at\").notNull(),\n  },\n  (t) => [\n    unique().on(\n      t.agentId,\n      t.sourceId,\n      t.postedAt,\n      t.amountUsd,\n      t.merchantNormalized,\n    ),\n  ],\n);\n\n/**\n * Aggregate schema object registered through the plugin `schema` field. The\n * SQL plugin's migration runner creates every table listed here under\n * `app_finances`.\n */\nexport const financesDbSchema = {\n  lifeSubscriptionAudits,\n  lifeSubscriptionCandidates,\n  lifeSubscriptionCancellations,\n  lifePaymentSources,\n  lifePaymentTransactions,\n} as const;\n\nexport type LifeSubscriptionAuditRow =\n  typeof lifeSubscriptionAudits.$inferSelect;\nexport type LifeSubscriptionAuditInsert =\n  typeof lifeSubscriptionAudits.$inferInsert;\nexport type LifeSubscriptionCandidateRow =\n  typeof lifeSubscriptionCandidates.$inferSelect;\nexport type LifeSubscriptionCandidateInsert =\n  typeof lifeSubscriptionCandidates.$inferInsert;\nexport type LifeSubscriptionCancellationRow =\n  typeof lifeSubscriptionCancellations.$inferSelect;\nexport type LifeSubscriptionCancellationInsert =\n  typeof lifeSubscriptionCancellations.$inferInsert;\nexport type LifePaymentSourceRow = typeof lifePaymentSources.$inferSelect;\nexport type LifePaymentSourceInsert = typeof lifePaymentSources.$inferInsert;\nexport type LifePaymentTransactionRow =\n  typeof lifePaymentTransactions.$inferSelect;\nexport type LifePaymentTransactionInsert =\n  typeof lifePaymentTransactions.$inferInsert;\n"],"mappings":"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","names":[]}

package/dist/db/sql.d.ts

@@ -0,0 +1,65 @@
+import type { IAgentRuntime } from "@elizaos/core";
+export type RawSqlQuery = {
+    queryChunks: Array<{
+        value?: unknown;
+    }>;
+};
+export type RuntimeDb = {
+    execute: (query: RawSqlQuery) => Promise<unknown>;
+};
+export declare function asObject(value: unknown): Record<string, unknown> | null;
+export declare function toText(value: unknown, fallback?: string): string;
+export declare function toNumber(value: unknown, fallback?: number): number;
+export declare function toBoolean(value: unknown, fallback?: boolean): boolean;
+export declare function parseJsonValue<T>(value: unknown, fallback: T): T;
+export declare function parseJsonRecord(value: unknown): Record<string, unknown>;
+export declare function parseJsonArray<T>(value: unknown): T[];
+export declare function extractRows(result: unknown): Array<Record<string, unknown>>;
+export declare function getRuntimeDb(runtime: IAgentRuntime): RuntimeDb;
+export declare function executeRawSql(runtime: IAgentRuntime, sqlText: string): Promise<Array<Record<string, unknown>>>;
+export type TransactionalDb = {
+    execute: (query: RawSqlQuery) => Promise<unknown>;
+};
+export declare class OptimisticLockError extends Error {
+    readonly code = "OPTIMISTIC_LOCK_ERROR";
+    readonly table: string;
+    readonly id: string;
+    readonly expectedVersion: number;
+    constructor(args: {
+        table: string;
+        id: string;
+        expectedVersion: number;
+    });
+}
+/**
+ * Run `fn` inside a database transaction. The handle passed to `fn` exposes
+ * the same `.execute(raw)` shape as the global runtime DB, but every call
+ * goes through the transaction. Throwing rolls back; returning commits.
+ *
+ * Drizzle's pg adapter supports `db.transaction(fn)` natively. If the adapter
+ * does not (e.g., a test fake), we fall back to running `fn` against the
+ * global DB and warn — atomicity is not guaranteed in that mode.
+ */
+export declare function withTransaction<T>(runtime: IAgentRuntime, fn: (tx: TransactionalDb) => Promise<T>): Promise<T>;
+/**
+ * Transactional analogue of `executeRawSql`. Pass the `tx` handed in by
+ * `withTransaction`'s callback — every statement participates in the same
+ * transaction and commits/rolls back together.
+ */
+export declare function executeRawSqlTx(tx: TransactionalDb, sqlText: string): Promise<Array<Record<string, unknown>>>;
+/**
+ * Retry policy for optimistic-lock conflicts. Default: 3 attempts with
+ * exponential backoff at 20ms / 50ms / 120ms. After 3 attempts the original
+ * `OptimisticLockError` is rethrown.
+ */
+export declare function withOptimisticRetry<T>(fn: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+}): Promise<T>;
+export declare function sqlQuote(value: string): string;
+export declare function sqlText(value: string | null | undefined): string;
+export declare function sqlInteger(value: number | null | undefined): string;
+export declare function sqlNumber(value: number | null | undefined): string;
+export declare function sqlBoolean(value: boolean): string;
+export declare function sqlJson(value: unknown): string;
+//# sourceMappingURL=sql.d.ts.map

package/dist/db/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/db/sql.ts"],"names":[],"mappings":"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"}

package/dist/db/sql.js

@@ -0,0 +1,182 @@
+let cachedSqlRaw = null;
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function toText(value, fallback = "") {
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return fallback;
+  return String(value);
+}
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+function toBoolean(value, fallback = false) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) return true;
+    if (["0", "false", "no", "off"].includes(normalized)) return false;
+  }
+  return fallback;
+}
+function isMissingJsonValue(value) {
+  return value === null || value === void 0 || value === "";
+}
+function parseJsonValue(value, fallback) {
+  if (isMissingJsonValue(value)) return fallback;
+  if (typeof value !== "string") {
+    if (typeof value === "object") return value;
+    throw new Error(
+      `[FinancesSql] Expected JSON string or object, received ${typeof value}`
+    );
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[FinancesSql] Invalid JSON value: ${message}`);
+  }
+}
+function parseJsonRecord(value) {
+  if (isMissingJsonValue(value)) return {};
+  const parsed = parseJsonValue(value, null);
+  const object = asObject(parsed);
+  if (object) return object;
+  throw new Error("[FinancesSql] Expected JSON object");
+}
+function parseJsonArray(value) {
+  if (isMissingJsonValue(value)) return [];
+  const parsed = parseJsonValue(value, null);
+  if (Array.isArray(parsed)) return parsed;
+  throw new Error("[FinancesSql] Expected JSON array");
+}
+function extractRows(result) {
+  if (Array.isArray(result)) {
+    return result.map((row) => asObject(row)).filter((row) => row !== null);
+  }
+  const object = asObject(result);
+  if (!object) return [];
+  const rows = object.rows;
+  if (!Array.isArray(rows)) return [];
+  return rows.map((row) => asObject(row)).filter((row) => row !== null);
+}
+async function getSqlRaw() {
+  if (cachedSqlRaw) return cachedSqlRaw;
+  const drizzle = await import("drizzle-orm");
+  cachedSqlRaw = drizzle.sql.raw;
+  return cachedSqlRaw;
+}
+function getRuntimeDb(runtime) {
+  const db = runtime.adapter.db;
+  if (!db || typeof db.execute !== "function") {
+    throw new Error("runtime database adapter unavailable");
+  }
+  return db;
+}
+async function executeRawSql(runtime, sqlText2) {
+  const raw = await getSqlRaw();
+  const db = getRuntimeDb(runtime);
+  const result = await db.execute(raw(sqlText2));
+  return extractRows(result);
+}
+class OptimisticLockError extends Error {
+  code = "OPTIMISTIC_LOCK_ERROR";
+  table;
+  id;
+  expectedVersion;
+  constructor(args) {
+    super(
+      `Optimistic lock conflict on ${args.table} id=${args.id} expectedVersion=${args.expectedVersion}`
+    );
+    this.table = args.table;
+    this.id = args.id;
+    this.expectedVersion = args.expectedVersion;
+  }
+}
+async function withTransaction(runtime, fn) {
+  const db = getRuntimeDb(runtime);
+  if (typeof db.transaction === "function") {
+    return await db.transaction(async (tx) => fn(tx));
+  }
+  return await fn({
+    execute: (query) => db.execute(query)
+  });
+}
+async function executeRawSqlTx(tx, sqlText2) {
+  const raw = await getSqlRaw();
+  const result = await tx.execute(raw(sqlText2));
+  return extractRows(result);
+}
+async function withOptimisticRetry(fn, options) {
+  const maxAttempts = Math.max(1, options?.maxAttempts ?? 3);
+  const baseDelay = Math.max(1, options?.baseDelayMs ?? 20);
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (!(error instanceof OptimisticLockError)) {
+        throw error;
+      }
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const delay = baseDelay * 2 ** attempt + Math.floor(Math.random() * baseDelay);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+function sqlQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function sqlText(value) {
+  if (value === null || value === void 0) return "NULL";
+  return sqlQuote(value);
+}
+function sqlInteger(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (!Number.isFinite(value)) throw new Error("invalid numeric SQL literal");
+  return String(Math.trunc(value));
+}
+function sqlNumber(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (!Number.isFinite(value)) throw new Error("invalid numeric SQL literal");
+  return String(value);
+}
+function sqlBoolean(value) {
+  return value ? "TRUE" : "FALSE";
+}
+function sqlJson(value) {
+  return sqlQuote(JSON.stringify(value ?? null));
+}
+export {
+  OptimisticLockError,
+  asObject,
+  executeRawSql,
+  executeRawSqlTx,
+  extractRows,
+  getRuntimeDb,
+  parseJsonArray,
+  parseJsonRecord,
+  parseJsonValue,
+  sqlBoolean,
+  sqlInteger,
+  sqlJson,
+  sqlNumber,
+  sqlQuote,
+  sqlText,
+  toBoolean,
+  toNumber,
+  toText,
+  withOptimisticRetry,
+  withTransaction
+};
+//# sourceMappingURL=sql.js.map

package/dist/db/sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/sql.ts"],"sourcesContent":["import type { IAgentRuntime } from \"@elizaos/core\";\n\nexport type RawSqlQuery = {\n  queryChunks: Array<{ value?: unknown }>;\n};\n\nexport type RuntimeDb = {\n  execute: (query: RawSqlQuery) => Promise<unknown>;\n};\n\nlet cachedSqlRaw: ((query: string) => RawSqlQuery) | null = null;\n\nexport function asObject(value: unknown): Record<string, unknown> | null {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) return null;\n  return value as Record<string, unknown>;\n}\n\nexport function toText(value: unknown, fallback = \"\"): string {\n  if (typeof value === \"string\") return value;\n  if (value === null || value === undefined) return fallback;\n  return String(value);\n}\n\nexport function toNumber(value: unknown, fallback = 0): number {\n  if (typeof value === \"number\" && Number.isFinite(value)) return value;\n  if (typeof value === \"string\") {\n    const parsed = Number(value);\n    if (Number.isFinite(parsed)) return parsed;\n  }\n  return fallback;\n}\n\nexport function toBoolean(value: unknown, fallback = false): boolean {\n  if (typeof value === \"boolean\") return value;\n  if (typeof value === \"number\") return value !== 0;\n  if (typeof value === \"string\") {\n    const normalized = value.trim().toLowerCase();\n    if ([\"1\", \"true\", \"yes\", \"on\"].includes(normalized)) return true;\n    if ([\"0\", \"false\", \"no\", \"off\"].includes(normalized)) return false;\n  }\n  return fallback;\n}\n\nfunction isMissingJsonValue(value: unknown): boolean {\n  return value === null || value === undefined || value === \"\";\n}\n\nexport function parseJsonValue<T>(value: unknown, fallback: T): T {\n  if (isMissingJsonValue(value)) return fallback;\n  if (typeof value !== \"string\") {\n    if (typeof value === \"object\") return value as T;\n    throw new Error(\n      `[FinancesSql] Expected JSON string or object, received ${typeof value}`,\n    );\n  }\n  try {\n    return JSON.parse(value) as T;\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    throw new Error(`[FinancesSql] Invalid JSON value: ${message}`);\n  }\n}\n\nexport function parseJsonRecord(value: unknown): Record<string, unknown> {\n  if (isMissingJsonValue(value)) return {};\n  const parsed = parseJsonValue<Record<string, unknown> | null>(value, null);\n  const object = asObject(parsed);\n  if (object) return object;\n  throw new Error(\"[FinancesSql] Expected JSON object\");\n}\n\nexport function parseJsonArray<T>(value: unknown): T[] {\n  if (isMissingJsonValue(value)) return [];\n  const parsed = parseJsonValue<T[] | null>(value, null);\n  if (Array.isArray(parsed)) return parsed;\n  throw new Error(\"[FinancesSql] Expected JSON array\");\n}\n\nexport function extractRows(result: unknown): Array<Record<string, unknown>> {\n  if (Array.isArray(result)) {\n    return result\n      .map((row) => asObject(row))\n      .filter((row): row is Record<string, unknown> => row !== null);\n  }\n  const object = asObject(result);\n  if (!object) return [];\n  const rows = object.rows;\n  if (!Array.isArray(rows)) return [];\n  return rows\n    .map((row) => asObject(row))\n    .filter((row): row is Record<string, unknown> => row !== null);\n}\n\nasync function getSqlRaw(): Promise<(query: string) => RawSqlQuery> {\n  if (cachedSqlRaw) return cachedSqlRaw;\n  const drizzle = (await import(\"drizzle-orm\")) as {\n    sql: { raw: (query: string) => RawSqlQuery };\n  };\n  cachedSqlRaw = drizzle.sql.raw;\n  return cachedSqlRaw;\n}\n\nexport function getRuntimeDb(runtime: IAgentRuntime): RuntimeDb {\n  const db = runtime.adapter.db as RuntimeDb | undefined;\n  if (!db || typeof db.execute !== \"function\") {\n    throw new Error(\"runtime database adapter unavailable\");\n  }\n  return db;\n}\n\nexport async function executeRawSql(\n  runtime: IAgentRuntime,\n  sqlText: string,\n): Promise<Array<Record<string, unknown>>> {\n  const raw = await getSqlRaw();\n  const db = getRuntimeDb(runtime);\n  const result = await db.execute(raw(sqlText));\n  return extractRows(result);\n}\n\n// ---------------------------------------------------------------------------\n// Transactions and optimistic concurrency\n//\n// Atomic multi-step operations (e.g., thread merge: update target + mark N\n// source threads stopped + append events) MUST run inside `withTransaction`.\n// Without it, a crash mid-loop leaves dangling state — half-merged threads,\n// scheduled tasks fired but not dispatched, etc.\n//\n// `withTransaction` opens a PostgreSQL transaction via the underlying drizzle\n// adapter and exposes a `TransactionalDb` handle with the same `.execute(raw)`\n// shape as the global runtime DB. Pass it into transaction-aware variants of\n// `executeRawSql`/repository methods (currently named `executeRawSqlTx`).\n//\n// `OptimisticLockError` is thrown when an UPDATE with a version check affects\n// 0 rows — caller catches once, re-reads fresh, retries (3x max, with\n// exponential backoff), then surfaces the conflict.\n// ---------------------------------------------------------------------------\n\nexport type TransactionalDb = {\n  execute: (query: RawSqlQuery) => Promise<unknown>;\n};\n\ntype DrizzleTransactionalDb = RuntimeDb & {\n  transaction?: <T>(fn: (tx: TransactionalDb) => Promise<T>) => Promise<T>;\n};\n\nexport class OptimisticLockError extends Error {\n  readonly code = \"OPTIMISTIC_LOCK_ERROR\";\n  readonly table: string;\n  readonly id: string;\n  readonly expectedVersion: number;\n  constructor(args: { table: string; id: string; expectedVersion: number }) {\n    super(\n      `Optimistic lock conflict on ${args.table} id=${args.id} expectedVersion=${args.expectedVersion}`,\n    );\n    this.table = args.table;\n    this.id = args.id;\n    this.expectedVersion = args.expectedVersion;\n  }\n}\n\n/**\n * Run `fn` inside a database transaction. The handle passed to `fn` exposes\n * the same `.execute(raw)` shape as the global runtime DB, but every call\n * goes through the transaction. Throwing rolls back; returning commits.\n *\n * Drizzle's pg adapter supports `db.transaction(fn)` natively. If the adapter\n * does not (e.g., a test fake), we fall back to running `fn` against the\n * global DB and warn — atomicity is not guaranteed in that mode.\n */\nexport async function withTransaction<T>(\n  runtime: IAgentRuntime,\n  fn: (tx: TransactionalDb) => Promise<T>,\n): Promise<T> {\n  const db = getRuntimeDb(runtime) as DrizzleTransactionalDb;\n  if (typeof db.transaction === \"function\") {\n    return await db.transaction(async (tx) => fn(tx));\n  }\n  // Adapter does not support transactions (likely a test fake). Run inline.\n  return await fn({\n    execute: (query) => db.execute(query),\n  });\n}\n\n/**\n * Transactional analogue of `executeRawSql`. Pass the `tx` handed in by\n * `withTransaction`'s callback — every statement participates in the same\n * transaction and commits/rolls back together.\n */\nexport async function executeRawSqlTx(\n  tx: TransactionalDb,\n  sqlText: string,\n): Promise<Array<Record<string, unknown>>> {\n  const raw = await getSqlRaw();\n  const result = await tx.execute(raw(sqlText));\n  return extractRows(result);\n}\n\n/**\n * Retry policy for optimistic-lock conflicts. Default: 3 attempts with\n * exponential backoff at 20ms / 50ms / 120ms. After 3 attempts the original\n * `OptimisticLockError` is rethrown.\n */\nexport async function withOptimisticRetry<T>(\n  fn: () => Promise<T>,\n  options?: { maxAttempts?: number; baseDelayMs?: number },\n): Promise<T> {\n  const maxAttempts = Math.max(1, options?.maxAttempts ?? 3);\n  const baseDelay = Math.max(1, options?.baseDelayMs ?? 20);\n  let lastError: unknown;\n  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {\n    try {\n      return await fn();\n    } catch (error) {\n      if (!(error instanceof OptimisticLockError)) {\n        throw error;\n      }\n      lastError = error;\n      if (attempt < maxAttempts - 1) {\n        const delay =\n          baseDelay * 2 ** attempt + Math.floor(Math.random() * baseDelay);\n        await new Promise((resolve) => setTimeout(resolve, delay));\n      }\n    }\n  }\n  throw lastError;\n}\n\n// ---------------------------------------------------------------------------\n// SQL value encoders\n// ---------------------------------------------------------------------------\n\nexport function sqlQuote(value: string): string {\n  return `'${value.replace(/'/g, \"''\")}'`;\n}\n\nexport function sqlText(value: string | null | undefined): string {\n  if (value === null || value === undefined) return \"NULL\";\n  return sqlQuote(value);\n}\n\nexport function sqlInteger(value: number | null | undefined): string {\n  if (value === null || value === undefined) return \"NULL\";\n  if (!Number.isFinite(value)) throw new Error(\"invalid numeric SQL literal\");\n  return String(Math.trunc(value));\n}\n\nexport function sqlNumber(value: number | null | undefined): string {\n  if (value === null || value === undefined) return \"NULL\";\n  if (!Number.isFinite(value)) throw new Error(\"invalid numeric SQL literal\");\n  return String(value);\n}\n\nexport function sqlBoolean(value: boolean): string {\n  return value ? \"TRUE\" : \"FALSE\";\n}\n\nexport function sqlJson(value: unknown): string {\n  return sqlQuote(JSON.stringify(value ?? null));\n}\n"],"mappings":"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","names":["sqlText"]}

package/dist/finance-normalize.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Self-contained input-normalization helpers for the finances back-end.
+ *
+ * These mirror the small subset of `@elizaos/plugin-personal-assistant`'s
+ * `service-normalize` helpers that the finance code actually used. They are
+ * reproduced here (rather than imported) so `@elizaos/plugin-finances` carries
+ * no dependency on plugin-personal-assistant. `fail` throws a
+ * {@link FinancesServiceError} carrying an HTTP status, which the action and
+ * route layers map to client-facing responses.
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+/** Error carrying an HTTP status for finance back-end failures. */
+export declare class FinancesServiceError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, message: string, code?: string | undefined);
+}
+export declare function financeErrorMessage(error: unknown): string;
+export declare function fail(status: number, message: string, code?: string): never;
+export declare function requireAgentId(runtime: IAgentRuntime): string;
+export declare function requireNonEmptyString(value: unknown, field: string): string;
+export declare function normalizeOptionalString(value: unknown): string | undefined;
+export declare function normalizeOptionalBoolean(value: unknown, field: string): boolean | undefined;
+//# sourceMappingURL=finance-normalize.d.ts.map

package/dist/finance-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finance-normalize.d.ts","sourceRoot":"","sources":["../src/finance-normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,mEAAmE;AACnE,qBAAa,oBAAqB,SAAQ,KAAK;aAE3B,MAAM,EAAE,MAAM;aAEd,IAAI,CAAC,EAAE,MAAM;gBAFb,MAAM,EAAE,MAAM,EAC9B,OAAO,EAAE,MAAM,EACC,IAAI,CAAC,EAAE,MAAM,YAAA;CAKhC;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE1D;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAE1E;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAM7D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAS3E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAI1E;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,GAAG,SAAS,CAiBrB"}

package/dist/finance-normalize.js

@@ -0,0 +1,66 @@
+class FinancesServiceError extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "FinancesServiceError";
+  }
+  status;
+  code;
+}
+function financeErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function fail(status, message, code) {
+  throw new FinancesServiceError(status, message, code);
+}
+function requireAgentId(runtime) {
+  const agentId = runtime.agentId;
+  if (typeof agentId !== "string" || agentId.trim().length === 0) {
+    fail(500, "agent runtime is missing agentId");
+  }
+  return agentId;
+}
+function requireNonEmptyString(value, field) {
+  if (typeof value !== "string") {
+    fail(400, `${field} must be a string`);
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    fail(400, `${field} is required`);
+  }
+  return normalized;
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeOptionalBoolean(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0") {
+      return false;
+    }
+  }
+  fail(400, `${field} must be a boolean`);
+}
+export {
+  FinancesServiceError,
+  fail,
+  financeErrorMessage,
+  normalizeOptionalBoolean,
+  normalizeOptionalString,
+  requireAgentId,
+  requireNonEmptyString
+};
+//# sourceMappingURL=finance-normalize.js.map

package/dist/finance-normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/finance-normalize.ts"],"sourcesContent":["/**\n * Self-contained input-normalization helpers for the finances back-end.\n *\n * These mirror the small subset of `@elizaos/plugin-personal-assistant`'s\n * `service-normalize` helpers that the finance code actually used. They are\n * reproduced here (rather than imported) so `@elizaos/plugin-finances` carries\n * no dependency on plugin-personal-assistant. `fail` throws a\n * {@link FinancesServiceError} carrying an HTTP status, which the action and\n * route layers map to client-facing responses.\n */\n\nimport type { IAgentRuntime } from \"@elizaos/core\";\n\n/** Error carrying an HTTP status for finance back-end failures. */\nexport class FinancesServiceError extends Error {\n  constructor(\n    public readonly status: number,\n    message: string,\n    public readonly code?: string,\n  ) {\n    super(message);\n    this.name = \"FinancesServiceError\";\n  }\n}\n\nexport function financeErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nexport function fail(status: number, message: string, code?: string): never {\n  throw new FinancesServiceError(status, message, code);\n}\n\nexport function requireAgentId(runtime: IAgentRuntime): string {\n  const agentId = runtime.agentId;\n  if (typeof agentId !== \"string\" || agentId.trim().length === 0) {\n    fail(500, \"agent runtime is missing agentId\");\n  }\n  return agentId;\n}\n\nexport function requireNonEmptyString(value: unknown, field: string): string {\n  if (typeof value !== \"string\") {\n    fail(400, `${field} must be a string`);\n  }\n  const normalized = value.trim();\n  if (normalized.length === 0) {\n    fail(400, `${field} is required`);\n  }\n  return normalized;\n}\n\nexport function normalizeOptionalString(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const normalized = value.trim();\n  return normalized.length > 0 ? normalized : undefined;\n}\n\nexport function normalizeOptionalBoolean(\n  value: unknown,\n  field: string,\n): boolean | undefined {\n  if (value === undefined) {\n    return undefined;\n  }\n  if (typeof value === \"boolean\") {\n    return value;\n  }\n  if (typeof value === \"string\") {\n    const normalized = value.trim().toLowerCase();\n    if (normalized === \"true\" || normalized === \"1\") {\n      return true;\n    }\n    if (normalized === \"false\" || normalized === \"0\") {\n      return false;\n    }\n  }\n  fail(400, `${field} must be a boolean`);\n}\n"],"mappings":"AAcO,MAAM,6BAA6B,MAAM;AAAA,EAC9C,YACkB,QAChB,SACgB,MAChB;AACA,UAAM,OAAO;AAJG;AAEA;AAGhB,SAAK,OAAO;AAAA,EACd;AAAA,EANkB;AAAA,EAEA;AAKpB;AAEO,SAAS,oBAAoB,OAAwB;AAC1D,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEO,SAAS,KAAK,QAAgB,SAAiB,MAAsB;AAC1E,QAAM,IAAI,qBAAqB,QAAQ,SAAS,IAAI;AACtD;AAEO,SAAS,eAAe,SAAgC;AAC7D,QAAM,UAAU,QAAQ;AACxB,MAAI,OAAO,YAAY,YAAY,QAAQ,KAAK,EAAE,WAAW,GAAG;AAC9D,SAAK,KAAK,kCAAkC;AAAA,EAC9C;AACA,SAAO;AACT;AAEO,SAAS,sBAAsB,OAAgB,OAAuB;AAC3E,MAAI,OAAO,UAAU,UAAU;AAC7B,SAAK,KAAK,GAAG,KAAK,mBAAmB;AAAA,EACvC;AACA,QAAM,aAAa,MAAM,KAAK;AAC9B,MAAI,WAAW,WAAW,GAAG;AAC3B,SAAK,KAAK,GAAG,KAAK,cAAc;AAAA,EAClC;AACA,SAAO;AACT;AAEO,SAAS,wBAAwB,OAAoC;AAC1E,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,QAAM,aAAa,MAAM,KAAK;AAC9B,SAAO,WAAW,SAAS,IAAI,aAAa;AAC9C;AAEO,SAAS,yBACd,OACA,OACqB;AACrB,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,WAAW;AAC9B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,aAAa,MAAM,KAAK,EAAE,YAAY;AAC5C,QAAI,eAAe,UAAU,eAAe,KAAK;AAC/C,aAAO;AAAA,IACT;AACA,QAAI,eAAe,WAAW,eAAe,KAAK;AAChD,aAAO;AAAA,IACT;AAAA,EACF;AACA,OAAK,KAAK,GAAG,KAAK,oBAAoB;AACxC;","names":[]}