@2kw/ai-mcp-server 6.3.0-dev.14 → 6.3.0-dev.153

package/dist/tools/ai-gateway.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { formatErrorForMcp } from "../errors.js";
+import { buildRunEnvelope, chatUrlFor, MODE_RULE, modeItem } from "../lib/agent-run.js";
 /**
  * The `model` value for an agent run: `agent/<ref>[@<label>]`, plus `#<model>` when the
  * request switches to another entry of the version's `models` list (#626, spec #591 §4.1).
@@ -92,7 +93,7 @@ export function register(server, client) {
         }
     });
     // ── create_response ─────────────────────────────────────────────────────
-    server.tool("2kw_create_response", "Send a request through Backbone's OpenAI-compatible OpenResponses endpoint (POST /v1/responses). Model format: 'provider/model' for a direct gateway call via `model`, or use `agent` to invoke a stored agent by id or name (optionally 'ref@label', e.g. 'support-bot@latest'). With `agent`, `agentModel` runs this one request on another model from the agent version's `models` list. The reply ends with the model that answered. Always non-streaming.", {
+    server.tool("2kw_create_response", "Send a request through Backbone's OpenAI-compatible OpenResponses endpoint (POST /v1/responses). Model format: 'provider/model' for a direct gateway call via `model`, or use `agent` to invoke a stored agent by id or name (optionally 'ref@label', e.g. 'support-bot@latest'). With `agent`, `agentModel` runs this one request on another model from the agent version's `models` list. With `agent`, the reply is the run envelope as JSON (status, text, tool calls, pending approvals, response id, next step) followed by the model that answered; answer an approval pause with 2kw_decide_agent_approvals. A run paused on a relayed (client-side) tool call comes back with status requires_tool_output and `pendingToolCalls`; answer it with 2kw_decide_agent_approvals `outputs`. A run that needs the user's own sign-in to a connector pauses with status requires_tool_output and `pendingConnections` (label, host, reason): no tool here can answer that; tell the user to connect it in chat.2kw.ai → Connectors, as the envelope's `next` says. Always non-streaming. " + MODE_RULE, {
         input: z.string().min(1).describe("The input text (sent as a single user message)"),
         agent: z
             .string()
@@ -108,7 +109,11 @@ export function register(server, client) {
             .optional()
             .describe("Model identifier in 'provider/model' format. Mutually exclusive with `agent`."),
         conversation: z.string().optional().describe("Conversation ID this response belongs to"),
-    }, async ({ input, agent, agentModel, model, conversation }) => {
+        mode: z
+            .enum(["plan", "ask", "auto"])
+            .optional()
+            .describe("Only with `agent`: the conversation mode for this and later turns (plan, ask or auto). Only on the user's explicit request."),
+    }, async ({ input, agent, agentModel, model, conversation, mode }) => {
         try {
             if (agent && model) {
                 throw new Error("Use either `agent` or `model`, not both.");
@@ -122,13 +127,16 @@ export function register(server, client) {
             if (agentModel !== undefined && agent?.includes("#")) {
                 throw new Error("Give the model switch once: either 'ref#model' in `agent` or `agentModel`.");
             }
+            if (mode !== undefined && !agent) {
+                throw new Error("`mode` applies to agent runs; it needs `agent`.");
+            }
             const resolvedModel = agentModelReference(agent, agentModel) ?? model;
             const body = {
                 model: resolvedModel,
-                // The wire `input` field also accepts a bare string (shorthand for
-                // a single user message; see ResponseItemInputDeserializer), which
-                // the generated type does not model.
-                input,
+                // Without `mode` the wire `input` is the bare string (shorthand for one user message; see
+                // ResponseItemInputDeserializer). With it, the backbone:mode item follows the message (#656);
+                // that literal item array is what the cast below is for.
+                input: mode ? [{ type: "message", role: "user", content: input }, modeItem(mode)] : input,
                 stream: false,
                 ...(conversation !== undefined && { conversation }),
             };
@@ -137,6 +145,17 @@ export function register(server, client) {
                 body: body,
             });
             const result = data;
+            if (agent) {
+                // The reference the run used, so the envelope's `next` keeps its label and model (D11).
+                const agentRef = agentModel !== undefined ? `${agent}#${agentModel}` : agent;
+                const envelope = buildRunEnvelope(result, agentRef, chatUrlFor(client._config?.baseUrl));
+                const content = [{ type: "text", text: JSON.stringify(envelope, null, 2) }];
+                // The echoed model is 'agent/<name>@<version>', plus '#<model>' when the request switched it (#591).
+                if (typeof result.model === "string") {
+                    content.push({ type: "text", text: `[model: ${result.model}]` });
+                }
+                return { content };
+            }
             const parts = [];
             const output = result.output;
             for (const item of output ?? []) {
@@ -162,11 +181,6 @@ export function register(server, client) {
             if (parts.length === 0) {
                 parts.push({ type: "text", text: JSON.stringify(result, null, 2) });
             }
-            // The response echoes the model that answered: for an agent run
-            // 'agent/<name>@<version>', plus '#<model>' when the request switched it (#591).
-            if (agent && typeof result.model === "string") {
-                parts.push({ type: "text", text: `[model: ${result.model}]` });
-            }
             return { content: parts };
         }
         catch (error) {

package/dist/tools/conversations.js

@@ -134,6 +134,32 @@ export function register(server, client) {
             };
         }
     });
+    // ── cancel_conversation_turn ─────────────────────────────────────────────
+    server.tool("2kw_cancel_conversation_turn", "Ask a running turn of a conversation to stop. turnId is the value the client sent as the Backbone-Turn-Id header on the responses call. The stop is accepted, not confirmed: the turn's own response reports status cancelled, or completed when the stop arrived too late.", {
+        conversationId: z.string().describe("The conversation ID"),
+        turnId: z
+            .string()
+            .regex(/^[A-Za-z0-9_-]{1,64}$/)
+            .describe("The turn id from the Backbone-Turn-Id header: 1-64 characters of A-Z, a-z, 0-9, '_' or '-'"),
+    }, async ({ conversationId, turnId }) => {
+        try {
+            await client.POST("/v1/conversations/{conversationId}/cancel", {
+                params: { path: { conversationId } },
+                body: { turn_id: turnId },
+            });
+            return {
+                content: [
+                    { type: "text", text: `Stop requested for turn ${turnId} of conversation ${conversationId}.` },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── list_conversation_items ──────────────────────────────────────────────
     server.tool("2kw_list_conversation_items", "Fetch a conversation's items in replay order, oldest first.", { conversationId: z.string().describe("The conversation ID") }, async ({ conversationId }) => {
         try {

package/dist/tools/datasets.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { formatErrorForMcp } from "../errors.js";
+import { assertNameNotBlank, overlay } from "../lib/overlay.js";
 async function resolveLatestVersionId(client, datasetId) {
     const { data } = await client.GET("/v1/datasets/{id}/versions/latest", { params: { path: { id: datasetId } } });
     const versionId = data?.id;
@@ -104,7 +105,7 @@ export function register(server, client) {
         }
     });
     // ── update_dataset ─────────────────────────────────────────────
-    server.tool("2kw_update_dataset", "Update an existing dataset's details.", {
+    server.tool("2kw_update_dataset", "Update an existing dataset's details. Omitted fields keep their current values (the tool reads the dataset first).", {
         datasetId: z.string().describe("The dataset ID"),
         name: z.string().optional().describe("New name"),
         description: z.string().optional().describe("New description"),
@@ -114,22 +115,16 @@ export function register(server, client) {
         metadata: z.unknown().optional().describe("Arbitrary metadata (JSON object)"),
     }, async ({ datasetId, name, description, type, inputSchema, expectedOutputSchema, metadata }) => {
         try {
-            const body = {};
-            if (name !== undefined)
-                body.name = name;
-            if (description !== undefined)
-                body.description = description;
-            if (type !== undefined)
-                body.type = type;
-            if (inputSchema !== undefined)
-                body.inputSchema = inputSchema;
-            if (expectedOutputSchema !== undefined)
-                body.expectedOutputSchema = expectedOutputSchema;
-            if (metadata !== undefined)
-                body.metadata = metadata;
+            assertNameNotBlank(name);
+            // PUT /v1/datasets/{id} replaces the whole dataset, so an omitted field would be stored as null.
+            const { data: current } = await client.GET("/v1/datasets/{id}", {
+                params: { path: { id: datasetId } },
+            });
+            if (!current)
+                throw new Error(`Dataset ${datasetId} could not be read.`);
             const { data } = await client.PUT("/v1/datasets/{id}", {
                 params: { path: { id: datasetId } },
-                body: body,
+                body: overlay(current, { name, description, type, inputSchema, expectedOutputSchema, metadata }),
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(data, null, 2) }],

package/dist/tools/experiments.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { formatErrorForMcp } from "../errors.js";
+import { assertNameNotBlank, overlay } from "../lib/overlay.js";
 export function register(server, client) {
     // ── list_experiments ────────────────────────────────────────────
     server.tool("2kw_list_experiments", "List experiments in the organization with optional search, status filter, and pagination.", {
@@ -99,7 +100,7 @@ export function register(server, client) {
         }
     });
     // ── update_experiment ───────────────────────────────────────────
-    server.tool("2kw_update_experiment", "Update an existing experiment's details.", {
+    server.tool("2kw_update_experiment", "Update an existing experiment's details. Omitted fields keep their current values (the tool reads the experiment first).", {
         experimentId: z.string().describe("The experiment ID"),
         name: z.string().optional().describe("New name"),
         description: z.string().optional().describe("New description"),
@@ -108,20 +109,16 @@ export function register(server, client) {
         metadata: z.unknown().optional().describe("Arbitrary metadata (JSON object)"),
     }, async ({ experimentId, name, description, type, datasetVersionId, metadata }) => {
         try {
-            const body = {};
-            if (name !== undefined)
-                body.name = name;
-            if (description !== undefined)
-                body.description = description;
-            if (type !== undefined)
-                body.type = type;
-            if (datasetVersionId !== undefined)
-                body.datasetVersionId = datasetVersionId;
-            if (metadata !== undefined)
-                body.metadata = metadata;
+            assertNameNotBlank(name);
+            // PUT /v1/experiments/{id} replaces the whole experiment, so an omitted field would be stored as null.
+            const { data: current } = await client.GET("/v1/experiments/{id}", {
+                params: { path: { id: experimentId } },
+            });
+            if (!current)
+                throw new Error(`Experiment ${experimentId} could not be read.`);
             const { data } = await client.PUT("/v1/experiments/{id}", {
                 params: { path: { id: experimentId } },
-                body: body,
+                body: overlay(current, { name, description, type, datasetVersionId, metadata }),
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
@@ -157,7 +154,7 @@ export function register(server, client) {
     server.tool("2kw_add_variant", "Add a variant to an experiment with a task type and configuration.", {
         experimentId: z.string().describe("The experiment ID"),
         name: z.string().min(1).describe("Variant name"),
-        taskType: z.string().min(1).describe("Task type (e.g., EXTRACTION, CLASSIFICATION)"),
+        taskType: z.string().min(1).describe("Task type: extraction or agent"),
         configuration: z.unknown().describe("Variant configuration (JSON object)"),
         description: z.string().optional().describe("Variant description"),
         sortOrder: z.number().optional().describe("Sort order for display"),
@@ -210,30 +207,29 @@ export function register(server, client) {
         }
     });
     // ── update_variant ──────────────────────────────────────────────
-    server.tool("2kw_update_variant", "Update an existing variant's details.", {
+    server.tool("2kw_update_variant", "Update an existing variant's details. Omitted fields keep their current values (the tool reads the variant first).", {
         experimentId: z.string().describe("The experiment ID"),
         variantId: z.string().describe("The variant ID"),
         name: z.string().optional().describe("New variant name"),
-        taskType: z.string().optional().describe("New task type"),
+        taskType: z.string().optional().describe("Task type; must equal the variant's current one (it cannot change)"),
         configuration: z.unknown().optional().describe("New variant configuration (JSON object)"),
         description: z.string().optional().describe("New variant description"),
         sortOrder: z.number().optional().describe("New sort order for display"),
     }, async ({ experimentId, variantId, name, taskType, configuration, description, sortOrder }) => {
         try {
-            const body = {};
-            if (name !== undefined)
-                body.name = name;
-            if (taskType !== undefined)
-                body.taskType = taskType;
-            if (configuration !== undefined)
-                body.configuration = configuration;
-            if (description !== undefined)
-                body.description = description;
-            if (sortOrder !== undefined)
-                body.sortOrder = sortOrder;
+            assertNameNotBlank(name);
+            // PUT .../variants/{variantId} writes name, description and configuration as sent, so an
+            // omitted one would be cleared. There is no single-variant GET: read it from the list. The
+            // read's version goes back with the body, so a change made since is refused with 409.
+            const { data: variants } = await client.GET("/v1/experiments/{id}/variants", {
+                params: { path: { id: experimentId } },
+            });
+            const current = variants?.find((v) => v.id === variantId);
+            if (!current)
+                throw new Error(`Variant ${variantId} is not a variant of experiment ${experimentId}.`);
             const { data } = await client.PUT("/v1/experiments/{id}/variants/{variantId}", {
                 params: { path: { id: experimentId, variantId } },
-                body: body,
+                body: overlay(current, { name, taskType, configuration, description, sortOrder }),
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(data, null, 2) }],

package/dist/tools/index.d.ts

@@ -0,0 +1,21 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../client.js";
+export interface ToolDeps {
+    client: ApiClient;
+    baseUrl: string;
+    apiKey: string;
+}
+/**
+ * One tool module. `id` is its file name under src/tools; `title` and `summary` head its table on
+ * the public docs page, which `npm run docs:tools` generates from this list (#1148).
+ */
+export interface ToolGroup {
+    id: string;
+    title: string;
+    summary: string;
+    register(server: McpServer, deps: ToolDeps): void;
+}
+/** Every tool module, in the order the docs page lists them. A new module must be added here. */
+export declare const TOOL_GROUPS: readonly ToolGroup[];
+export declare function registerAllTools(server: McpServer, deps: ToolDeps): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,190 @@
+import * as agents from "./agents.js";
+import * as aiGateway from "./ai-gateway.js";
+import * as analytics from "./analytics.js";
+import * as annotationQueues from "./annotation-queues.js";
+import * as billing from "./billing.js";
+import * as conversations from "./conversations.js";
+import * as conversion from "./conversion.js";
+import * as datasets from "./datasets.js";
+import * as docs from "./docs.js";
+import * as evaluators from "./evaluators.js";
+import * as experiments from "./experiments.js";
+import * as extraction from "./extraction.js";
+import * as files from "./files.js";
+import * as knowledge from "./knowledge.js";
+import * as memory from "./memory.js";
+import * as plugins from "./plugins.js";
+import * as prompts from "./prompts.js";
+import * as providers from "./providers.js";
+import * as schemaLabels from "./schema-labels.js";
+import * as schemaTesting from "./schema-testing.js";
+import * as schemaVersions from "./schema-versions.js";
+import * as schemas from "./schemas.js";
+import * as scores from "./scores.js";
+import * as skills from "./skills.js";
+import * as tracing from "./tracing.js";
+import * as transcription from "./transcription.js";
+/** Every tool module, in the order the docs page lists them. A new module must be added here. */
+export const TOOL_GROUPS = [
+    {
+        id: "ai-gateway",
+        title: "AI Gateway",
+        summary: "Call models through the gateway — chat completions, the Responses endpoint (including stored agents) and the model list.",
+        register: (s, d) => aiGateway.register(s, d.client),
+    },
+    {
+        id: "agents",
+        title: "Agents",
+        summary: "Manage agents, their versions, labels and tool catalogs, and decide a paused run's approvals and relayed tool calls. See [Running agents](#running-agents).",
+        register: (s, d) => agents.register(s, d.client),
+    },
+    {
+        id: "conversations",
+        title: "Conversations",
+        summary: "Create, read, rename and delete conversations, list their items and cancel a running turn.",
+        register: (s, d) => conversations.register(s, d.client),
+    },
+    {
+        id: "memory",
+        title: "Memory",
+        summary: "Read and edit your own agent memory, and see or erase a member's memory as an admin.",
+        register: (s, d) => memory.register(s, d.client),
+    },
+    {
+        id: "knowledge",
+        title: "Knowledge Bases",
+        summary: "Manage knowledge bases and their documents, search them and resolve citations.",
+        register: (s, d) => knowledge.register(s, d.client),
+    },
+    {
+        id: "files",
+        title: "Files",
+        summary: "Upload, list, download and delete files.",
+        register: (s, d) => files.register(s, d.client),
+    },
+    {
+        id: "skills",
+        title: "Skills",
+        summary: "Import, read, resolve and delete skills, with their versions and labels.",
+        register: (s, d) => skills.register(s, d.client),
+    },
+    {
+        id: "plugins",
+        title: "Plugins",
+        summary: "Install, sync, update and remove plugins.",
+        register: (s, d) => plugins.register(s, d.client),
+    },
+    {
+        id: "prompts",
+        title: "Prompts",
+        summary: "Manage prompts, their versions and labels, and resolve, compile or test them.",
+        register: (s, d) => prompts.register(s, d.client),
+    },
+    {
+        id: "schemas",
+        title: "Schemas",
+        summary: "Define extraction schemas within your organization.",
+        register: (s, d) => schemas.register(s, d.client),
+    },
+    {
+        id: "schema-versions",
+        title: "Schema Versions",
+        summary: "Manage versioned snapshots of schema definitions.",
+        register: (s, d) => schemaVersions.register(s, d.client),
+    },
+    {
+        id: "schema-labels",
+        title: "Schema Labels",
+        summary: "Point named labels at schema versions.",
+        register: (s, d) => schemaLabels.register(s, d.client),
+    },
+    {
+        id: "schema-testing",
+        title: "Schema Testing",
+        summary: "Validate schemas and test extractions without persisting data.",
+        register: (s, d) => schemaTesting.register(s, d.client),
+    },
+    {
+        id: "extraction",
+        title: "Extractions",
+        summary: "Extract structured data from text using schemas and AI models.",
+        register: (s, d) => extraction.register(s, d.client),
+    },
+    {
+        id: "conversion",
+        title: "Document Conversion",
+        summary: "Convert documents (PDF, DOCX and more) to Markdown, text, HTML or JSON.",
+        register: (s, d) => conversion.register(s, d.client),
+    },
+    {
+        id: "transcription",
+        title: "Audio Transcription",
+        summary: "Transcribe audio files using AI models.",
+        register: (s, d) => transcription.register(s, d.client),
+    },
+    {
+        id: "datasets",
+        title: "Datasets",
+        summary: "Manage evaluation datasets, their versions and items.",
+        register: (s, d) => datasets.register(s, d.client),
+    },
+    {
+        id: "experiments",
+        title: "Experiments",
+        summary: "Run experiments over datasets, compare variants and track regressions against a baseline.",
+        register: (s, d) => experiments.register(s, d.client),
+    },
+    {
+        id: "evaluators",
+        title: "Evaluators",
+        summary: "List evaluator types and manage evaluator templates.",
+        register: (s, d) => evaluators.register(s, d.client),
+    },
+    {
+        id: "scores",
+        title: "Scores",
+        summary: "Record and list human scores.",
+        register: (s, d) => scores.register(s, d.client),
+    },
+    {
+        id: "annotation-queues",
+        title: "Annotation Queues",
+        summary: "Manage annotation queues and work through their items.",
+        register: (s, d) => annotationQueues.register(s, d.client),
+    },
+    {
+        id: "tracing",
+        title: "Tracing",
+        summary: "Read traces and trace sessions, and change the tracing settings.",
+        register: (s, d) => tracing.register(s, d.client),
+    },
+    {
+        id: "analytics",
+        title: "Analytics",
+        summary: "Usage, error and quality analytics for your organization.",
+        register: (s, d) => analytics.register(s, d.client),
+    },
+    {
+        id: "providers",
+        title: "Providers",
+        summary: "Manage AI providers and list their models.",
+        register: (s, d) => providers.register(s, d.client),
+    },
+    {
+        id: "billing",
+        title: "Billing",
+        summary: "Read your billing tier and limits, and check available budget.",
+        register: (s, d) => billing.register(s, d.client),
+    },
+    {
+        id: "docs",
+        title: "API Documentation",
+        summary: "Browse the backend's OpenAPI documentation by section.",
+        register: (s, d) => docs.register(s, d.client, d.baseUrl, d.apiKey),
+    },
+];
+export function registerAllTools(server, deps) {
+    for (const group of TOOL_GROUPS)
+        group.register(server, deps);
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/knowledge.js

@@ -1,10 +1,42 @@
 import { z } from "zod";
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
-import { BackboneApiError, formatErrorForMcp } from "../errors.js";
+import { formatErrorForMcp } from "../errors.js";
 import { getMimeType } from "../mime.js";
 const ChunkingStrategy = z.enum(["AUTO", "FIXED", "HIERARCHICAL", "CUSTOM"]);
 const DocumentStatus = z.enum(["PENDING", "PARSING", "CHUNKING", "EMBEDDING", "READY", "ERROR"]);
+/** The 29 Postgres text-search configurations the backend's TextSearchLanguage enum accepts (#1249). */
+const TEXT_SEARCH_LANGUAGES = [
+    "arabic",
+    "armenian",
+    "basque",
+    "catalan",
+    "danish",
+    "dutch",
+    "english",
+    "finnish",
+    "french",
+    "german",
+    "greek",
+    "hindi",
+    "hungarian",
+    "indonesian",
+    "irish",
+    "italian",
+    "lithuanian",
+    "nepali",
+    "norwegian",
+    "portuguese",
+    "romanian",
+    "russian",
+    "serbian",
+    "simple",
+    "spanish",
+    "swedish",
+    "tamil",
+    "turkish",
+    "yiddish",
+];
 /**
  * Fields shared by knowledge-base create and update — the backend treats
  * every one of these as mandatory on both requests (name, slug,
@@ -24,6 +56,7 @@ const knowledgeBaseFields = {
     parentChunkSize: z.number().int().min(100).max(8000).optional().describe("Parent chunk size for hierarchical chunking (100-8000), must exceed chunkSize"),
     hybridSearchEnabled: z.boolean().optional().describe("Enable hybrid dense + lexical search"),
     rerankerProviderId: z.string().optional().describe("Provider id used for reranking"),
+    textSearchLanguage: z.enum(TEXT_SEARCH_LANGUAGES).optional().describe("Text-search language for the lexical leg (default simple on create). On update, omit to leave the active and any pending language untouched — resending the current value would cancel a reindex in progress; changing it starts one in the background."),
 };
 function buildKnowledgeBaseBody(params) {
     const body = {
@@ -41,6 +74,7 @@ function buildKnowledgeBaseBody(params) {
         "parentChunkSize",
         "hybridSearchEnabled",
         "rerankerProviderId",
+        "textSearchLanguage",
     ]) {
         if (params[key] !== undefined)
             body[key] = params[key];
@@ -203,29 +237,13 @@ export function register(server, client) {
                 const filename = basename(filePath);
                 formData.append("files", new Blob([buffer], { type: getMimeType(filename) }), filename);
             }
-            const { baseUrl, apiKey } = client._config;
-            const res = await fetch(`${baseUrl}/v1/knowledge-bases/${encodeURIComponent(knowledgeBaseId)}/documents`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${apiKey}` },
-                body: formData,
+            const { data } = await client.POST("/v1/knowledge-bases/{knowledgeBaseId}/documents", {
+                params: { path: { knowledgeBaseId } },
+                // Provide placeholder body for type checking; actual payload comes from bodySerializer
+                body: { files: [] },
+                bodySerializer: () => formData,
             });
-            if (!res.ok) {
-                let body;
-                try {
-                    body = await res.json();
-                }
-                catch {
-                    body = {
-                        error: res.statusText,
-                        message: `HTTP ${res.status}: ${res.statusText}`,
-                        status: res.status,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                throw new BackboneApiError(body);
-            }
-            const data = (await res.json());
-            const lines = data.map((r) => r.error
+            const lines = (data ?? []).map((r) => r.error
                 ? `- ${r.filename}: rejected — ${r.error}`
                 : `- ${r.filename}: accepted, documentId=${r.upload?.document?.id}, versionId=${r.upload?.acceptedVersion?.id}, status=${r.upload?.acceptedVersion?.status}`);
             return {

package/dist/tools/memory.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../client.js";
+/**
+ * Agent memory of organization members (agent memory spec §7.1, §7.4). The "my" tools act on
+ * the API key owner's own memory; the member tools are for ADMIN and OWNER keys and never
+ * show paths or content.
+ */
+export declare function register(server: McpServer, client: ApiClient): void;
+//# sourceMappingURL=memory.d.ts.map

package/dist/tools/memory.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+async function reply(action) {
+    try {
+        const data = await action();
+        return {
+            content: [{ type: "text", text: data === undefined ? "Done." : JSON.stringify(data, null, 2) }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: formatErrorForMcp(error) }], isError: true };
+    }
+}
+const path = z.string().min(1).describe("Memory path, /memories or below, e.g. /memories/preferences.md");
+/**
+ * Agent memory of organization members (agent memory spec §7.1, §7.4). The "my" tools act on
+ * the API key owner's own memory; the member tools are for ADMIN and OWNER keys and never
+ * show paths or content.
+ */
+export function register(server, client) {
+    server.tool("2kw_list_my_memory_files", "List the files in your agent memory (the API key owner's), ordered by path, without content.", {}, async () => reply(async () => (await client.GET("/v1/memories/me/files")).data));
+    server.tool("2kw_read_my_memory_file", "Read one of your agent memory files: the raw content, its version (for ifMatchVersion) and which agent wrote it last.", { path }, async ({ path }) => reply(async () => (await client.GET("/v1/memories/me/file", { params: { query: { path } } })).data));
+    server.tool("2kw_write_my_memory_file", "Create or replace one of your agent memory files with the complete content. Pass ifMatchVersion (the version from 2kw_read_my_memory_file) to refuse the write if the file changed since. Credentials are refused; files are limited to 32 KB.", {
+        path,
+        content: z.string().describe("The complete UTF-8 text content of the file"),
+        ifMatchVersion: z.number().int().min(0).optional().describe("Only replace the file if it still has this version"),
+    }, async ({ path, content, ifMatchVersion }) => reply(async () => (await client.PUT("/v1/memories/me/file", {
+        params: { query: { path } },
+        body: { content },
+        headers: ifMatchVersion === undefined ? undefined : { "If-Match": `"${ifMatchVersion}"` },
+    })).data));
+    server.tool("2kw_delete_my_memory_file", "Delete one of your agent memory files, or a directory with everything below it. Irreversible.", { path }, async ({ path }) => reply(async () => {
+        await client.DELETE("/v1/memories/me/file", { params: { query: { path } } });
+    }));
+    server.tool("2kw_forget_my_memory", "Delete your whole agent memory. Irreversible: confirm with the user before calling.", {}, async () => reply(async () => {
+        await client.DELETE("/v1/memories/me");
+    }));
+    server.tool("2kw_list_member_memory_usage", "Agent memory totals per organization member: file count, total bytes and last write. Never paths or content. Needs an ADMIN or OWNER key.", {}, async () => reply(async () => (await client.GET("/v1/memories/users")).data));
+    server.tool("2kw_erase_member_memory", "Erase one member's whole agent memory in this organization. Irreversible: confirm with the user before calling. Needs an ADMIN or OWNER key.", { userId: z.string().min(1).describe("The member's user id, from 2kw_list_member_memory_usage") }, async ({ userId }) => reply(async () => {
+        await client.DELETE("/v1/memories/users/{userId}", { params: { path: { userId } } });
+    }));
+}
+//# sourceMappingURL=memory.js.map