@withone/mcp 2.0.0 → 2.1.1

package/README.md

@@ -66,7 +66,7 @@ The server exposes three MCP tools:
 
 ### Finding actions
 
-`find_one_actions` takes one `requests` entry per operation, each a kebab-case `platform` and a short `intent` naming the operation alone (`"send a message to a channel"`, not the message). An optional `task` describes the whole job in general terms, which helps choose between similar actions. For each intent, One's decision model picks the action to use; the answer documents it, sets apart a substitute when the model was unsure, and lists a few alternatives. Large documents come back as a digest; call `find_one_actions` again with `load: [{ action_id, section }]` for a section it left out, `full: true` for the whole document, or `toc: true` for its table of contents. `ONE_ACTION_IDS`, `ONE_PERMISSIONS` and `ONE_CONNECTION_KEYS` apply to every answer: an action they refuse is never offered, and when they refuse the model's pick, the next allowed candidate takes its place.
+`find_one_actions` takes one `requests` entry per operation, each a kebab-case `platform` and a short `intent` naming the operation alone (`"send a message to a channel"`, not the message). A `task` describes the whole job in general terms, and an `ai_model` names the model asking; agents are asked to send both with every find, since the task helps tell similar actions apart. For each intent, One's decision model picks the action to use; the answer documents it, sets apart a substitute when the model was unsure, and lists a few alternatives. Large documents come back as a digest; call `find_one_actions` again with `load: [{ action_id, section }]` for a section it left out, `full: true` for the whole document, or `toc: true` for its table of contents. `ONE_ACTION_IDS`, `ONE_PERMISSIONS` and `ONE_CONNECTION_KEYS` apply to every answer: an action they refuse is never offered, and when they refuse the model's pick, the next allowed candidate takes its place.
 
 Upgrading from 1.x: `search_one_platform_actions` and `get_one_action_knowledge` are removed. `find_one_actions` replaces both.
 

package/build/caller.js

@@ -0,0 +1,28 @@
+/**
+ * How a find names who asked, for One's record of what agents ask
+ * `find_one_actions` (pica-v2 #993).
+ *
+ * `x-one-source: cli` says the call came through One's own local tooling
+ * rather than a script holding the same key; this server reaches One through
+ * the same door as the CLI, and `cli` is the only surface core lets a client
+ * claim. `x-one-agent` names the MCP client that connected, as its
+ * `clientInfo` gave it (`claude-code/2.4.1`), and `x-one-agent-model` the model
+ * the agent says it is running as, which only the agent knows. All three are
+ * declared, never authenticated, and core drops a value it cannot read rather
+ * than refusing the find, so a wrong one can never break it.
+ */
+export const CALLER_SOURCE_HEADER = 'x-one-source';
+export const CALLER_AGENT_HEADER = 'x-one-agent';
+export const CALLER_MODEL_HEADER = 'x-one-agent-model';
+export function callerHeaders(caller = {}) {
+    const headers = { [CALLER_SOURCE_HEADER]: 'cli' };
+    const name = caller.client?.name?.trim();
+    if (name) {
+        const version = caller.client?.version?.trim();
+        headers[CALLER_AGENT_HEADER] = version ? `${name}/${version}` : name;
+    }
+    const model = caller.model?.trim();
+    if (model)
+        headers[CALLER_MODEL_HEADER] = model;
+    return headers;
+}

package/build/caller.test.js

@@ -0,0 +1,17 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { callerHeaders } from './caller.js';
+describe('callerHeaders', () => {
+    it('always names the source, and nothing else when nothing is known', () => {
+        assert.deepEqual(callerHeaders(), { 'x-one-source': 'cli' });
+    });
+    it('names the MCP client with its version, as core reads it', () => {
+        assert.equal(callerHeaders({ client: { name: 'claude-code', version: '2.4.1' } })['x-one-agent'], 'claude-code/2.4.1');
+        assert.equal(callerHeaders({ client: { name: 'cursor' } })['x-one-agent'], 'cursor');
+        assert.equal(callerHeaders({ client: { name: '  ', version: '1.0' } })['x-one-agent'], undefined);
+    });
+    it('names the model only when the agent gave one', () => {
+        assert.equal(callerHeaders({ model: ' claude-sonnet-5 ' })['x-one-agent-model'], 'claude-sonnet-5');
+        assert.equal(callerHeaders({ model: '   ' })['x-one-agent-model'], undefined);
+    });
+});

package/build/client.js

@@ -8,6 +8,7 @@
  */
 import axios from 'axios';
 import FormData from 'form-data';
+import { callerHeaders } from './caller.js';
 import { fetchPaginatedData, replacePathVariables } from './helpers.js';
 /** Header names that only the server may set on an outgoing request. */
 const RESERVED_HEADER_PREFIX = 'x-one-';
