@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

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

@@ -0,0 +1,162 @@
+import z from "zod";
+import type { Content, DocumentMetadata, FragmentMetadata, MemoryType, UUID } from "../../types";
+/**
+ * Local metadata type for stored knowledge items.
+ * Uses a permissive record type to avoid conflicts between TypeScript and protobuf MemoryMetadata types.
+ */
+export type StoredKnowledgeMetadata = Record<string, unknown>;
+/**
+ * Stored knowledge item with content, metadata, and optional similarity score.
+ * Used for knowledge retrieval results and internal knowledge processing.
+ * This is a local definition to avoid conflicts with the proto KnowledgeItem type.
+ */
+export interface StoredKnowledgeItem {
+    id: UUID;
+    content: Content;
+    metadata?: StoredKnowledgeMetadata;
+    worldId?: UUID;
+    similarity?: number;
+}
+export declare const ModelConfigSchema: z.ZodObject<{
+    EMBEDDING_PROVIDER: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        openai: "openai";
+        google: "google";
+    }>>;
+    TEXT_PROVIDER: z.ZodOptional<z.ZodEnum<{
+        anthropic: "anthropic";
+        openai: "openai";
+        google: "google";
+        openrouter: "openrouter";
+    }>>;
+    OPENAI_API_KEY: z.ZodOptional<z.ZodString>;
+    ANTHROPIC_API_KEY: z.ZodOptional<z.ZodString>;
+    OPENROUTER_API_KEY: z.ZodOptional<z.ZodString>;
+    GOOGLE_API_KEY: z.ZodOptional<z.ZodString>;
+    OPENAI_BASE_URL: z.ZodOptional<z.ZodString>;
+    ANTHROPIC_BASE_URL: z.ZodOptional<z.ZodString>;
+    OPENROUTER_BASE_URL: z.ZodOptional<z.ZodString>;
+    GOOGLE_BASE_URL: z.ZodOptional<z.ZodString>;
+    TEXT_EMBEDDING_MODEL: z.ZodString;
+    TEXT_MODEL: z.ZodOptional<z.ZodString>;
+    MAX_INPUT_TOKENS: z.ZodPipe<z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodTransform<number, string | number>>;
+    MAX_OUTPUT_TOKENS: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, z.ZodTransform<number, string | number | undefined>>;
+    EMBEDDING_DIMENSION: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, z.ZodTransform<number, string | number | undefined>>;
+    LOAD_DOCS_ON_STARTUP: z.ZodDefault<z.ZodBoolean>;
+    CTX_KNOWLEDGE_ENABLED: z.ZodDefault<z.ZodBoolean>;
+    RATE_LIMIT_ENABLED: z.ZodDefault<z.ZodBoolean>;
+    MAX_CONCURRENT_REQUESTS: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, z.ZodTransform<number, string | number | undefined>>;
+    REQUESTS_PER_MINUTE: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, z.ZodTransform<number, string | number | undefined>>;
+    TOKENS_PER_MINUTE: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, z.ZodTransform<number, string | number | undefined>>;
+    BATCH_DELAY_MS: z.ZodPipe<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, z.ZodTransform<number, string | number | undefined>>;
+}, z.core.$strip>;
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+export interface ProviderRateLimits {
+    maxConcurrentRequests: number;
+    requestsPerMinute: number;
+    tokensPerMinute?: number;
+    provider: string;
+    rateLimitEnabled: boolean;
+    batchDelayMs: number;
+}
+export interface TextGenerationOptions {
+    provider?: "anthropic" | "openai" | "openrouter" | "google";
+    modelName?: string;
+    maxTokens?: number;
+    cacheDocument?: string;
+    cacheOptions?: {
+        type: "ephemeral";
+    };
+    autoCacheContextualRetrieval?: boolean;
+}
+export interface AddKnowledgeOptions {
+    agentId?: UUID;
+    worldId: UUID;
+    roomId: UUID;
+    entityId: UUID;
+    clientDocumentId: UUID;
+    contentType: string;
+    originalFilename: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+declare module "../../types/service.ts" {
+    interface ServiceTypeRegistry {
+        KNOWLEDGE: "knowledge";
+    }
+}
+export declare const KnowledgeServiceType: {
+    KNOWLEDGE: "knowledge";
+};
+export interface KnowledgeDocumentMetadata extends Record<string, unknown> {
+    type: string;
+    source: string;
+    title?: string;
+    filename?: string;
+    fileExt?: string;
+    fileType?: string;
+    fileSize?: number;
+}
+export interface KnowledgeDocumentMemoryMetadata extends DocumentMetadata, Record<string, unknown> {
+    type: typeof MemoryType.DOCUMENT;
+    documentId: UUID;
+    source: string;
+    title?: string;
+    filename?: string;
+    originalFilename?: string;
+    fileExt?: string;
+    fileType?: string;
+    contentType?: string;
+    fileSize?: number;
+    textBacked?: boolean;
+    timestamp?: number;
+    editedAt?: number;
+}
+export interface KnowledgeFragmentMemoryMetadata extends FragmentMetadata, Record<string, unknown> {
+    type: typeof MemoryType.FRAGMENT;
+    documentId: UUID;
+    position: number;
+    source?: string;
+    documentTitle?: string;
+    timestamp?: number;
+}
+export interface KnowledgeConfig {
+    CTX_KNOWLEDGE_ENABLED: boolean;
+    LOAD_DOCS_ON_STARTUP: boolean;
+    MAX_INPUT_TOKENS?: string | number;
+    MAX_OUTPUT_TOKENS?: string | number;
+    EMBEDDING_PROVIDER?: string;
+    TEXT_PROVIDER?: string;
+    TEXT_EMBEDDING_MODEL?: string;
+    RATE_LIMIT_ENABLED?: boolean;
+    MAX_CONCURRENT_REQUESTS?: number;
+    REQUESTS_PER_MINUTE?: number;
+    TOKENS_PER_MINUTE?: number;
+    BATCH_DELAY_MS?: number;
+}
+export interface LoadResult {
+    successful: number;
+    failed: number;
+    errors?: Array<{
+        filename: string;
+        error: string;
+    }>;
+}
+export interface ExtendedMemoryMetadata extends Record<string, unknown> {
+    type?: string;
+    title?: string;
+    filename?: string;
+    path?: string;
+    description?: string;
+    fileExt?: string;
+    timestamp?: number;
+    contentType?: string;
+    documentId?: string;
+    source?: string;
+    fileType?: string;
+    fileSize?: number;
+    position?: number;
+    originalFilename?: string;
+    url?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/knowledge/types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,57 @@
+import z from "zod";
+export const ModelConfigSchema = z.object({
+    EMBEDDING_PROVIDER: z.enum(["local", "openai", "google"]).optional(),
+    TEXT_PROVIDER: z
+        .enum(["openai", "anthropic", "openrouter", "google"])
+        .optional(),
+    OPENAI_API_KEY: z.string().optional(),
+    ANTHROPIC_API_KEY: z.string().optional(),
+    OPENROUTER_API_KEY: z.string().optional(),
+    GOOGLE_API_KEY: z.string().optional(),
+    OPENAI_BASE_URL: z.string().optional(),
+    ANTHROPIC_BASE_URL: z.string().optional(),
+    OPENROUTER_BASE_URL: z.string().optional(),
+    GOOGLE_BASE_URL: z.string().optional(),
+    TEXT_EMBEDDING_MODEL: z.string(),
+    TEXT_MODEL: z.string().optional(),
+    MAX_INPUT_TOKENS: z
+        .string()
+        .or(z.number())
+        .transform((val) => (typeof val === "string" ? parseInt(val, 10) : val)),
+    MAX_OUTPUT_TOKENS: z
+        .string()
+        .or(z.number())
+        .optional()
+        .transform((val) => val ? (typeof val === "string" ? parseInt(val, 10) : val) : 4096),
+    EMBEDDING_DIMENSION: z
+        .string()
+        .or(z.number())
+        .optional()
+        .transform((val) => val ? (typeof val === "string" ? parseInt(val, 10) : val) : 1536),
+    LOAD_DOCS_ON_STARTUP: z.boolean().default(false),
+    CTX_KNOWLEDGE_ENABLED: z.boolean().default(false),
+    RATE_LIMIT_ENABLED: z.boolean().default(true),
+    MAX_CONCURRENT_REQUESTS: z
+        .string()
+        .or(z.number())
+        .optional()
+        .transform((val) => val ? (typeof val === "string" ? parseInt(val, 10) : val) : 150),
+    REQUESTS_PER_MINUTE: z
+        .string()
+        .or(z.number())
+        .optional()
+        .transform((val) => val ? (typeof val === "string" ? parseInt(val, 10) : val) : 300),
+    TOKENS_PER_MINUTE: z
+        .string()
+        .or(z.number())
+        .optional()
+        .transform((val) => val ? (typeof val === "string" ? parseInt(val, 10) : val) : 750000),
+    BATCH_DELAY_MS: z
+        .string()
+        .or(z.number())
+        .optional()
+        .transform((val) => val ? (typeof val === "string" ? parseInt(val, 10) : val) : 100),
+});
+export const KnowledgeServiceType = {
+    KNOWLEDGE: "knowledge",
+};

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

@@ -0,0 +1,22 @@
+import { Buffer } from "node:buffer";
+export declare function extractTextFromFileBuffer(fileBuffer: Buffer, contentType: string, originalFilename: string): Promise<string>;
+export declare function convertPdfToTextFromBuffer(pdfBuffer: Buffer, _filename?: string): Promise<string>;
+export declare function isBinaryContentType(contentType: string, filename: string): boolean;
+export declare function stripKnowledgeFilenameExtension(filename: string): string;
+export declare function deriveKnowledgeTitle(content: string, fallback?: string): string;
+export declare function createKnowledgeNoteFilename(title: string, extension?: string): string;
+export declare function isTextBackedKnowledgeContent(contentType: string, filename: string): boolean;
+export declare function normalizeKnowledgeSourceValue(source: unknown): "upload" | "learned" | "character" | "url" | "youtube" | "bundled" | "unknown";
+export declare function normalizeS3Url(url: string): string;
+export declare function fetchUrlContent(url: string): Promise<{
+    content: string;
+    contentType: string;
+}>;
+export declare function looksLikeBase64(content?: string | null): boolean;
+export declare function generateContentBasedId(content: string, agentId: string, options?: {
+    maxChars?: number;
+    includeFilename?: string;
+    contentType?: string;
+}): string;
+export declare function extractFirstLines(content: string, maxLines?: number): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/knowledge/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAsBrC,wBAAsB,yBAAyB,CAC9C,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CA0DjB;AAED,wBAAsB,0BAA0B,CAC/C,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,CA6BjB;AAED,wBAAgB,mBAAmB,CAClC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACd,OAAO,CA2JT;AAUD,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOxE;AAED,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,SAAmB,GACzB,MAAM,CAoBR;AAED,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,MAAM,EACb,SAAS,SAAQ,GACf,MAAM,CAeR;AAED,wBAAgB,4BAA4B,CAC3C,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACd,OAAO,CAET;AAED,wBAAgB,6BAA6B,CAC5C,MAAM,EAAE,OAAO,GAEb,QAAQ,GACR,SAAS,GACT,WAAW,GACX,KAAK,GACL,SAAS,GACT,SAAS,GACT,SAAS,CAsBX;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOlD;AAED,wBAAsB,eAAe,CACpC,GAAG,EAAE,MAAM,GACT,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAiCnD;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAiBhE;AAED,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACT,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,GACC,MAAM,CAkCR;AAED,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAW,GACnB,MAAM,CAGR"}

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

@@ -0,0 +1,387 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import * as mammoth from "mammoth";
+import { extractText } from "unpdf";
+import { v5 as uuidv5 } from "uuid";
+const PLAIN_TEXT_CONTENT_TYPES = [
+    "application/typescript",
+    "text/typescript",
+    "text/x-python",
+    "application/x-python-code",
+    "application/yaml",
+    "text/yaml",
+    "application/x-yaml",
+    "application/json",
+    "text/markdown",
+    "text/csv",
+];
+const MAX_FALLBACK_SIZE_BYTES = 5 * 1024 * 1024;
+const BINARY_CHECK_BYTES = 1024;
+export async function extractTextFromFileBuffer(fileBuffer, contentType, originalFilename) {
+    const lowerContentType = contentType.toLowerCase();
+    if (lowerContentType ===
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
+        try {
+            const result = await mammoth.extractRawText({ buffer: fileBuffer });
+            return result.value;
+        }
+        catch (docxError) {
+            const errorMessage = docxError instanceof Error ? docxError.message : String(docxError);
+            throw new Error(`Failed to parse DOCX file ${originalFilename}: ${errorMessage}`);
+        }
+    }
+    else if (lowerContentType === "application/msword" ||
+        originalFilename.toLowerCase().endsWith(".doc")) {
+        return `[Microsoft Word Document: ${originalFilename}]\n\nThis document was indexed for search but cannot be displayed directly in the browser. The original document content is preserved for retrieval purposes.`;
+    }
+    else if (lowerContentType.startsWith("text/") ||
+        PLAIN_TEXT_CONTENT_TYPES.includes(lowerContentType)) {
+        return fileBuffer.toString("utf-8");
+    }
+    else {
+        if (fileBuffer.length > MAX_FALLBACK_SIZE_BYTES) {
+            throw new Error(`File ${originalFilename} exceeds maximum size for fallback (${MAX_FALLBACK_SIZE_BYTES} bytes)`);
+        }
+        const initialBytes = fileBuffer.subarray(0, Math.min(fileBuffer.length, BINARY_CHECK_BYTES));
+        if (initialBytes.includes(0)) {
+            throw new Error(`File ${originalFilename} appears to be binary based on initial byte check`);
+        }
+        try {
+            const textContent = fileBuffer.toString("utf-8");
+            if (textContent.includes("\ufffd")) {
+                throw new Error(`File ${originalFilename} seems to be binary or has encoding issues (detected \ufffd)`);
+            }
+            return textContent;
+        }
+        catch (_fallbackError) {
+            throw new Error(`Unsupported content type: ${contentType} for ${originalFilename}. Fallback to plain text failed`);
+        }
+    }
+}
+export async function convertPdfToTextFromBuffer(pdfBuffer, _filename) {
+    try {
+        const uint8Array = new Uint8Array(pdfBuffer.buffer.slice(pdfBuffer.byteOffset, pdfBuffer.byteOffset + pdfBuffer.byteLength));
+        const result = await extractText(uint8Array, {
+            mergePages: true,
+        });
+        if (!result.text || result.text.trim().length === 0) {
+            return "";
+        }
+        const cleanedText = result.text
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .join("\n")
+            .replace(/\n{3,}/g, "\n\n");
+        return cleanedText;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to convert PDF to text: ${errorMessage}`);
+    }
+}
+export function isBinaryContentType(contentType, filename) {
+    const textContentTypes = [
+        "text/",
+        "application/json",
+        "application/xml",
+        "application/javascript",
+        "application/typescript",
+        "application/x-yaml",
+        "application/x-sh",
+    ];
+    const isTextMimeType = textContentTypes.some((type) => contentType.includes(type));
+    if (isTextMimeType) {
+        return false;
+    }
+    const binaryContentTypes = [
+        "application/pdf",
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument",
+        "application/vnd.ms-excel",
+        "application/vnd.ms-powerpoint",
+        "application/zip",
+        "application/x-zip-compressed",
+        "application/octet-stream",
+        "image/",
+        "audio/",
+        "video/",
+    ];
+    const isBinaryMimeType = binaryContentTypes.some((type) => contentType.includes(type));
+    if (isBinaryMimeType) {
+        return true;
+    }
+    const fileExt = filename.split(".").pop()?.toLowerCase() || "";
+    const textExtensions = [
+        "txt",
+        "md",
+        "markdown",
+        "json",
+        "xml",
+        "html",
+        "htm",
+        "css",
+        "js",
+        "ts",
+        "jsx",
+        "tsx",
+        "yaml",
+        "yml",
+        "toml",
+        "ini",
+        "cfg",
+        "conf",
+        "sh",
+        "bash",
+        "zsh",
+        "fish",
+        "py",
+        "rb",
+        "go",
+        "rs",
+        "java",
+        "c",
+        "cpp",
+        "h",
+        "hpp",
+        "cs",
+        "php",
+        "sql",
+        "r",
+        "swift",
+        "kt",
+        "scala",
+        "clj",
+        "ex",
+        "exs",
+        "vim",
+        "env",
+        "gitignore",
+        "dockerignore",
+        "editorconfig",
+        "log",
+        "csv",
+        "tsv",
+        "properties",
+        "gradle",
+        "sbt",
+        "makefile",
+        "dockerfile",
+        "vagrantfile",
+        "gemfile",
+        "rakefile",
+        "podfile",
+        "csproj",
+        "vbproj",
+        "fsproj",
+        "sln",
+        "pom",
+    ];
+    if (textExtensions.includes(fileExt)) {
+        return false;
+    }
+    const binaryExtensions = [
+        "pdf",
+        "docx",
+        "doc",
+        "xls",
+        "xlsx",
+        "ppt",
+        "pptx",
+        "zip",
+        "rar",
+        "7z",
+        "tar",
+        "gz",
+        "bz2",
+        "xz",
+        "jpg",
+        "jpeg",
+        "png",
+        "gif",
+        "bmp",
+        "svg",
+        "ico",
+        "webp",
+        "mp3",
+        "mp4",
+        "avi",
+        "mov",
+        "wmv",
+        "flv",
+        "wav",
+        "flac",
+        "ogg",
+        "exe",
+        "dll",
+        "so",
+        "dylib",
+        "bin",
+        "dat",
+        "db",
+        "sqlite",
+    ];
+    return binaryExtensions.includes(fileExt);
+}
+const KNOWLEDGE_TITLE_MAX_LENGTH = 80;
+function truncateKnowledgeLabel(value) {
+    return value.length > KNOWLEDGE_TITLE_MAX_LENGTH
+        ? `${value.slice(0, KNOWLEDGE_TITLE_MAX_LENGTH - 1).trimEnd()}…`
+        : value;
+}
+export function stripKnowledgeFilenameExtension(filename) {
+    const trimmed = filename.trim();
+    if (!trimmed)
+        return "";
+    const lastDot = trimmed.lastIndexOf(".");
+    if (lastDot <= 0)
+        return trimmed;
+    return trimmed.slice(0, lastDot);
+}
+export function deriveKnowledgeTitle(content, fallback = "Knowledge note") {
+    const lines = content
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    for (const line of lines) {
+        if (/^path:\s+/i.test(line))
+            continue;
+        const candidate = line
+            .replace(/^#+\s*/, "")
+            .replace(/^[-*]\s+/, "")
+            .replace(/^\d+[.)]\s+/, "")
+            .trim();
+        if (candidate.length > 0) {
+            return truncateKnowledgeLabel(candidate);
+        }
+    }
+    return fallback;
+}
+export function createKnowledgeNoteFilename(title, extension = "txt") {
+    const normalizedTitle = title
+        .normalize("NFKD")
+        .replace(/[^\x00-\x7F]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64);
+    const basename = normalizedTitle.length > 0 ? normalizedTitle : "knowledge-note";
+    const normalizedExtension = extension.replace(/^\./, "").trim();
+    return normalizedExtension.length > 0
+        ? `${basename}.${normalizedExtension}`
+        : basename;
+}
+export function isTextBackedKnowledgeContent(contentType, filename) {
+    return !isBinaryContentType(contentType, filename);
+}
+export function normalizeKnowledgeSourceValue(source) {
+    if (typeof source !== "string") {
+        return "unknown";
+    }
+    switch (source) {
+        case "upload":
+        case "rag-service-main-upload":
+            return "upload";
+        case "learned":
+            return "learned";
+        case "character":
+            return "character";
+        case "url":
+            return "url";
+        case "youtube":
+            return "youtube";
+        case "eliza-default-knowledge":
+            return "bundled";
+        default:
+            return "unknown";
+    }
+}
+export function normalizeS3Url(url) {
+    try {
+        const urlObj = new URL(url);
+        return `${urlObj.origin}${urlObj.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+export async function fetchUrlContent(url) {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000);
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                "User-Agent": "Eliza-Knowledge-Plugin/1.0",
+            },
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
+        }
+        const contentType = response.headers.get("content-type") || "application/octet-stream";
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const base64Content = buffer.toString("base64");
+        return {
+            content: base64Content,
+            contentType,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to fetch content from URL: ${errorMessage}`);
+    }
+}
+export function looksLikeBase64(content) {
+    if (!content || content.length === 0)
+        return false;
+    const cleanContent = content.replace(/\s/g, "");
+    if (cleanContent.length < 16)
+        return false;
+    if (cleanContent.length % 4 !== 0)
+        return false;
+    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+    if (!base64Regex.test(cleanContent))
+        return false;
+    const hasNumbers = /\d/.test(cleanContent);
+    const hasUpperCase = /[A-Z]/.test(cleanContent);
+    const hasLowerCase = /[a-z]/.test(cleanContent);
+    return (hasNumbers || hasUpperCase) && hasLowerCase;
+}
+export function generateContentBasedId(content, agentId, options) {
+    const { maxChars = 2000, includeFilename, contentType } = options || {};
+    let contentForHashing;
+    if (looksLikeBase64(content)) {
+        try {
+            const decoded = Buffer.from(content, "base64").toString("utf8");
+            if (!decoded.includes("\ufffd") || contentType?.includes("pdf")) {
+                contentForHashing = content.slice(0, maxChars);
+            }
+            else {
+                contentForHashing = decoded.slice(0, maxChars);
+            }
+        }
+        catch {
+            contentForHashing = content.slice(0, maxChars);
+        }
+    }
+    else {
+        contentForHashing = content.slice(0, maxChars);
+    }
+    contentForHashing = contentForHashing
+        .replace(/\r\n/g, "\n") // Normalize line endings
+        .replace(/\r/g, "\n")
+        .trim();
+    const componentsToHash = [agentId, contentForHashing, includeFilename || ""]
+        .filter(Boolean)
+        .join("::");
+    const hash = createHash("sha256").update(componentsToHash).digest("hex");
+    const DOCUMENT_NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    return uuidv5(hash, DOCUMENT_NAMESPACE);
+}
+export function extractFirstLines(content, maxLines = 10) {
+    const lines = content.split(/\r?\n/);
+    return lines.slice(0, maxLines).join("\n");
+}

package/packages/typescript/src/features/plugin-manager/actions/coreStatusAction.d.ts

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

package/packages/typescript/src/features/plugin-manager/actions/coreStatusAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreStatusAction.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/plugin-manager/actions/coreStatusAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,8BAA8B,CAAC;AAS3E,eAAO,MAAM,gBAAgB,EAAE,MA8E9B,CAAC"}