@withone/mcp 1.2.4 → 1.3.1

package/README.md

@@ -89,6 +89,9 @@ One-click install:
 [![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_One-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=one&config=%7B%22type%22%3A%20%22http%22%2C%20%22url%22%3A%20%22https%3A%2F%2Fmcp.withone.ai%2Fmcp%22%7D)
 [![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_One-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=one&config=%7B%22type%22%3A%20%22http%22%2C%20%22url%22%3A%20%22https%3A%2F%2Fmcp.withone.ai%2Fmcp%22%7D)
 [![Add to Cursor](https://img.shields.io/badge/Cursor-Add_One-000000?style=flat-square)](https://cursor.com/en/install-mcp?name=one&config=eyJ1cmwiOiAiaHR0cHM6Ly9tY3Aud2l0aG9uZS5haS9tY3AifQ==)
+[![Open in Windsurf](https://img.shields.io/badge/Windsurf-Open_One-09B6A2?style=flat-square)](windsurf://windsurf-mcp-registry?serverName=ai.withone/mcp)
+
+The Windsurf link opens One's page in the editor's MCP marketplace, which is served from the official MCP registry where One is published as `ai.withone/mcp`. Windsurf handles the OAuth sign-in itself once you install from that page.
 
 ## Manual Installation
 

package/build/client.js

@@ -9,6 +9,62 @@
 import axios from 'axios';
 import FormData from 'form-data';
 import { fetchPaginatedData, replacePathVariables } from './helpers.js';
+/** Header names that only the server may set on an outgoing request. */
+const RESERVED_HEADER_PREFIX = 'x-one-';
+/**
+ * Drops any caller-supplied header that One itself controls (`x-one-secret`,
+ * `x-one-connection-key`, `x-one-action-id`, ...). Comparison is
+ * case-insensitive because HTTP header names are.
+ */
+export function stripReservedHeaders(headers) {
+    if (!headers)
+        return {};
+    return Object.fromEntries(Object.entries(headers)
+        .filter(([name]) => !name.toLowerCase().startsWith(RESERVED_HEADER_PREFIX))
+        .map(([name, value]) => [name, String(value)]));
+}
+/**
+ * Bounds an upstream error body before it is logged: small payloads pass
+ * through, larger ones are truncated to a string, and an unserializable value
+ * is replaced with a placeholder. Keeps a huge or odd error response from
+ * bloating a single log line.
+ */
+function summarizeErrorData(data) {
+    if (data === undefined || data === null)
+        return undefined;
+    let serialized;
+    try {
+        serialized = typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    catch {
+        return '[unserializable response body]';
+    }
+    const MAX = 1000;
+    return serialized.length <= MAX ? data : `${serialized.slice(0, MAX)}… (${serialized.length} chars, truncated)`;
+}
+/**
+ * A log-safe summary of a failed request. Axios errors carry the full request
+ * config, including the `x-one-secret` header, so they must never be logged
+ * whole. Only the status, the upstream message, the route (query stripped), and
+ * a bounded copy of the response body are kept.
+ */
+export function describeError(error) {
+    if (axios.isAxiosError(error)) {
+        const url = error.config?.url;
+        return {
+            status: error.response?.status,
+            statusText: error.response?.statusText,
+            method: error.config?.method?.toUpperCase(),
+            url: typeof url === 'string' ? url.split('?')[0] : undefined,
+            message: error.message,
+            data: summarizeErrorData(error.response?.data),
+        };
+    }
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message };
+    }
+    return { error: String(error) };
+}
 /**
  * Client for interacting with the One API
  */
@@ -22,6 +78,11 @@ export class OneClient {
     connectors = [];
     isInitialized = false;
     allowedActionsCache = null;
+    // Short-lived cache of fetched action details, keyed by action ID. The
+    // knowledge digest and a follow-up section/toc/full call both need the same
+    // document, so this lets the follow-up reuse it instead of re-fetching.
+    static ACTION_DETAILS_TTL_MS = 5 * 60_000;
+    actionDetailsCache = new Map();
     constructor(optionsOrSecret, baseUrl = "https://api.withone.ai") {
         if (typeof optionsOrSecret === 'string') {
             // Legacy constructor: (secret, baseUrl)
@@ -57,11 +118,11 @@ export class OneClient {
         ]);
         const [connectionsResult, connectorsResult] = results;
         if (connectionsResult.status === 'rejected') {
-            console.error("Failed to fetch connections:", connectionsResult.reason);
+            console.error("Failed to fetch connections:", describeError(connectionsResult.reason));
             this.connections = [];
         }
         if (connectorsResult.status === 'rejected') {
-            console.error("Failed to fetch connectors:", connectorsResult.reason);
+            console.error("Failed to fetch connectors:", describeError(connectorsResult.reason));
             this.connectors = [];
         }
         this.isInitialized = true;
@@ -100,7 +161,7 @@ export class OneClient {
             this.connections = await fetchPaginatedData(url, headers, Object.keys(additionalParams).length > 0 ? additionalParams : undefined);
         }
         catch (error) {
-            console.error("Failed to fetch connections:", error);
+            console.error("Failed to fetch connections:", describeError(error));
             this.connections = [];
             throw error;
         }
@@ -115,7 +176,7 @@ export class OneClient {
             this.connectors = await fetchPaginatedData(url, headers);
         }
         catch (error) {
-            console.error("Failed to fetch connection definitions:", error);
+            console.error("Failed to fetch connection definitions:", describeError(error));
             this.connectors = [];
             throw error;
         }
@@ -157,7 +218,7 @@ export class OneClient {
             return response.data || [];
         }
         catch (error) {
-            console.error("Error searching available actions:", error);
+            console.error("Error searching available actions:", describeError(error));
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to search available actions: ${error.response?.status} ${error.response?.statusText}`);
             }
@@ -174,6 +235,10 @@ export class OneClient {
         if (!actionId?.trim()) {
             throw new Error("Action ID is required");
         }
+        const cached = this.actionDetailsCache.get(actionId);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.details;
+        }
         try {
             const headers = this.generateHeaders();
             const url = `${this.baseUrl}/v1/knowledge`;
@@ -188,10 +253,14 @@ export class OneClient {
             if (actions.length === 0) {
                 throw new Error(`Action with ID ${actionId} not found`);
             }
+            this.actionDetailsCache.set(actionId, {
+                details: actions[0],
+                expiresAt: Date.now() + OneClient.ACTION_DETAILS_TTL_MS
+            });
             return actions[0];
         }
         catch (error) {
-            console.error("Error fetching action details:", error);
+            console.error("Error fetching action details:", describeError(error));
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to fetch action details: ${error.response?.status} ${error.response?.statusText}`);
             }
@@ -219,7 +288,7 @@ export class OneClient {
             };
         }
         catch (error) {
-            console.error("Error fetching action knowledge:", error);
+            console.error("Error fetching action knowledge:", describeError(error));
             throw error;
         }
     }
@@ -254,7 +323,7 @@ export class OneClient {
                 };
             }
             catch (error) {
-                console.error(`Failed to resolve allowed action ${actionId}:`, error);
+                console.error(`Failed to resolve allowed action ${actionId}:`, describeError(error));
                 return null;
             }
         }));
