@elizaos/agent 0.25.9 → 2.0.0-alpha.144

package/packages/typescript/src/features/knowledge/documents-provider.js

@@ -0,0 +1,106 @@
+import { logger } from "../../logger";
+import { MemoryType } from "../../types";
+import { addHeader } from "../../utils";
+export const documentsProvider = {
+    name: "AVAILABLE_DOCUMENTS",
+    description: "List of documents available in the knowledge base. Shows which documents the agent can reference and retrieve information from.",
+    dynamic: true,
+    get: async (runtime, _message, _state) => {
+        try {
+            const knowledgeService = runtime.getService("knowledge");
+            if (!knowledgeService) {
+                logger.warn("Knowledge service not available for documents provider");
+                return {
+                    data: { documents: [] },
+                    values: {
+                        documentsCount: 0,
+                        documents: "",
+                        availableDocuments: "",
+                    },
+                    text: "",
+                };
+            }
+            const allMemories = await knowledgeService.getMemories({
+                tableName: "documents",
+                roomId: runtime.agentId,
+                count: 100,
+            });
+            const documents = allMemories.filter((memory) => memory.metadata?.type === MemoryType.DOCUMENT);
+            if (!documents || documents.length === 0) {
+                return {
+                    data: { documents: [] },
+                    values: {
+                        documentsCount: 0,
+                        documents: "",
+                        availableDocuments: "",
+                    },
+                    text: "",
+                };
+            }
+            const documentsList = documents
+                .map((doc, index) => {
+                const metadata = doc.metadata;
+                const filename = metadata?.filename || metadata?.title || `Document ${index + 1}`;
+                const fileType = metadata?.fileExt || metadata?.fileType || "";
+                const source = metadata?.source || "upload";
+                const fileSize = metadata?.fileSize;
+                const parts = [filename];
+                if (fileType) {
+                    parts.push(fileType);
+                }
+                if (fileSize) {
+                    const sizeKB = Math.round(fileSize / 1024);
+                    if (sizeKB > 1024) {
+                        parts.push(`${Math.round(sizeKB / 1024)}MB`);
+                    }
+                    else {
+                        parts.push(`${sizeKB}KB`);
+                    }
+                }
+                if (source && source !== "upload") {
+                    parts.push(`from ${source}`);
+                }
+                return parts.join(" - ");
+            })
+                .join("\n");
+            const documentsText = addHeader("# Available Documents", `${documents.length} document(s) in knowledge base:\n${documentsList}`);
+            return {
+                data: {
+                    documents: documents.map((doc) => ({
+                        id: doc.id,
+                        filename: doc.metadata
+                            ?.filename ||
+                            doc.metadata?.title,
+                        fileType: doc.metadata
+                            ?.fileType ||
+                            doc.metadata?.fileExt,
+                        source: doc.metadata
+                            ?.source,
+                    })),
+                    count: documents.length,
+                },
+                values: {
+                    documentsCount: documents.length,
+                    documents: documentsList,
+                    availableDocuments: documentsText,
+                },
+                text: documentsText,
+            };
+        }
+        catch (error) {
+            logger.error("Error in documents provider:", error instanceof Error ? error.message : String(error));
+            return {
+                data: {
+                    documents: [],
+                    error: error instanceof Error ? error.message : String(error),
+                },
+                values: {
+                    documentsCount: 0,
+                    documents: "",
+                    availableDocuments: "",
+                },
+                text: "",
+            };
+        }
+    },
+};

