actual-mcp-server 0.22.25 → 0.22.28

package/README.md

@@ -454,7 +454,7 @@ For Claude Desktop (stdio), restart Claude after upgrading.
 
 Four tools take many items in one call, for clients that allow only a few tool calls per turn. They share ONE contract: each item is applied independently and **not atomically**. There is no rollback, so items applied before a failure stay applied; a bad item is reported by its index and the rest continue; an infrastructure failure (lost connection, timeout) fails the whole call, and then you must read the data back before retrying anything. A bulk path never retries a create on its own.
 
-- `actual_transactions_update_batch` (counted under Transactions): update up to 50 transactions, `{id, fields}` each. Result: `{ succeeded: [{id}], failed: [{id, error}], total, successCount, failureCount }`.
+- `actual_transactions_update_batch` (counted under Transactions): update up to 50 transactions, `{id, fields}` each. Result: `{ succeeded: [{id}], failed: [{id, error}], total, successCount, failureCount }`. Items marked "not attempted" were never sent. Re-read with `actual_transactions_get` before retrying any item.
 - `actual_transactions_import` (counted under Transactions): bulk create with import semantics (deduplication and reconciliation against existing transactions, rules optionally applied). Use it to add many transactions at once.
 - `actual_budget_updates_batch`: set budget amounts and/or carryover flags for 1 to 100 month/category pairs, and the way to rebalance categories: read the month with `actual_budgets_getMonth`, then send one batch of absolute amounts. Each operation needs at least one of `amount` (integer cents) or `carryover`. Result: `{ succeeded: [{index, month, categoryId}], failed: [{index, month, categoryId, error}], total, successCount, failureCount }`. An unknown category, an out-of-range month or a carryover on an income category fails only that item. After a timeout, read the months back with `actual_budgets_getMonth` before retrying.
 - `actual_rules_create_batch` (counted under Rules): create 1 to 50 rules, each exactly the input of `actual_rules_create`. Result: `{ succeeded: [{index, id}], failed: [{index, error}], total, successCount, failureCount }`. Items marked "not attempted" were never sent. Re-read with `actual_rules_get` before retrying any item.
@@ -835,7 +835,7 @@ The software is provided **as-is**, without warranty of any kind. The author acc
 
 ---
 
-**Version:** 0.22.25 | **Tool Count:** 83 (verified LibreChat-compatible)
+**Version:** 0.22.28 | **Tool Count:** 83 (verified LibreChat-compatible)
 
 ## Sponsor
 

package/dist/src/lib/actual-adapter.js

