@oneshot-agent/mcp-server 0.32.0 → 0.34.0

package/README.md

@@ -102,7 +102,7 @@ Read tools (inbox, SMS inbox, notifications, balance, browser profiles) return p
 ## Remote (hosted)
 
 Clients that run in someone else's cloud (Grok Bot, hosted runners) cannot spawn this
-server and must not hold a wallet key. For them, OneShot hosts the same 73 tools over
+server and must not hold a wallet key. For them, OneShot hosts the same 81 tools over
 Streamable HTTP at **`https://win.oneshotagent.com/mcp`**, authenticated with an
 **agent access token** and billed to the agent's credit balance:
 
@@ -125,6 +125,18 @@ instead of the wallet variables for a credits-only session on your own machine.
 
 ## Available Tools
 
+### Soul Hunt
+
+| Tool | Description |
+|------|-------------|
+| `oneshot_hunt_list` | List active or collected Soul Hunts. Free. |
+| `oneshot_hunt_status` | Detailed status, rounds and timeline for a specific hunt. Free. |
+| `oneshot_hunt_predict` | Submit a prediction for a hunt. Debits a stake from your balance. Paid, and requires a wallet session — Soul Hunt enforces a wallet-signed write proof that an access-token/OAuth session cannot produce. |
+| `oneshot_hunt_collection` | View the souls you have captured. Free. |
+| `oneshot_hunt_leaderboard` | Public predictor leaderboard. Free. |
+
+Soul Hunt is a separate service (`api.soulhunt.ai`) from the main OneShot API; the wallet session's `X-Agent-ID`/`x-agent-proof` carry over, but the OneShot bearer token never does.
+
 ### Communication
 
 | Tool | Description |

package/dist/index.js