package/packages/typescript/src/features/knowledge/index.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from "../../types";
+export interface KnowledgePluginConfig {
+    enableActions?: boolean;
+    enableProviders?: boolean;
+}
+export declare function createKnowledgePlugin(config?: KnowledgePluginConfig): Plugin;
+export declare const knowledgePlugin: Plugin;
+export declare const knowledgePluginCore: Plugin;
+export declare const knowledgePluginHeadless: Plugin;
+export default knowledgePlugin;
+export { knowledgeActions } from "./actions";
+export { documentsProvider } from "./documents-provider";
+export { knowledgeProvider } from "./provider";
+export { KnowledgeService } from "./service";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/knowledge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/knowledge/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAM1C,MAAM,WAAW,qBAAqB;IACrC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,qBAAqB,CACpC,MAAM,GAAE,qBAA0B,GAChC,MAAM,CAWR;AAED,eAAO,MAAM,eAAe,QAA0B,CAAC;AACvD,eAAO,MAAM,mBAAmB,QAG9B,CAAC;AACH,eAAO,MAAM,uBAAuB,QAGlC,CAAC;AAEH,eAAe,eAAe,CAAC;AAE/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,cAAc,SAAS,CAAC"}

package/packages/typescript/src/features/knowledge/index.js

@@ -0,0 +1,29 @@
+import { knowledgeActions } from "./actions";
+import { documentsProvider } from "./documents-provider";
+import { knowledgeProvider } from "./provider";
+import { KnowledgeService } from "./service";
+export function createKnowledgePlugin(config = {}) {
+    const { enableActions = true, enableProviders = true } = config;
+    return {
+        name: "knowledge",
+        description: "Native Retrieval Augmented Generation capabilities, including knowledge ingestion and retrieval.",
+        services: [KnowledgeService],
+        providers: enableProviders ? [knowledgeProvider, documentsProvider] : [],
+        actions: enableActions ? knowledgeActions : [],
+    };
+}
+export const knowledgePlugin = createKnowledgePlugin();
+export const knowledgePluginCore = createKnowledgePlugin({
+    enableActions: false,
+    enableProviders: true,
+});
+export const knowledgePluginHeadless = createKnowledgePlugin({
+    enableActions: true,
+    enableProviders: true,
+});
+export default knowledgePlugin;
+export { knowledgeActions } from "./actions";
+export { documentsProvider } from "./documents-provider";
+export { knowledgeProvider } from "./provider";
+export { KnowledgeService } from "./service";
+export * from "./types";

package/packages/typescript/src/features/knowledge/llm.d.ts

@@ -0,0 +1,27 @@
+import { type IAgentRuntime } from "../../types";
+interface TextGenerationResult {
+    text: string;
+    usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    finishReason?: string;
+    response?: {
+        id?: string;
+        modelId?: string;
+    };
+}
+import type { TextGenerationOptions } from "./types";
+export declare function generateTextEmbedding(runtime: IAgentRuntime, text: string): Promise<{
+    embedding: number[];
+}>;
+export declare function generateTextEmbeddingsBatch(runtime: IAgentRuntime, texts: string[], batchSize?: number): Promise<Array<{
+    embedding: number[] | null;
+    success: boolean;
+    error?: unknown;
+    index: number;
+}>>;
+export declare function generateText(runtime: IAgentRuntime, prompt: string, system?: string, overrideConfig?: TextGenerationOptions): Promise<TextGenerationResult>;
+export {};
+//# sourceMappingURL=llm.d.ts.map

package/packages/typescript/src/features/knowledge/llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/knowledge/llm.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,aAAa,CAAC;AAK5D,UAAU,oBAAoB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE;QACV,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,OAAO,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACF;AAGD,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAkDlE,wBAAsB,qBAAqB,CAC1C,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAoBlC;AAmBD,wBAAsB,2BAA2B,CAChD,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,GAAE,MAAW,GACpB,OAAO,CACT,KAAK,CAAC;IACL,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACd,CAAC,CACF,CAkEA;AAoED,wBAAsB,YAAY,CACjC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,qBAAqB,GACpC,OAAO,CAAC,oBAAoB,CAAC,CAwE/B"}

package/packages/typescript/src/features/knowledge/llm.js

