@2kw/ai-mcp-server 6.3.0-dev.13 → 6.3.0-dev.131

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

package/dist/tools/prompts.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) {
     // ── prompts ─────────────────────────────────────────────────────────────
     server.tool("2kw_list_prompts", "List org prompts with optional name/type filter and pagination.", {
@@ -74,23 +75,23 @@ export function register(server, client) {
             };
         }
     });
-    server.tool("2kw_update_prompt", "Update prompt metadata (name, description, type).", {
+    server.tool("2kw_update_prompt", "Update prompt metadata (name, description, type). Omitted fields keep their current values (the tool reads the prompt first).", {
         promptId: z.string(),
         name: z.string().optional(),
         description: z.string().optional(),
         type: z.enum(["TEXT", "CHAT"]).optional(),
     }, async (params) => {
         try {
-            const body = {};
-            if (params.name !== undefined)
-                body.name = params.name;
-            if (params.description !== undefined)
-                body.description = params.description;
-            if (params.type !== undefined)
-                body.type = params.type;
+            assertNameNotBlank(params.name);
+            // PUT /v1/prompts/{id} replaces the whole prompt, so an omitted field would be stored as null.
+            const { data: current } = await client.GET("/v1/prompts/{id}", {
+                params: { path: { id: params.promptId } },
+            });
+            if (!current)
+                throw new Error(`Prompt ${params.promptId} could not be read.`);
             const { data } = await client.PUT("/v1/prompts/{id}", {
                 params: { path: { id: params.promptId } },
-                body: body,
+                body: overlay(current, { name: params.name, description: params.description, type: params.type }),
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(data, null, 2) }],

package/dist/tools/schemas.js

@@ -85,20 +85,27 @@ export function register(server, client) {
         }
     });
     // ── update_schema ───────────────────────────────────────────────────────
-    server.tool("2kw_update_schema", "Update an existing schema.", {
+    server.tool("2kw_update_schema", "Update an existing schema. Omitted fields keep their current values (the tool reads the schema first).", {
         schemaId: z.string().describe("The schema ID"),
         name: z.string().optional().describe("New schema name"),
         description: z.string().optional().describe("New schema description"),
     }, async ({ schemaId, name, description }) => {
         try {
-            const body = {};
-            if (name !== undefined)
-                body.name = name;
-            if (description !== undefined)
-                body.description = description;
+            if (name !== undefined && !name.trim())
+                throw new Error("name must not be empty.");
+            // PUT /v1/schemas/{id} replaces the whole schema, so an omitted field would be stored as null.
+            if (name === undefined || description === undefined) {
+                const { data: current } = await client.GET("/v1/schemas/{id}", {
+                    params: { path: { id: schemaId } },
+                });
+                if (!current)
+                    throw new Error(`Schema ${schemaId} could not be read.`);
+                name ??= current.name;
+                description ??= current.description;
+            }
             const { data } = await client.PUT("/v1/schemas/{id}", {
                 params: { path: { id: schemaId } },
-                body: body,
+                body: { name, description },
             });
             return {
                 content: [{ type: "text", text: JSON.stringify(data, null, 2) }],

package/dist/tools/tracing.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { formatErrorForMcp } from "../errors.js";
 export function register(server, client) {
     // ── settings ────────────────────────────────────────────────────────────
-    server.tool("2kw_get_tracing_settings", "Return the org's tracing settings (includePrompts / includeCompletions). These control whether raw prompt and completion content are persisted on ingested spans. Defaults are false for both.", {}, async () => {
+    server.tool("2kw_get_tracing_settings", "Return the org's tracing settings: includePrompts / includeCompletions (whether raw prompt and completion content are persisted on ingested spans; false by default) and trace retention: retentionDays (the org's choice, null = follow the plan), planRetentionDays and effectiveRetentionDays.", {}, async () => {
         try {
             const { data } = await client.GET("/v1/tracing/settings");
             return {
@@ -16,7 +16,7 @@ export function register(server, client) {
             };
         }
     });
-    server.tool("2kw_update_tracing_settings", "Update the org's tracing settings. Admin-only. Omit a field to leave it at its current value — the tool reads the current setting first and merges.", {
+    server.tool("2kw_update_tracing_settings", "Update the org's tracing settings. Admin-only. Omit a field to leave it at its current value — the tool reads the current setting first and merges. Shortening retentionDays deletes older traces at the next daily sweep.", {
         includePrompts: z
             .boolean()
             .optional()
@@ -25,12 +25,20 @@ export function register(server, client) {
             .boolean()
             .optional()
             .describe("Retain completion content on ingested spans (default false)"),
+        retentionDays: z
+            .number()
+            .int()
+            .min(1)
+            .nullable()
+            .optional()
+            .describe("Trace retention in days, at most the plan's limit (planRetentionDays). null follows the plan. Shortening deletes older traces at the next daily sweep."),
     }, async (params) => {
         try {
             const { data: current } = await client.GET("/v1/tracing/settings");
             const merged = {
                 includePrompts: params.includePrompts ?? current?.includePrompts ?? false,
                 includeCompletions: params.includeCompletions ?? current?.includeCompletions ?? false,
+                retentionDays: params.retentionDays !== undefined ? params.retentionDays : (current?.retentionDays ?? null),
             };
             const { data } = await client.PUT("/v1/tracing/settings", {
                 body: merged,
@@ -121,8 +129,12 @@ export function register(server, client) {
         }
     });
     // ── sessions ────────────────────────────────────────────────────────────
-    server.tool("2kw_list_trace_sessions", "List sessions (spans grouped by an exporter-stamped session id) in the org, with turn/error counts, duration, tokens and cost. Optional free-text search across session id and name, and a start-time range.", {
+    server.tool("2kw_list_trace_sessions", "List sessions (spans grouped by an exporter-stamped session id) in the org, with turn/error counts, duration, tokens and cost. Optional free-text search across session id and name, an exact session id match, and a start-time range. Each line starts with the session's own id, which 2kw_get_trace_session takes.", {
         search: z.string().optional().describe("Free-text search across session id and name"),
+        sessionId: z
+            .string()
+            .optional()
+            .describe("Exact match on the session.id the exporter stamped (slashes allowed)"),
         from: z.string().optional().describe("Start of time range (ISO-8601)"),
         to: z.string().optional().describe("End of time range (ISO-8601)"),
         page: z.number().int().min(0).optional().describe("Page index (0-based)"),
@@ -133,6 +145,7 @@ export function register(server, client) {
                 params: {
                     query: {
                         search: params.search,
+                        sessionId: params.sessionId,
                         from: params.from,
                         to: params.to,
                         page: params.page ?? 0,
@@ -145,7 +158,7 @@ export function register(server, client) {
                 const services = Array.isArray(s.sourceServices)
                     ? s.sourceServices.join(", ")
                     : "";
-                return `- ${s.sessionId} ${s.name ?? "(unnamed)"} · ${s.durationMs}ms · ${s.turnCount} turns · ${s.errorCount} errors · ${services}`;
+                return `- ${s.id} ${s.sessionId} ${s.name ?? "(unnamed)"} · ${s.durationMs}ms · ${s.turnCount} turns · ${s.errorCount} errors · ${services}`;
             });
             return {
                 content: [
@@ -163,12 +176,12 @@ export function register(server, client) {
             };
         }
     });
-    server.tool("2kw_get_trace_session", "Get every span recorded under a session, flat and sorted by start time — reconstruct the conversation chronologically. The id is the external session id stamped by the exporter.", {
-        sessionId: z.string().describe("Session id"),
+    server.tool("2kw_get_trace_session", "Get every span recorded under a session, flat and sorted by start time — reconstruct the conversation chronologically. The id is the session's own id from 2kw_list_trace_sessions; to find a session by the session id the exporter stamped, use that tool's sessionId filter.", {
+        id: z.string().describe("Session id, as 2kw_list_trace_sessions lists it"),
     }, async (params) => {
         try {
-            const { data } = await client.GET("/v1/traces/sessions/{sessionId}", {
-                params: { path: { sessionId: params.sessionId } },
+            const { data } = await client.GET("/v1/traces/sessions/{id}", {
+                params: { path: { id: params.id } },
             });
             return {
                 content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai-mcp-server",
-  "version": "6.3.0-dev.13",
+  "version": "6.3.0-dev.131",
   "description": "MCP server for 2kw.ai — EU-hosted AI platform: OpenAI-compatible LLM gateway, schema-driven document extraction, transcription, agents with a knowledge base, and cost observability. 158 tools for Claude Code, Cursor, and Windsurf.",
   "mcpName": "ai.2kw/mcp-server",
   "keywords": [
@@ -41,6 +41,10 @@
     "check:generated": "tsx openapi/scripts/check-generated.ts",
     "fix:generated": "tsx openapi/scripts/check-generated.ts --write",
     "check:coverage": "tsx ../cli/openapi/scripts/check-coverage.ts",
+    "docs:tools": "tsx scripts/tool-docs.ts",
+    "check:tool-docs": "tsx scripts/tool-docs.ts --check",
+    "sync:connect-pause": "tsx scripts/sync-connect-pause.ts",
+    "check:connect-pause": "tsx scripts/sync-connect-pause.ts --check",
     "test": "tsx --test tests/*.test.ts",
     "typecheck": "tsc --noEmit"
   },