@@ -1946,9 +1946,11 @@ export async function transferBudgetAmount(month, fromCategoryId, toCategoryId,
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            // An infrastructure error says nothing about whether the write landed, so only a
-            // deterministic (domain) rejection may claim the target is unchanged.
-            const target = _shouldDropPoolOnError(error)
+            // A transient error (infrastructure or a rate limit) says nothing about whether the write
+            // landed, so only a deterministic (domain) rejection may claim the target is unchanged.
+            // #544: this is isRetryableError, not _shouldDropPoolOnError: a rate limit keeps the pool
+            // but its outcome is just as unknown. The pool-drop decision itself is untouched.
+            const target = isRetryableError(error)
                 ? `its outcome is unknown (it was ${prevTo})`
                 : `it is unchanged at ${prevTo}`;
             // The original text stays INSIDE the message: isRetryableError classifies by message only
@@ -2030,6 +2032,9 @@ export async function updateTransaction(id, fields) {
     observability.incrementToolCall('actual.transactions.update').catch(() => { });
     // Use write queue to batch concurrent updates in a single budget session
     return queueWriteOperation(async () => {
+        // #494: the drain's op timeout starts when this callback starts, so the split poll's cap
+        // below is measured from here, not from the end of the write (same origin as #538's startedAt).
+        const opStartedAt = Date.now();
         // Pre-flight existence check (#212): the raw API silently no-ops on a missing id,
         // so an update that changed nothing would otherwise be reported as success. A
         // targeted ActualQL query by id keeps this cheap (indexed lookup). #305 extends
@@ -2100,8 +2105,16 @@ export async function updateTransaction(id, fields) {
         // with every requested child. Polling here, inside the drain, also guarantees the change is
         // local before the drain's api.sync(). A retry after a timeout is safe: the row is then a
         // split, so a second call EDITS its children rather than creating anything new.
+        // #494: the poll must end before the op timeout does, or the caller sees "timed out" (which
+        // invites a retry) while this callback keeps reading in the background. Cap it at HALF the op
+        // timeout, counted from op start; 0 disables the op timeout, so the poll keeps its own bound.
+        // Do not cap at opStartedAt + boundMs: that term would also shorten the poll at the default.
         const expected = subs.length;
-        const deadline = Date.now() + SPLIT_VERIFY_TIMEOUT_MS;
+        const T = config.ACTUAL_OP_TIMEOUT_MS;
+        const deadline = T > 0
+            ? Math.min(Date.now() + SPLIT_VERIFY_TIMEOUT_MS, opStartedAt + Math.floor(T / 2))
+            : Date.now() + SPLIT_VERIFY_TIMEOUT_MS;
+        const boundMs = T > 0 ? Math.min(SPLIT_VERIFY_TIMEOUT_MS, Math.floor(T / 2)) : SPLIT_VERIFY_TIMEOUT_MS;
         for (;;) {
             const res = (await rawRunQuery(q('transactions').options({ splits: 'all' })
                 .filter({ $or: [{ id }, { parent_id: id }] })
@@ -2113,7 +2126,7 @@ export async function updateTransaction(id, fields) {
                 return { split: { parent: id, children } };
             }
             if (Date.now() >= deadline) {
-                throw new Error(`Transaction "${id}" was sent to be split into ${expected} parts, but the split was not visible after ${SPLIT_VERIFY_TIMEOUT_MS}ms (found ${children.length} children), so the outcome is unknown. ` +
+                throw new Error(`Transaction "${id}" was sent to be split into ${expected} parts, but the split was not visible after ${boundMs}ms (found ${children.length} children), so the outcome is unknown. ` +
                     'Read it back with actual_transactions_get before retrying: if it is already a split, a retry edits its children rather than duplicating them.');
             }
             await new Promise((resolve) => setTimeout(resolve, SPLIT_VERIFY_INTERVAL_MS));

package/dist/src/lib/constants.js

@@ -55,6 +55,13 @@ export const WRITE_SESSION_DELAY_MS = 100;
  * therefore reads the split back, polling every SPLIT_VERIFY_INTERVAL_MS, and refuses to report
  * success if it has not appeared within this bound. A local SQLite write, so milliseconds in
  * practice; the bound only decides how long a genuinely lost write takes to be reported.
+ *
+ * #494: the poll runs inside the drain under ACTUAL_OP_TIMEOUT_MS, which races the callback rather
+ * than cancelling it. So the effective bound is min(this, ACTUAL_OP_TIMEOUT_MS / 2), counted from
+ * the start of the operation; an op timeout of 0 (disabled) leaves this bound alone. The cap is
+ * cooperative: one read already in flight at the deadline can still outlive the op timeout if that
+ * single read takes longer than the remaining half. Separately, the pre-flight read's retry backoff
+ * (200ms then 400ms) can by itself exceed an op timeout under 600ms; that is outside the poll.
  */
 export const SPLIT_VERIFY_TIMEOUT_MS = 2000;
 export const SPLIT_VERIFY_INTERVAL_MS = 25;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "actual-mcp-server",
   "displayName": "Actual MCP Server",
-  "version": "0.22.25",
+  "version": "0.22.28",
   "engines": {
     "node": ">=22.0.0",
     "npm": ">=10.0.0"