@kognitivedev/cloud-knowledge-base 0.2.29

package/dist/workflow.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCloudKnowledgeBaseSearchStep = createCloudKnowledgeBaseSearchStep;
+exports.createCloudKnowledgeBaseAnswerStep = createCloudKnowledgeBaseAnswerStep;
+const workflows_1 = require("@kognitivedev/workflows");
+const search_1 = require("./search");
+async function resolveStepValue(value, input, context) {
+    if (typeof value === "function") {
+        return value(input, { resourceId: context.resourceId, abortSignal: context.abortSignal });
+    }
+    return value;
+}
+async function searchForWorkflow(options, input, context) {
+    var _a, _b;
+    const inheritedContext = context;
+    const query = await options.getQuery(input, {
+        resourceId: inheritedContext.resourceId,
+        abortSignal: inheritedContext.abortSignal,
+    });
+    return (0, search_1.searchCloudKnowledgeBase)({
+        client: options.client,
+        baseUrl: (_a = options.baseUrl) !== null && _a !== void 0 ? _a : inheritedContext.baseUrl,
+        apiKey: (_b = options.apiKey) !== null && _b !== void 0 ? _b : inheritedContext.apiKey,
+        fetch: options.fetch,
+        timeout: options.timeout,
+        logLevel: options.logLevel,
+        pipelineId: options.pipelineId,
+        resolvePipelineId: options.resolvePipelineId,
+        query,
+        topK: options.topK === undefined ? undefined : await resolveStepValue(options.topK, input, context),
+        retrievalMode: options.retrievalMode === undefined
+            ? undefined
+            : await resolveStepValue(options.retrievalMode, input, context),
+        snippetMaxLength: options.snippetMaxLength,
+        resourceId: inheritedContext.resourceId,
+        abortSignal: inheritedContext.abortSignal,
+    });
+}
+function createCloudKnowledgeBaseSearchStep(options) {
+    return (0, workflows_1.createKnowledgeBaseSearchStep)({
+        id: options.id,
+        description: options.description,
+        search: async (input, context) => searchForWorkflow(options, input, context),
+        extractOutput: options.extractOutput,
+    });
+}
+function createCloudKnowledgeBaseAnswerStep(options) {
+    return (0, workflows_1.createKnowledgeBaseAnswerStep)({
+        id: options.id,
+        description: options.description,
+        agent: options.agent,
+        search: async (input, context) => searchForWorkflow(options, input, context),
+        buildMessages: options.buildMessages,
+        temperature: options.temperature,
+        maxOutputTokens: options.maxOutputTokens,
+        emptyResultAnswer: options.emptyResultAnswer,
+        extractOutput: options.extractOutput,
+    });
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@kognitivedev/cloud-knowledge-base",
+  "version": "0.2.29",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --noCheck",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@kognitivedev/agents": "^0.2.29",
+    "@kognitivedev/documents": "^0.2.29",
+    "@kognitivedev/shared": "^0.2.29",
+    "@kognitivedev/tools": "^0.2.29",
+    "@kognitivedev/workflows": "^0.2.29"
+  },
+  "peerDependencies": {
+    "zod": ">=3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0",
+    "zod": "^3.23.8"
+  },
+  "description": "Managed cloud knowledge base SDK for Kognitive agents and workflows",
+  "keywords": [
+    "kognitive",
+    "knowledge-base",
+    "retrieval",
+    "agents",
+    "workflows",
+    "pipelines"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/cloud-knowledge-base"
+  },
+  "homepage": "https://kognitive.dev"
+}

package/src/__tests__/cloud-knowledge-base.test.ts

