@2kw/ai 6.3.0-dev.116 → 6.3.0-dev.122

package/dist/commands/knowledge.js

@@ -47,6 +47,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "Parent chunk size (hierarchical chunking)", parseInt)
         .option("--reranker-provider <id>", "Reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Text-search language for the lexical leg (default simple)")
         .action(async (opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -64,6 +65,7 @@ export function makeKnowledgeCommand() {
                     parentChunkSize: opts.parentChunkSize,
                     rerankerProviderId: opts.rerankerProvider,
                     hybridSearchEnabled: opts.hybridSearch !== undefined ? opts.hybridSearch === "true" : undefined,
+                    textSearchLanguage: opts.textSearchLanguage,
                 },
             });
             formatDetail(data, command);
@@ -83,6 +85,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "New parent chunk size", parseInt)
         .option("--reranker-provider <id>", "New reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Change the text-search language (reindexes in the background); omit to leave it untouched")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -107,6 +110,8 @@ export function makeKnowledgeCommand() {
                 body.rerankerProviderId = opts.rerankerProvider;
             if (opts.hybridSearch !== undefined)
                 body.hybridSearchEnabled = opts.hybridSearch === "true";
+            if (opts.textSearchLanguage)
+                body.textSearchLanguage = opts.textSearchLanguage;
             const { data } = await client.PATCH("/v1/knowledge-bases/{id}", {
                 params: { path: { id } },
                 body: body,

package/dist/lib/agent-run.d.ts

@@ -28,7 +28,8 @@ export interface PendingToolCall {
 /**
  * A connector the run waits for the user to connect, allow or reconnect in chat.2kw.ai: an open
  * `backbone:connector_auth_request` (#807 R12). The caller never answers the connect call; the
- * continuation re-checks access itself.
+ * continuation re-checks access itself. Decoded by `connect-pause.ts` (#1086), whose `id` and
+ * `callId` the envelope does not publish.
  */
 export interface PendingConnection {
     serverLabel: string;

package/dist/lib/agent-run.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import { DEFAULT_CHAT_URL } from "./config.js";
+import { connectCallIds, connectionsPhrase, pendingConnectionsOf } from "./connect-pause.js";
 import { CliUsageError } from "./errors.js";
 export const CONVERSATION_MODES = ["plan", "ask", "auto"];
 /** `--mode` help text, in the words of the embedded chat's mode chip (#655). */
@@ -92,49 +93,9 @@ export function shellQuote(value) {
         return value;
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-/** An open connector consent request; a continuation's projection carries another status. */
-function pendingConnectionsOf(output) {
-    return output
-        .filter((i) => i.type === "backbone:connector_auth_request" && (i.status === undefined || i.status === "in_progress"))
-        .map((i) => ({
-        serverLabel: String(i.server_label),
-        host: String(i.host),
-        reason: String(i.reason),
-        ...(Array.isArray(i.destinations) && i.destinations.length > 0
-            ? { destinations: i.destinations.map((d) => String(d)) }
-            : {}),
-    }));
-}
-/**
- * The call ids a connect pause withholds from the caller: the call each request names, and every
- * `mcp__<label>__connect` call for a pending connector (the model may call it more than once; one
- * request stands for all of them).
- */
-function connectCallIds(output, connections) {
-    const connectNames = new Set(connections.map((c) => `mcp__${c.serverLabel}__connect`));
-    const ids = new Set();
-    for (const item of output) {
-        if (item.type === "backbone:connector_auth_request" && (item.status === undefined || item.status === "in_progress")) {
-            ids.add(String(item.call_id));
-        }
-        else if (item.type === "function_call" && connectNames.has(String(item.name))) {
-            ids.add(String(item.call_id));
-        }
-    }
-    return ids;
-}
-function connectionPhrase(c) {
-    const target = `${c.serverLabel} (${c.host})`;
-    if (c.reason === "allow")
-        return `allow the agent to use ${target}`;
-    if (c.reason === "reconnect")
-        return `reconnect ${target}`;
-    return `connect ${target}`;
-}
 /** "Connect a (h), allow the agent to use b (h) and reconnect c (h)". */
 export function connectionsSentence(connections) {
-    const phrases = connections.map(connectionPhrase);
-    const joined = phrases.length > 1 ? `${phrases.slice(0, -1).join(", ")} and ${phrases.at(-1)}` : phrases[0] ?? "";
+    const joined = connectionsPhrase(connections);
     return joined.charAt(0).toUpperCase() + joined.slice(1);
 }
 /** Joins a connect pause's instruction to the command that continues it; {@link printRunText} breaks the line there. */
@@ -204,8 +165,15 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         reason: typeof i.reason === "string" && i.reason ? i.reason : null,
         preview: i.preview && typeof i.preview === "object" && !Array.isArray(i.preview) ? i.preview : null,
     }));
-    const pendingConnections = pendingConnectionsOf(output);
-    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, pendingConnections)]);
+    // The one decoding rule (#1086): only an open request with its id, call id, label and host.
+    const connectRequests = pendingConnectionsOf(output);
+    const pendingConnections = connectRequests.map(({ serverLabel, host, reason, destinations }) => ({
+        serverLabel,
+        host,
+        reason,
+        ...(destinations ? { destinations } : {}),
+    }));
+    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, connectRequests)]);
     const toolCalls = [];
     const pendingToolCalls = [];
     for (const item of output) {

package/dist/lib/config.d.ts

@@ -52,12 +52,12 @@ export declare const DEFAULT_BASE_URL: string;
  */
 export declare const DEFAULT_AUTH_URL: string;
 export declare function defaultAuthUrlFor(baseUrl: string): string;
-/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
-export declare const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+export { DEFAULT_CHAT_URL } from "./connect-pause.js";
 /**
  * The chat web host that belongs to an API base URL, where a member connects a connector
  * (`<chat>/connectors`). `AI_2KW_CHAT_URL` overrides the mapping, for deployments the map
- * does not know; a trailing slash is dropped so callers can append a path.
+ * does not know; a trailing slash is dropped so callers can append a path. The mapping itself
+ * is `connect-pause.ts`'s {@link chatOriginFor}, shared with the MCP server and n8n (#1086).
  */
 export declare function chatUrlFor(baseUrl: string, env?: NodeJS.ProcessEnv): string;
 declare const store: Conf<BackboneConfigStore>;

package/dist/lib/config.js

@@ -1,6 +1,7 @@
 import Conf from "conf";
 import { readFileSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { chatOriginFor } from "./connect-pause.js";
 /**
  * Fallback base URL when the user has no context, env var, or local config.
  * Override at runtime by setting AI_2KW_DEFAULT_BASE_URL (or the legacy
@@ -36,33 +37,18 @@ export function defaultAuthUrlFor(baseUrl) {
         return DEFAULT_AUTH_URL;
     }
 }
-/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
-export const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
-/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
-const CHAT_URL_BY_API_HOST = {
-    "api.2kw.ai": "https://chat.2kw.ai",
-    "api-dev.2kw.ai": "https://chat-dev.2kw.ai",
-    "backbone.manfred-kunze.dev": "https://chat.2kw.ai",
-    "localhost:8080": "http://localhost:3000",
-    "127.0.0.1:8080": "http://localhost:3000",
-};
+export { DEFAULT_CHAT_URL } from "./connect-pause.js";
 /**
  * The chat web host that belongs to an API base URL, where a member connects a connector
  * (`<chat>/connectors`). `AI_2KW_CHAT_URL` overrides the mapping, for deployments the map
- * does not know; a trailing slash is dropped so callers can append a path.
+ * does not know; a trailing slash is dropped so callers can append a path. The mapping itself
+ * is `connect-pause.ts`'s {@link chatOriginFor}, shared with the MCP server and n8n (#1086).
  */
 export function chatUrlFor(baseUrl, env = process.env) {
     const override = env.AI_2KW_CHAT_URL?.trim();
     if (override)
         return override.replace(/\/+$/, "");
-    try {
-        const host = new URL(baseUrl).host;
-        // hasOwn, as in defaultAuthUrlFor: a host named after an Object.prototype key must not resolve.
-        return Object.hasOwn(CHAT_URL_BY_API_HOST, host) ? CHAT_URL_BY_API_HOST[host] : DEFAULT_CHAT_URL;
-    }
-    catch {
-        return DEFAULT_CHAT_URL;
-    }
+    return chatOriginFor(baseUrl);
 }
 // One-shot flag so we only print the deprecation warning once per process,
 // even if resolveConfig is called multiple times across commands.

package/dist/lib/connect-pause.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The connect pause, decoded one way for every client (#1086, spec §4, D4): an open
+ * `backbone:connector_auth_request` (#807 R12) is a connector the run waits for the user to
+ * connect, allow or reconnect in chat.2kw.ai.
+ *
+ * This file is canonical. `mcp/src/lib/connect-pause.ts` and
+ * `n8n/nodes/TwoKw/operations/connect-pause.ts` are byte copies of it under a header: edit it
+ * here, then run `npm run sync:connect-pause` in mcp/ and `npm run sync-connect-pause` in n8n/.
+ * Its golden fixture, `cli/tests/fixtures/connect-pause-cases.json`, is copied the same way into
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it.
+ *
+ * Plain TypeScript with no imports, no `process`, no Node types and no timers, so n8n's source
+ * scanner and its empty `dependencies` accept the copy. The CLI and the MCP server keep their
+ * `AI_2KW_CHAT_URL` override in their own code, around {@link chatOriginFor}.
+ */
+/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
+export declare const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
+export declare const CHAT_URL_BY_API_HOST: Readonly<Record<string, string>>;
+/**
+ * The chat web host that belongs to an API base URL, where a member connects a connector
+ * (`<chat>/connectors`). An unknown host, an unparsable URL or no URL at all is chat.2kw.ai.
+ */
+export declare function chatOriginFor(baseUrl: unknown): string;
+/** What the user is asked to do: connect, allow the agent, or reconnect. */
+export type ConnectReason = "connect" | "allow" | "reconnect";
+export declare const CONNECT_REASONS: readonly ConnectReason[];
+/**
+ * One open connect request. `id` (`cauth_<call id>`) and `callId` (the first connect call for
+ * this connector) are what a client needs to withhold the connect calls; the CLI and the MCP
+ * server drop both from what they publish.
+ */
+export interface PendingConnection {
+    id: string;
+    callId: string;
+    serverLabel: string;
+    /** The MCP server's host: what the user is asked to connect to. */
+    host: string;
+    reason: ConnectReason;
+    /** The egress difference an allow is asked again for (#807 R9); absent otherwise, never empty. */
+    destinations?: string[];
+}
+/** Enough of a connection to name it in a sentence. */
+export interface ConnectTarget {
+    serverLabel: string;
+    host: string;
+    reason: string;
+}
+/** The synthetic tool a connector's connect pause is raised through (#806). */
+export declare function connectToolName(serverLabel: string): string;
+/**
+ * The connectors a response's `output` still waits on: every `in_progress` connect request whose
+ * id no other-status projection in the same list resolved, one per id, in order. An item without
+ * a non-empty `id`, `call_id`, `server_label` or `host` cannot be acted on and is skipped; a
+ * `reason` outside the three reads as `connect`, the action that always applies; only the string
+ * entries of `destinations` are kept, and none at all omits the field.
+ */
+export declare function pendingConnectionsOf(output: unknown): PendingConnection[];
+/**
+ * The call ids a connect pause withholds from the caller: the call each pending request names;
+ * the own `call_id` of every open connect request, even one {@link pendingConnectionsOf} could not
+ * describe (a missing `server_label` or `host`), since a connect call is the engine's to answer,
+ * never the client's (R7); and every `mcp__<label>__connect` call for a connector in
+ * `connections` (the model may call it more than once; one request stands for all of them).
+ */
+export declare function connectCallIds(output: unknown, connections: readonly Pick<PendingConnection, "callId" | "serverLabel">[]): Set<string>;
+/** "connect erp (erp.example.com)", "allow the agent to use …" or "reconnect …". */
+export declare function connectionPhrase(c: ConnectTarget): string;
+/** "connect a (h), allow the agent to use b (h) and reconnect c (h)"; empty for none. */
+export declare function connectionsPhrase(connections: readonly ConnectTarget[]): string;
+//# sourceMappingURL=connect-pause.d.ts.map

package/dist/lib/connect-pause.js

@@ -0,0 +1,147 @@
+/**
+ * The connect pause, decoded one way for every client (#1086, spec §4, D4): an open
+ * `backbone:connector_auth_request` (#807 R12) is a connector the run waits for the user to
+ * connect, allow or reconnect in chat.2kw.ai.
+ *
+ * This file is canonical. `mcp/src/lib/connect-pause.ts` and
+ * `n8n/nodes/TwoKw/operations/connect-pause.ts` are byte copies of it under a header: edit it
+ * here, then run `npm run sync:connect-pause` in mcp/ and `npm run sync-connect-pause` in n8n/.
+ * Its golden fixture, `cli/tests/fixtures/connect-pause-cases.json`, is copied the same way into
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it.
+ *
+ * Plain TypeScript with no imports, no `process`, no Node types and no timers, so n8n's source
+ * scanner and its empty `dependencies` accept the copy. The CLI and the MCP server keep their
+ * `AI_2KW_CHAT_URL` override in their own code, around {@link chatOriginFor}.
+ */
+/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
+export const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
+export const CHAT_URL_BY_API_HOST = {
+    "api.2kw.ai": "https://chat.2kw.ai",
+    "api-dev.2kw.ai": "https://chat-dev.2kw.ai",
+    "backbone.manfred-kunze.dev": "https://chat.2kw.ai",
+    "localhost:8080": "http://localhost:3000",
+    "127.0.0.1:8080": "http://localhost:3000",
+};
+/**
+ * The chat web host that belongs to an API base URL, where a member connects a connector
+ * (`<chat>/connectors`). An unknown host, an unparsable URL or no URL at all is chat.2kw.ai.
+ */
+export function chatOriginFor(baseUrl) {
+    try {
+        const host = new URL(String(baseUrl ?? "")).host;
+        // hasOwn, not a bare index: a host named after an Object.prototype key must not resolve.
+        return Object.hasOwn(CHAT_URL_BY_API_HOST, host) ? CHAT_URL_BY_API_HOST[host] ?? DEFAULT_CHAT_URL : DEFAULT_CHAT_URL;
+    }
+    catch {
+        return DEFAULT_CHAT_URL;
+    }
+}
+export const CONNECT_REASONS = ["connect", "allow", "reconnect"];
+const CONNECT_REQUEST = "backbone:connector_auth_request";
+function itemsOf(output) {
+    if (!Array.isArray(output))
+        return [];
+    return output.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item));
+}
+function text(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/** The synthetic tool a connector's connect pause is raised through (#806). */
+export function connectToolName(serverLabel) {
+    return `mcp__${serverLabel}__connect`;
+}
+/**
+ * The connectors a response's `output` still waits on: every `in_progress` connect request whose
+ * id no other-status projection in the same list resolved, one per id, in order. An item without
+ * a non-empty `id`, `call_id`, `server_label` or `host` cannot be acted on and is skipped; a
+ * `reason` outside the three reads as `connect`, the action that always applies; only the string
+ * entries of `destinations` are kept, and none at all omits the field.
+ */
+export function pendingConnectionsOf(output) {
+    const items = itemsOf(output);
+    const resolved = new Set();
+    for (const item of items) {
+        const id = text(item.id);
+        if (item.type === CONNECT_REQUEST && id && item.status !== "in_progress")
+            resolved.add(id);
+    }
+    const pending = new Map();
+    for (const item of items) {
+        if (item.type !== CONNECT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        const callId = text(item.call_id);
+        const serverLabel = text(item.server_label);
+        const host = text(item.host);
+        if (!id || !callId || !serverLabel || !host || resolved.has(id) || pending.has(id))
+            continue;
+        const reason = text(item.reason);
+        const destinations = Array.isArray(item.destinations)
+            ? item.destinations.filter((entry) => typeof entry === "string")
+            : [];
+        pending.set(id, {
+            id,
+            callId,
+            serverLabel,
+            host,
+            reason: reason && CONNECT_REASONS.includes(reason) ? reason : "connect",
+            ...(destinations.length > 0 ? { destinations } : {}),
+        });
+    }
+    return [...pending.values()];
+}
+/**
+ * The call ids a connect pause withholds from the caller: the call each pending request names;
+ * the own `call_id` of every open connect request, even one {@link pendingConnectionsOf} could not
+ * describe (a missing `server_label` or `host`), since a connect call is the engine's to answer,
+ * never the client's (R7); and every `mcp__<label>__connect` call for a connector in
+ * `connections` (the model may call it more than once; one request stands for all of them).
+ */
+export function connectCallIds(output, connections) {
+    const names = new Set(connections.map((c) => connectToolName(c.serverLabel)));
+    const ids = new Set(connections.map((c) => c.callId));
+    const items = itemsOf(output);
+    // Every open connect request's own call id is withheld, even one pendingConnectionsOf could
+    // not fully describe (a missing server_label or host): the paired function_call must never be
+    // left for the caller to fabricate an output for (R7).
+    const resolved = new Set();
+    for (const item of items) {
+        const id = text(item.id);
+        if (item.type === CONNECT_REQUEST && id && item.status !== "in_progress")
+            resolved.add(id);
+    }
+    for (const item of items) {
+        if (item.type !== CONNECT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        if (id && resolved.has(id))
+            continue;
+        const callId = text(item.call_id);
+        if (callId)
+            ids.add(callId);
+    }
+    for (const item of items) {
+        const callId = text(item.call_id);
+        if (item.type === "function_call" && callId && typeof item.name === "string" && names.has(item.name))
+            ids.add(callId);
+    }
+    return ids;
+}
+/** "connect erp (erp.example.com)", "allow the agent to use …" or "reconnect …". */
+export function connectionPhrase(c) {
+    const target = `${c.serverLabel} (${c.host})`;
+    if (c.reason === "allow")
+        return `allow the agent to use ${target}`;
+    if (c.reason === "reconnect")
+        return `reconnect ${target}`;
+    return `connect ${target}`;
+}
+/** "connect a (h), allow the agent to use b (h) and reconnect c (h)"; empty for none. */
+export function connectionsPhrase(connections) {
+    const phrases = connections.map(connectionPhrase);
+    if (phrases.length < 2)
+        return phrases[0] ?? "";
+    return `${phrases.slice(0, -1).join(", ")} and ${phrases[phrases.length - 1]}`;
+}
+//# sourceMappingURL=connect-pause.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai",
-  "version": "6.3.0-dev.116",
+  "version": "6.3.0-dev.122",
   "description": "CLI for 2kw.ai — schema-driven document extraction, an OpenAI-compatible EU LLM gateway, transcription, prompts, datasets, and experiments from your terminal or agentic workflows. Ships as 2kw, backbone, and bb.",
   "keywords": [
     "cli",