@@ -190,12 +191,14 @@ export class OneClient {
      * @param task - The whole task in one line, which helps break ties
      * @param knowledgeAgent - Search the catalog for writing integration code
      *   rather than the one for executing actions
+     * @param caller - The MCP client that connected and the model it named,
+     *   sent so One records who asked
      * @returns One answer per intent, in the order asked
      * @throws {Error} Naming core's reason when it refuses the request
      */
-    async findActions(requests, task, knowledgeAgent) {
+    async findActions(requests, task, knowledgeAgent, caller = {}) {
         try {
-            const response = await axios.post(`${this.baseUrl}/v1/available-actions/find`, { requests, ...(task ? { task } : {}), knowledgeAgent }, { headers: this.generateHeaders() });
+            const response = await axios.post(`${this.baseUrl}/v1/available-actions/find`, { requests, ...(task ? { task } : {}), knowledgeAgent }, { headers: { ...this.generateHeaders(), ...callerHeaders(caller) } });
             return response.data || [];
         }
         catch (error) {

package/build/find.js

@@ -37,7 +37,7 @@ export class FindArgsError extends Error {
  */
 export async function findOneActions(args, deps, settings) {
     if (args.requests && !args.load) {
-        return find(args.requests, args.task, deps, settings);
+        return find(args.requests, args.task, deps, settings, { client: settings.client, model: args.ai_model });
     }
     if (args.load && !args.requests && args.task === undefined) {
         return load(args.load, deps, settings);
@@ -141,12 +141,12 @@ function finish(sections, documented, settings) {
         return body;
     return `${body}\n\n---\n\n${settings.knowledgeAgent ? codeGuideRules() : FIND_EXECUTE_HINT}`;
 }
-async function find(requests, task, deps, settings) {
+async function find(requests, task, deps, settings, caller) {
     if (requests.length === 0 || requests.length > FIND_MAX_INTENTS) {
         throw new FindArgsError(`Send between 1 and ${FIND_MAX_INTENTS} requests.`);
     }
     const reachable = requests.filter((r) => reaches(settings, r.platform));
-    const answers = reachable.length > 0 ? await deps.findActions(reachable, task, settings.knowledgeAgent) : [];
+    const answers = reachable.length > 0 ? await deps.findActions(reachable, task, settings.knowledgeAgent, caller) : [];
     let next = 0;
     const plans = requests.map((intent) => {
         if (!reaches(settings, intent.platform)) {

package/build/find.test.js

@@ -37,10 +37,13 @@ const settings = (overrides = {}) => ({
 /** Core answering `answers` in turn, and raw knowledge per action. */
 function deps(answers, knowledge = {}) {
     const asked = [];
+    const callers = [];
     return {
         asked,
-        async findActions(requests) {
+        callers,
+        async findActions(requests, _task, _knowledgeAgent, caller) {
             asked.push(requests);
+            callers.push(caller);
             return answers.slice(0, requests.length);
         },
         async getActionDetails(id) {
@@ -60,6 +63,11 @@ function deps(answers, knowledge = {}) {
 }
 const intent = [{ platform: 'gmail', intent: 'send an email' }];
 describe('find_one_actions', () => {
+    it('tells core which client and model asked', async () => {
+        const found = deps([answer()]);
+        await findOneActions({ requests: intent, ai_model: 'claude-sonnet-5' }, found, settings({ client: { name: 'claude-code', version: '2.4.1' } }));
+        assert.deepEqual(found.callers, [{ client: { name: 'claude-code', version: '2.4.1' }, model: 'claude-sonnet-5' }]);
+    });
     it('takes requests or load, never both, never neither, and no task with a load', async () => {
         for (const args of [{}, { requests: intent, load: [{ action_id: 'a' }] }, { load: [{ action_id: 'a' }], task: 't' }]) {
             await assert.rejects(findOneActions(args, deps([answer()]), settings()), (e) => e instanceof FindArgsError && e.message === FIND_ARGS_ERROR);

package/build/index.js

@@ -123,6 +123,7 @@ async function handleFindOneActions(args) {
                 ? null
                 : oneClient.getUserConnections().map(c => c.platform),
             baseUrl: oneClient.getBaseUrl(),
+            client: server.server.getClientVersion(),
         });
         return {
             content: [

package/build/schemas.js

@@ -21,14 +21,14 @@ export const findOneActionsInputSchema = {
         platform: z.string().describe('The kebab-case platform identifier (e.g. "gmail", "stripe").'),
         intent: z.string().describe('The operation alone, in a few words (e.g. "send a message to a channel"), without its data: no IDs, names or message text.')
     })).min(1).max(10).optional().describe('What to do, one entry per API operation, on any platforms (1 to 10). Each is the kebab-case platform (e.g. "gmail", "hubspot") and a short intent (e.g. "send an email", "find a contact by email").'),
-    task: z.string().optional().describe('The whole task in one line, in general terms (e.g. "email a report to a contact"): what it does, without names, addresses, IDs or message text. It helps choose between similar actions. Never the chat history. Only with `requests`.'),
+    task: z.string().optional().describe('The whole task in one line, in general terms (e.g. "email a report to a contact"): what it does, without names, addresses, IDs or message text. Send it with every find: it helps tell similar actions apart. Never the chat history. Only with `requests`.'),
     load: z.array(z.object({
         action_id: z.string().describe("The actionId from a find_one_actions answer."),
         section: z.string().optional().describe('Section name(s) to load, comma-separated (e.g. "Response Fields"). Omit, with `full` and `toc` unset, for the digest. In knowledge mode every load returns the whole document, so `section` and `toc` do not narrow it.'),
         full: z.boolean().optional().describe("Load the whole document. Ignored when `section` is set."),
         toc: z.boolean().optional().describe("Load only the table of contents. Ignored when `section` is set.")
     })).min(1).max(10).optional().describe("More documentation for actions already found (1 to 10): a section the digest omitted, the whole document, the table of contents, or an alternative's documentation. Use instead of `requests`."),
-    ai_model: z.string().optional().describe('The AI model you are running as (e.g. "claude-sonnet-5", "gpt-5"), which helps optimize the documentation returned. Optional.')
+    ai_model: z.string().optional().describe('Your model name as you know it (e.g. "claude-sonnet-5", "gpt-5"), recorded with this find. Send it with every find; leave it out only if you do not know which model you are.')
 };
 /**
  * Schema for executing One actions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/mcp",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "A Model Context Protocol Server for One",
   "type": "module",
   "bin": {