@@ -0,0 +1,493 @@
+import { describe, expect, it, vi } from "vitest";
+import { createWorkflow } from "@kognitivedev/workflows";
+import type { KognitiveDocumentsClient, PipelineSearchResult } from "@kognitivedev/documents";
+import {
+    createCloudKnowledgeBaseAnswerStep,
+    createCloudKnowledgeBaseContextAdapter,
+    createCloudKnowledgeBaseSearchStep,
+    createCloudKnowledgeBaseSearchTool,
+    searchCloudKnowledgeBase,
+} from "../index";
+
+function makePipelineResult(overrides: Partial<PipelineSearchResult> = {}): PipelineSearchResult {
+    return {
+        id: "artifact_1",
+        content: "Retention policy is 30 days for standard workspaces.",
+        score: 0.92,
+        metadata: {
+            filename: "policy.pdf",
+            mimeType: "application/pdf",
+            pageNumber: 3,
+            artifactType: "chunk",
+            parseDocumentId: "parse_1",
+        },
+        ...overrides,
+    };
+}
+
+describe("@kognitivedev/cloud-knowledge-base", () => {
+    it("normalizes search results and forwards auth/baseUrl via the documents client", async () => {
+        const fetchMock = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+            expect(String(_input)).toBe("https://kb.example.com/api/cloud/pipelines/pipeline-1/search");
+            expect(init?.method).toBe("POST");
+            expect(new Headers(init?.headers).get("authorization")).toBe("Bearer secret-key");
+            return new Response(JSON.stringify({
+                results: [makePipelineResult()],
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        });
+
+        const result = await searchCloudKnowledgeBase({
+            baseUrl: "https://kb.example.com",
+            apiKey: "secret-key",
+            fetch: fetchMock,
+            pipelineId: "pipeline-1",
+            query: "retention policy",
+            resourceId: { userId: "user-1" },
+        });
+
+        expect(result).toEqual({
+            pipelineId: "pipeline-1",
+            query: "retention policy",
+            hits: [{
+                sourceId: "artifact_1",
+                content: "Retention policy is 30 days for standard workspaces.",
+                score: 0.92,
+                citation: {
+                    sourceId: "artifact_1",
+                    snippet: "Retention policy is 30 days for standard workspaces.",
+                    filename: "policy.pdf",
+                    mimeType: "application/pdf",
+                    pageNumber: 3,
+                    artifactType: "chunk",
+                    parseDocumentId: "parse_1",
+                },
+                metadata: {
+                    filename: "policy.pdf",
+                    mimeType: "application/pdf",
+                    pageNumber: 3,
+                    artifactType: "chunk",
+                    parseDocumentId: "parse_1",
+                },
+            }],
+            citations: [{
+                sourceId: "artifact_1",
+                snippet: "Retention policy is 30 days for standard workspaces.",
+                filename: "policy.pdf",
+                mimeType: "application/pdf",
+                pageNumber: 3,
+                artifactType: "chunk",
+                parseDocumentId: "parse_1",
+            }],
+        });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("supports dynamic pipeline resolution with a provided documents client", async () => {
+        const client = {
+            pipelines: {
+                search: vi.fn(async () => [makePipelineResult({ id: "artifact_2" })]),
+            },
+        } as unknown as KognitiveDocumentsClient;
+        const resolvePipelineId = vi.fn(async ({ resourceId }) => `pipeline-for-${resourceId.userId}`);
+
+        const result = await searchCloudKnowledgeBase({
+            client,
+            resolvePipelineId,
+            query: "retention policy",
+            resourceId: { userId: "tenant-42" },
+        });
+
+        expect(resolvePipelineId).toHaveBeenCalledWith(expect.objectContaining({
+            resourceId: { userId: "tenant-42" },
+        }));
+        expect((client.pipelines.search as any)).toHaveBeenCalledWith("pipeline-for-tenant-42", expect.objectContaining({
+            query: "retention policy",
+        }));
+        expect(result.pipelineId).toBe("pipeline-for-tenant-42");
+        expect(result.hits[0]?.sourceId).toBe("artifact_2");
+    });
+
+    it("preserves spreadsheet and section citation metadata for grounded answers", async () => {
+        const client = {
+            pipelines: {
+                search: vi.fn(async () => [makePipelineResult({
+                    metadata: {
+                        filename: "Excel recetas oncoalicia 2024.xlsx",
+                        artifactType: "spreadsheet_row",
+                        sheetName: "Recetas",
+                        rowNumber: 42,
+                        cellRange: "A42:Z42",
+                        sectionTitle: "Náuseas y vómitos",
+                    },
+                })]),
+            },
+        } as unknown as KognitiveDocumentsClient;
+
+        const result = await searchCloudKnowledgeBase({
+            client,
+            pipelineId: "pipeline-1",
+            query: "nausea recipes",
+            resourceId: { userId: "user-1" },
+        });
+
+        expect(result.hits[0]?.citation).toMatchObject({
+            filename: "Excel recetas oncoalicia 2024.xlsx",
+            artifactType: "spreadsheet_row",
+            sheetName: "Recetas",
+            rowNumber: 42,
+            cellRange: "A42:Z42",
+            sectionTitle: "Náuseas y vómitos",
+        });
+        expect(result.citations[0]).toMatchObject({
+            sheetName: "Recetas",
+            rowNumber: 42,
+            cellRange: "A42:Z42",
+        });
+    });
+
+    it("maps transport failures to a pipeline-scoped error", async () => {
+        const fetchMock = vi.fn(async () => new Response(JSON.stringify({
+            error: "Pipeline unavailable",
+        }), {
+            status: 503,
+            headers: { "content-type": "application/json" },
+        }));
+
+        await expect(searchCloudKnowledgeBase({
+            baseUrl: "https://kb.example.com",
+            fetch: fetchMock,
+            pipelineId: "pipeline-1",
+            query: "retention policy",
+            resourceId: { userId: "user-1" },
+        })).rejects.toThrow('Cloud knowledge base search failed for pipeline "pipeline-1": Pipeline unavailable');
+    });
+
+    it("preserves abort propagation through the documents client transport", async () => {
+        const controller = new AbortController();
+        let requestSignal: AbortSignal | undefined;
+        const fetchMock = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+            requestSignal = init?.signal;
+            return new Promise<Response>((resolve) => {
+                setTimeout(() => {
+                    resolve(new Response(JSON.stringify({
+                        results: [makePipelineResult()],
+                    }), {
+                        status: 200,
+                        headers: { "content-type": "application/json" },
+                    }));
+                }, 20);
+            });
+        });
+
+        const request = searchCloudKnowledgeBase({
+            baseUrl: "https://kb.example.com",
+            fetch: fetchMock,
+            pipelineId: "pipeline-1",
+            query: "retention policy",
+            resourceId: { userId: "user-1" },
+            abortSignal: controller.signal,
+        });
+        controller.abort(new Error("cancelled"));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
+        await expect(request).resolves.toEqual(expect.objectContaining({
+            pipelineId: "pipeline-1",
+        }));
+        expect(requestSignal).toBeInstanceOf(AbortSignal);
+        expect(requestSignal).not.toBe(controller.signal);
+    });
+
+    it("creates a search tool with bounded citation-rich model output", async () => {
+        const client = {
+            pipelines: {
+                search: vi.fn(async () => [
+                    makePipelineResult({
+                        content: "Retention policy is 30 days. ".repeat(20),
+                    }),
+                    makePipelineResult({
+                        id: "artifact_2",
+                        content: "Backups are retained for 90 days. ".repeat(10),
+                    }),
+                ]),
+            },
+        } as unknown as KognitiveDocumentsClient;
+
+        const tool = createCloudKnowledgeBaseSearchTool({
+            client,
+            pipelineId: "pipeline-1",
+            modelSummaryMaxHits: 1,
+            modelSummaryMaxCharacters: 80,
+        });
+
+        const output = await tool.execute({
+            query: "retention policy",
+        }, {
+            resourceId: { userId: "user-1" },
+            abortSignal: new AbortController().signal,
+            emit: () => {},
+        });
+
+        const modelOutput = tool.toModelOutput?.(output);
+        expect(typeof modelOutput).toBe("string");
+        expect(modelOutput).toContain('Knowledge base search results for "retention policy"');
+        expect(modelOutput).toContain("citation=");
+        expect(modelOutput).toContain("Additional hits omitted");
+    });
+
+    it("creates a context adapter that injects system context and auto-registers the search tool", async () => {
+        const adapter = createCloudKnowledgeBaseContextAdapter({
+            pipelineId: "pipeline-1",
+            maxContextHits: 1,
+            maxContextCharacters: 120,
+            fetch: vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+                expect(String(_input)).toBe("https://kb.example.com/api/cloud/pipelines/pipeline-1/search");
+                expect(new Headers(init?.headers).get("authorization")).toBe("Bearer inherited-key");
+                return new Response(JSON.stringify({
+                    results: [makePipelineResult()],
+                }), {
+                    status: 200,
+                    headers: { "content-type": "application/json" },
+                });
+            }),
+        });
+
+        const result = await adapter.resolve({
+            resourceId: { userId: "user-1" },
+            messages: [{
+                role: "user",
+                content: "What is the retention policy?",
+            }] as any,
+            abortSignal: new AbortController().signal,
+            apiKey: "inherited-key",
+            baseUrl: "https://kb.example.com",
+        });
+
+        expect(result.systemBlock).toContain("<CloudKnowledgeBaseContext>");
+        expect(result.systemBlock).toContain("pipeline-1");
+        expect(result.tools?.[0]?.id).toBe("search-cloud-knowledge-base");
+
+        const toolResult = await result.tools?.[0]?.execute({
+            query: "retention policy",
+        }, {
+            resourceId: { userId: "user-1" },
+            abortSignal: new AbortController().signal,
+            emit: () => {},
+        } as any);
+        expect(toolResult).toEqual(expect.objectContaining({
+            pipelineId: "pipeline-1",
+        }));
+    });
+
+    it("prefers explicit adapter backend config over inherited host config", async () => {
+        const fetchMock = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+            expect(String(_input)).toBe("https://explicit.example.com/api/cloud/pipelines/pipeline-1/search");
+            expect(new Headers(init?.headers).get("authorization")).toBe("Bearer explicit-key");
+            return new Response(JSON.stringify({
+                results: [makePipelineResult()],
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        });
+
+        const adapter = createCloudKnowledgeBaseContextAdapter({
+            pipelineId: "pipeline-1",
+            baseUrl: "https://explicit.example.com",
+            apiKey: "explicit-key",
+            fetch: fetchMock,
+        });
+
+        await adapter.resolve({
+            resourceId: { userId: "user-1" },
+            messages: [{ role: "user", content: "retention policy" }] as any,
+            abortSignal: new AbortController().signal,
+            apiKey: "inherited-key",
+            baseUrl: "https://inherited.example.com",
+        });
+
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("prefers an explicit adapter client over inherited backend config", async () => {
+        const client = {
+            pipelines: {
+                search: vi.fn(async () => [makePipelineResult()]),
+            },
+        } as unknown as KognitiveDocumentsClient;
+
+        const adapter = createCloudKnowledgeBaseContextAdapter({
+            client,
+            pipelineId: "pipeline-1",
+        });
+
+        await adapter.resolve({
+            resourceId: { userId: "user-1" },
+            messages: [{ role: "user", content: "retention policy" }] as any,
+            abortSignal: new AbortController().signal,
+            apiKey: "inherited-key",
+            baseUrl: "https://inherited.example.com",
+        });
+
+        expect((client.pipelines.search as any)).toHaveBeenCalledWith(
+            "pipeline-1",
+            expect.objectContaining({ query: "retention policy" }),
+        );
+    });
+
+    it("throws a clear error when neither explicit nor inherited backend config is available", async () => {
+        const adapter = createCloudKnowledgeBaseContextAdapter({
+            pipelineId: "pipeline-1",
+        });
+
+        await expect(adapter.resolve({
+            resourceId: { userId: "user-1" },
+            messages: [{ role: "user", content: "retention policy" }] as any,
+            abortSignal: new AbortController().signal,
+        })).rejects.toThrow(
+            "Cloud knowledge base backend configuration is missing. Provide a documents client or a baseUrl, or inherit them from the host agent/workflow.",
+        );
+    });
+
+    it("provides cloud knowledge base search and answer workflow wrappers", async () => {
+        const client = {
+            pipelines: {
+                search: vi.fn(async () => [makePipelineResult()]),
+            },
+        } as unknown as KognitiveDocumentsClient;
+        const agent = {
+            generateObject: vi.fn(async () => ({
+                text: "",
+                object: {
+                    answer: "The retention policy is 30 days.",
+                    citations: [{
+                        sourceId: "artifact_1",
+                        snippet: "Retention policy is 30 days for standard workspaces.",
+                        filename: "policy.pdf",
+                    }],
+                },
+                toolCalls: [],
+            })),
+        };
+
+        const searchWorkflow = createWorkflow<{ query: string }>({ name: "cloud-kb-search" })
+            .then(createCloudKnowledgeBaseSearchStep({
+                id: "kb-search",
+                client,
+                resolvePipelineId: ({ resourceId }) => `pipeline-${resourceId.userId}`,
+                getQuery: (input) => input.query,
+            }))
+            .build();
+
+        const answerWorkflow = createWorkflow<{ query: string }>({ name: "cloud-kb-answer" })
+            .then(createCloudKnowledgeBaseAnswerStep({
+                id: "kb-answer",
+                client,
+                pipelineId: "pipeline-1",
+                agent,
+                getQuery: (input) => input.query,
+            }))
+            .build();
+
+        const searchResult = await searchWorkflow.execute(
+            { query: "retention policy" },
+            { resourceId: { userId: "user-1" } },
+        );
+        const answerResult = await answerWorkflow.execute(
+            { query: "retention policy" },
+            { resourceId: { userId: "user-1" } },
+        );
+
+        expect(searchResult.output).toEqual(expect.objectContaining({
+            pipelineId: "pipeline-user-1",
+            citations: expect.arrayContaining([expect.objectContaining({ sourceId: "artifact_1" })]),
+        }));
+        expect(answerResult.output).toEqual({
+            answer: "The retention policy is 30 days.",
+            citations: [{
+                sourceId: "artifact_1",
+                snippet: "Retention policy is 30 days for standard workspaces.",
+                filename: "policy.pdf",
+            }],
+        });
+    });
+
+    it("inherits workflow backend config from execute options and lets explicit step config override it", async () => {
+        const inheritedFetch = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+            expect(String(_input)).toBe("https://workflow.example.com/api/cloud/pipelines/pipeline-1/search");
+            expect(new Headers(init?.headers).get("authorization")).toBe("Bearer workflow-key");
+            return new Response(JSON.stringify({
+                results: [makePipelineResult()],
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        });
+        const explicitFetch = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+            expect(String(_input)).toBe("https://explicit.example.com/api/cloud/pipelines/pipeline-2/search");
+            expect(new Headers(init?.headers).get("authorization")).toBe("Bearer explicit-key");
+            return new Response(JSON.stringify({
+                results: [makePipelineResult({ id: "artifact_2" })],
+            }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        });
+
+        const inheritedStep = createCloudKnowledgeBaseSearchStep({
+            id: "kb-search",
+            pipelineId: "pipeline-1",
+            fetch: inheritedFetch,
+            getQuery: (input: { query: string }) => input.query,
+        });
+        const explicitStep = createCloudKnowledgeBaseSearchStep({
+            id: "kb-search",
+            pipelineId: "pipeline-2",
+            baseUrl: "https://explicit.example.com",
+            apiKey: "explicit-key",
+            fetch: explicitFetch,
+            getQuery: (input: { query: string }) => input.query,
+        });
+
+        const inheritedResult = await inheritedStep.execute(
+            { query: "retention policy" },
+            {
+                state: {},
+                resourceId: { userId: "user-1" },
+                abortSignal: new AbortController().signal,
+                suspend: async () => {
+                    throw new Error("suspend should not be called");
+                },
+                emit: () => {},
+                apiKey: "workflow-key",
+                baseUrl: "https://workflow.example.com",
+            } as any,
+        );
+        const explicitResult = await explicitStep.execute(
+            { query: "retention policy" },
+            {
+                state: {},
+                resourceId: { userId: "user-1" },
+                abortSignal: new AbortController().signal,
+                suspend: async () => {
+                    throw new Error("suspend should not be called");
+                },
+                emit: () => {},
+                apiKey: "workflow-key",
+                baseUrl: "https://workflow.example.com",
+            } as any,
+        );
+
+        expect(inheritedFetch).toHaveBeenCalledTimes(1);
+        expect(explicitFetch).toHaveBeenCalledTimes(1);
+        expect(inheritedResult).toEqual(expect.objectContaining({
+            pipelineId: "pipeline-1",
+        }));
+        expect(explicitResult).toEqual(expect.objectContaining({
+            pipelineId: "pipeline-2",
+            hits: [expect.objectContaining({ sourceId: "artifact_2" })],
+        }));
+    });
+});

package/src/context-adapter.ts

@@ -0,0 +1,65 @@
+import type { CloudKnowledgeBaseContextAdapter, CloudKnowledgeBaseContextAdapterOptions } from "./types";
+import { buildSystemBlock, extractLastUserText } from "./shared";
+import { searchCloudKnowledgeBase } from "./search";
+import { createCloudKnowledgeBaseSearchTool } from "./tool";
+
+function createInheritedSearchTool(
+    options: CloudKnowledgeBaseContextAdapterOptions,
+    input: { apiKey?: string; baseUrl?: string },
+) {
+    if (options.autoRegisterSearchTool === false) {
+        return null;
+    }
+
+    return createCloudKnowledgeBaseSearchTool({
+        ...options,
+        ...options.searchTool,
+        client: options.searchTool?.client ?? options.client,
+        baseUrl: options.searchTool?.baseUrl ?? options.baseUrl ?? input.baseUrl,
+        apiKey: options.searchTool?.apiKey ?? options.apiKey ?? input.apiKey,
+        fetch: options.searchTool?.fetch ?? options.fetch,
+        timeout: options.searchTool?.timeout ?? options.timeout,
+        logLevel: options.searchTool?.logLevel ?? options.logLevel,
+        pipelineId: options.searchTool?.pipelineId ?? options.pipelineId,
+        resolvePipelineId: options.searchTool?.resolvePipelineId ?? options.resolvePipelineId,
+    });
+}
+
+export function createCloudKnowledgeBaseContextAdapter(
+    options: CloudKnowledgeBaseContextAdapterOptions,
+): CloudKnowledgeBaseContextAdapter {
+    return {
+        async resolve(input) {
+            const resolvedInput = input as typeof input & { apiKey?: string; baseUrl?: string };
+            const searchTool = createInheritedSearchTool(options, resolvedInput);
+            const query = (options.buildQuery
+                ? await options.buildQuery(resolvedInput)
+                : extractLastUserText(resolvedInput.messages))
+                .trim();
+
+            if (!query) {
+                return searchTool ? { tools: [searchTool] } : {};
+            }
+
+            const search = await searchCloudKnowledgeBase({
+                ...options,
+                query,
+                resourceId: resolvedInput.resourceId,
+                messages: resolvedInput.messages,
+                metadata: resolvedInput.metadata,
+                abortSignal: resolvedInput.abortSignal,
+                apiKey: options.apiKey ?? resolvedInput.apiKey,
+                baseUrl: options.baseUrl ?? resolvedInput.baseUrl,
+            });
+
+            return {
+                systemBlock: buildSystemBlock(search, {
+                    maxHits: options.maxContextHits,
+                    maxCharacters: options.maxContextCharacters,
+                    emptyStateMessage: options.emptyStateMessage,
+                }),
+                ...(searchTool ? { tools: [searchTool] } : {}),
+            };
+        },
+    };
+}