@botbotgo/agent-harness 0.0.309 → 0.0.311

package/dist/mcp.d.ts

@@ -1,76 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ApprovalRecord, ArtifactListing, CompiledTool, HarnessEvent, ParsedToolObject, RequestRecord, RequestResult, RequestState, RequestSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, SessionRecord, SessionSummary } from "./contracts/types.js";
-export type ToolMcpServerOptions = {
-    agentId: string;
-    serverInfo?: {
-        name?: string;
-        version?: string;
-    };
-    includeToolNames?: string[];
-};
-export type ToolMcpServerTool = {
-    compiledTool: CompiledTool;
-    resolvedTool: unknown;
-    sourceTool?: ParsedToolObject;
-};
-export type RuntimeMcpServerOptions = {
-    serverInfo?: {
-        name?: string;
-        version?: string;
-    };
-};
-export type RuntimeMcpStreamableHttpServerOptions = RuntimeMcpServerOptions & {
-    hostname?: string;
-    port?: number;
-    path?: string;
-};
-export type RuntimeMcpStreamableHttpServer = {
-    hostname: string;
-    port: number;
-    path: string;
-    url: string;
-    completed: Promise<void>;
-    close: () => Promise<void>;
-};
-type RuntimeMcpRuntime = {
-    listSessions: (filter?: {
-        agentId?: string;
-    }) => Promise<SessionSummary[]>;
-    getSessionRecord: (sessionId: string) => Promise<SessionRecord | null>;
-    listRequests: (filter?: {
-        agentId?: string;
-        sessionId?: string;
-        state?: RequestState;
-    }) => Promise<RequestSummary[]>;
-    getRequest: (requestId: string) => Promise<RequestRecord | null>;
-    listApprovals: (filter?: {
-        status?: ApprovalRecord["status"];
-        sessionId?: string;
-        requestId?: string;
-    }) => Promise<ApprovalRecord[]>;
-    getApproval: (approvalId: string) => Promise<ApprovalRecord | null>;
-    resume: (options: {
-        approvalId?: string;
-        sessionId?: string;
-        requestId?: string;
-        decision?: "approve" | "edit" | "reject";
-        editedInput?: Record<string, unknown>;
-    }) => Promise<RequestResult>;
-    listRequestArtifacts: (sessionId: string, requestId: string) => Promise<ArtifactListing>;
-    readRequestArtifact: (sessionId: string, requestId: string, artifactPath: string) => Promise<unknown>;
-    listRequestEvents: (sessionId: string, requestId: string) => Promise<HarnessEvent[]>;
-    exportRequestPackage: (input: {
-        sessionId: string;
-        requestId: string;
-        includeArtifacts?: boolean;
-        includeArtifactContents?: boolean;
-        includeRuntimeHealth?: boolean;
-    }) => Promise<unknown>;
-    exportSessionPackage: (input: RuntimeSessionPackageInput) => Promise<RuntimeSessionPackage>;
-};
-export declare function createToolMcpServerFromTools(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
-export declare function serveToolsOverStdioFromHarness(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
-export declare function createRuntimeMcpServer(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
-export declare function serveRuntimeMcpOverStdio(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
-export declare function serveRuntimeMcpOverStreamableHttp(runtime: RuntimeMcpRuntime, options?: RuntimeMcpStreamableHttpServerOptions): Promise<RuntimeMcpStreamableHttpServer>;
-export {};
+export { AGENT_HARNESS_VERSION } from "./package-version.js";
+export * from "./protocol/mcp/server.js";

package/dist/mcp.js

@@ -1,428 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { randomUUID } from "node:crypto";
-import { createServer } from "node:http";
-import { pathToFileURL } from "node:url";
-import { z } from "zod";
-import { AGENT_HARNESS_VERSION } from "./package-version.js";
-import { loadToolModuleDefinition } from "./tool-modules.js";
-function asResolvedTool(value) {
-    return typeof value === "object" && value !== null ? value : null;
-}
-async function buildRawShapeForTool(sourceTool, resolvedTool) {
-    if (!sourceTool) {
-        return undefined;
-    }
-    if (sourceTool.type === "function") {
-        const imported = await import(pathToFileURL(sourceTool.sourcePath).href);
-        const definition = loadToolModuleDefinition(imported, sourceTool.implementationName ?? sourceTool.id);
-        return typeof definition.schema.shape === "object" && definition.schema.shape !== null
-            ? definition.schema.shape
-            : undefined;
-    }
-    const typedResolvedTool = asResolvedTool(resolvedTool);
-    if (!typedResolvedTool?.inputSchemaPromise) {
-        return undefined;
-    }
-    return jsonSchemaObjectToRawShape(await typedResolvedTool.inputSchemaPromise);
-}
-async function invokeResolvedTool(resolvedTool, input) {
-    const typed = asResolvedTool(resolvedTool);
-    if (!typed) {
-        throw new Error("Resolved tool is not invokable.");
-    }
-    if (typeof typed.invoke === "function") {
-        return typed.invoke(input);
-    }
-    if (typeof typed.call === "function") {
-        return typed.call(input);
-    }
-    if (typeof typed.func === "function") {
-        return typed.func(input);
-    }
-    throw new Error("Resolved tool does not expose invoke, call, or func.");
-}
-function renderToolOutput(output) {
-    if (typeof output === "string") {
-        return output;
-    }
-    return JSON.stringify(output, null, 2);
-}
-function normalizePath(value, fallback) {
-    const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
-    return source.startsWith("/") ? source : `/${source}`;
-}
-function writeJson(response, statusCode, payload) {
-    response.statusCode = statusCode;
-    response.setHeader("content-type", "application/json; charset=utf-8");
-    response.end(JSON.stringify(payload));
-}
-function readRequestBody(request) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        request.on("data", (chunk) => {
-            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        });
-        request.on("end", () => {
-            resolve(Buffer.concat(chunks).toString("utf8"));
-        });
-        request.on("error", reject);
-    });
-}
-function isInitializeRequest(payload) {
-    return typeof payload === "object"
-        && payload !== null
-        && !Array.isArray(payload)
-        && payload.method === "initialize";
-}
-function jsonSchemaObjectToRawShape(schema) {
-    if (!schema || schema.type !== "object") {
-        return undefined;
-    }
-    const properties = typeof schema.properties === "object" && schema.properties
-        ? schema.properties
-        : {};
-    const required = Array.isArray(schema.required)
-        ? new Set(schema.required.filter((item) => typeof item === "string"))
-        : new Set();
-    const shape = {};
-    for (const [key, propertySchema] of Object.entries(properties)) {
-        const built = jsonSchemaToZod(propertySchema);
-        shape[key] = required.has(key) ? built : built.optional();
-    }
-    return shape;
-}
-function jsonSchemaToZod(schema) {
-    switch (schema?.type) {
-        case "string":
-            return z.string();
-        case "number":
-            return z.number();
-        case "integer":
-            return z.number().int();
-        case "boolean":
-            return z.boolean();
-        case "array":
-            return z.array(jsonSchemaToZod(typeof schema.items === "object" && schema.items ? schema.items : undefined));
-        case "object": {
-            const shape = jsonSchemaObjectToRawShape(schema);
-            return z.object(shape ?? {}).passthrough();
-        }
-        default:
-            return z.any();
-    }
-}
-export async function createToolMcpServerFromTools(tools, options) {
-    const server = new McpServer({
-        name: options.serverInfo?.name ?? `agent-harness-${options.agentId}`,
-        version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
-    });
-    const allowedNames = options.includeToolNames ? new Set(options.includeToolNames) : null;
-    for (const { compiledTool, resolvedTool, sourceTool } of tools) {
-        if (allowedNames && !allowedNames.has(compiledTool.name)) {
-            continue;
-        }
-        const rawShape = await buildRawShapeForTool(sourceTool, resolvedTool);
-        server.tool(compiledTool.name, compiledTool.description, rawShape ?? {}, async (input) => ({
-            content: [
-                {
-                    type: "text",
-                    text: renderToolOutput(await invokeResolvedTool(resolvedTool, input)),
-                },
-            ],
-        }));
-    }
-    return server;
-}
-export async function serveToolsOverStdioFromHarness(tools, options) {
-    const server = await createToolMcpServerFromTools(tools, options);
-    await server.connect(new StdioServerTransport());
-    return server;
-}
-export async function createRuntimeMcpServer(runtime, options = {}) {
-    const server = new McpServer({
-        name: options.serverInfo?.name ?? "agent-harness-runtime",
-        version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
-    });
-    server.tool("list_sessions", "List persisted runtime sessions.", {
-        agentId: z.string().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listSessions(input.agentId ? { agentId: input.agentId } : undefined)),
-            }],
-    }));
-    server.tool("get_session", "Get one persisted runtime session by id.", {
-        sessionId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.getSessionRecord(input.sessionId)),
-            }],
-    }));
-    server.tool("list_requests", "List persisted runtime requests.", {
-        agentId: z.string().optional(),
-        sessionId: z.string().optional(),
-        state: z.enum(["queued", "running", "waiting_for_approval", "completed", "failed", "cancelled"]).optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listRequests({
-                    ...(input.agentId ? { agentId: input.agentId } : {}),
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    ...(input.state ? { state: input.state } : {}),
-                })),
-            }],
-    }));
-    server.tool("get_request", "Get one persisted runtime request by id.", {
-        requestId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.getRequest(input.requestId)),
-            }],
-    }));
-    server.tool("list_approvals", "List runtime approvals.", {
-        status: z.enum(["pending", "approved", "edited", "rejected", "expired"]).optional(),
-        sessionId: z.string().optional(),
-        requestId: z.string().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listApprovals({
-                    ...(input.status ? { status: input.status } : {}),
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    ...(input.requestId ? { requestId: input.requestId } : {}),
-                })),
-            }],
-    }));
-    server.tool("get_approval", "Get one runtime approval by id.", {
-        approvalId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.getApproval(input.approvalId)),
-            }],
-    }));
-    server.tool("resolve_approval", "Resolve one runtime approval.", {
-        approvalId: z.string(),
-        decision: z.enum(["approve", "edit", "reject"]),
-        sessionId: z.string().optional(),
-        requestId: z.string().optional(),
-        editedInput: z.record(z.string(), z.any()).optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.resume({
-                    approvalId: input.approvalId,
-                    decision: input.decision,
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    ...(input.requestId ? { requestId: input.requestId } : {}),
-                    ...(input.editedInput ? { editedInput: input.editedInput } : {}),
-                })),
-            }],
-    }));
-    server.tool("list_artifacts", "List artifacts for one runtime request.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listRequestArtifacts(input.sessionId, input.requestId)),
-            }],
-    }));
-    server.tool("read_artifact", "Read one runtime artifact.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-        artifactPath: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.readRequestArtifact(input.sessionId, input.requestId, input.artifactPath)),
-            }],
-    }));
-    server.tool("list_request_events", "List persisted runtime events for one request.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listRequestEvents(input.sessionId, input.requestId)),
-            }],
-    }));
-    server.tool("export_request_package", "Export a stable runtime request package for one request.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-        includeArtifacts: z.boolean().optional(),
-        includeArtifactContents: z.boolean().optional(),
-        includeRuntimeHealth: z.boolean().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.exportRequestPackage(input)),
-            }],
-    }));
-    server.tool("export_session_package", "Export a stable runtime session package.", {
-        sessionId: z.string(),
-        includeArtifacts: z.boolean().optional(),
-        includeArtifactContents: z.boolean().optional(),
-        includeRuntimeHealth: z.boolean().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.exportSessionPackage(input)),
-            }],
-    }));
-    return server;
-}
-export async function serveRuntimeMcpOverStdio(runtime, options = {}) {
-    const server = await createRuntimeMcpServer(runtime, options);
-    await server.connect(new StdioServerTransport());
-    return server;
-}
-export async function serveRuntimeMcpOverStreamableHttp(runtime, options = {}) {
-    const hostname = options.hostname?.trim() || "127.0.0.1";
-    const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
-    const mcpPath = normalizePath(options.path, "/mcp");
-    const sessions = new Map();
-    const closeSession = async (sessionId) => {
-        const session = sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        sessions.delete(sessionId);
-        await Promise.allSettled([
-            session.transport.close(),
-            session.server.close(),
-        ]);
-    };
-    const httpServer = createServer(async (request, response) => {
-        try {
-            const requestUrl = new URL(request.url ?? "/", `http://${hostname}`);
-            if (requestUrl.pathname !== mcpPath) {
-                writeJson(response, 404, {
-                    error: "Not Found",
-                    path: mcpPath,
-                });
-                return;
-            }
-            const headerValue = request.headers["mcp-session-id"];
-            const sessionId = Array.isArray(headerValue) ? headerValue[0] : headerValue;
-            if (request.method === "POST") {
-                const body = await readRequestBody(request);
-                let payload;
-                try {
-                    payload = JSON.parse(body);
-                }
-                catch {
-                    writeJson(response, 400, {
-                        jsonrpc: "2.0",
-                        id: null,
-                        error: {
-                            code: -32700,
-                            message: "Invalid JSON payload.",
-                        },
-                    });
-                    return;
-                }
-                const existingSession = sessionId ? sessions.get(sessionId) : undefined;
-                if (existingSession) {
-                    await existingSession.transport.handleRequest(request, response, payload);
-                    return;
-                }
-                if (sessionId || !isInitializeRequest(payload)) {
-                    writeJson(response, 400, {
-                        jsonrpc: "2.0",
-                        id: null,
-                        error: {
-                            code: -32000,
-                            message: "Bad Request: No valid MCP session was provided.",
-                        },
-                    });
-                    return;
-                }
-                let createdTransport;
-                const server = await createRuntimeMcpServer(runtime, options);
-                const transport = new StreamableHTTPServerTransport({
-                    sessionIdGenerator: () => randomUUID(),
-                    onsessioninitialized: (initializedSessionId) => {
-                        sessions.set(initializedSessionId, { transport, server });
-                    },
-                });
-                createdTransport = transport;
-                transport.onclose = () => {
-                    const activeSessionId = createdTransport?.sessionId;
-                    if (activeSessionId) {
-                        const active = sessions.get(activeSessionId);
-                        if (active?.transport === createdTransport) {
-                            sessions.delete(activeSessionId);
-                        }
-                    }
-                };
-                await server.connect(transport);
-                await transport.handleRequest(request, response, payload);
-                return;
-            }
-            if (request.method === "GET" || request.method === "DELETE") {
-                if (!sessionId || !sessions.has(sessionId)) {
-                    writeJson(response, 400, {
-                        jsonrpc: "2.0",
-                        id: null,
-                        error: {
-                            code: -32000,
-                            message: "Bad Request: No valid MCP session was provided.",
-                        },
-                    });
-                    return;
-                }
-                const session = sessions.get(sessionId);
-                await session.transport.handleRequest(request, response);
-                if (request.method === "DELETE") {
-                    await closeSession(sessionId);
-                }
-                return;
-            }
-            response.statusCode = 405;
-            response.setHeader("allow", "GET, POST, DELETE");
-            response.end();
-        }
-        catch (error) {
-            writeJson(response, 500, {
-                error: error instanceof Error ? error.message : "Runtime MCP Streamable HTTP transport failed.",
-            });
-        }
-    });
-    const completed = new Promise((resolve, reject) => {
-        httpServer.once("close", resolve);
-        httpServer.once("error", reject);
-    });
-    await new Promise((resolve, reject) => {
-        httpServer.listen(port, hostname, () => resolve());
-        httpServer.once("error", reject);
-    });
-    const address = httpServer.address();
-    const resolvedPort = typeof address === "object" && address ? address.port : port;
-    return {
-        hostname,
-        port: resolvedPort,
-        path: mcpPath,
-        url: `http://${hostname}:${resolvedPort}${mcpPath}`,
-        completed,
-        close: async () => {
-            const sessionIds = Array.from(sessions.keys());
-            for (const sessionId of sessionIds) {
-                await closeSession(sessionId);
-            }
-            await new Promise((resolve, reject) => {
-                httpServer.close((error) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-        },
-    };
-}
+export { AGENT_HARNESS_VERSION } from "./package-version.js";
+export * from "./protocol/mcp/server.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.308";
+export declare const AGENT_HARNESS_VERSION = "0.0.310";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.308";
+export const AGENT_HARNESS_VERSION = "0.0.310";

package/dist/persistence/file-store.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { appendFile, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { ensureDir, fileExists, readJson, writeJson } from "../utils/fs.js";
-import { resolveRuntimeArtifactsRoot } from "../runtime/support/runtime-layout.js";
+import { resolveRuntimeArtifactsRoot } from "../runtime/layout/runtime-layout.js";
 function nowIso() {
     return new Date(Date.now()).toISOString();
 }

package/dist/persistence/sqlite-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { Client, InValue } from "@libsql/client";
+export type SqlRow = Record<string, unknown>;
+export declare const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
+export declare const SQLITE_BUSY_RETRY_DELAY_MS = 100;
+export declare function asRow(value: unknown): SqlRow;
+export declare function asString(value: unknown): string;
+export declare function asNullableString(value: unknown): string | null;
+export declare function asBoolean(value: unknown): boolean;
+export declare function parseJson<T>(value: unknown): T;
+export declare function toSqliteUrl(filePath: string): string;
+export declare function nowIso(): string;
+export declare function throwWrappedRuntimeSqliteError(dbPath: string, sql: string | undefined, error: unknown): never;
+export declare function isSqliteBusyError(error: unknown): boolean;
+export declare function sleep(ms: number): Promise<void>;
+export declare function executeWithBusyRetry<T>(client: Client, dbPath: string, sql: string, args: InValue[] | undefined, run: () => Promise<T>): Promise<T>;
+export declare function buildWhereClause(filters: Array<[sql: string, value: InValue | undefined]>): {
+    clause: string;
+    args: InValue[];
+};

package/dist/persistence/sqlite-runtime.js

@@ -0,0 +1,86 @@
+export const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
+export const SQLITE_BUSY_RETRY_DELAY_MS = 100;
+export function asRow(value) {
+    return value;
+}
+export function asString(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+export function asNullableString(value) {
+    return value == null ? null : asString(value);
+}
+export function asBoolean(value) {
+    return value === true || value === 1 || value === "1";
+}
+export function parseJson(value) {
+    return JSON.parse(asString(value));
+}
+export function toSqliteUrl(filePath) {
+    return `file:${filePath}`;
+}
+export function nowIso() {
+    return new Date(Date.now()).toISOString();
+}
+function runtimeSqliteErrorShouldIncludeSql(baseMessage) {
+    if (process.env.AGENT_HARNESS_RUNTIME_SQLITE_DEBUG === "1") {
+        return true;
+    }
+    return /SQLITE_CONSTRAINT|FOREIGN KEY|UNIQUE constraint|NOT NULL/i.test(baseMessage);
+}
+function formatRuntimeSqliteErrorMessage(dbPath, sql, baseMessage) {
+    let detail = `agent-harness runtime SQLite (${dbPath}): ${baseMessage}`;
+    if (sql && runtimeSqliteErrorShouldIncludeSql(baseMessage)) {
+        const sqlPreview = sql.replace(/\s+/g, " ").trim();
+        const truncated = sqlPreview.length > 220 ? `${sqlPreview.slice(0, 220)}…` : sqlPreview;
+        detail += ` [sql=${truncated}]`;
+    }
+    return detail;
+}
+export function throwWrappedRuntimeSqliteError(dbPath, sql, error) {
+    const base = error instanceof Error ? error.message : String(error);
+    const wrapped = new Error(formatRuntimeSqliteErrorMessage(dbPath, sql, base));
+    wrapped.cause = error;
+    throw wrapped;
+}
+function collectErrorMessages(error) {
+    const messages = [];
+    let current = error;
+    while (current instanceof Error) {
+        messages.push(current.message);
+        current = current.cause;
+    }
+    if (typeof current === "string" && current.length > 0) {
+        messages.push(current);
+    }
+    return messages;
+}
+export function isSqliteBusyError(error) {
+    return collectErrorMessages(error).some((message) => /SQLITE_BUSY|database is locked/i.test(message));
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function executeWithBusyRetry(client, dbPath, sql, args, run) {
+    void client;
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
+                throwWrappedRuntimeSqliteError(dbPath, sql, error);
+            }
+            await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
+        }
+    }
+}
+export function buildWhereClause(filters) {
+    const active = filters.filter(([, value]) => value !== undefined);
+    if (active.length === 0) {
+        return { clause: "", args: [] };
+    }
+    return {
+        clause: ` WHERE ${active.map(([sql]) => sql).join(" AND ")}`,
+        args: active.map(([, value]) => value),
+    };
+}