@@ -0,0 +1,444 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { google } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { generateText as aiGenerateText, embed } from "ai";
+import { logger } from "../../logger";
+import { logActiveTrajectoryLlmCall, withStandaloneTrajectory, } from "../../trajectory-utils";
+import { ModelType } from "../../types";
+import { BatchProcessor } from "../../utils/batch-queue";
+import { validateModelConfig } from "./config";
+function serializeMessages(messages) {
+    return JSON.stringify(messages);
+}
+async function generateLoggedText({ runtime, modelName, systemPrompt, userPrompt, maxTokens, temperature, purpose, actionType, invoke, }) {
+    const startedAt = Date.now();
+    const result = await invoke();
+    logActiveTrajectoryLlmCall?.(runtime, {
+        model: modelName,
+        modelVersion: result.response?.modelId,
+        systemPrompt,
+        userPrompt,
+        response: result.text,
+        temperature,
+        maxTokens,
+        purpose,
+        actionType,
+        latencyMs: Date.now() - startedAt,
+        promptTokens: result.usage.inputTokens,
+        completionTokens: result.usage.outputTokens,
+    });
+    return result;
+}
+export async function generateTextEmbedding(runtime, text) {
+    const config = validateModelConfig(runtime);
+    const dimensions = config.EMBEDDING_DIMENSION;
+    try {
+        if (config.EMBEDDING_PROVIDER === "local") {
+            return await generateLocalEmbedding(runtime, text);
+        }
+        else if (config.EMBEDDING_PROVIDER === "openai") {
+            return await generateOpenAIEmbedding(text, config, dimensions);
+        }
+        else if (config.EMBEDDING_PROVIDER === "google") {
+            return await generateGoogleEmbedding(text, config);
+        }
+        throw new Error(`Unsupported embedding provider: ${config.EMBEDDING_PROVIDER}`);
+    }
+    catch (error) {
+        logger.error({ error }, `${config.EMBEDDING_PROVIDER} embedding error`);
+        throw error;
+    }
+}
+async function generateLocalEmbedding(runtime, text) {
+    const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+        text,
+    });
+    if (!Array.isArray(embedding)) {
+        throw new Error("Local embedding model returned an invalid embedding payload");
+    }
+    return { embedding };
+}
+export async function generateTextEmbeddingsBatch(runtime, texts, batchSize = 20) {
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+        const batch = texts.slice(i, i + batchSize);
+        const batchStartIndex = i;
+        const items = batch.map((text, batchIndex) => ({
+            text,
+            globalIndex: batchStartIndex + batchIndex,
+            batchPos: batchIndex,
+        }));
+        const slot = batch.map(() => null);
+        // Note: BatchProcessor is used here purely as a concurrency limiter (semaphore).
+        // Errors are caught internally and written to `slot`, so retries and onExhausted are bypassed.
+        const processor = new BatchProcessor({
+            maxParallel: 10,
+            maxRetriesAfterFailure: 0,
+            process: async (item) => {
+                try {
+                    const result = await generateTextEmbedding(runtime, item.text);
+                    slot[item.batchPos] = {
+                        embedding: result.embedding,
+                        success: true,
+                        index: item.globalIndex,
+                    };
+                }
+                catch (error) {
+                    logger.error({ error }, `Embedding error for item ${item.globalIndex}`);
+                    slot[item.batchPos] = {
+                        embedding: null,
+                        success: false,
+                        error,
+                        index: item.globalIndex,
+                    };
+                }
+            },
+        });
+        await processor.processBatch(items);
+        for (let j = 0; j < slot.length; j++) {
+            const row = slot[j];
+            if (row) {
+                results.push(row);
+            }
+        }
+        if (i + batchSize < texts.length) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    return results;
+}
+async function generateOpenAIEmbedding(text, config, dimensions) {
+    const openai = createOpenAI({
+        apiKey: config.OPENAI_API_KEY,
+        baseURL: config.OPENAI_BASE_URL,
+    });
+    const modelInstance = openai.embedding(config.TEXT_EMBEDDING_MODEL);
+    const embedOptions = {
+        model: modelInstance,
+        value: text,
+    };
+    if (dimensions &&
+        ["text-embedding-3-small", "text-embedding-3-large"].includes(config.TEXT_EMBEDDING_MODEL)) {
+        embedOptions.dimensions = dimensions;
+    }
+    const { embedding, usage } = await embed(embedOptions);
+    const totalTokens = usage?.totalTokens;
+    logger.debug(`OpenAI embedding ${config.TEXT_EMBEDDING_MODEL}${embedOptions.dimensions ? ` (${embedOptions.dimensions}D)` : ""}: ${totalTokens || 0} tokens`);
+    return { embedding };
+}
+async function generateGoogleEmbedding(text, config) {
+    const googleProvider = google;
+    if (config.GOOGLE_API_KEY) {
+        process.env.GOOGLE_GENERATIVE_AI_API_KEY = config.GOOGLE_API_KEY;
+    }
+    const modelInstance = googleProvider.textEmbeddingModel(config.TEXT_EMBEDDING_MODEL);
+    const { embedding, usage } = await embed({
+        model: modelInstance,
+        value: text,
+    });
+    const totalTokens = usage?.totalTokens;
+    logger.debug(`Google embedding ${config.TEXT_EMBEDDING_MODEL}: ${totalTokens || 0} tokens`);
+    return { embedding };
+}
+export async function generateText(runtime, prompt, system, overrideConfig) {
+    const config = validateModelConfig(runtime);
+    const provider = overrideConfig?.provider || config.TEXT_PROVIDER;
+    const modelName = overrideConfig?.modelName || config.TEXT_MODEL;
+    const maxTokens = overrideConfig?.maxTokens || config.MAX_OUTPUT_TOKENS;
+    const autoCacheContextualRetrieval = overrideConfig?.autoCacheContextualRetrieval !== false;
+    if (!modelName) {
+        throw new Error(`No model name configured for provider: ${provider}`);
+    }
+    try {
+        return await withStandaloneTrajectory(runtime, {
+            source: "knowledge",
+            metadata: {
+                provider,
+                model: modelName,
+            },
+        }, async () => {
+            switch (provider) {
+                case "anthropic":
+                    return await generateAnthropicText(runtime, config, prompt, system, modelName, maxTokens);
+                case "openai":
+                    return await generateOpenAIText(runtime, config, prompt, system, modelName, maxTokens);
+                case "openrouter":
+                    return await generateOpenRouterText(runtime, config, prompt, system, modelName, maxTokens, overrideConfig?.cacheDocument, overrideConfig?.cacheOptions, autoCacheContextualRetrieval);
+                case "google":
+                    return await generateGoogleText(runtime, prompt, system, modelName, maxTokens, config);
+                default:
+                    throw new Error(`Unsupported text provider: ${provider}`);
+            }
+        });
+    }
+    catch (error) {
+        logger.error({ error }, `${provider} ${modelName} error`);
+        throw error;
+    }
+}
+async function generateAnthropicText(runtime, config, prompt, system, modelName, maxTokens) {
+    const anthropic = createAnthropic({
+        apiKey: config.ANTHROPIC_API_KEY,
+        baseURL: config.ANTHROPIC_BASE_URL,
+    });
+    const modelInstance = anthropic(modelName);
+    const maxRetries = 3;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await generateLoggedText({
+                runtime,
+                modelName,
+                systemPrompt: system ?? "",
+                userPrompt: prompt,
+                maxTokens,
+                temperature: 0.3,
+                purpose: "knowledge",
+                actionType: "knowledge.anthropic.generate_text",
+                invoke: () => aiGenerateText({
+                    model: modelInstance,
+                    prompt: prompt,
+                    system: system,
+                    temperature: 0.3,
+                    maxOutputTokens: maxTokens,
+                }),
+            });
+        }
+        catch (error) {
+            const errorObj = error;
+            const isRateLimit = errorObj?.status === 429 ||
+                errorObj?.message?.includes("rate limit") ||
+                errorObj?.message?.includes("429");
+            if (isRateLimit && attempt < maxRetries - 1) {
+                const delay = 2 ** (attempt + 1) * 1000;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Max retries exceeded for Anthropic text generation");
+}
+async function generateOpenAIText(runtime, config, prompt, system, modelName, maxTokens) {
+    const openai = createOpenAI({
+        apiKey: config.OPENAI_API_KEY,
+        baseURL: config.OPENAI_BASE_URL,
+    });
+    const modelInstance = openai.chat(modelName);
+    const result = await generateLoggedText({
+        runtime,
+        modelName,
+        systemPrompt: system ?? "",
+        userPrompt: prompt,
+        maxTokens,
+        temperature: 0.3,
+        purpose: "knowledge",
+        actionType: "knowledge.openai.generate_text",
+        invoke: () => aiGenerateText({
+            model: modelInstance,
+            prompt: prompt,
+            system: system,
+            temperature: 0.3,
+            maxOutputTokens: maxTokens,
+        }),
+    });
+    return result;
+}
+async function generateGoogleText(runtime, prompt, system, modelName, maxTokens, config) {
+    const googleProvider = google;
+    if (config.GOOGLE_API_KEY) {
+        process.env.GOOGLE_GENERATIVE_AI_API_KEY = config.GOOGLE_API_KEY;
+    }
+    const modelInstance = googleProvider(modelName);
+    const result = await generateLoggedText({
+        runtime,
+        modelName,
+        systemPrompt: system ?? "",
+        userPrompt: prompt,
+        maxTokens,
+        temperature: 0.3,
+        purpose: "knowledge",
+        actionType: "knowledge.google.generate_text",
+        invoke: () => aiGenerateText({
+            model: modelInstance,
+            prompt: prompt,
+            system: system,
+            temperature: 0.3,
+            maxOutputTokens: maxTokens,
+        }),
+    });
+    return result;
+}
+async function generateOpenRouterText(runtime, config, prompt, system, modelName, maxTokens, cacheDocument, _cacheOptions, autoCacheContextualRetrieval = true) {
+    const openrouter = createOpenRouter({
+        apiKey: config.OPENROUTER_API_KEY,
+        baseURL: config.OPENROUTER_BASE_URL,
+    });
+    const modelInstance = openrouter.chat(modelName);
+    const isClaudeModel = modelName.toLowerCase().includes("claude");
+    const isGeminiModel = modelName.toLowerCase().includes("gemini");
+    const isGemini25Model = modelName.toLowerCase().includes("gemini-2.5");
+    const supportsCaching = isClaudeModel || isGeminiModel;
+    let documentForCaching = cacheDocument;
+    if (!documentForCaching && autoCacheContextualRetrieval && supportsCaching) {
+        const docMatch = prompt.match(/<document>([\s\S]*?)<\/document>/);
+        if (docMatch?.[1]) {
+            documentForCaching = docMatch[1].trim();
+        }
+    }
+    if (documentForCaching && supportsCaching) {
+        let promptText = prompt;
+        if (promptText.includes("<document>")) {
+            promptText = promptText
+                .replace(/<document>[\s\S]*?<\/document>/, "")
+                .trim();
+        }
+        if (isClaudeModel) {
+            return await generateClaudeWithCaching(runtime, promptText, system, modelInstance, modelName, maxTokens, documentForCaching);
+        }
+        else if (isGeminiModel) {
+            return await generateGeminiWithCaching(runtime, promptText, system, modelInstance, modelName, maxTokens, documentForCaching, isGemini25Model);
+        }
+    }
+    return await generateStandardOpenRouterText(runtime, prompt, system, modelInstance, modelName, maxTokens);
+}
+async function generateClaudeWithCaching(runtime, promptText, system, modelInstance, modelName, maxTokens, documentForCaching) {
+    const messages = [
+        system
+            ? {
+                role: "system",
+                content: [
+                    {
+                        type: "text",
+                        text: system,
+                    },
+                    {
+                        type: "text",
+                        text: documentForCaching,
+                        cache_control: {
+                            type: "ephemeral",
+                        },
+                    },
+                ],
+            }
+            : {
+                role: "user",
+                content: [
+                    {
+                        type: "text",
+                        text: "Document for context:",
+                    },
+                    {
+                        type: "text",
+                        text: documentForCaching,
+                        cache_control: {
+                            type: "ephemeral",
+                        },
+                    },
+                    {
+                        type: "text",
+                        text: promptText,
+                    },
+                ],
+            },
+        system
+            ? {
+                role: "user",
+                content: [
+                    {
+                        type: "text",
+                        text: promptText,
+                    },
+                ],
+            }
+            : null,
+    ].filter(Boolean);
+    const result = await generateLoggedText({
+        runtime,
+        modelName,
+        systemPrompt: system ?? "",
+        userPrompt: serializeMessages(messages),
+        maxTokens,
+        temperature: 0.3,
+        purpose: "knowledge",
+        actionType: "knowledge.openrouter.generate_text.claude_cached",
+        invoke: () => aiGenerateText({
+            model: modelInstance,
+            messages: messages,
+            temperature: 0.3,
+            maxOutputTokens: maxTokens,
+            providerOptions: {
+                openrouter: {
+                    usage: {
+                        include: true,
+                    },
+                },
+            },
+        }),
+    });
+    logCacheMetrics(result);
+    const totalTokens = (result.usage.inputTokens || 0) + (result.usage.outputTokens || 0);
+    logger.debug(`OpenRouter ${modelName}: ${totalTokens} tokens (${result.usage.inputTokens || 0}→${result.usage.outputTokens || 0})`);
+    return result;
+}
+async function generateGeminiWithCaching(runtime, promptText, system, modelInstance, modelName, maxTokens, documentForCaching, _isGemini25Model) {
+    const geminiSystemPrefix = system ? `${system}\n\n` : "";
+    const geminiPrompt = `${geminiSystemPrefix}${documentForCaching}\n\n${promptText}`;
+    const result = await generateLoggedText({
+        runtime,
+        modelName,
+        systemPrompt: "",
+        userPrompt: geminiPrompt,
+        maxTokens,
+        temperature: 0.3,
+        purpose: "knowledge",
+        actionType: "knowledge.openrouter.generate_text.gemini_cached",
+        invoke: () => aiGenerateText({
+            model: modelInstance,
+            prompt: geminiPrompt,
+            temperature: 0.3,
+            maxOutputTokens: maxTokens,
+            providerOptions: {
+                openrouter: {
+                    usage: {
+                        include: true,
+                    },
+                },
+            },
+        }),
+    });
+    logCacheMetrics(result);
+    const totalTokens = (result.usage.inputTokens || 0) + (result.usage.outputTokens || 0);
+    logger.debug(`OpenRouter ${modelName}: ${totalTokens} tokens (${result.usage.inputTokens || 0}→${result.usage.outputTokens || 0})`);
+    return result;
+}
+async function generateStandardOpenRouterText(runtime, prompt, system, modelInstance, modelName, maxTokens) {
+    const result = await generateLoggedText({
+        runtime,
+        modelName,
+        systemPrompt: system ?? "",
+        userPrompt: prompt,
+        maxTokens,
+        temperature: 0.3,
+        purpose: "knowledge",
+        actionType: "knowledge.openrouter.generate_text",
+        invoke: () => aiGenerateText({
+            model: modelInstance,
+            prompt: prompt,
+            system: system,
+            temperature: 0.3,
+            maxOutputTokens: maxTokens,
+            providerOptions: {
+                openrouter: {
+                    usage: {
+                        include: true,
+                    },
+                },
+            },
+        }),
+    });
+    const totalTokens = (result.usage.inputTokens || 0) + (result.usage.outputTokens || 0);
+    logger.debug(`OpenRouter ${modelName}: ${totalTokens} tokens (${result.usage.inputTokens || 0}→${result.usage.outputTokens || 0})`);
+    return result;
+}
+function logCacheMetrics(_result) { }

package/packages/typescript/src/features/knowledge/provider.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../../types";
+export declare const knowledgeProvider: Provider;
+//# sourceMappingURL=provider.d.ts.map

package/packages/typescript/src/features/knowledge/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/knowledge/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAInE,eAAO,MAAM,iBAAiB,EAAE,QA6E/B,CAAC"}