@okrlinkhub/agent-factory 0.2.13 → 0.2.14

package/src/component/lib.test.ts

@@ -52,6 +52,181 @@ describe("component lib", () => {
     expect(claimed?.conversationId).toBe("telegram:chat:1");
   });
 
+  test("minimal agent profile should work when payload provides providerUserId", async () => {
+    const t = initConvexTest();
+    await t.mutation(api.queue.upsertAgentProfile, {
+      agentKey: "minimal-agent",
+      version: "1.0.0",
+      secretsRef: [],
+      enabled: true,
+    });
+
+    const messageId = await t.mutation(api.lib.enqueue, {
+      conversationId: "telegram:chat:minimal",
+      agentKey: "minimal-agent",
+      payload: {
+        provider: "telegram",
+        providerUserId: "u-minimal-1",
+        messageText: "hello",
+      },
+    });
+
+    const claim = await t.mutation(api.lib.claim, {
+      workerId: "worker-minimal-1",
+    });
+    expect(claim?.messageId).toBe(messageId);
+    expect(claim?.payload.providerUserId).toBe("u-minimal-1");
+
+    const bundle = await t.query(api.lib.getHydrationBundle, {
+      messageId,
+      workspaceId: "default",
+    });
+    expect(bundle).not.toBeNull();
+    expect(bundle?.payload.providerUserId).toBe("u-minimal-1");
+    expect(bundle?.bridgeRuntimeConfig).toBeNull();
+  });
+
+  test("enqueue should append global system prompt to queued message", async () => {
+    const t = initConvexTest();
+    await t.mutation(api.queue.upsertAgentProfile, {
+      agentKey: "system-prompt-agent",
+      version: "1.0.0",
+      secretsRef: [],
+      enabled: true,
+    });
+    await t.mutation(api.lib.setMessageRuntimeConfig, {
+      messageConfig: {
+        systemPrompt: "  Rispondi sempre con un breve riassunto finale.  ",
+      },
+    });
+
+    const storedMessageConfig = await t.query(api.lib.messageRuntimeConfig, {});
+    expect(storedMessageConfig).toEqual({
+      systemPrompt: "Rispondi sempre con un breve riassunto finale.",
+    });
+
+    const messageId = await t.mutation(api.lib.enqueue, {
+      conversationId: "telegram:chat:system-prompt",
+      agentKey: "system-prompt-agent",
+      payload: {
+        provider: "telegram",
+        providerUserId: "u-system-prompt-1",
+        messageText: "Come va?",
+      },
+    });
+
+    const claim = await t.mutation(api.lib.claim, {
+      workerId: "worker-system-prompt-1",
+    });
+    expect(claim?.messageId).toBe(messageId);
+    expect(claim?.payload.messageText).toBe(
+      "Come va?\n\nRispondi sempre con un breve riassunto finale.",
+    );
+  });
+
+  test("blank global system prompt should not modify queued messages", async () => {
+    const t = initConvexTest();
+    await t.mutation(api.queue.upsertAgentProfile, {
+      agentKey: "blank-system-prompt-agent",
+      version: "1.0.0",
+      secretsRef: [],
+      enabled: true,
+    });
+    await t.mutation(api.lib.setMessageRuntimeConfig, {
+      messageConfig: {
+        systemPrompt: "   ",
+      },
+    });
+
+    const storedMessageConfig = await t.query(api.lib.messageRuntimeConfig, {});
+    expect(storedMessageConfig).toBeNull();
+
+    const messageId = await t.mutation(api.lib.enqueue, {
+      conversationId: "telegram:chat:blank-system-prompt",
+      agentKey: "blank-system-prompt-agent",
+      payload: {
+        provider: "telegram",
+        providerUserId: "u-blank-system-prompt-1",
+        messageText: "hello",
+      },
+    });
+
+    const claim = await t.mutation(api.lib.claim, {
+      workerId: "worker-blank-system-prompt-1",
+    });
+    expect(claim?.messageId).toBe(messageId);
+    expect(claim?.payload.messageText).toBe("hello");
+  });
+
+  test("enqueue should fail when providerUserId is blank in both profile and payload", async () => {
+    const t = initConvexTest();
+    await t.mutation(api.queue.upsertAgentProfile, {
+      agentKey: "missing-provider-user-agent",
+      version: "1.0.0",
+      providerUserId: "   ",
+      secretsRef: [],
+      enabled: true,
+    });
+
+    await expect(
+      t.mutation(api.queue.enqueueMessage, {
+        conversationId: "telegram:chat:missing-provider-user",
+        agentKey: "missing-provider-user-agent",
+        payload: {
+          provider: "telegram",
+          providerUserId: "   ",
+          messageText: "hello",
+        },
+      }),
+    ).rejects.toThrow("providerUserId is required but missing");
+  });
+
+  test("clearDeprecatedAgentProfileFields should remove deprecated profile fields", async () => {
+    const t = initConvexTest();
+    await t.mutation(api.queue.upsertAgentProfile, {
+      agentKey: "cleanup-agent",
+      version: "1.0.0",
+      providerUserId: "legacy-user-1",
+      soulMd: "# Legacy Soul",
+      clientMd: "# Legacy Client",
+      skills: ["agent-bridge"],
+      secretsRef: [],
+      enabled: true,
+    });
+    await t.mutation(api.queue.upsertAgentProfile, {
+      agentKey: "already-clean-agent",
+      version: "1.0.0",
+      secretsRef: [],
+      enabled: true,
+    });
+
+    const dryRun = await t.mutation((api.lib as any).clearDeprecatedAgentProfileFields, {
+      dryRun: true,
+    });
+    expect(dryRun.dryRun).toBe(true);
+    expect(dryRun.scanned).toBe(2);
+    expect(dryRun.updated).toBe(1);
+    expect(dryRun.unchanged).toBe(1);
+    expect(dryRun.clearedProviderUserId).toBe(1);
+    expect(dryRun.clearedSoulMd).toBe(1);
+    expect(dryRun.clearedClientMd).toBe(1);
+    expect(dryRun.clearedSkills).toBe(1);
+    expect(dryRun.updatedAgentKeys).toEqual(["cleanup-agent"]);
+
+    const cleanup = await t.mutation((api.lib as any).clearDeprecatedAgentProfileFields, {});
+    expect(cleanup.dryRun).toBe(false);
+    expect(cleanup.updated).toBe(1);
+    expect(cleanup.updatedAgentKeys).toEqual(["cleanup-agent"]);
+
+    const secondPass = await t.mutation((api.lib as any).clearDeprecatedAgentProfileFields, {});
+    expect(secondPass.updated).toBe(0);
+    expect(secondPass.unchanged).toBe(2);
+    expect(secondPass.clearedProviderUserId).toBe(0);
+    expect(secondPass.clearedSoulMd).toBe(0);
+    expect(secondPass.clearedClientMd).toBe(0);
+    expect(secondPass.clearedSkills).toBe(0);
+  });
+
   test("identity binding should resolve, rebind and revoke", async () => {
     const t = initConvexTest();
     await t.mutation(api.queue.upsertAgentProfile, {

package/src/component/lib.ts

@@ -1,9 +1,12 @@
 export {
   upsertAgentProfile as configureAgent,
+  clearDeprecatedAgentProfileFields,
   importPlaintextSecret as importSecret,
   getSecretsStatus as secretStatus,
   providerRuntimeConfig,
   setProviderRuntimeConfig,
+  messageRuntimeConfig,
+  setMessageRuntimeConfig,
   enqueueMessage as enqueue,
   releaseStuckJobs,
   appendConversationMessages,

package/src/component/queue.ts

@@ -65,6 +65,10 @@ const bridgeRuntimeConfigValidator = v.object({
   serviceKeySecretRef: v.union(v.null(), v.string()),
 });
 
+const messageRuntimeConfigValidator = v.object({
+  systemPrompt: v.optional(v.string()),
+});
+
 const globalSkillStatusValidator = v.union(v.literal("active"), v.literal("disabled"));
 const globalSkillReleaseChannelValidator = v.union(v.literal("stable"), v.literal("canary"));
 const globalSkillModuleFormatValidator = v.union(v.literal("esm"), v.literal("cjs"));
@@ -86,6 +90,11 @@ const BRIDGE_SECRET_REFS = {
   appKey: "agent-bridge.appKey",
 } as const;
 
+const RUNTIME_CONFIG_KEYS = {
+  provider: "provider",
+  message: "message",
+} as const;
+
 export const enqueueMessage = mutation({
   args: {
     conversationId: v.string(),
@@ -100,6 +109,10 @@ export const enqueueMessage = mutation({
   returns: v.id("messageQueue"),
   handler: async (ctx, args) => {
     const nowMs = args.nowMs ?? Date.now();
+    const messageRuntimeConfigRow = await ctx.db
+      .query("runtimeConfig")
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.message))
+      .unique();
     const profile = await ctx.db
       .query("agentProfiles")
       .withIndex("by_agentKey", (q) => q.eq("agentKey", args.agentKey))
@@ -126,6 +139,10 @@ export const enqueueMessage = mutation({
 
     const payload = {
       ...args.payload,
+      messageText: appendSystemPromptToMessage(
+        args.payload.messageText,
+        messageRuntimeConfigRow?.messageConfig?.systemPrompt,
+      ),
       providerUserId: providerUserIdStr,
       metadata: {
         ...(args.payload.metadata ?? {}),
@@ -252,9 +269,9 @@ export const upsertAgentProfile = mutation({
     agentKey: v.string(),
     providerUserId: v.optional(v.string()),
     version: v.string(),
-    soulMd: v.string(),
+    soulMd: v.optional(v.string()),
     clientMd: v.optional(v.string()),
-    skills: v.array(v.string()),
+    skills: v.optional(v.array(v.string())),
     secretsRef: v.array(v.string()),
     bridgeConfig: v.optional(bridgeProfileConfigValidator),
     enabled: v.boolean(),
@@ -278,6 +295,85 @@ export const upsertAgentProfile = mutation({
   },
 });
 
+export const clearDeprecatedAgentProfileFields = mutation({
+  args: {
+    dryRun: v.optional(v.boolean()),
+  },
+  returns: v.object({
+    dryRun: v.boolean(),
+    scanned: v.number(),
+    updated: v.number(),
+    unchanged: v.number(),
+    clearedProviderUserId: v.number(),
+    clearedSoulMd: v.number(),
+    clearedClientMd: v.number(),
+    clearedSkills: v.number(),
+    updatedAgentKeys: v.array(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const profiles = await ctx.db.query("agentProfiles").collect();
+    const dryRun = args.dryRun ?? false;
+
+    let updated = 0;
+    let clearedProviderUserId = 0;
+    let clearedSoulMd = 0;
+    let clearedClientMd = 0;
+    let clearedSkills = 0;
+    const updatedAgentKeys: Array<string> = [];
+
+    for (const profile of profiles) {
+      const patch: {
+        providerUserId?: undefined;
+        soulMd?: undefined;
+        clientMd?: undefined;
+        skills?: undefined;
+      } = {};
+      let shouldPatch = false;
+
+      if (profile.providerUserId !== undefined) {
+        patch.providerUserId = undefined;
+        clearedProviderUserId += 1;
+        shouldPatch = true;
+      }
+      if (profile.soulMd !== undefined) {
+        patch.soulMd = undefined;
+        clearedSoulMd += 1;
+        shouldPatch = true;
+      }
+      if (profile.clientMd !== undefined) {
+        patch.clientMd = undefined;
+        clearedClientMd += 1;
+        shouldPatch = true;
+      }
+      if (profile.skills !== undefined) {
+        patch.skills = undefined;
+        clearedSkills += 1;
+        shouldPatch = true;
+      }
+
+      if (!shouldPatch) continue;
+
+      updated += 1;
+      updatedAgentKeys.push(profile.agentKey);
+      if (!dryRun) {
+        await ctx.db.patch(profile._id, patch);
+      }
+    }
+
+    return {
+      dryRun,
+      scanned: profiles.length,
+      updated,
+      unchanged: profiles.length - updated,
+      clearedProviderUserId,
+      clearedSoulMd,
+      clearedClientMd,
+      clearedSkills,
+      updatedAgentKeys,
+    };
+  },
+});
+
 export const importPlaintextSecret = mutation({
   args: {
     secretRef: v.string(),
@@ -378,9 +474,9 @@ export const getProviderRuntimeConfig = internalQuery({
   handler: async (ctx) => {
     const row = await ctx.db
       .query("runtimeConfig")
-      .withIndex("by_key", (q) => q.eq("key", "provider"))
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.provider))
       .unique();
-    if (!row) {
+    if (!row?.providerConfig) {
       return null;
     }
     return row.providerConfig;
@@ -397,11 +493,11 @@ export const upsertProviderRuntimeConfig = internalMutation({
     const nowMs = args.nowMs ?? Date.now();
     const existing = await ctx.db
       .query("runtimeConfig")
-      .withIndex("by_key", (q) => q.eq("key", "provider"))
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.provider))
       .unique();
     if (!existing) {
       await ctx.db.insert("runtimeConfig", {
-        key: "provider",
+        key: RUNTIME_CONFIG_KEYS.provider,
         providerConfig: args.providerConfig,
         updatedAt: nowMs,
       });
@@ -421,9 +517,9 @@ export const providerRuntimeConfig = query({
   handler: async (ctx) => {
     const row = await ctx.db
       .query("runtimeConfig")
-      .withIndex("by_key", (q) => q.eq("key", "provider"))
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.provider))
       .unique();
-    if (!row) {
+    if (!row?.providerConfig) {
       return null;
     }
     return row.providerConfig;
@@ -440,11 +536,11 @@ export const setProviderRuntimeConfig = mutation({
     const nowMs = args.nowMs ?? Date.now();
     const existing = await ctx.db
       .query("runtimeConfig")
-      .withIndex("by_key", (q) => q.eq("key", "provider"))
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.provider))
       .unique();
     if (!existing) {
       await ctx.db.insert("runtimeConfig", {
-        key: "provider",
+        key: RUNTIME_CONFIG_KEYS.provider,
         providerConfig: args.providerConfig,
         updatedAt: nowMs,
       });
@@ -458,6 +554,106 @@ export const setProviderRuntimeConfig = mutation({
   },
 });
 
+export const getMessageRuntimeConfig = internalQuery({
+  args: {},
+  returns: v.union(v.null(), messageRuntimeConfigValidator),
+  handler: async (ctx) => {
+    const row = await ctx.db
+      .query("runtimeConfig")
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.message))
+      .unique();
+    if (!row?.messageConfig) {
+      return null;
+    }
+    return row.messageConfig;
+  },
+});
+
+export const upsertMessageRuntimeConfig = internalMutation({
+  args: {
+    messageConfig: messageRuntimeConfigValidator,
+    nowMs: v.optional(v.number()),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const nowMs = args.nowMs ?? Date.now();
+    const normalizedMessageConfig = normalizeMessageRuntimeConfig(args.messageConfig);
+    const existing = await ctx.db
+      .query("runtimeConfig")
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.message))
+      .unique();
+    if (normalizedMessageConfig === null) {
+      if (existing) {
+        await ctx.db.delete(existing._id);
+      }
+      return null;
+    }
+    if (!existing) {
+      await ctx.db.insert("runtimeConfig", {
+        key: RUNTIME_CONFIG_KEYS.message,
+        messageConfig: normalizedMessageConfig,
+        updatedAt: nowMs,
+      });
+      return null;
+    }
+    await ctx.db.patch(existing._id, {
+      messageConfig: normalizedMessageConfig,
+      updatedAt: nowMs,
+    });
+    return null;
+  },
+});
+
+export const messageRuntimeConfig = query({
+  args: {},
+  returns: v.union(v.null(), messageRuntimeConfigValidator),
+  handler: async (ctx) => {
+    const row = await ctx.db
+      .query("runtimeConfig")
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.message))
+      .unique();
+    if (!row?.messageConfig) {
+      return null;
+    }
+    return row.messageConfig;
+  },
+});
+
+export const setMessageRuntimeConfig = mutation({
+  args: {
+    messageConfig: messageRuntimeConfigValidator,
+    nowMs: v.optional(v.number()),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const nowMs = args.nowMs ?? Date.now();
+    const normalizedMessageConfig = normalizeMessageRuntimeConfig(args.messageConfig);
+    const existing = await ctx.db
+      .query("runtimeConfig")
+      .withIndex("by_key", (q) => q.eq("key", RUNTIME_CONFIG_KEYS.message))
+      .unique();
+    if (normalizedMessageConfig === null) {
+      if (existing) {
+        await ctx.db.delete(existing._id);
+      }
+      return null;
+    }
+    if (!existing) {
+      await ctx.db.insert("runtimeConfig", {
+        key: RUNTIME_CONFIG_KEYS.message,
+        messageConfig: normalizedMessageConfig,
+        updatedAt: nowMs,
+      });
+      return null;
+    }
+    await ctx.db.patch(existing._id, {
+      messageConfig: normalizedMessageConfig,
+      updatedAt: nowMs,
+    });
+    return null;
+  },
+});
+
 export const deployGlobalSkill = mutation({
   args: {
     slug: v.string(),
@@ -2041,6 +2237,36 @@ async function resolveBridgeRuntimeConfig(
   };
 }
 
+function appendSystemPromptToMessage(messageText: string, systemPrompt?: string): string {
+  const normalizedSystemPrompt = normalizeSystemPrompt(systemPrompt);
+  if (normalizedSystemPrompt === null) {
+    return messageText;
+  }
+  const normalizedMessageText = messageText.trimEnd();
+  if (normalizedMessageText.length === 0) {
+    return normalizedSystemPrompt;
+  }
+  return `${normalizedMessageText}\n\n${normalizedSystemPrompt}`;
+}
+
+function normalizeMessageRuntimeConfig(
+  messageConfig: { systemPrompt?: string } | null | undefined,
+): { systemPrompt?: string } | null {
+  const systemPrompt = normalizeSystemPrompt(messageConfig?.systemPrompt);
+  if (systemPrompt === null) {
+    return null;
+  }
+  return { systemPrompt };
+}
+
+function normalizeSystemPrompt(systemPrompt?: string | null): string | null {
+  if (typeof systemPrompt !== "string") {
+    return null;
+  }
+  const normalizedSystemPrompt = systemPrompt.trim();
+  return normalizedSystemPrompt.length > 0 ? normalizedSystemPrompt : null;
+}
+
 function getBridgeSecretRefsForProfile(
   agentKey: string,
   bridgeConfig:

package/src/component/schema.ts

@@ -6,9 +6,9 @@ export default defineSchema({
     agentKey: v.string(),
     providerUserId: v.optional(v.string()),
     version: v.string(),
-    soulMd: v.string(),
+    soulMd: v.optional(v.string()),
     clientMd: v.optional(v.string()),
-    skills: v.array(v.string()),
+    skills: v.optional(v.array(v.string())),
     secretsRef: v.array(v.string()),
     bridgeConfig: v.optional(
       v.object({
@@ -134,16 +134,23 @@ export default defineSchema({
 
   runtimeConfig: defineTable({
     key: v.string(),
-    providerConfig: v.object({
-      kind: v.union(v.literal("fly"), v.literal("runpod"), v.literal("ecs")),
-      appName: v.string(),
-      organizationSlug: v.string(),
-      image: v.string(),
-      region: v.string(),
-      volumeName: v.string(),
-      volumePath: v.string(),
-      volumeSizeGb: v.number(),
-    }),
+    providerConfig: v.optional(
+      v.object({
+        kind: v.union(v.literal("fly"), v.literal("runpod"), v.literal("ecs")),
+        appName: v.string(),
+        organizationSlug: v.string(),
+        image: v.string(),
+        region: v.string(),
+        volumeName: v.string(),
+        volumePath: v.string(),
+        volumeSizeGb: v.number(),
+      }),
+    ),
+    messageConfig: v.optional(
+      v.object({
+        systemPrompt: v.optional(v.string()),
+      }),
+    ),
     updatedAt: v.number(),
   }).index("by_key", ["key"]),