@okrlinkhub/agent-factory 2.0.1 → 2.0.3

package/dist/component/queue.js

@@ -1,6 +1,6 @@
 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"));
@@ -15,6 +15,14 @@ const telegramAttachmentValidator = v.object({
     mimeType: v.optional(v.string()),
     sizeBytes: v.optional(v.number()),
     expiresAt: v.number(),
+    downloadUrl: v.optional(v.string()),
+});
+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(),
@@ -474,6 +482,23 @@ export const getTelegramIngressRuntimeConfig = internalQuery({
         };
     },
 });
+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,
@@ -1451,11 +1476,12 @@ export const getHydrationBundleForClaimedJob = query({
             ? conversationCache.deltaContext
             : conversation.contextHistory;
         const bridgeRuntimeConfig = await resolveBridgeRuntimeConfig(ctx, profile);
+        const hydratedPayload = await hydrateQueuePayloadAttachments(ctx, message.payload);
         return {
             messageId: message._id,
             conversationId: message.conversationId,
             agentKey: message.agentKey,
-            payload: message.payload,
+            payload: hydratedPayload,
             conversationState: {
                 contextHistory,
                 pendingToolCalls: conversation.pendingToolCalls,
@@ -2310,6 +2336,21 @@ async function enqueueMessageRecord(ctx, args) {
     }
     return messageId;
 }
+async function hydrateQueuePayloadAttachments(ctx, payload) {
+    if (!payload.attachments?.length) {
+        return payload;
+    }
+    const attachments = await Promise.all(payload.attachments.map(async (attachment) => ({
+        ...attachment,
+        downloadUrl: attachment.status === "ready"
+            ? ((await ctx.storage.getUrl(attachment.storageId)) ?? undefined)
+            : undefined,
+    })));
+    return {
+        ...payload,
+        attachments,
+    };
+}
 async function resolveConversationTargetForUserAgent(ctx, consumerUserId, agentKey, requireActive = false) {
     const bindings = await ctx.db
         .query("identityBindings")
@@ -2480,6 +2521,115 @@ async function resolveActiveTelegramBotToken(ctx, secretRefs) {
     }
     return null;
 }
+async function persistTelegramAttachmentFromCandidate(ctx, telegramBotToken, attachment, expiresAt) {
+    const filePath = await fetchTelegramFilePath(telegramBotToken, attachment.telegramFileId);
+    const downloaded = await downloadTelegramFile(telegramBotToken, filePath);
+    const resolvedMimeType = resolvePreferredTelegramAttachmentMimeType(attachment.mimeType, attachment.fileName, downloaded.mimeType, filePath);
+    const uploadTarget = await ctx.runMutation(api.queue.generateMediaUploadUrl, {});
+    const uploadResponse = await fetch(uploadTarget.uploadUrl, {
+        method: "POST",
+        headers: resolvedMimeType.length > 0
+            ? {
+                "Content-Type": resolvedMimeType,
+            }
+            : 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: resolvedMimeType,
+        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 resolvePreferredTelegramAttachmentMimeType(originalMimeType, fileName, downloadedMimeType, filePath) {
+    const normalizedOriginalMimeType = normalizeNonGenericMimeType(originalMimeType);
+    if (normalizedOriginalMimeType) {
+        return normalizedOriginalMimeType;
+    }
+    const inferredFromFileName = inferMimeTypeFromFileName(fileName);
+    if (inferredFromFileName) {
+        return inferredFromFileName;
+    }
+    const normalizedDownloadedMimeType = normalizeNonGenericMimeType(downloadedMimeType);
+    if (normalizedDownloadedMimeType) {
+        return normalizedDownloadedMimeType;
+    }
+    return inferMimeTypeFromFilePath(filePath) ?? "application/octet-stream";
+}
+function normalizeNonGenericMimeType(mimeType) {
+    if (typeof mimeType !== "string") {
+        return null;
+    }
+    const normalizedMimeType = mimeType.trim().toLowerCase();
+    if (!normalizedMimeType || normalizedMimeType === "application/octet-stream") {
+        return null;
+    }
+    return normalizedMimeType;
+}
+function inferMimeTypeFromFileName(fileName) {
+    if (typeof fileName !== "string") {
+        return null;
+    }
+    return inferMimeTypeFromFilePath(fileName);
+}
+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";