@lobehub/lobehub 2.0.0-next.322 → 2.0.0-next.323

package/src/server/globalConfig/parseMemoryExtractionConfig.ts

@@ -1,4 +1,5 @@
-import { DEFAULT_USER_MEMORY_EMBEDDING_MODEL_ITEM } from '@lobechat/const';
+import { DEFAULT_MINI_PROVIDER } from '@lobechat/business-const';
+import { DEFAULT_MINI_MODEL, DEFAULT_USER_MEMORY_EMBEDDING_MODEL_ITEM } from '@lobechat/const';
 
 import {
   type GlobalMemoryExtractionConfig,
@@ -8,8 +9,6 @@ import {
 } from '@/types/serverConfig';
 
 const MEMORY_LAYERS: GlobalMemoryLayer[] = ['context', 'experience', 'identity', 'preference'];
-const DEFAULT_GATE_MODEL = 'gpt-5-mini';
-const DEFAULT_PROVIDER = 'openai';
 
 const parseTokenLimitEnv = (value?: string) => {
   if (value === undefined) return undefined;
@@ -62,8 +61,8 @@ export interface MemoryExtractionPrivateConfig {
 const parseGateKeeperAgent = (): MemoryAgentConfig => {
   const apiKey = process.env.MEMORY_USER_MEMORY_GATEKEEPER_API_KEY;
   const baseURL = process.env.MEMORY_USER_MEMORY_GATEKEEPER_BASE_URL;
-  const model = process.env.MEMORY_USER_MEMORY_GATEKEEPER_MODEL || DEFAULT_GATE_MODEL;
-  const provider = process.env.MEMORY_USER_MEMORY_GATEKEEPER_PROVIDER || DEFAULT_PROVIDER;
+  const model = process.env.MEMORY_USER_MEMORY_GATEKEEPER_MODEL || DEFAULT_MINI_MODEL;
+  const provider = process.env.MEMORY_USER_MEMORY_GATEKEEPER_PROVIDER || DEFAULT_MINI_PROVIDER;
   const language = process.env.MEMORY_USER_MEMORY_GATEKEEPER_LANGUAGE || 'English';
 
   return {
@@ -79,7 +78,7 @@ const parseLayerExtractorAgent = (fallbackModel: string): MemoryLayerExtractorCo
   const apiKey = process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_API_KEY;
   const baseURL = process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_BASE_URL;
   const model = process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_MODEL || fallbackModel;
-  const provider = process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_PROVIDER || DEFAULT_PROVIDER;
+  const provider = process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_PROVIDER || DEFAULT_MINI_PROVIDER;
   const contextLimit = parseTokenLimitEnv(
     process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_CONTEXT_LIMIT,
   );
@@ -117,7 +116,7 @@ const parseEmbeddingAgent = (
     process.env.MEMORY_USER_MEMORY_EMBEDDING_PROVIDER ||
     fallbackProvider ||
     defaultProvider ||
-    DEFAULT_PROVIDER;
+    DEFAULT_MINI_PROVIDER;
 
   return {
     apiKey: process.env.MEMORY_USER_MEMORY_EMBEDDING_API_KEY ?? fallbackApiKey,
@@ -174,7 +173,7 @@ export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig =>
   const agentLayerExtractor = parseLayerExtractorAgent(agentGateKeeper.model);
   const embedding = parseEmbeddingAgent(
     agentLayerExtractor.model,
-    agentLayerExtractor.provider || DEFAULT_PROVIDER,
+    agentLayerExtractor.provider || DEFAULT_MINI_PROVIDER,
     agentGateKeeper.apiKey || agentLayerExtractor.apiKey,
   );
   const extractorObservabilityS3 = parseExtractorAgentObservabilityS3();

package/src/server/routers/lambda/agent.ts

@@ -169,6 +169,20 @@ export const agentRouter = router({
       return ctx.agentModel.duplicate(input.agentId, input.newTitle);
     }),
 
+  /**
+   * Get an agent by forkedFromIdentifier stored in params
+   * @returns agent id if exists, null otherwise
+   */
+  getAgentByForkedFromIdentifier: agentProcedure
+    .input(
+      z.object({
+        forkedFromIdentifier: z.string(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      return ctx.agentModel.getAgentByForkedFromIdentifier(input.forkedFromIdentifier);
+    }),
+
   /**
    * Get an agent by marketIdentifier
    * @returns agent id if exists, null otherwise

package/src/server/routers/lambda/agentGroup.ts

@@ -165,12 +165,14 @@ export const agentGroupRouter = router({
           )
         : undefined;
 
+      const normalizedConfig = ctx.agentGroupService.normalizeGroupConfig(
+        input.groupConfig.config as ChatGroupConfig | null,
+      );
+
       const { group, supervisorAgentId } = await ctx.agentGroupRepo.createGroupWithSupervisor(
         {
           ...input.groupConfig,
-          config: ctx.agentGroupService.normalizeGroupConfig(
-            input.groupConfig.config as ChatGroupConfig | null,
-          ),
+          config: normalizedConfig,
         },
         memberAgentIds,
         supervisorConfig as any,
@@ -213,6 +215,20 @@ export const agentGroupRouter = router({
       return ctx.chatGroupModel.getGroupAgents(input.groupId);
     }),
 
+  /**
+   * Get a group by forkedFromIdentifier stored in config
+   * @returns group id if exists, null otherwise
+   */
+  getGroupByForkedFromIdentifier: agentGroupProcedure
+    .input(
+      z.object({
+        forkedFromIdentifier: z.string(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      return ctx.chatGroupModel.getGroupByForkedFromIdentifier(input.forkedFromIdentifier);
+    }),
+
   getGroupDetail: agentGroupProcedure
     .input(z.object({ id: z.string() }))
     .query(async ({ input, ctx }) => {

package/src/server/routers/lambda/market/agent.ts

@@ -163,31 +163,23 @@ const paginationSchema = z.object({
 
 // Schema for the unified publish/create flow
 const publishOrCreateSchema = z.object({
-  
   // Version data
-avatar: z.string().optional(), 
-  
+  avatar: z.string().optional(),
 
-category: z.string().optional(),
+  category: z.string().optional(),
 
-  
-  
+  changelog: z.string().optional(),
 
-changelog: z.string().optional(),
-  
+  config: z.record(z.any()).optional(),
 
-config: z.record(z.any()).optional(),
-  
+  description: z.string().optional(),
 
-description: z.string().optional(),
-  
+  editorData: z.record(z.any()).optional(),
 
-editorData: z.record(z.any()).optional(),
-  
-// Agent basic info
-identifier: z.string().optional(),
+  // Agent basic info
+  identifier: z.string().optional(),
   // Optional - if not provided or not owned, will create new
-name: z.string(),
+  name: z.string(),
   tags: z.array(z.string()).optional(),
   tokenUsage: z.number().optional(),
 });
@@ -320,11 +312,86 @@ export const agentRouter = router({
       }
     }),
 
+  
   /**
+   * Fork an agent
+   * POST /market/agent/:identifier/fork
+   */
+forkAgent: agentProcedure
+    .input(
+      z.object({
+        identifier: z.string(),
+        name: z.string().optional(),
+        sourceIdentifier: z.string(),
+        status: z.enum(['published', 'unpublished', 'archived', 'deprecated']).optional(),
+        versionNumber: z.number().optional(),
+        visibility: z.enum(['public', 'private', 'internal']).optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('forkAgent input: %O', input);
+
+      try {
+        // Call Market API directly to fork agent
+        const forkUrl = `${MARKET_BASE_URL}/api/v1/agents/${input.sourceIdentifier}/fork`;
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        };
+
+        // Use trustedClientToken or accessToken for authentication
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+
+        if (userInfo) {
+          const trustedClientToken = generateTrustedClientToken(userInfo);
+          if (trustedClientToken) {
+            headers['x-lobe-trust-token'] = trustedClientToken;
+          }
+        }
+
+        if (!headers['x-lobe-trust-token'] && accessToken) {
+          headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+
+        const response = await fetch(forkUrl, {
+          body: JSON.stringify({
+            identifier: input.identifier,
+            name: input.name,
+            status: input.status,
+            versionNumber: input.versionNumber,
+            visibility: input.visibility,
+          }),
+          headers,
+          method: 'POST',
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          log('Fork agent failed: %s %s - %s', response.status, response.statusText, errorText);
+          throw new Error(`Failed to fork agent: ${response.statusText}`);
+        }
+
+        const result = await response.json();
+        log('Fork agent success: %O', result);
+        return result;
+      } catch (error) {
+        log('Error forking agent: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to fork agent',
+        });
+      }
+    }),
+
+  
+  
+/**
    * Get agent detail by identifier
    * GET /market/agent/:identifier
    */
-  getAgentDetail: agentProcedure
+getAgentDetail: agentProcedure
     .input(z.object({ identifier: z.string() }))
     .query(async ({ input, ctx }) => {
       log('getAgentDetail input: %O', input);
@@ -342,11 +409,141 @@ export const agentRouter = router({
       }
     }),
 
-  /**
+  
+  
+
+/**
+   * Get the fork source of an agent
+   * GET /market/agent/:identifier/fork-source
+   */
+getAgentForkSource: agentProcedure
+    .input(z.object({ identifier: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('getAgentForkSource input: %O', input);
+
+      try {
+        const forkSourceUrl = `${MARKET_BASE_URL}/api/v1/agents/${input.identifier}/fork-source`;
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        };
+
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+
+        if (userInfo) {
+          const trustedClientToken = generateTrustedClientToken(userInfo);
+          if (trustedClientToken) {
+            headers['x-lobe-trust-token'] = trustedClientToken;
+          }
+        }
+
+        if (!headers['x-lobe-trust-token'] && accessToken) {
+          headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+
+        const response = await fetch(forkSourceUrl, {
+          headers,
+          method: 'GET',
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          log(
+            'Get agent fork source failed: %s %s - %s',
+            response.status,
+            response.statusText,
+            errorText,
+          );
+          throw new Error(`Failed to get agent fork source: ${response.statusText}`);
+        }
+
+        const result = await response.json();
+        return result;
+      } catch (error) {
+        log('Error getting agent fork source: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get agent fork source',
+        });
+      }
+    }),
+
+  
+  
+
+
+
+/**
+   * Get all forks of an agent
+   * GET /market/agent/:identifier/forks
+   */
+getAgentForks: agentProcedure
+    .input(z.object({ identifier: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('getAgentForks input: %O', input);
+
+      try {
+        const forksUrl = `${MARKET_BASE_URL}/api/v1/agents/${input.identifier}/forks`;
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        };
+
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+
+        if (userInfo) {
+          const trustedClientToken = generateTrustedClientToken(userInfo);
+          if (trustedClientToken) {
+            headers['x-lobe-trust-token'] = trustedClientToken;
+          }
+        }
+
+        if (!headers['x-lobe-trust-token'] && accessToken) {
+          headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+
+        const response = await fetch(forksUrl, {
+          headers,
+          method: 'GET',
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          log(
+            'Get agent forks failed: %s %s - %s',
+            response.status,
+            response.statusText,
+            errorText,
+          );
+          throw new Error(`Failed to get agent forks: ${response.statusText}`);
+        }
+
+        const result = await response.json();
+        return result;
+      } catch (error) {
+        log('Error getting agent forks: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get agent forks',
+        });
+      }
+    }),
+
+  
+  
+
+
+
+
+/**
    * Get own agents (requires authentication)
    * GET /market/agent/own
    */
-  getOwnAgents: agentProcedure.input(paginationSchema.optional()).query(async ({ input, ctx }) => {
+getOwnAgents: agentProcedure.input(paginationSchema.optional()).query(async ({ input, ctx }) => {
     log('getOwnAgents input: %O', input);
 
     try {
@@ -365,11 +562,16 @@ export const agentRouter = router({
     }
   }),
 
-  /**
+  
+  
+
+
+
+/**
    * Publish an agent (make it visible in marketplace)
    * POST /market/agent/:identifier/publish
    */
-  publishAgent: agentProcedure
+publishAgent: agentProcedure
     .input(z.object({ identifier: z.string() }))
     .mutation(async ({ input, ctx }) => {
       log('publishAgent input: %O', input);
@@ -387,7 +589,11 @@ export const agentRouter = router({
       }
     }),
 
-  /**
+  
+  
+
+
+/**
    * Unified publish or create agent flow
    * This procedure handles the complete publish logic:
    * 1. Check if identifier exists and if current user is owner
@@ -396,7 +602,7 @@ export const agentRouter = router({
    *
    * Returns: { identifier, isNewAgent, success }
    */
-  publishOrCreate: agentProcedure.input(publishOrCreateSchema).mutation(async ({ input, ctx }) => {
+publishOrCreate: agentProcedure.input(publishOrCreateSchema).mutation(async ({ input, ctx }) => {
     log('publishOrCreate input: %O', input);
 
     const { identifier: inputIdentifier, name, ...versionData } = input;
@@ -478,11 +684,13 @@ export const agentRouter = router({
     }
   }),
 
-  /**
+  
+  
+/**
    * Unpublish an agent (hide from marketplace, can be republished)
    * POST /market/agent/:identifier/unpublish
    */
-  unpublishAgent: agentProcedure
+unpublishAgent: agentProcedure
     .input(z.object({ identifier: z.string() }))
     .mutation(async ({ input, ctx }) => {
       log('unpublishAgent input: %O', input);

package/src/server/routers/lambda/market/agentGroup.ts

@@ -200,13 +200,214 @@ export const agentGroupRouter = router({
       }
     }),
 
+  
   /**
+   * Fork an agent group
+   * POST /market/agent-group/:identifier/fork
+   */
+forkAgentGroup: agentGroupProcedure
+    .input(
+      z.object({
+        identifier: z.string(),
+        name: z.string().optional(),
+        sourceIdentifier: z.string(),
+        status: z.enum(['published', 'unpublished', 'archived', 'deprecated']).optional(),
+        versionNumber: z.number().optional(),
+        visibility: z.enum(['public', 'private', 'internal']).optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('forkAgentGroup input: %O', input);
+
+      try {
+        // Call Market API directly to fork agent group
+        const forkUrl = `${MARKET_BASE_URL}/api/v1/agent-groups/${input.sourceIdentifier}/fork`;
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        };
+
+        // Use trustedClientToken or accessToken for authentication
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+
+        if (userInfo) {
+          const trustedClientToken = generateTrustedClientToken(userInfo);
+          if (trustedClientToken) {
+            headers['x-lobe-trust-token'] = trustedClientToken;
+          }
+        }
+
+        if (!headers['x-lobe-trust-token'] && accessToken) {
+          headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+
+        const response = await fetch(forkUrl, {
+          body: JSON.stringify({
+            identifier: input.identifier,
+            name: input.name,
+            status: input.status,
+            versionNumber: input.versionNumber,
+            visibility: input.visibility,
+          }),
+          headers,
+          method: 'POST',
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          log(
+            'Fork agent group failed: %s %s - %s',
+            response.status,
+            response.statusText,
+            errorText,
+          );
+          throw new Error(`Failed to fork agent group: ${response.statusText}`);
+        }
+
+        const result = await response.json();
+        log('Fork agent group success: %O', result);
+        return result;
+      } catch (error) {
+        log('Error forking agent group: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to fork agent group',
+        });
+      }
+    }),
+
+  
+  
+/**
+   * Get the fork source of an agent group
+   * GET /market/agent-group/:identifier/fork-source
+   */
+getAgentGroupForkSource: agentGroupProcedure
+    .input(z.object({ identifier: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('getAgentGroupForkSource input: %O', input);
+
+      try {
+        const forkSourceUrl = `${MARKET_BASE_URL}/api/v1/agent-groups/${input.identifier}/fork-source`;
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        };
+
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+
+        if (userInfo) {
+          const trustedClientToken = generateTrustedClientToken(userInfo);
+          if (trustedClientToken) {
+            headers['x-lobe-trust-token'] = trustedClientToken;
+          }
+        }
+
+        if (!headers['x-lobe-trust-token'] && accessToken) {
+          headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+
+        const response = await fetch(forkSourceUrl, {
+          headers,
+          method: 'GET',
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          log(
+            'Get agent group fork source failed: %s %s - %s',
+            response.status,
+            response.statusText,
+            errorText,
+          );
+          throw new Error(`Failed to get agent group fork source: ${response.statusText}`);
+        }
+
+        const result = await response.json();
+        return result;
+      } catch (error) {
+        log('Error getting agent group fork source: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get agent group fork source',
+        });
+      }
+    }),
+
+  
+  
+
+/**
+   * Get all forks of an agent group
+   * GET /market/agent-group/:identifier/forks
+   */
+getAgentGroupForks: agentGroupProcedure
+    .input(z.object({ identifier: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('getAgentGroupForks input: %O', input);
+
+      try {
+        const forksUrl = `${MARKET_BASE_URL}/api/v1/agent-groups/${input.identifier}/forks`;
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+        };
+
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+
+        if (userInfo) {
+          const trustedClientToken = generateTrustedClientToken(userInfo);
+          if (trustedClientToken) {
+            headers['x-lobe-trust-token'] = trustedClientToken;
+          }
+        }
+
+        if (!headers['x-lobe-trust-token'] && accessToken) {
+          headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+
+        const response = await fetch(forksUrl, {
+          headers,
+          method: 'GET',
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          log(
+            'Get agent group forks failed: %s %s - %s',
+            response.status,
+            response.statusText,
+            errorText,
+          );
+          throw new Error(`Failed to get agent group forks: ${response.statusText}`);
+        }
+
+        const result = await response.json();
+        return result;
+      } catch (error) {
+        log('Error getting agent group forks: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get agent group forks',
+        });
+      }
+    }),
+
+  
+  
+/**
    * Unified publish or create agent group flow
    * 1. Check if identifier exists and if current user is owner
    * 2. If not owner or no identifier, create new group
    * 3. Create new version for the group if updating
    */
-  publishOrCreate: agentGroupProcedure
+publishOrCreate: agentGroupProcedure
     .input(publishOrCreateGroupSchema)
     .mutation(async ({ input, ctx }) => {
       log('publishOrCreate input: %O', input);
@@ -294,3 +495,5 @@ export const agentGroupRouter = router({
       }
     }),
 });
+
+export type AgentGroupRouter = typeof agentGroupRouter;