@okrlinkhub/agent-factory 2.0.0 → 2.0.2

package/dist/component/queue.js

@@ -1,9 +1,28 @@
 import { v } from "convex/values";
-import { internal } from "./_generated/api.js";
-import { internalMutation, internalQuery, mutation, query, } from "./_generated/server.js";
+import { api, internal } from "./_generated/api.js";
+import { action, internalMutation, internalQuery, mutation, query, } from "./_generated/server.js";
 import { computeRetryDelayMs, DEFAULT_CONFIG, providerConfigValidator } from "./config.js";
 import { canTransitionWorkerStatus, isWorkerClaimable, isWorkerRunning, isWorkerTerminal, workerStatusValidator, } from "./workerLifecycle.js";
 const queueStatusValidator = v.union(v.literal("queued"), v.literal("processing"), v.literal("done"), v.literal("failed"), v.literal("dead_letter"));
+const telegramAttachmentKindValidator = v.union(v.literal("photo"), v.literal("video"), v.literal("audio"), v.literal("voice"), v.literal("document"));
+const telegramAttachmentStatusValidator = v.union(v.literal("ready"), v.literal("expired"));
+const telegramAttachmentValidator = v.object({
+    kind: telegramAttachmentKindValidator,
+    status: telegramAttachmentStatusValidator,
+    storageId: v.id("_storage"),
+    telegramFileId: v.string(),
+    fileName: v.optional(v.string()),
+    mimeType: v.optional(v.string()),
+    sizeBytes: v.optional(v.number()),
+    expiresAt: v.number(),
+});
+const telegramAttachmentCandidateValidator = v.object({
+    kind: telegramAttachmentKindValidator,
+    telegramFileId: v.string(),
+    fileName: v.optional(v.string()),
+    mimeType: v.optional(v.string()),
+    sizeBytes: v.optional(v.number()),
+});
 const queuePayloadValidator = v.object({
     provider: v.string(),
     providerUserId: v.string(),
@@ -11,6 +30,7 @@ const queuePayloadValidator = v.object({
     externalMessageId: v.optional(v.string()),
     rawUpdateJson: v.optional(v.string()),
     metadata: v.optional(v.record(v.string(), v.string())),
+    attachments: v.optional(v.array(telegramAttachmentValidator)),
 });
 const snapshotReasonValidator = v.union(v.literal("drain"), v.literal("signal"), v.literal("manual"));
 const DATA_SNAPSHOT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
@@ -102,6 +122,7 @@ const workerSpawnOpenClawEnvValidator = v.object({
 });
 const messageRuntimeConfigValidator = v.object({
     systemPrompt: v.optional(v.string()),
+    telegramAttachmentRetentionMs: v.optional(v.number()),
 });
 const globalSkillStatusValidator = v.union(v.literal("active"), v.literal("disabled"));
 const globalSkillReleaseChannelValidator = v.union(v.literal("stable"), v.literal("canary"));
@@ -133,6 +154,7 @@ const RUNTIME_CONFIG_KEYS = {
     provider: "provider",
     message: "message",
 };
+const DEFAULT_TELEGRAM_ATTACHMENT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 export const enqueueMessage = mutation({
     args: {
         conversationId: v.string(),
@@ -435,6 +457,47 @@ export const getMessageRuntimeConfig = internalQuery({
         return row.messageConfig;
     },
 });
+export const getTelegramIngressRuntimeConfig = internalQuery({
+    args: {
+        agentKey: v.string(),
+    },
+    returns: v.object({
+        botToken: v.union(v.null(), v.string()),
+        attachmentRetentionMs: v.number(),
+    }),
+    handler: async (ctx, args) => {
+        const profile = await ctx.db
+            .query("agentProfiles")
+            .withIndex("by_agentKey", (q) => q.eq("agentKey", args.agentKey))
+            .unique();
+        const botToken = profile ? await resolveActiveTelegramBotToken(ctx, profile.secretsRef) : null;
+        const row = await ctx.db
+            .query("runtimeConfig")
+            .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.message))
+            .unique();
+        return {
+            botToken,
+            attachmentRetentionMs: resolveTelegramAttachmentRetentionMs(row?.messageConfig?.telegramAttachmentRetentionMs),
+        };
+    },
+});
+export const prepareTelegramAttachmentsForEnqueue = action({
+    args: {
+        agentKey: v.string(),
+        attachments: v.array(telegramAttachmentCandidateValidator),
+    },
+    returns: v.array(telegramAttachmentValidator),
+    handler: async (ctx, args) => {
+        const ingressConfig = await ctx.runQuery(internal.queue.getTelegramIngressRuntimeConfig, {
+            agentKey: args.agentKey,
+        });
+        if (!ingressConfig.botToken) {
+            throw new Error(`missing active telegram bot token for agent '${args.agentKey}'`);
+        }
+        const expiresAt = Date.now() + ingressConfig.attachmentRetentionMs;
+        return await Promise.all(args.attachments.map((attachment) => persistTelegramAttachmentFromCandidate(ctx, ingressConfig.botToken, attachment, expiresAt)));
+    },
+});
 export const upsertMessageRuntimeConfig = internalMutation({
     args: {
         messageConfig: messageRuntimeConfigValidator,
@@ -1407,18 +1470,7 @@ export const getHydrationBundleForClaimedJob = query({
             .query("conversationHydrationCache")
             .withIndex("by_conversationId", (q) => q.eq("conversationId", message.conversationId))
             .first();
-        let telegramBotToken = null;
-        const telegramSecretRefs = profile.secretsRef.filter((ref) => ref === "telegram.botToken" || ref.startsWith("telegram.botToken."));
-        for (const telegramSecretRef of telegramSecretRefs) {
-            const activeSecret = await ctx.db
-                .query("secrets")
-                .withIndex("by_secretRef_and_active", (q) => q.eq("secretRef", telegramSecretRef).eq("active", true))
-                .unique();
-            if (activeSecret) {
-                telegramBotToken = decryptSecretValue(activeSecret.encryptedValue, activeSecret.algorithm);
-                break;
-            }
-        }
+        const telegramBotToken = await resolveActiveTelegramBotToken(ctx, profile.secretsRef);
         const contextHistory = conversationCache && conversationCache.snapshotKey === snapshotKey
             ? conversationCache.deltaContext
             : conversation.contextHistory;
@@ -2050,6 +2102,42 @@ export const expireOldDataSnapshots = internalMutation({
         return rows.length;
     },
 });
+export const expireOldTelegramAttachments = internalMutation({
+    args: {
+        nowMs: v.optional(v.number()),
+        limit: v.optional(v.number()),
+    },
+    returns: v.number(),
+    handler: async (ctx, args) => {
+        const nowMs = args.nowMs ?? Date.now();
+        const limit = args.limit ?? 100;
+        const rows = await ctx.db
+            .query("messageAttachments")
+            .withIndex("by_status_and_expiresAt", (q) => q.eq("status", "ready").lte("expiresAt", nowMs))
+            .take(limit);
+        for (const row of rows) {
+            await ctx.db.patch(row._id, {
+                status: "expired",
+            });
+            const message = await ctx.db.get(row.messageId);
+            if (message?.payload.attachments?.length) {
+                await ctx.db.patch(message._id, {
+                    payload: {
+                        ...message.payload,
+                        attachments: message.payload.attachments.map((attachment) => attachment.storageId === row.storageId
+                            ? {
+                                ...attachment,
+                                status: "expired",
+                            }
+                            : attachment),
+                    },
+                });
+            }
+            await ctx.storage.delete?.(row.storageId);
+        }
+        return rows.length;
+    },
+});
 export const getWorkerStats = query({
     args: {},
     returns: v.object({
@@ -2218,6 +2306,23 @@ async function enqueueMessageRecord(ctx, args) {
         attempts: 0,
         maxAttempts: args.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
     });
+    for (const attachment of payload.attachments ?? []) {
+        await ctx.db.insert("messageAttachments", {
+            messageId,
+            conversationId: args.conversationId,
+            agentKey: args.agentKey,
+            provider: payload.provider,
+            kind: attachment.kind,
+            status: attachment.status,
+            storageId: attachment.storageId,
+            telegramFileId: attachment.telegramFileId,
+            fileName: attachment.fileName,
+            mimeType: attachment.mimeType,
+            sizeBytes: attachment.sizeBytes,
+            createdAt: nowMs,
+            expiresAt: attachment.expiresAt,
+        });
+    }
     try {
         await ctx.scheduler.runAfter(0, internal.scheduler.reconcileWorkerPoolFromEnqueue, {
             workspaceId: "default",
@@ -2354,10 +2459,16 @@ function dedupeMessagesById(messages) {
 }
 function normalizeMessageRuntimeConfig(messageConfig) {
     const systemPrompt = normalizeSystemPrompt(messageConfig?.systemPrompt);
-    if (systemPrompt === null) {
+    const telegramAttachmentRetentionMs = normalizeTelegramAttachmentRetentionMs(messageConfig?.telegramAttachmentRetentionMs);
+    if (systemPrompt === null && telegramAttachmentRetentionMs === undefined) {
         return null;
     }
-    return { systemPrompt };
+    return {
+        ...(systemPrompt === null ? {} : { systemPrompt }),
+        ...(telegramAttachmentRetentionMs === undefined
+            ? {}
+            : { telegramAttachmentRetentionMs }),
+    };
 }
 function normalizeSystemPrompt(systemPrompt) {
     if (typeof systemPrompt !== "string") {
@@ -2366,6 +2477,110 @@ function normalizeSystemPrompt(systemPrompt) {
     const normalizedSystemPrompt = systemPrompt.trim();
     return normalizedSystemPrompt.length > 0 ? normalizedSystemPrompt : null;
 }
+function normalizeTelegramAttachmentRetentionMs(retentionMs) {
+    if (typeof retentionMs !== "number" || !Number.isFinite(retentionMs)) {
+        return undefined;
+    }
+    const normalizedRetentionMs = Math.floor(retentionMs);
+    if (normalizedRetentionMs <= 0) {
+        return undefined;
+    }
+    return normalizedRetentionMs;
+}
+function resolveTelegramAttachmentRetentionMs(retentionMs) {
+    return (normalizeTelegramAttachmentRetentionMs(retentionMs) ??
+        DEFAULT_TELEGRAM_ATTACHMENT_RETENTION_MS);
+}
+async function resolveActiveTelegramBotToken(ctx, secretRefs) {
+    const telegramSecretRefs = secretRefs.filter((ref) => ref === "telegram.botToken" || ref.startsWith("telegram.botToken."));
+    for (const telegramSecretRef of telegramSecretRefs) {
+        const activeSecret = await ctx.db
+            .query("secrets")
+            .withIndex("by_secretRef_and_active", (q) => q.eq("secretRef", telegramSecretRef).eq("active", true))
+            .unique();
+        if (activeSecret) {
+            return decryptSecretValue(activeSecret.encryptedValue, activeSecret.algorithm);
+        }
+    }
+    return null;
+}
+async function persistTelegramAttachmentFromCandidate(ctx, telegramBotToken, attachment, expiresAt) {
+    const filePath = await fetchTelegramFilePath(telegramBotToken, attachment.telegramFileId);
+    const downloaded = await downloadTelegramFile(telegramBotToken, filePath);
+    const uploadTarget = await ctx.runMutation(api.queue.generateMediaUploadUrl, {});
+    const uploadResponse = await fetch(uploadTarget.uploadUrl, {
+        method: "POST",
+        headers: downloaded.mimeType.length > 0
+            ? {
+                "Content-Type": downloaded.mimeType,
+            }
+            : undefined,
+        body: downloaded.blob,
+    });
+    const uploadPayload = (await uploadResponse.json().catch(() => ({})));
+    if (!uploadResponse.ok || !uploadPayload.storageId) {
+        throw new Error(`Convex storage upload failed for Telegram ${attachment.kind} attachment`);
+    }
+    return {
+        kind: attachment.kind,
+        status: "ready",
+        storageId: uploadPayload.storageId,
+        telegramFileId: attachment.telegramFileId,
+        fileName: attachment.fileName,
+        mimeType: downloaded.mimeType || attachment.mimeType,
+        sizeBytes: attachment.sizeBytes ?? downloaded.blob.size,
+        expiresAt,
+    };
+}
+async function fetchTelegramFilePath(telegramBotToken, telegramFileId) {
+    const telegramApiBaseUrl = `https://api.telegram.org/bot${encodeURIComponent(telegramBotToken)}`;
+    const response = await fetch(`${telegramApiBaseUrl}/getFile?file_id=${encodeURIComponent(telegramFileId)}`);
+    const payload = (await response.json().catch(() => ({})));
+    if (!response.ok || payload.ok !== true || typeof payload.result?.file_path !== "string") {
+        throw new Error(`Telegram getFile failed: ${typeof payload.description === "string" ? payload.description : "missing file_path"}`);
+    }
+    return payload.result.file_path;
+}
+async function downloadTelegramFile(telegramBotToken, filePath) {
+    const response = await fetch(`https://api.telegram.org/file/bot${encodeURIComponent(telegramBotToken)}/${filePath}`);
+    if (!response.ok) {
+        throw new Error(`Telegram file download failed with status ${response.status}`);
+    }
+    const blob = await response.blob();
+    const mimeType = response.headers.get("Content-Type") ??
+        blob.type ??
+        inferMimeTypeFromFilePath(filePath) ??
+        "application/octet-stream";
+    return {
+        blob: mimeType === blob.type ? blob : new Blob([await blob.arrayBuffer()], { type: mimeType }),
+        mimeType,
+    };
+}
+function inferMimeTypeFromFilePath(filePath) {
+    const normalizedPath = filePath.toLowerCase();
+    if (normalizedPath.endsWith(".jpg") || normalizedPath.endsWith(".jpeg")) {
+        return "image/jpeg";
+    }
+    if (normalizedPath.endsWith(".png")) {
+        return "image/png";
+    }
+    if (normalizedPath.endsWith(".webp")) {
+        return "image/webp";
+    }
+    if (normalizedPath.endsWith(".mp4")) {
+        return "video/mp4";
+    }
+    if (normalizedPath.endsWith(".mp3")) {
+        return "audio/mpeg";
+    }
+    if (normalizedPath.endsWith(".ogg")) {
+        return "audio/ogg";
+    }
+    if (normalizedPath.endsWith(".pdf")) {
+        return "application/pdf";
+    }
+    return null;
+}
 async function buildGlobalSkillMaterialization(skill) {
     const skillDirName = normalizeGlobalSkillDirName(skill.slug);
     const scriptExt = skill.moduleFormat === "cjs" ? "cjs" : "mjs";