@kognitivedev/cloud-knowledge-base 0.2.29

package/src/index.ts

@@ -0,0 +1,29 @@
+export { searchCloudKnowledgeBase } from "./search";
+export { createCloudKnowledgeBaseSearchTool } from "./tool";
+export { createCloudKnowledgeBaseContextAdapter } from "./context-adapter";
+export {
+    createCloudKnowledgeBaseSearchStep,
+    createCloudKnowledgeBaseAnswerStep,
+} from "./workflow";
+
+export {
+    createKnowledgeBaseSearchStep,
+    createKnowledgeBaseAnswerStep,
+    DEFAULT_KNOWLEDGE_BASE_ANSWER_SCHEMA,
+} from "@kognitivedev/workflows";
+
+export type {
+    CloudKnowledgeBaseCitation,
+    CloudKnowledgeBaseHit,
+    CloudKnowledgeBaseSearchResponse,
+    CloudKnowledgeBaseAnswer,
+    CloudKnowledgeBaseResolverInput,
+    CloudKnowledgeBaseClientOptions,
+    CloudKnowledgeBasePipelineOptions,
+    CloudKnowledgeBaseSearchOptions,
+    CloudKnowledgeBaseSearchToolOptions,
+    CloudKnowledgeBaseContextAdapterOptions,
+    CloudKnowledgeBaseContextAdapter,
+    CloudKnowledgeBaseSearchStepOptions,
+    CloudKnowledgeBaseAnswerStepOptions,
+} from "./types";

package/src/search.ts

@@ -0,0 +1,40 @@
+import type { CloudKnowledgeBaseSearchOptions, CloudKnowledgeBaseSearchResponse } from "./types";
+import { normalizeSearchResult, resolveSearchConfig } from "./shared";
+
+export async function searchCloudKnowledgeBase(
+    options: CloudKnowledgeBaseSearchOptions,
+): Promise<CloudKnowledgeBaseSearchResponse> {
+    const query = options.query.trim();
+    if (!query) {
+        throw new Error("Cloud knowledge base search requires a non-empty query.");
+    }
+
+    const { client, pipelineId } = await resolveSearchConfig(options, {
+        resourceId: options.resourceId,
+        messages: options.messages,
+        metadata: options.metadata,
+        abortSignal: options.abortSignal,
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+    });
+
+    try {
+        const results = await client.pipelines.search(pipelineId, {
+            query,
+            topK: options.topK,
+            retrievalMode: options.retrievalMode,
+        });
+        const hits = results.map((result) => normalizeSearchResult(result, options.snippetMaxLength));
+        return {
+            pipelineId,
+            query,
+            hits,
+            citations: hits.map((hit) => hit.citation),
+        };
+    } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        const wrapped = new Error(`Cloud knowledge base search failed for pipeline "${pipelineId}": ${reason}`);
+        (wrapped as Error & { cause?: unknown }).cause = error;
+        throw wrapped;
+    }
+}

package/src/shared.ts

