@dfm-fi/agent 0.2.1967 → 0.2.1969

package/dist/api-client.d.ts

@@ -22,6 +22,8 @@ import type { VaultListResponse, VaultDetailResponse, ZapV2Status, ZapV2PrepareR
 export declare class DfmApiClient {
     private readonly session;
     private readonly baseUrl;
+    /** Keyless writes that have not returned a result yet: base → the key their retry must reuse. */
+    private readonly unansweredOps;
     constructor(config: AgentConfig, session: SiwsSession);
     private publicRequest;
     private authRequest;

package/dist/api-client.js

@@ -37,11 +37,15 @@ function stableStringify(value) {
     return `{${entries.join(',')}}`;
 }
 /**
- * The deterministic operation id for ONE keyless write (A7): same tool + same
- * args → same id, so a retry after a LOST response names the first attempt
- * instead of executing twice. This is what "the same logical operation" means
- * here — a genuinely NEW write with byte-identical args is deliberately
- * treated as a retry; change an argument to make a new operation.
+ * The operation's identity for ONE keyless write (A7): same tool + same args.
+ * It is only the BASE of the idempotency key — `executeViaOperatingWallet`
+ * adds a per-operation nonce, reused only while the previous identical call
+ * has not returned a result (a lost response, a timeout, an error): that is a
+ * retry, and the server collapses it. Once a call returns, the next identical
+ * call is a NEW operation — pinning the key to the args alone made the server
+ * replay a 24 h-old result to state-dependent tools (`rebalance_to_targets`
+ * said "already converged" on a fund 10 % off target; a second identical
+ * deposit would have returned the first one's signature) — #109.
  */
 function operatingOperationKey(tool, args) {
     const digest = createHash('sha256').update(`${tool}\n${stableStringify(args)}`).digest('hex');
@@ -49,9 +53,13 @@ function operatingOperationKey(tool, args) {
 }
 /** Launch-surface label (`launchedVia: 'mcp'` on the API side) — never a credential. */
 const CLIENT_HEADERS = dfmClientHeaders();
+/** How long an unanswered keyless write keeps its key for a retry. */
+const OPERATION_RETRY_WINDOW_MS = 30 * 60_000;
 export class DfmApiClient {
     session;
     baseUrl;
+    /** Keyless writes that have not returned a result yet: base → the key their retry must reuse. */
+    unansweredOps = new Map();
     constructor(config, session) {
         this.session = session;
         this.baseUrl = config.apiUrl;
@@ -403,19 +411,31 @@ export class DfmApiClient {
      * executing a second time (the two-vaults-two-fees bug, A7).
      */
     async executeViaOperatingWallet(tool, args) {
+        const base = operatingOperationKey(tool, args);
+        const now = Date.now();
+        let op = this.unansweredOps.get(base);
+        if (!op || now - op.at > OPERATION_RETRY_WINDOW_MS) {
+            op = { key: `${base}-${randomUUID().slice(0, 8)}`, at: now };
+            this.unansweredOps.set(base, op);
+        }
         const first = await this.authRequest('/agent/operating/execute', {
             method: 'POST',
             body: JSON.stringify({ tool, args }),
-            idempotencyKey: operatingOperationKey(tool, args),
+            idempotencyKey: op.key,
         });
         // Finished inside the server's inline window — the shape this method has
-        // always returned.
-        if (!('jobId' in first))
+        // always returned. A result came back, so the next identical call is new.
+        if (!('jobId' in first)) {
+            this.unansweredOps.delete(base);
             return first;
+        }
         // 202: the write outlives the gateway timeout and is still running. This is
         // the ONLY correct response to that — retrying the POST would execute the
-        // write a SECOND time (a duplicate vault, the creation fee paid twice).
-        return this.pollOperatingJob(first.jobId);
+        // write a SECOND time (a duplicate vault, the creation fee paid twice). A
+        // poll that throws (failed, or still running) leaves the key for the retry.
+        const done = await this.pollOperatingJob(first.jobId);
+        this.unansweredOps.delete(base);
+        return done;
     }
     /**
      * Poll a 202'd write to completion.

package/dist/config.js

@@ -6,7 +6,7 @@
  *     operator from a file path (`DFM_AGENT_KEYPAIR_PATH`) or an env-injected
  *     secret (`DFM_AGENT_KEYPAIR_JSON`). The keypair is NEVER passed through the
  *     MCP protocol, tool arguments, or tool results, and is NEVER logged.
- *   - The protocol wallet (`9GjE…`) must NOT be used here. The agent signs with
+ *   - The protocol wallet must NOT be used here. The agent signs with
  *     a throwaway test wallet funded with a few dollars of USDC.
  *   - All real-money WRITE tools (deposit / redeem) are GATED behind
  *     `DFM_AGENT_WRITE_ENABLED=true` and default OFF.

package/dist/mcp-server.js

@@ -61,6 +61,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 import { z } from 'zod';
 import { loadConfig } from './config.js';
+import { leanTokenRows, MAX_TOKEN_LIMIT } from './token-search.js';
 import { SiwsSession } from './session.js';
 import { DfmApiClient } from './api-client.js';
 import { isKeylessMode, executeAppWalletWrite, KEYLESS_SETUP_HINT, } from './keyless.js';
@@ -317,9 +318,13 @@ server.registerTool('discover_tokens', {
         'way to obtain a mint address: never type one from memory, and always ' +
         'resolve a pasted one before using it — tickers collide and impersonation ' +
         'is routine. DECIMALS ARE NOT COSMETIC: every onchain amount is raw ' +
-        'integer units, and a 6-decimal token differs from a 9-decimal one by 1000x.',
+        'integer units, and a 6-decimal token differs from a 9-decimal one by 1000x. ' +
+        'Returns the top `limit` matches (default 10, max 50) as lean rows, with ' +
+        '`basketEligibility` — a token missing from the results may simply not be ' +
+        'holdable by a fund (e.g. wSOL, or Token-2022 with non-allowlisted extensions).',
     inputSchema: {
         query: z.string().min(1).max(64),
+        limit: z.number().int().min(1).max(MAX_TOKEN_LIMIT).optional(),
         assetClass: z
             .string()
             .optional()
@@ -333,9 +338,9 @@ server.registerTool('discover_tokens', {
             'fun (pump.fun) | stable | ybt (yield-bearing) | rwa (tokenized real-world assets)'),
     },
     annotations: { readOnlyHint: true, openWorldHint: true },
-}, async ({ query, assetClass }) => {
+}, async ({ query, assetClass, limit }) => {
     try {
-        return text(await api.searchTokens(query, assetClass));
+        return text(leanTokenRows(await api.searchTokens(query, assetClass), limit));
     }
     catch (e) {
         return errText(`discover_tokens failed: ${e.message}`);

package/dist/owner-tx-verify.js

@@ -12,10 +12,10 @@
  *            the app wallet, source = its input-mint ATA, destination = its
  *            output-mint ATA, input amount = the requested amount, slippage ≤
  *            the requested slippage, platform fee ≤ 20 bps to none or DFM's
- *            (9GjE) ATA of either mint, and a quoted output that — after its
+ *            (PROTOCOL_WALLET) ATA of either mint, and a quoted output that — after its
  *            own slippage — is at least what an INDEPENDENT Jupiter quote
  *            (fetched by the MCP, never via DFM) gives after the requested
- *            slippage, minus 0.5% drift · at most one SOL transfer to 9GjE ≤
+ *            slippage, minus 0.5% drift · at most one SOL transfer to PROTOCOL_WALLET ≤
  *            0.05 SOL, and only when the route carries no token fee ·
  *            ComputeBudget: ≤ 1 unit limit (≤ 1.4M), ≤ 1 unit price with a
  *            total priority fee ≤ 0.001 SOL, heap frame; nothing else.

package/dist/token-search.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `discover_tokens` output shaping (#109): `/assets/search` answers ~100 rows of
+ * full Jupiter metadata (90–117 KB per query) — more than an MCP host can put in
+ * context, so the one legitimate way to get a mint fell back to a file. The
+ * agent needs the identity, the safety signals and whether a fund may hold it.
+ */
+export declare const DEFAULT_TOKEN_LIMIT = 10;
+export declare const MAX_TOKEN_LIMIT = 50;
+export declare function leanTokenRows(rows: unknown, limit?: number): unknown;
+//# sourceMappingURL=token-search.d.ts.map

package/dist/token-search.js

@@ -0,0 +1,27 @@
+/**
+ * `discover_tokens` output shaping (#109): `/assets/search` answers ~100 rows of
+ * full Jupiter metadata (90–117 KB per query) — more than an MCP host can put in
+ * context, so the one legitimate way to get a mint fell back to a file. The
+ * agent needs the identity, the safety signals and whether a fund may hold it.
+ */
+export const DEFAULT_TOKEN_LIMIT = 10;
+export const MAX_TOKEN_LIMIT = 50;
+const LEAN_FIELDS = [
+    'mint', 'symbol', 'name', 'decimals', 'isVerified', 'assetClass', 'isToken2022',
+    'liquidityUsd', 'mcap', 'organicScoreLabel', 'basketEligibility', 'eligibilityReason',
+];
+export function leanTokenRows(rows, limit = DEFAULT_TOKEN_LIMIT) {
+    if (!Array.isArray(rows))
+        return rows;
+    const n = Math.min(Math.max(1, Math.floor(limit)), MAX_TOKEN_LIMIT);
+    const out = rows.slice(0, n).map((r) => {
+        const row = r;
+        const lean = {};
+        for (const k of LEAN_FIELDS)
+            if (row[k] !== undefined)
+                lean[k] = row[k];
+        return lean;
+    });
+    return { results: out, shown: out.length, total: rows.length };
+}
+//# sourceMappingURL=token-search.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfm-fi/agent",
-  "version": "0.2.1967",
+  "version": "0.2.1969",
   "description": "DFM v2 MCP server — drive the full fund launch → deposit → redeem (+ manage) lifecycle from an AI agent against the live API.",
   "homepage": "https://app.dfm.finance/docs/agent",
   "mcpName": "io.github.DFM-Finance/dfm-agent",
@@ -55,7 +55,7 @@
     "lint": "eslint .",
     "example:read": "tsx src/examples/list-and-status.ts",
     "example:lifecycle": "tsx src/examples/launch-deposit-redeem.ts",
-    "test": "npm run build && node scripts/smoke-signing.mjs && node scripts/smoke-signing-v1.mjs &&node scripts/smoke-cli.mjs && node scripts/smoke-keyless.mjs && node scripts/smoke-zap-options.mjs && tsx src/who-pays.test.ts && tsx src/wallet-identity.test.ts && tsx src/money-path.test.ts && tsx src/control-flow.test.ts && tsx src/create-flow.metadata.test.ts && tsx src/manager-flow.reconfigure.test.ts && tsx src/recovery-flow.deadleg.test.ts && tsx src/zap-v2-flow.pending.test.ts && tsx src/mcp-server.confirm-gate.test.ts && tsx src/app-wallet-owner.test.ts && tsx src/onboarding.test.ts && tsx src/default-avatar.test.ts && tsx src/client-header.test.ts && tsx src/owner-actions.test.ts && tsx src/owner-rebalance.test.ts"
+    "test": "npm run build && node scripts/smoke-signing.mjs && node scripts/smoke-signing-v1.mjs &&node scripts/smoke-cli.mjs && node scripts/smoke-keyless.mjs && node scripts/smoke-zap-options.mjs && tsx src/who-pays.test.ts && tsx src/wallet-identity.test.ts && tsx src/money-path.test.ts && tsx src/control-flow.test.ts && tsx src/create-flow.metadata.test.ts && tsx src/manager-flow.reconfigure.test.ts && tsx src/recovery-flow.deadleg.test.ts && tsx src/zap-v2-flow.pending.test.ts && tsx src/mcp-server.confirm-gate.test.ts && tsx src/app-wallet-owner.test.ts && tsx src/onboarding.test.ts && tsx src/default-avatar.test.ts && tsx src/client-header.test.ts && tsx src/owner-actions.test.ts && tsx src/owner-rebalance.test.ts && tsx src/token-search.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",