@okrlinkhub/agent-factory 2.0.0 → 2.0.1

package/dist/component/queue.js

@@ -4,6 +4,18 @@ import { internalMutation, internalQuery, mutation, query, } from "./_generated/
 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 queuePayloadValidator = v.object({
     provider: v.string(),
     providerUserId: v.string(),
@@ -11,6 +23,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 +115,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 +147,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 +450,30 @@ 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 upsertMessageRuntimeConfig = internalMutation({
     args: {
         messageConfig: messageRuntimeConfigValidator,
@@ -1407,18 +1446,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 +2078,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 +2282,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 +2435,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 +2453,33 @@ 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 buildGlobalSkillMaterialization(skill) {
     const skillDirName = normalizeGlobalSkillDirName(skill.slug);
     const scriptExt = skill.moduleFormat === "cjs" ? "cjs" : "mjs";