@@ -50,7 +50,7 @@ async function main() {
     const agent = await initAgent();
     const server = new Server({
         name: "oneshot-mcp",
-        version: "0.32.0", // keep in sync with package.json; guarded by version.test.ts
+        version: "0.34.0", // keep in sync with package.json; guarded by version.test.ts
     }, {
         capabilities: {
             tools: {},

package/dist/tools/analytics.js

@@ -25,7 +25,7 @@ export const receiptsListTool = {
         type: "object",
         properties: {
             period: { type: "number", description: "Lookback window in days" },
-            category: { type: "string", description: "Filter by tool category" },
+            category: { type: "string", enum: ["data", "verification", "communication", "commerce", "infrastructure", "agent_to_agent"], description: "Filter by receipt category" },
             limit: { type: "number", description: "Max receipts to return (1-100, default 50)" },
             offset: { type: "number", description: "Pagination offset" },
             since: { type: "string", description: "Lower bound on created_at (ISO 8601). Page back to older receipts." },
@@ -72,6 +72,10 @@ export async function handleRocs(agent, args) {
     return agent.rocs({ period: args.period });
 }
 export async function handleReceiptsList(agent, args) {
+    // Pass `category` through as received — an unrecognized value must still
+    // reach the API and get its 400 invalid_category response (#1078), not be
+    // silently dropped here into an unfiltered list. The cast only satisfies
+    // the SDK's compile-time enum narrowing; the API validates at runtime.
     return agent.receiptsList({
         period: args.period,
         category: args.category,

package/dist/tools/annotations.js

@@ -6,6 +6,11 @@ const OPEN = true;
 const OWN = false;
 const DESTRUCTIVE = true;
 export const TOOL_ANNOTATIONS = {
+    oneshot_hunt_list: read("List Soul Hunts", OPEN),
+    oneshot_hunt_status: read("Get Soul Hunt Status", OPEN),
+    oneshot_hunt_predict: write("Predict Soul Hunt", OPEN),
+    oneshot_hunt_collection: read("List Collected Souls", OWN),
+    oneshot_hunt_leaderboard: read("Soul Hunt Leaderboard", OPEN),
     oneshot_email: write("Send email", OPEN),
     oneshot_voice: write("Place a phone call", OPEN),
     oneshot_sms: write("Send a text message", OPEN),
@@ -57,7 +62,10 @@ export const TOOL_ANNOTATIONS = {
     oneshot_linkedin_sync: write("Sync LinkedIn messages", OPEN), // paid; imports history into the account
     oneshot_linkedin_conversations: read("List LinkedIn conversations", OWN),
     oneshot_linkedin_messages: read("Read LinkedIn messages", OWN),
-    oneshot_linkedin_reply: write("Send a LinkedIn message", OPEN),
+    oneshot_linkedin_reply: write("Reply in a LinkedIn conversation", OPEN),
+    oneshot_linkedin_message: write("Message a LinkedIn connection", OPEN),
+    oneshot_linkedin_invitation: read("Check a LinkedIn invitation", OWN),
+    oneshot_linkedin_invitations: read("List LinkedIn invitations", OWN),
     oneshot_linkedin_invite: write("Send a LinkedIn invitation", OPEN),
     oneshot_linkedin_withdraw_invitation: write("Withdraw a LinkedIn invitation", OPEN, DESTRUCTIVE),
     oneshot_linkedin_view_profile: write("View a LinkedIn profile", OPEN), // notify=true is visible to the person

package/dist/tools/approvals.js

@@ -71,7 +71,7 @@ export async function handleApprovalCancel(agent, args) {
 }
 export const actionPolicyGetTool = {
     name: "oneshot_action_policy",
-    description: "Read-only: this agent's action policy — which email/SMS/voice/commerce calls run, are denied, or need a human approval " +
+    description: "Read-only: this agent's action policy — which side-effect calls (email, SMS, voice, commerce, physical mail, LinkedIn actions, builds, browser tasks) run, are denied, or need a human approval " +
         "(rules, approver channel, timeout). The policy is set by the operator from a wallet session and cannot be changed from here. Free.",
     inputSchema: { type: "object", properties: {} },
 };

package/dist/tools/email.js

@@ -1,6 +1,7 @@
 export const emailTool = {
     name: "oneshot_email",
-    description: "Send an email. Supports HTML body, attachments, and threaded replies (set reply_to_email_id to an inbound email id from oneshot_inbox_list/oneshot_inbox_get). Paid tool — quote provided before payment.",
+    description: "Send an email. Supports HTML body, attachments, and threaded replies (set reply_to_email_id to an inbound email id from oneshot_inbox_list/oneshot_inbox_get). Paid tool — quote provided before payment.\n\n" +
+        "Sending requires a domain the agent owns. A fresh account has none — call oneshot_list_domains first to see what's already owned. If there is no usable domain, pass from_domain with a new domain to register it. A call with a new from_domain only quotes — nothing is charged — and returns status 'confirmation_required' with the exact cost (registrar price + a service fee, plus a mailbox fee if mailbox_mode is 'mailbox') and a quote_id. Tell the user that exact computed number, never a guessed or approximate one, and only once they say to proceed, call this again with the same arguments and confirm_new_domain set to that quote_id: that registers the domain, charges exactly the quoted total (the stored quote is used, there is no re-quote), and sends the email in one call. The workspace balance must cover it, or the call fails with insufficient_credits.",
     inputSchema: {
         type: "object",
         properties: {
@@ -22,7 +23,7 @@ export const emailTool = {
             },
             from_domain: {
                 type: "string",
-                description: "Domain to send from (must be one you own). Omit both from_domain and from_mailbox to rotate across your warmed domains — the chosen address comes back on the quote.",
+                description: "Domain to send from. If you already own it, pass it to pin that domain. If you don't, pass a new domain here to register it — a call with a new from_domain only quotes (status 'confirmation_required' with a quote_id, nothing charged); repeat the call with confirm_new_domain set to that quote_id to register it, charge exactly the quoted registration + service fee (and a mailbox fee if mailbox_mode is 'mailbox'), and send. Only confirm once the user has seen that amount and asked to proceed. Omit both from_domain and from_mailbox to rotate across your warmed domains — the chosen address comes back on the result. Call oneshot_list_domains first to see what you already own.",
             },
             from_mailbox: {
                 type: "string",
@@ -54,6 +55,10 @@ export const emailTool = {
                 type: "string",
                 description: "Only when retrying a call the action policy held: the approval_id from the approval_required error, once a human approved it. The call then runs once.",
             },
+            confirm_new_domain: {
+                type: "string",
+                description: "The quote_id from a 'confirmation_required' result, and nothing else. A call with a from_domain you don't own yet always stops before charging and returns that result with the exact total. Only after showing that total to the user and getting their go-ahead, call this again with the same arguments and confirm_new_domain set to the quote_id: the domain is registered, exactly that quote's total is charged, and the email is sent in that one call. Passing true never charges; it only quotes again. A wrong, expired or already-used quote id is rejected by the server without charge: drop it and call again without confirm_new_domain for a fresh quote.",
+            },
         },
         required: ["body"],
     },
@@ -70,5 +75,7 @@ export async function handleEmail(agent, args) {
         mailbox_mode: args.mailbox_mode,
         attachments: args.attachments,
         approvalId: args.approval_id,
+        // Only the quote id confirms; `true` or anything else is not a confirmation.
+        confirmNewDomain: typeof args.confirm_new_domain === "string" ? args.confirm_new_domain : undefined,
     });
 }

package/dist/tools/hunt.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { OneShot } from "@oneshot-agent/sdk";
+export declare const huntListTool: Tool;
+export declare const huntStatusTool: Tool;
+export declare const huntPredictTool: Tool;
+export declare const huntCollectionTool: Tool;
+export declare const huntLeaderboardTool: Tool;
+export declare function handleHuntList(agent: OneShot, args: Record<string, unknown>): Promise<any>;
+export declare function handleHuntStatus(agent: OneShot, args: Record<string, unknown>): Promise<any>;
+export declare function handleHuntPredict(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").HuntQuote>;
+export declare function handleHuntCollection(agent: OneShot, args: Record<string, unknown>): Promise<any[]>;
+export declare function handleHuntLeaderboard(agent: OneShot, args: Record<string, unknown>): Promise<any>;

package/dist/tools/hunt.js

@@ -0,0 +1,76 @@
+export const huntListTool = {
+    name: "oneshot_hunt_list",
+    description: "List active or collected Soul Hunts. Free.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            status: { type: "string", description: "Hunt status ('active', 'captured', 'expired', etc.)", default: "active" },
+            limit: { type: "number", default: 20 },
+            offset: { type: "number", default: 0 },
+        },
+    },
+};
+export const huntStatusTool = {
+    name: "oneshot_hunt_status",
+    description: "Get detailed status, rounds, and timeline for a specific Soul Hunt. Free.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            hunt_id: { type: "string", description: "Hunt ID or Soul Slug" },
+        },
+        required: ["hunt_id"],
+    },
+};
+export const huntPredictTool = {
+    name: "oneshot_hunt_predict",
+    description: "Submit a prediction for a Soul Hunt. Debits a stake (USDC) from your balance based on the round tier. Paid.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            hunt_id: { type: "string", description: "Hunt ID or Soul Slug" },
+            predicted_tool: { type: "string", description: "The exact tool the soul will use next (e.g., 'research', 'email_send')" },
+            predicted_action: { type: "string", description: "What the soul will do with the tool (max 500 chars)" },
+            predicted_motivation: { type: "string", description: "Why the soul will do this, based on its objective (max 500 chars)" },
+        },
+        required: ["hunt_id", "predicted_tool", "predicted_action", "predicted_motivation"],
+    },
+};
+export const huntCollectionTool = {
+    name: "oneshot_hunt_collection",
+    description: "View the souls you have successfully captured. Free.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+};
+export const huntLeaderboardTool = {
+    name: "oneshot_hunt_leaderboard",
+    description: "Get the public predictor leaderboard. Free.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            period: { type: "string", description: "Time period ('all', 'month', 'week')", default: "all" },
+            sort: { type: "string", description: "Sort column ('captures', 'score', 'earned')", default: "captures" },
+            limit: { type: "number", default: 25 },
+            offset: { type: "number", default: 0 },
+        },
+    },
+};
+// MCP clients may send explicit nulls for optional fields; map null to
+// undefined so the SDK's defaults apply instead of serializing "null".
+const opt = (v) => (v === null ? undefined : v);
+export async function handleHuntList(agent, args) {
+    return agent.hunts.list(opt(args.status), opt(args.limit), opt(args.offset));
+}
+export async function handleHuntStatus(agent, args) {
+    return agent.hunts.status(args.hunt_id);
+}
+export async function handleHuntPredict(agent, args) {
+    return agent.hunts.predict(args.hunt_id, args.predicted_tool, args.predicted_action, args.predicted_motivation);
+}
+export async function handleHuntCollection(agent, args) {
+    return agent.hunts.collection();
+}
+export async function handleHuntLeaderboard(agent, args) {
+    return agent.hunts.leaderboard(opt(args.period), opt(args.sort), opt(args.limit), opt(args.offset));
+}

package/dist/tools/index.js

@@ -19,9 +19,10 @@ import { deepResearchPersonTool, socialProfilesTool, articleSearchTool, personNe
 import { companySearchTool, enrichCompanyTool, handleCompanySearch, handleEnrichCompany } from "./company.js";
 import { localSearchTool, localResolveTool, handleLocalSearch, handleLocalResolve } from "./local.js";
 import { govSolicitationsTool, handleGovSolicitations } from "./gov.js";
-import { linkedinConnectTool, linkedinAccountsTool, linkedinSyncTool, linkedinConversationsTool, linkedinMessagesTool, linkedinReplyTool, linkedinViewProfileTool, linkedinReactTool, linkedinInviteTool, linkedinWithdrawInvitationTool, handleLinkedinConnect, handleLinkedinAccounts, handleLinkedinSync, handleLinkedinConversations, handleLinkedinMessages, handleLinkedinReply, handleLinkedinViewProfile, handleLinkedinReact, handleLinkedinInvite, handleLinkedinWithdrawInvitation, } from "./linkedin.js";
+import { linkedinConnectTool, linkedinAccountsTool, linkedinSyncTool, linkedinConversationsTool, linkedinMessagesTool, linkedinReplyTool, linkedinViewProfileTool, linkedinReactTool, linkedinInviteTool, linkedinWithdrawInvitationTool, linkedinMessageTool, linkedinInvitationTool, linkedinInvitationsTool, handleLinkedinConnect, handleLinkedinAccounts, handleLinkedinSync, handleLinkedinConversations, handleLinkedinMessages, handleLinkedinReply, handleLinkedinViewProfile, handleLinkedinReact, handleLinkedinInvite, handleLinkedinWithdrawInvitation, handleLinkedinMessage, handleLinkedinInvitation, handleLinkedinInvitations, } from "./linkedin.js";
 import { computeTool, computeStatusTool, computeTasksTool, computeCancelTool, computeRespondTool, computePauseTool, computeResumeTool, computeFundTool, handleCompute, handleComputeStatus, handleComputeTasks, handleComputeCancel, handleComputeRespond, handleComputePause, handleComputeResume, handleComputeFund } from "./compute.js";
 import { listDomainsTool, pauseDomainTool, resumeDomainTool, handleListDomains, handlePauseDomain, handleResumeDomain } from "./domains.js";
+import { huntListTool, huntStatusTool, huntPredictTool, huntCollectionTool, huntLeaderboardTool, handleHuntList, handleHuntStatus, handleHuntPredict, handleHuntCollection, handleHuntLeaderboard } from "./hunt.js";
 import { TOOL_ANNOTATIONS } from "./annotations.js";
 import { spendBreakdownTool, rocsTool, rocsByGoalTool, receiptsListTool, tagReceiptValueTool, handleSpendBreakdown, handleRocs, handleRocsByGoal, handleReceiptsList, handleTagReceiptValue } from "./analytics.js";
 const toolDefinitions = [
@@ -78,11 +79,17 @@ const toolDefinitions = [
     linkedinMessagesTool,
     linkedinReplyTool,
     linkedinInviteTool, linkedinWithdrawInvitationTool,
+    linkedinMessageTool, linkedinInvitationTool, linkedinInvitationsTool,
     linkedinViewProfileTool,
     linkedinReactTool,
     listDomainsTool,
     pauseDomainTool,
     resumeDomainTool,
+    huntListTool,
+    huntStatusTool,
+    huntPredictTool,
+    huntCollectionTool,
+    huntLeaderboardTool,
     spendBreakdownTool,
     rocsTool,
     rocsByGoalTool,
@@ -161,11 +168,19 @@ const handlers = {
     "oneshot_linkedin_reply": handleLinkedinReply,
     "oneshot_linkedin_invite": handleLinkedinInvite,
     "oneshot_linkedin_withdraw_invitation": handleLinkedinWithdrawInvitation,
+    "oneshot_linkedin_message": handleLinkedinMessage,
+    "oneshot_linkedin_invitation": handleLinkedinInvitation,
+    "oneshot_linkedin_invitations": handleLinkedinInvitations,
     "oneshot_linkedin_view_profile": handleLinkedinViewProfile,
     "oneshot_linkedin_react": handleLinkedinReact,
     "oneshot_list_domains": handleListDomains,
     "oneshot_pause_domain": handlePauseDomain,
     "oneshot_resume_domain": handleResumeDomain,
+    "oneshot_hunt_list": handleHuntList,
+    "oneshot_hunt_status": handleHuntStatus,
+    "oneshot_hunt_predict": handleHuntPredict,
+    "oneshot_hunt_collection": handleHuntCollection,
+    "oneshot_hunt_leaderboard": handleHuntLeaderboard,
     "oneshot_spend_breakdown": handleSpendBreakdown,
     "oneshot_return_on_spend": handleRocs,
     "oneshot_return_on_spend_by_goal": handleRocsByGoal,
@@ -235,6 +250,36 @@ export function structuredToolError(error) {
             };
         case "PaymentError":
             return { error: "payment_failed", message: e.message, reason: e.reason };
+        case "ToolError": {
+            // Every 4xx the SDK doesn't recognize as one of the typed errors above
+            // (budget/credits/payment) lands here as a plain ToolError, and its
+            // `message` is the generic "Tool request failed" — the API's actual
+            // `error`/`reason`/`message` body only survives in `responseBody`
+            // (issue #1070). Parse it so the model sees e.g. `no_sending_domain`
+            // instead of a dead end. Only these four bounded, validated fields are
+            // ever surfaced — never the raw body, which could carry anything.
+            const bodyText = typeof e.responseBody === "string" ? e.responseBody : undefined;
+            let body;
+            if (bodyText) {
+                try {
+                    const parsed = JSON.parse(bodyText);
+                    if (parsed && typeof parsed === "object" && typeof parsed.error === "string")
+                        body = parsed;
+                }
+                catch {
+                    // Malformed/non-JSON body: fall through to the generic prose fallback.
+                }
+            }
+            if (!body)
+                return undefined;
+            const status = typeof e.statusCode === "number" ? e.statusCode : undefined;
+            return {
+                error: body.error,
+                ...(typeof body.reason === "string" ? { reason: body.reason } : {}),
+                message: typeof body.message === "string" ? body.message : e.message,
+                ...(status !== undefined ? { status } : {}),
+            };
+        }
         default:
             return undefined;
     }

package/dist/tools/linkedin.d.ts

@@ -30,3 +30,11 @@ export declare const linkedinInviteTool: Tool;
 export declare function handleLinkedinInvite(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInInviteResult>;
 export declare const linkedinWithdrawInvitationTool: Tool;
 export declare function handleLinkedinWithdrawInvitation(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInWithdrawInvitationResult>;
+export declare const linkedinMessageTool: Tool;
+export declare function handleLinkedinMessage(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInMessageResult>;
+export declare const linkedinInvitationTool: Tool;
+export declare function handleLinkedinInvitation(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInInvitation>;
+export declare const linkedinInvitationsTool: Tool;
+export declare function handleLinkedinInvitations(agent: OneShot, args: Record<string, unknown>): Promise<{
+    invitations: import("@oneshot-agent/sdk").LinkedInInvitation[];
+}>;

package/dist/tools/linkedin.js

@@ -215,3 +215,64 @@ export async function handleLinkedinWithdrawInvitation(agent, args) {
     return agent.linkedinWithdrawInvitation({ accountId: args.account_id, invitationId: args.invitation_id,
         memo: args.memo, idempotencyKey: args.idempotency_key });
 }
+export const linkedinMessageTool = {
+    name: "oneshot_linkedin_message",
+    description: "Message a first-degree LinkedIn connection through a connected account that granted 'reply': into the 1:1 conversation the account already has with them, or a new one. Use it once an invitation is accepted, or for a connection the account has never messaged. Returns conversation_id. The human's account sends it; a message LinkedIn accepted cannot be recalled. Shares the reply daily cap (default 50); sends are paced. A failed send with not_connected (invite them first) or rate_limited means defer, not give up. An Idempotency-Key is generated automatically so a retry never double-sends. Paid tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            profile: { type: "string", description: "The connection: a linkedin.com/in/<slug> URL, a slug or a profile id, as oneshot_linkedin_invite takes (required)" },
+            text: { type: "string", description: "Message text, 1-4000 characters (required)" },
+            memo: { type: "string", description: "Why this message is being sent (audit trail)" },
+            idempotency_key: { type: "string", description: "Optional caller-supplied key; reuse it to safely retry the same send" },
+        },
+        required: ["account_id", "profile", "text"],
+    },
+};
+export async function handleLinkedinMessage(agent, args) {
+    return agent.linkedinMessage({
+        accountId: args.account_id,
+        profile: args.profile,
+        text: args.text,
+        memo: args.memo,
+        idempotencyKey: args.idempotency_key,
+    });
+}
+export const linkedinInvitationTool = {
+    name: "oneshot_linkedin_invitation",
+    description: "Status of one invitation sent with oneshot_linkedin_invite: pending, accepted (with accepted_at), withdrawn, declined_or_unknown or not_sent. Reads accepted as soon as the person is a connection, without a message being exchanged. Free tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            invitation_id: { type: "string", description: "invitation_id returned by oneshot_linkedin_invite (required)" },
+        },
+        required: ["account_id", "invitation_id"],
+    },
+};
+export async function handleLinkedinInvitation(agent, args) {
+    return agent.linkedinInvitation({ accountId: args.account_id, invitationId: args.invitation_id });
+}
+export const linkedinInvitationsTool = {
+    name: "oneshot_linkedin_invitations",
+    description: "List invitations sent with oneshot_linkedin_invite for a connected account, most recently changed first. Filter by status; poll with changed_since to learn which were accepted. Free tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            status: { type: "string", enum: ["pending", "accepted", "withdrawn", "declined_or_unknown", "not_sent"] },
+            changed_since: { type: "string", description: "ISO time: only invitations whose status changed after this" },
+            limit: { type: "number", description: "1-100, default 50" },
+        },
+        required: ["account_id"],
+    },
+};
+export async function handleLinkedinInvitations(agent, args) {
+    return agent.linkedinInvitations({
+        accountId: args.account_id,
+        status: args.status,
+        changedSince: args.changed_since,
+        limit: args.limit,
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oneshot-agent/mcp-server",
-  "version": "0.32.0",
-  "description": "MCP server for OneShot - 73 tools for AI agents",
+  "version": "0.34.0",
+  "description": "MCP server for OneShot - 81 tools for AI agents",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit --incremental false"
   },
   "keywords": [
     "mcp",
@@ -25,7 +26,7 @@
   "dependencies": {
     "@coinbase/cdp-sdk": "1.45.0",
     "@modelcontextprotocol/sdk": "1.27.1",
-    "@oneshot-agent/sdk": "^0.46.0",
+    "@oneshot-agent/sdk": "^0.48.0",
     "zod": "3.25.76"
   },
   "devDependencies": {
@@ -39,5 +40,19 @@
     "dist",
     "bin",
     "README.md"
-  ]
+  ],
+  "nx": {
+    "targets": {
+      "build": {
+        "cache": true,
+        "inputs": [
+          "default",
+          "^default"
+        ],
+        "outputs": [
+          "{projectRoot}/dist"
+        ]
+      }
+    }
+  }
 }