@@ -273,12 +342,21 @@ export class OneClient {
         const action = preloadedAction ?? await this.getActionDetails(actionId);
         const method = action.method;
         const contentType = isFormData ? 'multipart/form-data' : isFormUrlEncoded ? 'application/x-www-form-urlencoded' : 'application/json';
+        // Caller-supplied headers are merged first and may adjust things like
+        // Content-Type, but they can never override One's own routing and auth
+        // headers. Those are applied last, after the connection and action
+        // allowlist checks in index.ts have already passed, so an `x-one-*`
+        // header in `headers` cannot redirect the call to another connection,
+        // action, or secret.
+        // Drop One's default Content-Type (any casing) so the caller's choice,
+        // merged in below, is not clobbered when the auth headers are applied last.
+        const authHeaders = Object.fromEntries(Object.entries(this.generateHeaders()).filter(([name]) => name.toLowerCase() !== 'content-type'));
         const requestHeaders = {
-            ...this.generateHeaders(),
+            'Content-Type': contentType,
+            ...stripReservedHeaders(headers),
+            ...authHeaders,
             'x-one-connection-key': connectionKey,
             'x-one-action-id': action._id,
-            'Content-Type': contentType,
-            ...headers
         };
         const finalActionPath = pathVariables
             ? replacePathVariables(action.path, pathVariables)
@@ -355,7 +433,7 @@ export class OneClient {
             };
         }
         catch (error) {
-            console.error("Error executing passthrough request:", error);
+            console.error("Error executing passthrough request:", describeError(error));
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to execute passthrough request: ${error.response?.status} ${error.response?.statusText}`);
             }

package/build/client.test.js

@@ -0,0 +1,101 @@
+import { describe, it, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { OneClient, stripReservedHeaders, describeError } from './client.js';
+// A passthrough call must never let the caller override One's own routing/auth
+// headers (the scoping bypass), and a failed call must never log the secret.
+const SECRET = 'sk_test_REALSECRET_abc123';
+const ACTION = { _id: 'conn_mod_def::ALLOWED_ACTION', method: 'GET', path: '/v1/things', tags: [] };
+const exec = (extra) => ({
+    platform: 'test',
+    actionId: 'conn_mod_def::ALLOWED_ACTION',
+    connectionKey: 'live::allowed::default::aaaa',
+    ...extra,
+});
+describe("executePassthroughRequest keeps One's headers authoritative", () => {
+    let server;
+    let base = '';
+    let received = [];
+    let failBody = null;
+    before(async () => {
+        server = http.createServer((req, res) => {
+            received.push({ headers: req.headers });
+            if (failBody !== null) {
+                res.writeHead(422, { 'Content-Type': 'application/json' });
+                res.end(failBody);
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+        });
+        await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+        base = `http://127.0.0.1:${server.address().port}`;
+    });
+    after(() => {
+        server.close();
+    });
+    beforeEach(() => {
+        received = [];
+        failBody = null;
+    });
+    it('a caller cannot override the x-one-* routing/auth headers', async () => {
+        const client = new OneClient(SECRET, base);
+        await client.executePassthroughRequest(exec({
+            headers: {
+                'x-one-connection-key': 'live::EXCLUDED::default::zzzz',
+                'X-One-Secret': 'sk_live_stolen',
+                'X-ONE-ACTION-ID': 'conn_mod_def::OTHER',
+                'x-custom-trace': 't-1',
+            },
+        }), ACTION);
+        const h = received[0].headers;
+        assert.equal(h['x-one-connection-key'], 'live::allowed::default::aaaa');
+        assert.equal(h['x-one-secret'], SECRET);
+        assert.equal(h['x-one-action-id'], 'conn_mod_def::ALLOWED_ACTION');
+        assert.equal(h['x-custom-trace'], 't-1', 'a non-reserved custom header still passes through');
+        assert.equal(h['content-type'], 'application/json', 'the default content type is kept');
+    });
+    it('a caller may still set Content-Type, in any casing', async () => {
+        const client = new OneClient(SECRET, base);
+        await client.executePassthroughRequest(exec({ headers: { 'content-type': 'text/plain' } }), ACTION);
+        assert.equal(received[0].headers['content-type'], 'text/plain');
+    });
+    it('a failed call throws with the status, never logs the secret, and bounds the body', async () => {
+        failBody = JSON.stringify({ error: 'upstream said no', padding: 'x'.repeat(2000) });
+        const client = new OneClient(SECRET, base);
+        const logged = [];
+        const original = console.error;
+        console.error = (...args) => {
+            logged.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+        };
+        let message = '';
+        try {
+            await client.executePassthroughRequest(exec({}), ACTION);
+        }
+        catch (error) {
+            message = error.message;
+        }
+        finally {
+            console.error = original;
+        }
+        const log = logged.join('\n');
+        assert.ok(!log.includes(SECRET), 'the secret never reaches the log');
+        assert.ok(log.includes('422') && log.includes('upstream said no'), 'the log still says what failed');
+        assert.ok(log.includes('truncated'), 'a huge upstream body is bounded');
+        assert.ok(message.includes('422'), 'the thrown tool error carries the status');
+    });
+});
+describe('stripReservedHeaders', () => {
+    it('drops x-one-* case-insensitively and stringifies values', () => {
+        assert.deepEqual(stripReservedHeaders({ 'X-One-Secret': 'a', 'x-one-action-id': 'b', Accept: 'x' }), { Accept: 'x' });
+        assert.deepEqual(stripReservedHeaders({ n: 5 }), { n: '5' });
+        assert.deepEqual(stripReservedHeaders(undefined), {});
+    });
+});
+describe('describeError', () => {
+    it('summarizes a plain error to its name and message', () => {
+        const described = describeError(new Error('boom'));
+        assert.equal(described.name, 'Error');
+        assert.equal(described.message, 'boom');
+    });
+});