@@ -0,0 +1,224 @@
+import { KognitiveDocumentsClient, type PipelineSearchResult } from "@kognitivedev/documents";
+import type {
+    CloudKnowledgeBaseCitation,
+    CloudKnowledgeBaseClientOptions,
+    CloudKnowledgeBasePipelineOptions,
+    CloudKnowledgeBaseResolverInput,
+    CloudKnowledgeBaseSearchResponse,
+    ResolvedCloudKnowledgeBaseSearchConfig,
+} from "./types";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeText(value: unknown): string | undefined {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function normalizeNumber(value: unknown): number | undefined {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+    return undefined;
+}
+
+export function createSnippet(content: string, maxLength = 240): string {
+    const normalized = content.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+export function createModelSummary(
+    response: CloudKnowledgeBaseSearchResponse,
+    options: { maxHits?: number; maxCharacters?: number } = {},
+): string {
+    const maxHits = options.maxHits ?? 4;
+    const maxCharacters = options.maxCharacters ?? 320;
+    const lines = [
+        `Knowledge base search results for "${response.query}" in pipeline ${response.pipelineId}:`,
+    ];
+
+    for (const [index, hit] of response.hits.slice(0, maxHits).entries()) {
+        const citation = hit.citation;
+        const source = [
+            citation.filename ?? hit.sourceId,
+            typeof citation.pageNumber === "number" ? `page ${citation.pageNumber}` : null,
+            citation.sectionTitle ? `section ${citation.sectionTitle}` : null,
+            citation.sheetName ? `sheet ${citation.sheetName}` : null,
+            typeof citation.rowNumber === "number" ? `row ${citation.rowNumber}` : null,
+            citation.cellRange ? `range ${citation.cellRange}` : null,
+            citation.artifactType ?? null,
+        ].filter(Boolean).join(" | ");
+        lines.push(
+            `[${index + 1}] score=${hit.score.toFixed(3)} source=${source}`,
+            createSnippet(hit.content || citation.snippet, maxCharacters),
+            `citation=${JSON.stringify(citation)}`,
+        );
+    }
+
+    if (response.hits.length > maxHits) {
+        lines.push(`Additional hits omitted: ${response.hits.length - maxHits}`);
+    }
+
+    return lines.join("\n");
+}
+
+export function buildSystemBlock(
+    response: CloudKnowledgeBaseSearchResponse,
+    options: { maxHits?: number; maxCharacters?: number; emptyStateMessage?: string } = {},
+): string {
+    if (response.hits.length === 0) {
+        return [
+            "<CloudKnowledgeBaseContext>",
+            options.emptyStateMessage ?? `No relevant cloud knowledge base hits were found for query "${response.query}".`,
+            "</CloudKnowledgeBaseContext>",
+        ].join("\n");
+    }
+
+    return [
+        "<CloudKnowledgeBaseContext>",
+        `Pipeline: ${response.pipelineId}`,
+        `Query: ${response.query}`,
+        createModelSummary(response, {
+            maxHits: options.maxHits,
+            maxCharacters: options.maxCharacters,
+        }),
+        "Use these results as authoritative managed knowledge base context and cite matching sources when answering.",
+        "</CloudKnowledgeBaseContext>",
+    ].join("\n");
+}
+
+export function createDocumentsClient(options: CloudKnowledgeBaseClientOptions) {
+    if (options.client) {
+        return options.client;
+    }
+    if (!options.baseUrl) {
+        throw new Error(
+            "Cloud knowledge base backend configuration is missing. Provide a documents client or a baseUrl.",
+        );
+    }
+    return new KognitiveDocumentsClient({
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
+        fetch: options.fetch,
+        timeout: options.timeout,
+        logLevel: options.logLevel,
+    });
+}
+
+export function resolveClientOptions(
+    options: CloudKnowledgeBaseClientOptions,
+    inherited?: Pick<CloudKnowledgeBaseResolverInput, "apiKey" | "baseUrl">,
+): CloudKnowledgeBaseClientOptions {
+    if (options.client) {
+        return options;
+    }
+
+    const baseUrl = options.baseUrl ?? inherited?.baseUrl;
+    if (!baseUrl) {
+        throw new Error(
+            "Cloud knowledge base backend configuration is missing. Provide a documents client or a baseUrl, or inherit them from the host agent/workflow.",
+        );
+    }
+
+    return {
+        ...options,
+        baseUrl,
+        apiKey: options.apiKey ?? inherited?.apiKey,
+    };
+}
+
+export async function resolveSearchConfig(
+    options: CloudKnowledgeBaseClientOptions & CloudKnowledgeBasePipelineOptions,
+    input: CloudKnowledgeBaseResolverInput,
+): Promise<ResolvedCloudKnowledgeBaseSearchConfig> {
+    const hasPipelineId = typeof options.pipelineId === "string" && options.pipelineId.trim().length > 0;
+    const hasResolver = typeof options.resolvePipelineId === "function";
+
+    if (hasPipelineId === hasResolver) {
+        throw new Error("Configure exactly one of pipelineId or resolvePipelineId for the cloud knowledge base.");
+    }
+
+    const pipelineId = hasPipelineId
+        ? options.pipelineId!.trim()
+        : await options.resolvePipelineId!({
+            resourceId: input.resourceId,
+            messages: input.messages,
+            metadata: input.metadata,
+            abortSignal: input.abortSignal,
+            apiKey: input.apiKey,
+            baseUrl: input.baseUrl,
+        });
+
+    if (typeof pipelineId !== "string" || pipelineId.trim().length === 0) {
+        throw new Error("Cloud knowledge base pipeline resolution returned an empty pipeline id.");
+    }
+
+    return {
+        client: createDocumentsClient(resolveClientOptions(options, input)),
+        pipelineId: pipelineId.trim(),
+    };
+}
+
+export function normalizeSearchResult(result: PipelineSearchResult, snippetMaxLength = 240) {
+    const metadata = isRecord(result.metadata) ? result.metadata : undefined;
+    const content = normalizeText(result.content) ?? "";
+    const citation: CloudKnowledgeBaseCitation = {
+        sourceId: result.id,
+        snippet: normalizeText(metadata?.snippet) ?? createSnippet(content, snippetMaxLength),
+        ...(normalizeText(metadata?.filename) ? { filename: normalizeText(metadata?.filename) } : {}),
+        ...(normalizeText(metadata?.mimeType) ? { mimeType: normalizeText(metadata?.mimeType) } : {}),
+        ...(normalizeNumber(metadata?.pageNumber) !== undefined ? { pageNumber: normalizeNumber(metadata?.pageNumber) } : {}),
+        ...(normalizeText(metadata?.artifactType) || normalizeText(metadata?.blockType) || normalizeText(metadata?.kind)
+            ? { artifactType: normalizeText(metadata?.artifactType) ?? normalizeText(metadata?.blockType) ?? normalizeText(metadata?.kind) }
+            : {}),
+        ...(normalizeText(metadata?.parseDocumentId) ? { parseDocumentId: normalizeText(metadata?.parseDocumentId) } : {}),
+        ...(normalizeText(metadata?.sectionTitle) ? { sectionTitle: normalizeText(metadata?.sectionTitle) } : {}),
+        ...(normalizeText(metadata?.sheetName) ? { sheetName: normalizeText(metadata?.sheetName) } : {}),
+        ...(normalizeNumber(metadata?.rowNumber) !== undefined ? { rowNumber: normalizeNumber(metadata?.rowNumber) } : {}),
+        ...(normalizeText(metadata?.cellRange) ? { cellRange: normalizeText(metadata?.cellRange) } : {}),
+    };
+
+    return {
+        sourceId: result.id,
+        content,
+        score: typeof result.score === "number" ? result.score : 0,
+        citation,
+        ...(metadata ? { metadata } : {}),
+    };
+}
+
+export function extractLastUserText(messages: unknown[] | undefined): string {
+    if (!Array.isArray(messages)) return "";
+
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (!isRecord(message) || message.role !== "user") continue;
+
+        const parts = Array.isArray(message.parts)
+            ? message.parts
+            : Array.isArray(message.content)
+                ? message.content
+                : [message.content];
+
+        const text = parts
+            .map((part) => {
+                if (typeof part === "string") return part;
+                if (isRecord(part) && typeof part.text === "string") return part.text;
+                return "";
+            })
+            .join("\n")
+            .trim();
+
+        if (text) {
+            return text;
+        }
+    }
+
+    return "";
+}

package/src/tool.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { createTool } from "@kognitivedev/tools";
+import type { Tool } from "@kognitivedev/tools";
+import { searchCloudKnowledgeBase } from "./search";
+import { createModelSummary } from "./shared";
+import type { CloudKnowledgeBaseSearchResponse, CloudKnowledgeBaseSearchToolOptions } from "./types";
+
+const SearchInputSchema = z.object({
+    query: z.string().min(1).describe("Natural-language query to run against the managed cloud knowledge base."),
+    topK: z.number().int().min(1).max(50).optional().describe("Maximum number of results to return."),
+    retrievalMode: z.enum(["chunks", "files_via_metadata", "files_via_content", "auto_routed"]).optional()
+        .describe("Pipeline retrieval mode override."),
+});
+
+const CitationSchema = z.object({
+    sourceId: z.string(),
+    snippet: z.string(),
+    filename: z.string().optional(),
+    mimeType: z.string().optional(),
+    pageNumber: z.number().optional(),
+    artifactType: z.string().optional(),
+    parseDocumentId: z.string().optional(),
+    sectionTitle: z.string().optional(),
+    sheetName: z.string().optional(),
+    rowNumber: z.number().optional(),
+    cellRange: z.string().optional(),
+});
+
+const HitSchema = z.object({
+    sourceId: z.string(),
+    content: z.string(),
+    score: z.number(),
+    citation: CitationSchema,
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+const SearchOutputSchema = z.object({
+    pipelineId: z.string(),
+    query: z.string(),
+    hits: z.array(HitSchema),
+    citations: z.array(CitationSchema),
+});
+
+export function createCloudKnowledgeBaseSearchTool(
+    options: CloudKnowledgeBaseSearchToolOptions,
+): Tool<
+    z.infer<typeof SearchInputSchema>,
+    CloudKnowledgeBaseSearchResponse
+> {
+    return createTool<z.infer<typeof SearchInputSchema>, CloudKnowledgeBaseSearchResponse>({
+        id: options.id ?? "search-cloud-knowledge-base",
+        description: options.description
+            ?? "Search a managed cloud knowledge base pipeline and return normalized hits with enterprise-grade citations.",
+        inputSchema: SearchInputSchema,
+        outputSchema: SearchOutputSchema as z.ZodType<CloudKnowledgeBaseSearchResponse>,
+        execute: async (input, context) => searchCloudKnowledgeBase({
+            ...options,
+            query: input.query,
+            topK: input.topK ?? options.topK,
+            retrievalMode: input.retrievalMode ?? options.retrievalMode,
+            resourceId: context.resourceId,
+            metadata: context.metadata,
+            abortSignal: context.abortSignal,
+        }),
+        toModelOutput: (output) => createModelSummary(output, {
+            maxHits: options.modelSummaryMaxHits,
+            maxCharacters: options.modelSummaryMaxCharacters,
+        }),
+    });
+}

package/src/types.ts

@@ -0,0 +1,131 @@
+import type { AgentContextAdapter } from "@kognitivedev/agents";
+import type {
+    DocumentsClientConfig,
+    KognitiveDocumentsClient,
+    LogLevel,
+    PipelineRetrievalMode,
+} from "@kognitivedev/documents";
+import type { KognitiveMessage, Metadata, ResourceId } from "@kognitivedev/shared";
+import type {
+    KnowledgeBaseAnswer,
+    KnowledgeBaseCitation,
+    KnowledgeBaseHit,
+    KnowledgeBaseSearchResponse,
+} from "@kognitivedev/workflows";
+
+export type CloudKnowledgeBaseCitation = KnowledgeBaseCitation;
+export type CloudKnowledgeBaseHit = KnowledgeBaseHit;
+export type CloudKnowledgeBaseSearchResponse = KnowledgeBaseSearchResponse;
+export type CloudKnowledgeBaseAnswer = KnowledgeBaseAnswer;
+
+export interface CloudKnowledgeBaseResolverInput {
+    resourceId: ResourceId;
+    messages?: KognitiveMessage[];
+    metadata?: Metadata;
+    abortSignal?: AbortSignal;
+    apiKey?: string;
+    baseUrl?: string;
+}
+
+export interface CloudKnowledgeBaseClientOptions {
+    client?: KognitiveDocumentsClient;
+    baseUrl?: string;
+    apiKey?: string;
+    fetch?: DocumentsClientConfig["fetch"];
+    timeout?: number;
+    logLevel?: LogLevel;
+}
+
+export interface CloudKnowledgeBasePipelineOptions {
+    pipelineId?: string;
+    resolvePipelineId?: (input: CloudKnowledgeBaseResolverInput) => Promise<string> | string;
+}
+
+export interface CloudKnowledgeBaseSearchOptions
+    extends CloudKnowledgeBaseClientOptions, CloudKnowledgeBasePipelineOptions {
+    query: string;
+    topK?: number;
+    retrievalMode?: PipelineRetrievalMode;
+    resourceId: ResourceId;
+    messages?: KognitiveMessage[];
+    metadata?: Metadata;
+    abortSignal?: AbortSignal;
+    snippetMaxLength?: number;
+}
+
+export interface CloudKnowledgeBaseSearchToolOptions
+    extends CloudKnowledgeBaseClientOptions, CloudKnowledgeBasePipelineOptions {
+    id?: string;
+    description?: string;
+    topK?: number;
+    retrievalMode?: PipelineRetrievalMode;
+    snippetMaxLength?: number;
+    modelSummaryMaxHits?: number;
+    modelSummaryMaxCharacters?: number;
+}
+
+export interface CloudKnowledgeBaseContextAdapterOptions
+    extends CloudKnowledgeBaseClientOptions, CloudKnowledgeBasePipelineOptions {
+    topK?: number;
+    retrievalMode?: PipelineRetrievalMode;
+    snippetMaxLength?: number;
+    maxContextHits?: number;
+    maxContextCharacters?: number;
+    autoRegisterSearchTool?: boolean;
+    searchTool?: CloudKnowledgeBaseSearchToolOptions;
+    buildQuery?: (input: CloudKnowledgeBaseResolverInput) => Promise<string> | string;
+    emptyStateMessage?: string;
+}
+
+export interface CloudKnowledgeBaseSearchStepOptions<TInput, TOutput = CloudKnowledgeBaseSearchResponse>
+    extends CloudKnowledgeBaseClientOptions, CloudKnowledgeBasePipelineOptions {
+    id: string;
+    description?: string;
+    getQuery: (input: TInput, context: { resourceId: ResourceId; abortSignal: AbortSignal }) => Promise<string> | string;
+    topK?: number | ((input: TInput, context: { resourceId: ResourceId; abortSignal: AbortSignal }) => Promise<number | undefined> | number | undefined);
+    retrievalMode?: PipelineRetrievalMode | ((
+        input: TInput,
+        context: { resourceId: ResourceId; abortSignal: AbortSignal },
+    ) => Promise<PipelineRetrievalMode | undefined> | PipelineRetrievalMode | undefined);
+    snippetMaxLength?: number;
+    extractOutput?: (result: CloudKnowledgeBaseSearchResponse) => TOutput;
+}
+
+export interface CloudKnowledgeBaseAnswerStepOptions<TInput, TOutput = CloudKnowledgeBaseAnswer>
+    extends CloudKnowledgeBaseClientOptions, CloudKnowledgeBasePipelineOptions {
+    id: string;
+    description?: string;
+    agent: {
+        generateObject(options: {
+            messages: any[];
+            resourceId: ResourceId;
+            abortSignal?: AbortSignal;
+            structuredOutput: any;
+            temperature?: number;
+            maxOutputTokens?: number;
+        }): Promise<any>;
+    };
+    getQuery: (input: TInput, context: { resourceId: ResourceId; abortSignal: AbortSignal }) => Promise<string> | string;
+    topK?: number | ((input: TInput, context: { resourceId: ResourceId; abortSignal: AbortSignal }) => Promise<number | undefined> | number | undefined);
+    retrievalMode?: PipelineRetrievalMode | ((
+        input: TInput,
+        context: { resourceId: ResourceId; abortSignal: AbortSignal },
+    ) => Promise<PipelineRetrievalMode | undefined> | PipelineRetrievalMode | undefined);
+    snippetMaxLength?: number;
+    buildMessages?: (input: TInput, search: CloudKnowledgeBaseSearchResponse) => any[];
+    temperature?: number;
+    maxOutputTokens?: number;
+    emptyResultAnswer?: string;
+    extractOutput?: (result: {
+        answer: CloudKnowledgeBaseAnswer;
+        search: CloudKnowledgeBaseSearchResponse;
+        agentResult?: any;
+    }) => TOutput;
+}
+
+export interface ResolvedCloudKnowledgeBaseSearchConfig {
+    client: KognitiveDocumentsClient;
+    pipelineId: string;
+}
+
+export interface CloudKnowledgeBaseContextAdapter extends AgentContextAdapter {}

package/src/workflow.ts

@@ -0,0 +1,102 @@
+import type { PipelineRetrievalMode } from "@kognitivedev/documents";
+import {
+    createKnowledgeBaseAnswerStep,
+    createKnowledgeBaseSearchStep,
+    type StepContext,
+    type StepDefinition,
+} from "@kognitivedev/workflows";
+import { searchCloudKnowledgeBase } from "./search";
+import type {
+    CloudKnowledgeBaseAnswer,
+    CloudKnowledgeBaseAnswerStepOptions,
+    CloudKnowledgeBaseSearchResponse,
+    CloudKnowledgeBaseSearchStepOptions,
+} from "./types";
+
+async function resolveStepValue<TInput, TValue>(
+    value: TValue | ((input: TInput, context: { resourceId: StepContext["resourceId"]; abortSignal: AbortSignal }) => Promise<TValue> | TValue),
+    input: TInput,
+    context: StepContext,
+): Promise<TValue> {
+    if (typeof value === "function") {
+        return (value as (input: TInput, context: { resourceId: StepContext["resourceId"]; abortSignal: AbortSignal }) => Promise<TValue> | TValue)(
+            input,
+            { resourceId: context.resourceId, abortSignal: context.abortSignal },
+        );
+    }
+    return value;
+}
+
+async function searchForWorkflow<TInput>(
+    options: {
+        getQuery: (input: TInput, context: { resourceId: StepContext["resourceId"]; abortSignal: AbortSignal }) => Promise<string> | string;
+        topK?: number | ((input: TInput, context: { resourceId: StepContext["resourceId"]; abortSignal: AbortSignal }) => Promise<number | undefined> | number | undefined);
+        retrievalMode?: PipelineRetrievalMode | ((
+            input: TInput,
+            context: { resourceId: StepContext["resourceId"]; abortSignal: AbortSignal },
+        ) => Promise<PipelineRetrievalMode | undefined> | PipelineRetrievalMode | undefined);
+        snippetMaxLength?: number;
+        client?: CloudKnowledgeBaseSearchStepOptions<TInput>["client"];
+        baseUrl?: CloudKnowledgeBaseSearchStepOptions<TInput>["baseUrl"];
+        apiKey?: CloudKnowledgeBaseSearchStepOptions<TInput>["apiKey"];
+        fetch?: CloudKnowledgeBaseSearchStepOptions<TInput>["fetch"];
+        timeout?: CloudKnowledgeBaseSearchStepOptions<TInput>["timeout"];
+        logLevel?: CloudKnowledgeBaseSearchStepOptions<TInput>["logLevel"];
+        pipelineId?: CloudKnowledgeBaseSearchStepOptions<TInput>["pipelineId"];
+        resolvePipelineId?: CloudKnowledgeBaseSearchStepOptions<TInput>["resolvePipelineId"];
+    },
+    input: TInput,
+    context: StepContext,
+): Promise<CloudKnowledgeBaseSearchResponse> {
+    const inheritedContext = context as StepContext & { apiKey?: string; baseUrl?: string };
+    const query = await options.getQuery(input, {
+        resourceId: inheritedContext.resourceId,
+        abortSignal: inheritedContext.abortSignal,
+    });
+
+    return searchCloudKnowledgeBase({
+        client: options.client,
+        baseUrl: options.baseUrl ?? inheritedContext.baseUrl,
+        apiKey: options.apiKey ?? 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,
+    });
+}
+
+export function createCloudKnowledgeBaseSearchStep<TInput, TOutput = CloudKnowledgeBaseSearchResponse>(
+    options: CloudKnowledgeBaseSearchStepOptions<TInput, TOutput>,
+): StepDefinition<TInput, TOutput> {
+    return createKnowledgeBaseSearchStep<TInput, CloudKnowledgeBaseSearchResponse, TOutput>({
+        id: options.id,
+        description: options.description,
+        search: async (input, context) => searchForWorkflow(options, input, context),
+        extractOutput: options.extractOutput,
+    });
+}
+
+export function createCloudKnowledgeBaseAnswerStep<TInput, TOutput = CloudKnowledgeBaseAnswer>(
+    options: CloudKnowledgeBaseAnswerStepOptions<TInput, TOutput>,
+): StepDefinition<TInput, TOutput> {
+    return createKnowledgeBaseAnswerStep<TInput, CloudKnowledgeBaseSearchResponse, TOutput>({
+        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/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "module": "commonjs",
+        "rootDir": "src",
+        "outDir": "dist",
+        "declaration": true,
+        "noEmit": false,
+        "incremental": false
+    },
+    "include": ["src"],
+    "exclude": ["src/__tests__"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: "node",
+    },
+});