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

package/dist/lib/agent-run.js

@@ -0,0 +1,259 @@
+/**
+ * The run envelope of `bb agents run --json` (spec 2026-09-14-cli-agents-design.md §4.3), copied
+ * from `cli/src/lib/agent-run.ts` because cli/ and mcp/ share no package (#667). Keep the two in step;
+ * only the text of `next` differs, because an MCP caller decides through a tool, not a shell command.
+ * The connect pause is not copied by hand: `connect-pause.ts` is a guarded byte copy of the CLI's (#1086).
+ */
+import { chatOriginFor, connectCallIds, connectionsPhrase, DEFAULT_CHAT_URL, pendingConnectionsOf, } from "./connect-pause.js";
+export { DEFAULT_CHAT_URL };
+/**
+ * The chat web host that belongs to the server's API base URL (`AI_2KW_BASE_URL`), where a member
+ * connects a connector. `AI_2KW_CHAT_URL` overrides the mapping; a trailing slash is dropped. The
+ * mapping itself is the shared `connect-pause.ts`'s {@link chatOriginFor} (#1086).
+ */
+export function chatUrlFor(baseUrl, env = process.env) {
+    const override = env.AI_2KW_CHAT_URL?.trim();
+    if (override)
+        return override.replace(/\/+$/, "");
+    return chatOriginFor(baseUrl);
+}
+export const CONVERSATION_MODES = ["plan", "ask", "auto"];
+/**
+ * Who may change the mode (#656 D8), stated in both tool descriptions: the mode outlives the request
+ * that sets it, so a model that switched on its own would lift the user's choice for every later turn.
+ */
+export const MODE_RULE = "Set `mode` only when the user explicitly asks for that mode. Never set it to retry a refused approval " +
+    "or to leave plan mode on your own: ask the user first. plan = read-only; ask = no automatic approver, " +
+    "calls that need approval wait for a person; auto = the operator's policy as written. Leave it out to " +
+    "keep the conversation's mode.";
+function isConversationMode(value) {
+    return typeof value === "string" && CONVERSATION_MODES.includes(value);
+}
+/** The `backbone:mode` input item (S1 D7); always appended last. */
+export function modeItem(mode) {
+    return { type: "backbone:mode", mode };
+}
+/**
+ * The mode the response ran under (`conversation_mode`, #656). An absent key (a server before #656)
+ * and any value other than the three read as null, which also means "none set".
+ */
+export function responseMode(result) {
+    const raw = result?.conversation_mode;
+    return isConversationMode(raw) ? raw : null;
+}
+/** The assistant's text: every `output_text` part of every `message` item, in order. */
+export function extractResponseText(result) {
+    const parts = [];
+    for (const item of result?.output ?? []) {
+        if (item.type !== "message")
+            continue;
+        for (const part of item.content ?? []) {
+            if (part.type === "output_text" && part.text)
+                parts.push(part.text);
+        }
+    }
+    return parts.join("\n");
+}
+/**
+ * The response echoes `model` as `agent/{name}@{versionNumber}` (all digits), optionally
+ * followed by a `#<model>` override. Only a trailing all-digit `@N` is read as a version;
+ * any other `@` suffix stays part of the name.
+ */
+export function parseAgentModel(model) {
+    // Strip the `#<model>` override (from the last `#`, as the server splits it) before matching.
+    const hash = (model ?? "").lastIndexOf("#");
+    const ref = hash >= 0 ? (model ?? "").slice(0, hash) : model ?? "";
+    const withVersion = /^agent\/(.+)@(\d+)$/.exec(ref);
+    if (withVersion)
+        return { agent: withVersion[1], version: Number(withVersion[2]) };
+    const bare = /^agent\/(.+)$/.exec(ref);
+    if (bare)
+        return { agent: bare[1], version: null };
+    return { agent: null, version: null };
+}
+function parseArguments(raw) {
+    if (typeof raw !== "string")
+        return raw ?? {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/**
+ * Output item types the envelope decodes, or that never hold a run: text, reasoning and finished
+ * connector calls. A pause on anything else (a connector approval's `mcp_approval_request`) is named.
+ */
+const DECODED_ITEM_TYPES = new Set([
+    "message",
+    "reasoning",
+    "function_call",
+    "function_call_output",
+    "backbone:approval_request",
+    "backbone:connector_auth_request",
+    "mcp_call",
+    "mcp_list_tools",
+]);
+/**
+ * The relay pause's `next` sentence (#1254 M7, M9): names every relayed call (JSON-quoted, P2: call
+ * ids and tool names are the agent's model's own, not this server's) and the decide call that answers
+ * them within the relay window.
+ */
+function relayNext(pendingToolCalls, ref, responseId) {
+    const calls = pendingToolCalls.map((c) => `${JSON.stringify(c.callId)} (tool ${JSON.stringify(c.tool)})`).join(", ");
+    return (`The agent waits for client-side tool output: ${calls}. Within one hour, answer each one: run it only when it clearly maps ` +
+        "onto something you can do here, and ask the user first when it has side effects; otherwise answer it with `failed: true`. " +
+        `Then call 2kw_decide_agent_approvals with agent ${JSON.stringify(ref)}, responseId ${JSON.stringify(responseId)} and one ` +
+        "`outputs` entry per call.");
+}
+/** Output item types this server does not decode into anything the envelope shows (e.g. a connector-tool approval's `mcp_approval_request`). */
+function extraUndecodedTypes(output) {
+    return [...new Set(output.map((i) => String(i.type)).filter((t) => !DECODED_ITEM_TYPES.has(t)))];
+}
+function undecodedPause(output) {
+    const types = extraUndecodedTypes(output);
+    return types.length > 0
+        ? `This server cannot show or answer ${types.join(", ")}.`
+        : "This server cannot tell what the run waits for.";
+}
+/**
+ * @param agentRef the reference the run was started with (`name[@label][#model]`); `next` names it so
+ *   the decision continues on the same label and model (D11). Falls back to the echoed agent name.
+ * @param chatUrl the chat web host of the API ({@link chatUrlFor}); a connect pause's `next` names its
+ *   Connectors page.
+ */
+export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
+    const output = result?.output ?? [];
+    const { agent, version } = parseAgentModel(result?.model);
+    // call_id → status of its tool output; a failed server-side tool run is marked `incomplete`.
+    const outputStatuses = new Map(output
+        .filter((i) => i.type === "function_call_output")
+        .map((i) => [
+        String(i.call_id),
+        i.status === "incomplete" ? "incomplete" : "completed",
+    ]));
+    const pendingApprovals = output
+        // Only an open request is pending; judge- or grant-decided requests (#634, #629) carry another status.
+        .filter((i) => i.type === "backbone:approval_request" && (i.status === undefined || i.status === "in_progress"))
+        .map((i) => ({
+        approvalId: String(i.id),
+        callId: String(i.call_id),
+        tool: String(i.tool),
+        arguments: parseArguments(i.arguments),
+        policyClass: String(i.policy_class),
+        reason: typeof i.reason === "string" && i.reason ? i.reason : null,
+    }));
+    // 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) {
+        if (item.type !== "function_call")
+            continue;
+        const callId = String(item.call_id);
+        const outputStatus = outputStatuses.get(callId);
+        if (outputStatus) {
+            toolCalls.push({ tool: String(item.name), callId, status: outputStatus });
+        }
+        else if (!withheldCallIds.has(callId)) {
+            pendingToolCalls.push({ tool: String(item.name), callId, arguments: parseArguments(item.arguments) });
+        }
+    }
+    let status;
+    switch (result?.status) {
+        case "completed":
+            status = "completed";
+            break;
+        case "incomplete":
+            status = "incomplete";
+            break;
+        case "requires_action":
+            // A connect pause is requires_tool_output too (#807 R12): no tool here can answer it.
+            status =
+                pendingToolCalls.length > 0 || pendingConnections.length > 0 || pendingApprovals.length === 0
+                    ? "requires_tool_output"
+                    : "requires_approval";
+            break;
+        default:
+            throw new Error(`Unexpected response status: ${result?.status}`);
+    }
+    const responseId = result?.id ?? null;
+    const ref = agentRef ?? agent;
+    let next = null;
+    if (status === "requires_approval" && ref && responseId) {
+        // Never an "approve all" hint: the assistant decides only what the user decided (D12).
+        next = `Show the pending approvals to the user; after they decide each one, call 2kw_decide_agent_approvals with agent ${JSON.stringify(ref)} and responseId ${JSON.stringify(responseId)}.`;
+    }
+    else if (status === "requires_tool_output" && pendingToolCalls.length > 0 && ref && responseId) {
+        // The engine answers a connect call itself on the continuation, so connecting first is enough
+        // to also resolve a relay + connect pause (#1254 M7).
+        const relay = relayNext(pendingToolCalls, ref, responseId);
+        // The relay window started at the pause, not at the connection (#1254 review): connecting takes
+        // however long it takes, and does not reset the clock the relay text below names.
+        const connectPrefix = pendingConnections.length > 0
+            ? `Tell the user to ${connectionsPhrase(pendingConnections)} in ${chatUrl}/connectors; once they have, continue as follows ` +
+                "without delay — the window below started at the pause, not at the connection. "
+            : "";
+        // Never a decideAll hint: the assistant decides only what the user decided (D12, #667). The
+        // approval also has to fit inside the relay window named above (#1254 review).
+        const approvalsSuffix = pendingApprovals.length > 0
+            ? " Show the pending approvals to the user and pass their decisions in the same call, within the same window."
+            : "";
+        // A connector-tool approval (mcp_approval_request) never decodes into pendingApprovals, so this
+        // envelope can under-report what is actually pending; say so rather than sound falsely complete
+        // (#1254 review). The continuation itself still refuses an incomplete answer (400
+        // incomplete_tool_outputs, decideErrorText's hint), this only tells the assistant to expect that.
+        const undecodedTypes = extraUndecodedTypes(output);
+        const undecodedSuffix = undecodedTypes.length > 0
+            ? ` This server also cannot show or answer ${undecodedTypes.join(", ")} on this response — it may hold more than ` +
+                "the relayed calls above (for example another pending approval); if the continuation answers " +
+                "400 incomplete_tool_outputs, that is why."
+            : "";
+        next = `${connectPrefix}${relay}${approvalsSuffix}${undecodedSuffix}`;
+    }
+    else if (status === "requires_tool_output" && pendingConnections.length > 0 && pendingToolCalls.length === 0 && responseId) {
+        // A connector-only pause (no relayed call, so 2kw_decide_agent_approvals has nothing to decide,
+        // spec M11) has no tool here to continue it by id, and a connect pause cannot be continued by
+        // conversation (the gateway answers 400), so the honest ways on are a fresh request or a client
+        // that continues by response id (#1254 review: continueWithDecisions does send previous_response_id
+        // for every other pause this server can decide).
+        next =
+            `Tell the user to ${connectionsPhrase(pendingConnections)} in ${chatUrl}/connectors. ` +
+                `This server cannot continue response ${JSON.stringify(responseId)}: once they have connected, send the request again ` +
+                "with 2kw_create_response without `conversation` (a connect pause cannot be continued by conversation), " +
+                "or continue the response by its id from n8n (Previous Response ID) or any client that sends previous_response_id.";
+    }
+    else if (status === "requires_tool_output" && pendingConnections.length === 0 && pendingToolCalls.length === 0 && responseId) {
+        // Paused on nothing the envelope decodes: say so, rather than hand back a pause with no way on.
+        next =
+            `${undecodedPause(output)} Response ${JSON.stringify(responseId)} stays paused: tell the user to answer it ` +
+                `in ${chatUrl}/, or continue it from a client that sends previous_response_id.`;
+    }
+    return {
+        status,
+        mode: responseMode(result),
+        agent,
+        version,
+        responseId,
+        conversationId: result?.conversation?.id ?? null,
+        text: extractResponseText(result),
+        toolCalls,
+        pendingApprovals,
+        pendingToolCalls,
+        pendingConnections,
+        incompleteReason: result?.incomplete_details?.reason ?? null,
+        usage: result?.usage
+            ? { inputTokens: result.usage.input_tokens ?? 0, outputTokens: result.usage.output_tokens ?? 0 }
+            : null,
+        next,
+    };
+}
+//# sourceMappingURL=agent-run.js.map

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,149 @@
+// GENERATED COPY of cli/src/lib/connect-pause.ts (#1086). Do not edit here: edit the CLI's file,
+// then run `npm run sync:connect-pause` in mcp/. `npm run check:connect-pause` fails on any drift.
+/**
+ * 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/dist/lib/overlay.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The body for a PUT that replaces the whole row: the stored resource as its GET returned it, with
+ * every change the caller gave written over it. A change that is `undefined` was not given and keeps
+ * the stored value; the backend would store it as null otherwise (#1195). Server-managed fields in
+ * `current` (a dataset's or prompt's latestVersionId) go back as read, which is what keeps them.
+ */
+export declare function overlay<T extends object>(current: T, changes: Record<string, unknown>): T;
+/** Refuses a name that is present but blank, which a full-replace PUT would otherwise store. */
+export declare function assertNameNotBlank(name: string | undefined): void;
+//# sourceMappingURL=overlay.d.ts.map

package/dist/lib/overlay.js

@@ -0,0 +1,20 @@
+/**
+ * The body for a PUT that replaces the whole row: the stored resource as its GET returned it, with
+ * every change the caller gave written over it. A change that is `undefined` was not given and keeps
+ * the stored value; the backend would store it as null otherwise (#1195). Server-managed fields in
+ * `current` (a dataset's or prompt's latestVersionId) go back as read, which is what keeps them.
+ */
+export function overlay(current, changes) {
+    const body = { ...current };
+    for (const [key, value] of Object.entries(changes)) {
+        if (value !== undefined)
+            body[key] = value;
+    }
+    return body;
+}
+/** Refuses a name that is present but blank, which a full-replace PUT would otherwise store. */
+export function assertNameNotBlank(name) {
+    if (name !== undefined && !name.trim())
+        throw new Error("name must not be empty.");
+}
+//# sourceMappingURL=overlay.js.map