package/build/helpers.js

@@ -7,6 +7,7 @@
  * @author One
  */
 import axios from 'axios';
+import { parseSections, buildDigest, renderDigestBanner, renderDigestNotice, selectSections, flattenSections, parseSectionFlag, collapseSections, omittedSections, } from './knowledge-sections.js';
 /**
  * Paginates through API results by repeatedly calling a fetch function until all data is retrieved.
  * @param fetchFn - Function that fetches paginated data, takes skip and limit parameters
@@ -60,6 +61,110 @@ export async function fetchPaginatedData(baseUrl, headers, additionalParams) {
     };
     return paginateResults(fetchFn);
 }
+/**
+ * Reduce an action's knowledge document to what the agent asked for, returning
+ * both the text to read and a machine-readable envelope.
+ *
+ * By default a large doc is handed back as a digest (request-building sections
+ * in full, plus a trailer and a `sections` list naming what was omitted); a
+ * small doc is returned whole. `section` selects named section(s), `toc`
+ * returns the full table of contents, and `full` (or `section: "all"`) returns
+ * the document verbatim. Only the digest and full cases carry the API request
+ * guidance, so `wrap` is set for those.
+ *
+ * @param knowledge - The raw knowledge markdown for the action
+ * @param method - The action's HTTP method (echoed into the envelope)
+ * @param platform - The kebab-case platform identifier (for the load-more hint)
+ * @param actionId - The action ID (for the load-more hint)
+ * @param options - `section`/`toc`/`full` select what to return
+ */
+export function buildKnowledgeResponse(knowledge, method, platform, actionId, options = {}) {
+    const doc = parseSections(knowledge);
+    const fullToc = flattenSections(doc.sections).map((s) => ({
+        id: s.id,
+        heading: s.heading,
+        level: s.level,
+        chars: s.chars,
+    }));
+    const sectionNames = parseSectionFlag(options.section);
+    const specificSections = sectionNames.filter((n) => n.toLowerCase() !== 'all');
+    // `full: true`, or a `section` value that is only "all", asks for the whole doc.
+    const wantFull = options.full === true || (sectionNames.length > 0 && specificSections.length === 0);
+    // A specific named section takes precedence over `toc` and `full`.
+    if (specificSections.length > 0) {
+        const picked = selectSections(doc, specificSections);
+        if (!picked.ok) {
+            // Collapse candidates the same way the digest does: a not-found on a
+            // 400-heading doc must not answer with tens of KB of names.
+            const toc = collapseSections(picked.candidates);
+            const listing = toc.sections
+                .map((c) => `${c.heading} [${c.id}] (${c.chars} chars${c.children ? `, +${c.children} nested` : ''})`)
+                .join('\n');
+            const lead = picked.reason === 'ambiguous'
+                ? `Section "${picked.query}" matches several sections; pick one by id or full heading.`
+                : `No section named "${picked.query}". Use one of the names below, or full: true.`;
+            return {
+                wrap: false,
+                text: `${lead}\n\n${listing}`,
+                structured: {
+                    error: lead,
+                    query: picked.query,
+                    reason: picked.reason,
+                    sections: toc.sections,
+                    ...(toc.collapsed ? { sectionsCollapsed: true, sectionCount: picked.candidates.length } : {}),
+                },
+            };
+        }
+        return {
+            wrap: false,
+            text: picked.markdown,
+            structured: {
+                title: doc.title,
+                method,
+                truncated: false,
+                requested: specificSections,
+                resolved: picked.sections.map((s) => ({ id: s.id, heading: s.heading, chars: s.chars })),
+                sectionCount: fullToc.length,
+            },
+        };
+    }
+    if (options.toc) {
+        const listing = fullToc.length
+            ? fullToc.map((t) => `${'  '.repeat(Math.max(0, t.level - 1))}${t.heading} [${t.id}] (${t.chars} chars)`).join('\n')
+            : '(this document has no sections)';
+        return {
+            wrap: false,
+            text: `Table of contents. Load any by name with section: "<id or heading>", or the whole document with full: true.\n\n${listing}`,
+            structured: { title: doc.title, method, chars: doc.chars, sections: fullToc },
+        };
+    }
+    // `full`, and any document small enough to keep whole, are returned verbatim
+    // rather than reconstructed from the parsed tree, so nothing is reformatted.
+    if (wantFull) {
+        return { wrap: true, text: knowledge, structured: { title: doc.title, method, truncated: false } };
+    }
+    const digest = buildDigest(doc);
+    if (!digest.truncated) {
+        return { wrap: true, text: knowledge, structured: { title: doc.title, method, truncated: false } };
+    }
+    const toc = omittedSections(digest);
+    const text = [renderDigestBanner(digest), digest.markdown, renderDigestNotice(digest, platform, actionId)]
+        .filter(Boolean)
+        .join('\n\n');
+    return {
+        wrap: true,
+        text,
+        structured: {
+            title: doc.title,
+            method,
+            truncated: true,
+            omitted: digest.omitted,
+            omittedChars: digest.omittedChars,
+            sections: toc.sections,
+            ...(toc.collapsed ? { sectionsCollapsed: true, sectionCount: digest.sections.length } : {}),
+        },
+    };
+}
 /**
  * Builds action knowledge with API request structure guidance.
  * @param knowledge - The raw knowledge content for the action

package/build/index.js

@@ -11,7 +11,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { OneClient } from './client.js';
-import { buildActionKnowledgeWithGuidance, buildKnowledgeModeGuidance, filterByPermissions, isMethodAllowed, isActionAllowed, computeConnectionAccess, } from './helpers.js';
+import { buildActionKnowledgeWithGuidance, buildKnowledgeModeGuidance, buildKnowledgeResponse, filterByPermissions, isMethodAllowed, isActionAllowed, computeConnectionAccess, } from './helpers.js';
 import { listOneIntegrationsToolConfig, searchOnePlatformActionsToolConfig, getOneActionKnowledgeToolConfig, executeOneActionToolConfig } from './schemas.js';
 const SERVER_NAME = "one-mcp-server";
 const SERVER_VERSION = "1.0.0";
@@ -212,6 +212,11 @@ async function handleGetActionKnowledge(args) {
             }
         }
         if (ONE_KNOWLEDGE_AGENT) {
+            // Knowledge/code-gen mode returns the full document: the appended
+            // Integration Code Guide tells the agent to reproduce the complete
+            // input and output structure, which the digest would defer. Digesting
+            // is for the execute flow below, where the agent only needs to build
+            // one request.
             const details = await oneClient.getActionDetails(actionId);
             const knowledgeWithGuide = buildKnowledgeModeGuidance(details, args.platform, oneClient.getBaseUrl());
             return {
@@ -224,14 +229,22 @@ async function handleGetActionKnowledge(args) {
             };
         }
         const { knowledge, method } = await oneClient.getActionKnowledge(actionId);
-        const knowledgeWithGuidance = buildActionKnowledgeWithGuidance(knowledge, method, oneClient.getBaseUrl(), args.platform, actionId);
+        const response = buildKnowledgeResponse(knowledge, method, args.platform, actionId, {
+            section: args.section,
+            full: args.full,
+            toc: args.toc,
+        });
+        const text = response.wrap
+            ? buildActionKnowledgeWithGuidance(response.text, method, oneClient.getBaseUrl(), args.platform, actionId)
+            : response.text;
         return {
             content: [
                 {
                     type: "text",
-                    text: knowledgeWithGuidance,
+                    text,
                 },
             ],
+            structuredContent: response.structured,
         };
     }
     catch (error) {

package/build/knowledge-response.test.js

@@ -0,0 +1,73 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildKnowledgeResponse } from './helpers.js';
+// Pure: string in, response out. No network, no home-directory access.
+const bigSection = (label) => `## ${label}\n` +
+    Array.from({ length: 120 }, (_, i) => `- ${label} field ${i}: descriptive text adding length to the section body.`).join('\n');
+const LARGE = [
+    '# Send Email',
+    '## Method\nPOST',
+    '## URL\n/gmail/v1/messages/send',
+    '## Headers\n- Authorization: Bearer',
+    '## Request Body\n### Required Request Body Fields\n- to: string\n- subject: string',
+    bigSection('Response Fields'),
+    bigSection('Success Response'),
+    bigSection('Optional Request Body Fields'),
+].join('\n\n');
+const SMALL = '# Tiny\n\n## Method\nGET\n\n## URL\n/x';
+describe('buildKnowledgeResponse', () => {
+    it('digests a large doc: request-building sections in full, omitted ones named in the envelope', () => {
+        const r = buildKnowledgeResponse(LARGE, 'POST', 'gmail', 'act_1', {});
+        assert.equal(r.wrap, true);
+        assert.equal(r.structured.truncated, true);
+        assert.ok(r.structured.omitted >= 1);
+        assert.ok(Array.isArray(r.structured.sections) && r.structured.sections.length >= 1);
+        assert.ok(r.text.includes('**Digest.**'));
+        assert.ok(r.text.includes('get_one_action_knowledge'));
+        // A deferred body is not inlined into the digest text.
+        assert.ok(!r.text.includes('Response Fields field 100'));
+        // No CLI-flag phrasing leaks into agent-visible text.
+        assert.ok(!/--section|one --agent|--full|--toc/.test(r.text));
+    });
+    it('returns the whole table of contents for toc, with no bodies', () => {
+        const r = buildKnowledgeResponse(LARGE, 'POST', 'gmail', 'act_1', { toc: true });
+        assert.equal(r.wrap, false);
+        assert.ok(r.structured.sections.length >= 5);
+        assert.ok(r.text.includes('[response-fields]'));
+        assert.ok(!r.text.includes('Response Fields field 100'));
+    });
+    it('returns a named section with its body and what it resolved to', () => {
+        const r = buildKnowledgeResponse(LARGE, 'POST', 'gmail', 'act_1', { section: 'Response Fields' });
+        assert.equal(r.wrap, false);
+        assert.deepEqual(r.structured.resolved.map((s) => s.heading), ['Response Fields']);
+        assert.ok(r.text.includes('Response Fields field 100'));
+    });
+    it('reports a not-found section with a bounded candidate list', () => {
+        const r = buildKnowledgeResponse(LARGE, 'POST', 'gmail', 'act_1', { section: 'nope' });
+        assert.equal(r.wrap, false);
+        assert.ok(r.structured.error);
+        assert.equal(r.structured.reason, 'not-found');
+        assert.ok(r.structured.sections.length >= 1);
+        assert.ok(r.text.startsWith('No section named "nope"'));
+    });
+    it('treats section: "all" and full: true as the verbatim whole document', () => {
+        for (const opts of [{ section: 'all' }, { full: true }]) {
+            const r = buildKnowledgeResponse(LARGE, 'POST', 'gmail', 'act_1', opts);
+            assert.equal(r.wrap, true);
+            assert.equal(r.text, LARGE);
+            assert.equal(r.structured.truncated, false);
+        }
+    });
+    it('returns a small doc verbatim with no digest', () => {
+        const r = buildKnowledgeResponse(SMALL, 'GET', 'gmail', 'act_1', {});
+        assert.equal(r.wrap, true);
+        assert.equal(r.text, SMALL);
+        assert.equal(r.structured.truncated, false);
+    });
+    it('section wins over full when both are set', () => {
+        const r = buildKnowledgeResponse(LARGE, 'POST', 'gmail', 'act_1', { section: 'Response Fields', full: true });
+        assert.equal(r.wrap, false);
+        assert.notEqual(r.text, LARGE);
+        assert.ok(r.text.includes('Response Fields field 100'));
+    });
+});