@nlabs/reaktor 1.8.0 → 1.9.1

package/lib/actions/geminiVideo.js

@@ -0,0 +1,161 @@
+import { get, post } from '@nlabs/rip-hunter';
+import { get as httpsGet } from 'node:https';
+import { validateGeminiVideoInput } from '../adapters/geminiGenerationAdapter.js';
+import { Config } from '../config.js';
+export class GeminiGenerationRejectedError extends Error {
+}
+const origin = 'https://generativelanguage.googleapis.com';
+const operationPattern = /^(?:models\/[a-zA-Z0-9._-]+\/)?operations\/[a-zA-Z0-9_-]+$/;
+const getKey = (config)=>{
+    const key = config?.key || Config.get('contentGeneration.geminiKey');
+    if (!key) {
+        throw new GeminiGenerationRejectedError('Gemini video generation is not configured.');
+    }
+    return key;
+};
+const operationUrl = (name)=>{
+    if (!operationPattern.test(name)) {
+        throw new Error('Invalid Gemini operation identifier.');
+    }
+    return `${origin}/v1beta/${name}`;
+};
+/** Submit once; an unconfirmed response must be reconciled rather than retried. */ export const generateGeminiVideo = async (_context, input, config)=>{
+    const validated = validateGeminiVideoInput(input);
+    const key = getKey(config);
+    const model = validated.model || config?.model || 'veo-3.1-generate-preview';
+    if (!/^[a-zA-Z0-9._-]+$/.test(model)) {
+        throw new GeminiGenerationRejectedError('Invalid Gemini video model.');
+    }
+    const result = await post(`${origin}/v1beta/models/${model}:predictLongRunning`, {
+        instances: [
+            {
+                prompt: validated.prompt
+            }
+        ],
+        parameters: {
+            ...validated.aspectRatio ? {
+                aspectRatio: validated.aspectRatio
+            } : {},
+            durationSeconds: validated.duration,
+            resolution: validated.resolution,
+            sampleCount: 1
+        }
+    }, {
+        cache: false,
+        headers: new Headers({
+            'x-goog-api-key': key
+        }),
+        timeout: 120_000
+    });
+    if (result.error && [
+        400,
+        401,
+        403,
+        404
+    ].includes(result.error.code || 0)) {
+        throw new GeminiGenerationRejectedError('Gemini rejected the video request. Check model access and settings.');
+    }
+    if (result.error || !result.name) {
+        throw new Error('Gemini video submission could not be confirmed.');
+    }
+    return {
+        provider: 'gemini',
+        requestId: result.name,
+        status: 'queued',
+        statusUrl: operationUrl(result.name)
+    };
+};
+export const getGeminiVideoStatus = async (requestId, config)=>{
+    const result = await get(operationUrl(requestId), undefined, {
+        cache: false,
+        headers: new Headers({
+            'x-goog-api-key': getKey(config)
+        }),
+        timeout: 30_000
+    });
+    if (result.done !== true) {
+        if (result.error) {
+            throw new Error('Gemini video status could not be confirmed.');
+        }
+        return {
+            status: 'processing'
+        };
+    }
+    if (result.error || result.response?.generateVideoResponse?.raiMediaFilteredCount) {
+        return {
+            error: 'Gemini video generation failed or was filtered.',
+            status: 'failed'
+        };
+    }
+    const mediaUrl = result.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;
+    if (!mediaUrl) {
+        throw new Error('Gemini completed without verifiable video output.');
+    }
+    validateDownloadUrl(mediaUrl, false);
+    return {
+        mediaUrl,
+        status: 'succeeded'
+    };
+};
+const validateDownloadUrl = (value, redirected)=>{
+    const url = new URL(value);
+    const allowed = url.origin === origin && /^\/(?:download\/)?v1beta\/files\/[a-zA-Z0-9_-]+(?::download)?$/.test(url.pathname);
+    const storage = redirected && (url.hostname === 'storage.googleapis.com' || url.hostname.endsWith('.googleusercontent.com'));
+    if (url.protocol !== 'https:' || url.port || url.username || url.password || url.hash || url.searchParams.has('key') || !(allowed || storage)) {
+        throw new Error('Invalid Gemini video download URL.');
+    }
+    return url;
+};
+/** Binary downloads use HTTPS streams because Rip-Hunter currently decodes non-JSON bodies as text. */ export const downloadGeminiVideo = async (mediaUrl, config)=>{
+    const key = getKey(config);
+    const download = (value, redirects)=>new Promise((resolve, reject)=>{
+            const url = validateDownloadUrl(value, redirects > 0);
+            const request = httpsGet(url, {
+                headers: url.origin === origin ? {
+                    'x-goog-api-key': key
+                } : {},
+                timeout: 60_000
+            }, (response)=>{
+                if ([
+                    301,
+                    302,
+                    303,
+                    307,
+                    308
+                ].includes(response.statusCode || 0) && response.headers.location && redirects < 3) {
+                    response.resume();
+                    download(new URL(response.headers.location, url).href, redirects + 1).then(resolve, reject);
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    response.resume();
+                    reject(new Error('Gemini video download failed.'));
+                    return;
+                }
+                const chunks = [];
+                let length = 0;
+                response.on('data', (chunk)=>{
+                    length += chunk.length;
+                    if (length > 128 * 1024 * 1024) {
+                        response.destroy(new Error('Gemini video exceeds the download limit.'));
+                    } else {
+                        chunks.push(chunk);
+                    }
+                });
+                response.on('error', reject);
+                response.on('end', ()=>{
+                    const bytes = Buffer.concat(chunks);
+                    if (bytes.subarray(4, 8).toString('ascii') !== 'ftyp') {
+                        reject(new Error('Gemini did not return MP4 video bytes.'));
+                        return;
+                    }
+                    resolve(bytes);
+                });
+            });
+            request.on('error', reject);
+            request.on('timeout', ()=>request.destroy(new Error('Gemini video download timed out.')));
+        });
+    return download(mediaUrl, 0);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/geminiVideo.ts"],"sourcesContent":["import {get, post} from '@nlabs/rip-hunter';\nimport {get as httpsGet} from 'node:https';\n\nimport {validateGeminiVideoInput} from '../adapters/geminiGenerationAdapter.js';\nimport {Config} from '../config.js';\n\nimport type {GeminiVideoInput} from '../adapters/geminiGenerationAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {VideoGenerationResult} from './videoGeneration.js';\n\nexport class GeminiGenerationRejectedError extends Error {}\nexport interface GeminiVideoConfig {key?: string; model?: string}\nexport interface GeminiVideoStatus {error?: string; mediaUrl?: string; status: 'failed' | 'processing' | 'succeeded'}\nconst origin = 'https://generativelanguage.googleapis.com';\nconst operationPattern = /^(?:models\\/[a-zA-Z0-9._-]+\\/)?operations\\/[a-zA-Z0-9_-]+$/;\nconst getKey = (config?: GeminiVideoConfig): string => {\n  const key = config?.key || Config.get<string>('contentGeneration.geminiKey');\n  if(!key) {\n    throw new GeminiGenerationRejectedError('Gemini video generation is not configured.');\n  }\n  return key;\n};\nconst operationUrl = (name: string): string => {\n  if(!operationPattern.test(name)) {\n    throw new Error('Invalid Gemini operation identifier.');\n  }\n  return `${origin}/v1beta/${name}`;\n};\n\n/** Submit once; an unconfirmed response must be reconciled rather than retried. */\nexport const generateGeminiVideo = async (\n  _context: ApiContext, input: GeminiVideoInput, config?: GeminiVideoConfig\n): Promise<VideoGenerationResult> => {\n  const validated = validateGeminiVideoInput(input);\n  const key = getKey(config);\n  const model = validated.model || config?.model || 'veo-3.1-generate-preview';\n  if(!/^[a-zA-Z0-9._-]+$/.test(model)) {\n    throw new GeminiGenerationRejectedError('Invalid Gemini video model.');\n  }\n  const result = await post(`${origin}/v1beta/models/${model}:predictLongRunning`, {\n    instances: [{prompt: validated.prompt}],\n    parameters: {\n      ...(validated.aspectRatio ? {aspectRatio: validated.aspectRatio} : {}),\n      durationSeconds: validated.duration,\n      resolution: validated.resolution,\n      sampleCount: 1\n    }\n  }, {cache: false, headers: new Headers({'x-goog-api-key': key}), timeout: 120_000}) as {error?: {code?: number}; name?: string};\n  if(result.error && [400, 401, 403, 404].includes(result.error.code || 0)) {\n    throw new GeminiGenerationRejectedError('Gemini rejected the video request. Check model access and settings.');\n  }\n  if(result.error || !result.name) {\n    throw new Error('Gemini video submission could not be confirmed.');\n  }\n  return {provider: 'gemini', requestId: result.name, status: 'queued', statusUrl: operationUrl(result.name)};\n};\n\nexport const getGeminiVideoStatus = async (\n  requestId: string, config?: GeminiVideoConfig\n): Promise<GeminiVideoStatus> => {\n  const result = await get(operationUrl(requestId), undefined, {\n    cache: false, headers: new Headers({'x-goog-api-key': getKey(config)}), timeout: 30_000\n  }) as {\n    done?: boolean;\n    error?: {code?: number};\n    response?: {generateVideoResponse?: {\n      generatedSamples?: {video?: {uri?: string}}[]; raiMediaFilteredCount?: number;\n    };};\n  };\n  if(result.done !== true) {\n    if(result.error) {\n      throw new Error('Gemini video status could not be confirmed.');\n    }\n    return {status: 'processing'};\n  }\n  if(result.error || result.response?.generateVideoResponse?.raiMediaFilteredCount) {\n    return {error: 'Gemini video generation failed or was filtered.', status: 'failed'};\n  }\n  const mediaUrl = result.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;\n  if(!mediaUrl) {\n    throw new Error('Gemini completed without verifiable video output.');\n  }\n  validateDownloadUrl(mediaUrl, false);\n  return {mediaUrl, status: 'succeeded'};\n};\n\nconst validateDownloadUrl = (value: string, redirected: boolean): URL => {\n  const url = new URL(value);\n  const allowed = url.origin === origin && /^\\/(?:download\\/)?v1beta\\/files\\/[a-zA-Z0-9_-]+(?::download)?$/.test(url.pathname);\n  const storage = redirected && (url.hostname === 'storage.googleapis.com' || url.hostname.endsWith('.googleusercontent.com'));\n  if(url.protocol !== 'https:' || url.port || url.username || url.password || url.hash || url.searchParams.has('key') || !(allowed || storage)) {\n    throw new Error('Invalid Gemini video download URL.');\n  }\n  return url;\n};\n\n/** Binary downloads use HTTPS streams because Rip-Hunter currently decodes non-JSON bodies as text. */\nexport const downloadGeminiVideo = async (mediaUrl: string, config?: GeminiVideoConfig): Promise<Buffer> => {\n  const key = getKey(config);\n  const download = (value: string, redirects: number): Promise<Buffer> => new Promise((resolve, reject) => {\n    const url = validateDownloadUrl(value, redirects > 0);\n    const request = httpsGet(url, {\n      headers: url.origin === origin ? {'x-goog-api-key': key} : {}, timeout: 60_000\n    }, (response) => {\n      if([301, 302, 303, 307, 308].includes(response.statusCode || 0) && response.headers.location && redirects < 3) {\n        response.resume();\n        download(new URL(response.headers.location, url).href, redirects + 1).then(resolve, reject);\n        return;\n      }\n      if(response.statusCode !== 200) {\n        response.resume();\n        reject(new Error('Gemini video download failed.'));\n        return;\n      }\n      const chunks: Buffer[] = [];\n      let length = 0;\n      response.on('data', (chunk: Buffer) => {\n        length += chunk.length;\n        if(length > 128 * 1024 * 1024) {\n          response.destroy(new Error('Gemini video exceeds the download limit.'));\n        } else {\n          chunks.push(chunk);\n        }\n      });\n      response.on('error', reject);\n      response.on('end', () => {\n        const bytes = Buffer.concat(chunks);\n        if(bytes.subarray(4, 8).toString('ascii') !== 'ftyp') {\n          reject(new Error('Gemini did not return MP4 video bytes.'));\n          return;\n        }\n        resolve(bytes);\n      });\n    });\n    request.on('error', reject);\n    request.on('timeout', () => request.destroy(new Error('Gemini video download timed out.')));\n  });\n  return download(mediaUrl, 0);\n};\n"],"names":["get","post","httpsGet","validateGeminiVideoInput","Config","GeminiGenerationRejectedError","Error","origin","operationPattern","getKey","config","key","operationUrl","name","test","generateGeminiVideo","_context","input","validated","model","result","instances","prompt","parameters","aspectRatio","durationSeconds","duration","resolution","sampleCount","cache","headers","Headers","timeout","error","includes","code","provider","requestId","status","statusUrl","getGeminiVideoStatus","undefined","done","response","generateVideoResponse","raiMediaFilteredCount","mediaUrl","generatedSamples","video","uri","validateDownloadUrl","value","redirected","url","URL","allowed","pathname","storage","hostname","endsWith","protocol","port","username","password","hash","searchParams","has","downloadGeminiVideo","download","redirects","Promise","resolve","reject","request","statusCode","location","resume","href","then","chunks","length","on","chunk","destroy","push","bytes","Buffer","concat","subarray","toString"],"mappings":"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"}

package/lib/actions/groups.js

@@ -277,4 +277,4 @@ export const isGrouped = (context, userId, groupId)=>{
         }).then(()=>null));
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/reaktor/reaktor/packages/reaktor/src/actions/groups.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {flatten} from '@nlabs/utils/arrays/flatten';\nimport {uniqBy} from '@nlabs/utils/arrays/uniq';\nimport {createHash, parseArangoId, parseChar, parseId} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery, literal} from 'arangojs/aql';\n\nimport {COLLECTIONS, EDGES} from '../constants/collections.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {addItem, deleteItem, getItemBy, updateItem} from './crud.js';\nimport {extractTags, getTagListByName, updateTagsInItem} from './tags.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {GroupEdgeType, GroupType, GroupUser} from '../types/groups.types.js';\n\nconst eventCategory = 'groups';\nconst groupsCollection = literal(COLLECTIONS.GROUPS);\nconst usersCollection = literal(COLLECTIONS.USERS);\nconst hasConnectionCollection = literal(EDGES.HAS_CONNECTION);\nconst isTaggedCollection = literal(EDGES.IS_TAGGED);\n\n/**\n * Get all groups for the app with their users\n * Note: Uses custom query for edge traversal to include users\n */\nexport const getGroupListByApp = (context: ApiContext, from?: number, to?: number): Promise<GroupType[]> => {\n  const action = 'getGroupListByApp';\n  const {databaseName} = context;\n\n  // Complex edge traversal query - keep custom implementation\n  const aqlQry: AqlQuery = aql`\n    FOR g IN ${groupsCollection}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id ${hasConnectionCollection}\n        RETURN MERGE(u, {type: l.type})\n      )\n      ${from !== undefined && to !== undefined ? literal(`LIMIT ${from}, ${to - from}`) : literal('')}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users})\n  `;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context).then(() => null);\n\n      return [];\n    });\n};\n\nexport const getGroupListByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number,\n  to: number\n): Promise<GroupType[]> => {\n  const action = 'getGroupListByUser';\n  const {databaseName} = context;\n\n  // Complex edge traversal query with user filtering - keep custom implementation\n  const aqlQry: AqlQuery = aql`\n    FOR g, e IN INBOUND ${`users/${userId}`} ${hasConnectionCollection}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id ${hasConnectionCollection}\n        RETURN MERGE(u, {type: l.type})\n      )\n      ${from !== undefined && to !== undefined ? literal(`LIMIT ${from}, ${to - from}`) : literal('')}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users})\n  `;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context).then(() => null);\n\n      return [];\n    });\n};\n\nexport const getGroupListByTags = (\n  context: ApiContext,\n  tagNames: string[],\n  from: number,\n  to: number\n): Promise<GroupType[]> => {\n  const action = 'getListByTags';\n  const {databaseName} = context;\n\n  // Complex multi-tag query with edge traversal - keep custom implementation\n  return Promise.all(\n    tagNames.map((tagName: string) => {\n      const formatTagName = parseId(tagName);\n      const limitClause = from !== undefined && to !== undefined ? `LIMIT ${from}, ${to - from}` : '';\n      const aqlQry: AqlQuery = aql`FOR p, e IN OUTBOUND ${`tags/${formatTagName}`} ${isTaggedCollection}\n          FOR u IN ${usersCollection}\n          LET likes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'like'\n            RETURN like\n          )\n          LET dislikes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'dislike'\n            RETURN like\n          )\n          FILTER e.type == 'post' && p.userId == u._key\n          ${literal(limitClause)}\n          SORT p.added\n          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;\n\n      return useDb(databaseName).query(aqlQry).then((cursor) => cursor.all())\n        .catch((error: Error) => {\n          logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context).then(() => null);\n\n          return [];\n        });\n    })\n  )\n    .then((results) => uniqBy(flatten(results), (item: any) => item._key))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupById = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action = 'getItem';\n  const {databaseName, session} = context;\n  const sessionId = session?.userId || '';\n  const formatItemId = parseId(itemId);\n\n  // Complex edge traversal with user ownership check - keep custom implementation\n  const aqlQry: AqlQuery = aql`FOR g, e IN OUTBOUND ${`users/${sessionId}`} hasConnection\n      FILTER g._key == ${formatItemId}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id hasConnection\n        RETURN MERGE (u, {type:l.type})\n      )\n      LIMIT 1\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupDetails = (context: ApiContext, groupId: string): Promise<GroupType> => {\n  const formatGroupId = parseId(groupId);\n  return getItemBy<GroupType>(context, COLLECTIONS.GROUPS, {_key: formatGroupId});\n};\n\nexport const createGroupEdge = (\n  context: ApiContext,\n  userDocId: string,\n  groupDocId: string\n): Promise<GroupEdgeType> => {\n  const action = 'createGroupEdge';\n  const {databaseName} = context;\n  const formatUseDocId = parseArangoId(userDocId);\n  const formatGroupDocId = parseArangoId(groupDocId);\n\n  const now = Date.now();\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasConnection');\n  const edgeId = createHash(`group-${formatUseDocId}-${formatGroupDocId}`);\n  const edge: any = {\n    _from: formatUseDocId,\n    _key: edgeId,\n    _to: formatGroupDocId,\n    added: now,\n    type: 'groups'\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, {session: {userId: formatUseDocId}}).then(() => null));\n};\n\nconst buildGroupMutation = ({description = '', name = 'Untitled', type}: GroupType): Partial<GroupType> => ({\n  description: description.substring(0, 640),\n  name,\n  type: parseChar(type, 16) || 'private'\n});\n\nexport const addGroup = (context: ApiContext, item: GroupType): Promise<GroupType> => {\n  const action = 'add';\n  const {session: {userId: sessionId}} = context;\n  const sessionDocId = `${COLLECTIONS.USERS}/${sessionId}`;\n  const {description = ''}: GroupType = item;\n  const id = createHash(`group-${sessionId}`);\n  const insert: GroupType = {\n    _key: id,\n    ...buildGroupMutation(item)\n  };\n\n  return addItem<GroupType>(context, COLLECTIONS.GROUPS, insert)\n    .then((group: GroupType) => {\n      // Update linked tags\n      const {_id: groupDocId}: GroupType = group;\n\n      // Validate sessionDocId and groupDocId\n      if (!sessionDocId || typeof sessionDocId !== 'string' || !sessionDocId.startsWith('users/')) {\n        logError({\n          action,\n          category: eventCategory,\n          label: ErrorTypes.INVALID_INPUT\n        }, new Error('Invalid or missing sessionDocId for edge creation'), context);\n        return null;\n      }\n      if (!groupDocId || typeof groupDocId !== 'string' || !groupDocId.startsWith('groups/')) {\n        logError({\n          action,\n          category: eventCategory,\n          label: ErrorTypes.INVALID_INPUT\n        }, new Error('Invalid or missing groupDocId for edge creation'), context);\n        return null;\n      }\n\n      const tagNames = extractTags(description);\n      return getTagListByName(context, tagNames)\n        .then((resolvedTags) => updateTagsInItem(context, {itemDocId: groupDocId, tags: resolvedTags}))\n        .then(() => createGroupEdge(context, sessionDocId, groupDocId)\n        .then(() => group));\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const updateGroup = (context: ApiContext, item: GroupType): Promise<GroupType> => {\n  const action = 'update';\n  const {\n    description = '',\n    id\n  }: GroupType = item;\n  const itemId = parseId(id);\n\n  return updateItem<GroupType>(context, COLLECTIONS.GROUPS, itemId, buildGroupMutation(item))\n    .then((group: GroupType) => {\n      const {_id: groupDocId} = group;\n\n      // Update linked tags\n      const tagNames = extractTags(description);\n      return getTagListByName(context, tagNames)\n        .then((resolvedTags) => updateTagsInItem(context, {itemDocId: groupDocId, tags: resolvedTags}))\n        .then(() => group);\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const deleteGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action = 'delete';\n  const formatItemId = parseId(itemId);\n\n  return deleteItem<GroupType>(context, COLLECTIONS.GROUPS, formatItemId)\n    .then((group) => group || ({_key: formatItemId} as GroupType))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupsByReaction = (context: ApiContext, reaction: string): Promise<GroupType[]> => {\n  const action = 'getGroupsByReaction';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatReaction = parseChar(reaction, 32);\n  const userDocId = `users/${sessionId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction\n      FILTER r.value == ${formatReaction}\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const isGrouped = (context: ApiContext, userId: string, groupId: string): Promise<GroupUser> => {\n  const action = 'isGrouped';\n  const {databaseName} = context;\n  const formatUserId = parseId(userId);\n  const formatGroupId = parseId(groupId);\n\n  // Complex edge traversal to check group membership - keep custom implementation\n  const aqlQry: AqlQuery = aql`FOR g IN ${groupsCollection}\n    FILTER g._key == ${formatGroupId}\n    FOR u IN INBOUND g._id ${hasConnectionCollection}\n    FILTER u._key == ${formatUserId}\n    LIMIT 1\n    RETURN u`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .then((results = []) => {\n      const isValid = !!results.length;\n\n      return {\n        groupId,\n        isValid,\n        userId\n      };\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, {session: {userId}}).then(() => null));\n};\n"],"names":["flatten","uniqBy","createHash","parseArangoId","parseChar","parseId","aql","literal","COLLECTIONS","EDGES","ErrorTypes","logError","useDb","addItem","deleteItem","getItemBy","updateItem","extractTags","getTagListByName","updateTagsInItem","eventCategory","groupsCollection","GROUPS","usersCollection","USERS","hasConnectionCollection","HAS_CONNECTION","isTaggedCollection","IS_TAGGED","getGroupListByApp","context","from","to","action","databaseName","aqlQry","undefined","query","then","cursor","all","catch","error","category","label","DATABASE_ERROR","getGroupListByUser","userId","getGroupListByTags","tagNames","Promise","map","tagName","formatTagName","limitClause","results","item","_key","getGroupById","itemId","session","sessionId","formatItemId","next","group","getGroupDetails","groupId","formatGroupId","createGroupEdge","userDocId","groupDocId","formatUseDocId","formatGroupDocId","now","Date","edgeCollection","collection","edgeId","edge","_from","_to","added","type","save","returnNew","buildGroupMutation","description","name","substring","addGroup","sessionDocId","id","insert","_id","startsWith","INVALID_INPUT","Error","resolvedTags","itemDocId","tags","updateGroup","deleteGroup","getGroupsByReaction","reaction","formatReaction","isGrouped","formatUserId","isValid","length"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/groups.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {flatten} from '@nlabs/utils/arrays/flatten';\nimport {uniqBy} from '@nlabs/utils/arrays/uniq';\nimport {createHash, parseArangoId, parseChar, parseId} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery, literal} from 'arangojs/aql';\n\nimport {COLLECTIONS, EDGES} from '../constants/collections.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {addItem, deleteItem, getItemBy, updateItem} from './crud.js';\nimport {extractTags, getTagListByName, updateTagsInItem} from './tags.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {GroupEdgeType, GroupType, GroupUser} from '../types/groups.types.js';\n\nconst eventCategory = 'groups';\nconst groupsCollection = literal(COLLECTIONS.GROUPS);\nconst usersCollection = literal(COLLECTIONS.USERS);\nconst hasConnectionCollection = literal(EDGES.HAS_CONNECTION);\nconst isTaggedCollection = literal(EDGES.IS_TAGGED);\n\n/**\n * Get all groups for the app with their users\n * Note: Uses custom query for edge traversal to include users\n */\nexport const getGroupListByApp = (context: ApiContext, from?: number, to?: number): Promise<GroupType[]> => {\n  const action = 'getGroupListByApp';\n  const {databaseName} = context;\n\n  // Complex edge traversal query - keep custom implementation\n  const aqlQry: AqlQuery = aql`\n    FOR g IN ${groupsCollection}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id ${hasConnectionCollection}\n        RETURN MERGE(u, {type: l.type})\n      )\n      ${from !== undefined && to !== undefined ? literal(`LIMIT ${from}, ${to - from}`) : literal('')}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users})\n  `;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context).then(() => null);\n\n      return [];\n    });\n};\n\nexport const getGroupListByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number,\n  to: number\n): Promise<GroupType[]> => {\n  const action = 'getGroupListByUser';\n  const {databaseName} = context;\n\n  // Complex edge traversal query with user filtering - keep custom implementation\n  const aqlQry: AqlQuery = aql`\n    FOR g, e IN INBOUND ${`users/${userId}`} ${hasConnectionCollection}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id ${hasConnectionCollection}\n        RETURN MERGE(u, {type: l.type})\n      )\n      ${from !== undefined && to !== undefined ? literal(`LIMIT ${from}, ${to - from}`) : literal('')}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users})\n  `;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context).then(() => null);\n\n      return [];\n    });\n};\n\nexport const getGroupListByTags = (\n  context: ApiContext,\n  tagNames: string[],\n  from: number,\n  to: number\n): Promise<GroupType[]> => {\n  const action = 'getListByTags';\n  const {databaseName} = context;\n\n  // Complex multi-tag query with edge traversal - keep custom implementation\n  return Promise.all(\n    tagNames.map((tagName: string) => {\n      const formatTagName = parseId(tagName);\n      const limitClause = from !== undefined && to !== undefined ? `LIMIT ${from}, ${to - from}` : '';\n      const aqlQry: AqlQuery = aql`FOR p, e IN OUTBOUND ${`tags/${formatTagName}`} ${isTaggedCollection}\n          FOR u IN ${usersCollection}\n          LET likes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'like'\n            RETURN like\n          )\n          LET dislikes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'dislike'\n            RETURN like\n          )\n          FILTER e.type == 'post' && p.userId == u._key\n          ${literal(limitClause)}\n          SORT p.added\n          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;\n\n      return useDb(databaseName).query(aqlQry).then((cursor) => cursor.all())\n        .catch((error: Error) => {\n          logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context).then(() => null);\n\n          return [];\n        });\n    })\n  )\n    .then((results) => uniqBy(flatten(results), (item: any) => item._key))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupById = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action = 'getItem';\n  const {databaseName, session} = context;\n  const sessionId = session?.userId || '';\n  const formatItemId = parseId(itemId);\n\n  // Complex edge traversal with user ownership check - keep custom implementation\n  const aqlQry: AqlQuery = aql`FOR g, e IN OUTBOUND ${`users/${sessionId}`} hasConnection\n      FILTER g._key == ${formatItemId}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id hasConnection\n        RETURN MERGE (u, {type:l.type})\n      )\n      LIMIT 1\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupDetails = (context: ApiContext, groupId: string): Promise<GroupType> => {\n  const formatGroupId = parseId(groupId);\n  return getItemBy<GroupType>(context, COLLECTIONS.GROUPS, {_key: formatGroupId});\n};\n\nexport const createGroupEdge = (\n  context: ApiContext,\n  userDocId: string,\n  groupDocId: string\n): Promise<GroupEdgeType> => {\n  const action = 'createGroupEdge';\n  const {databaseName} = context;\n  const formatUseDocId = parseArangoId(userDocId);\n  const formatGroupDocId = parseArangoId(groupDocId);\n\n  const now = Date.now();\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasConnection');\n  const edgeId = createHash(`group-${formatUseDocId}-${formatGroupDocId}`);\n  const edge: any = {\n    _from: formatUseDocId,\n    _key: edgeId,\n    _to: formatGroupDocId,\n    added: now,\n    type: 'groups'\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, {session: {userId: formatUseDocId}}).then(() => null));\n};\n\nconst buildGroupMutation = ({description = '', name = 'Untitled', type}: GroupType): Partial<GroupType> => ({\n  description: description.substring(0, 640),\n  name,\n  type: parseChar(type, 16) || 'private'\n});\n\nexport const addGroup = (context: ApiContext, item: GroupType): Promise<GroupType> => {\n  const action = 'add';\n  const {session: {userId: sessionId}} = context;\n  const sessionDocId = `${COLLECTIONS.USERS}/${sessionId}`;\n  const {description = ''}: GroupType = item;\n  const id = createHash(`group-${sessionId}`);\n  const insert: GroupType = {\n    _key: id,\n    ...buildGroupMutation(item)\n  };\n\n  return addItem<GroupType>(context, COLLECTIONS.GROUPS, insert)\n    .then((group: GroupType) => {\n      // Update linked tags\n      const {_id: groupDocId}: GroupType = group;\n\n      // Validate sessionDocId and groupDocId\n      if (!sessionDocId || typeof sessionDocId !== 'string' || !sessionDocId.startsWith('users/')) {\n        logError({\n          action,\n          category: eventCategory,\n          label: ErrorTypes.INVALID_INPUT\n        }, new Error('Invalid or missing sessionDocId for edge creation'), context);\n        return null;\n      }\n      if (!groupDocId || typeof groupDocId !== 'string' || !groupDocId.startsWith('groups/')) {\n        logError({\n          action,\n          category: eventCategory,\n          label: ErrorTypes.INVALID_INPUT\n        }, new Error('Invalid or missing groupDocId for edge creation'), context);\n        return null;\n      }\n\n      const tagNames = extractTags(description);\n      return getTagListByName(context, tagNames)\n        .then((resolvedTags) => updateTagsInItem(context, {itemDocId: groupDocId, tags: resolvedTags}))\n        .then(() => createGroupEdge(context, sessionDocId, groupDocId)\n        .then(() => group));\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const updateGroup = (context: ApiContext, item: GroupType): Promise<GroupType> => {\n  const action = 'update';\n  const {\n    description = '',\n    id\n  }: GroupType = item;\n  const itemId = parseId(id);\n\n  return updateItem<GroupType>(context, COLLECTIONS.GROUPS, itemId, buildGroupMutation(item))\n    .then((group: GroupType) => {\n      const {_id: groupDocId} = group;\n\n      // Update linked tags\n      const tagNames = extractTags(description);\n      return getTagListByName(context, tagNames)\n        .then((resolvedTags) => updateTagsInItem(context, {itemDocId: groupDocId, tags: resolvedTags}))\n        .then(() => group);\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const deleteGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action = 'delete';\n  const formatItemId = parseId(itemId);\n\n  return deleteItem<GroupType>(context, COLLECTIONS.GROUPS, formatItemId)\n    .then((group) => group || ({_key: formatItemId} as GroupType))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupsByReaction = (context: ApiContext, reaction: string): Promise<GroupType[]> => {\n  const action = 'getGroupsByReaction';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatReaction = parseChar(reaction, 32);\n  const userDocId = `users/${sessionId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction\n      FILTER r.value == ${formatReaction}\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const isGrouped = (context: ApiContext, userId: string, groupId: string): Promise<GroupUser> => {\n  const action = 'isGrouped';\n  const {databaseName} = context;\n  const formatUserId = parseId(userId);\n  const formatGroupId = parseId(groupId);\n\n  // Complex edge traversal to check group membership - keep custom implementation\n  const aqlQry: AqlQuery = aql`FOR g IN ${groupsCollection}\n    FILTER g._key == ${formatGroupId}\n    FOR u IN INBOUND g._id ${hasConnectionCollection}\n    FILTER u._key == ${formatUserId}\n    LIMIT 1\n    RETURN u`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .then((results = []) => {\n      const isValid = !!results.length;\n\n      return {\n        groupId,\n        isValid,\n        userId\n      };\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, {session: {userId}}).then(() => null));\n};\n"],"names":["flatten","uniqBy","createHash","parseArangoId","parseChar","parseId","aql","literal","COLLECTIONS","EDGES","ErrorTypes","logError","useDb","addItem","deleteItem","getItemBy","updateItem","extractTags","getTagListByName","updateTagsInItem","eventCategory","groupsCollection","GROUPS","usersCollection","USERS","hasConnectionCollection","HAS_CONNECTION","isTaggedCollection","IS_TAGGED","getGroupListByApp","context","from","to","action","databaseName","aqlQry","undefined","query","then","cursor","all","catch","error","category","label","DATABASE_ERROR","getGroupListByUser","userId","getGroupListByTags","tagNames","Promise","map","tagName","formatTagName","limitClause","results","item","_key","getGroupById","itemId","session","sessionId","formatItemId","next","group","getGroupDetails","groupId","formatGroupId","createGroupEdge","userDocId","groupDocId","formatUseDocId","formatGroupDocId","now","Date","edgeCollection","collection","edgeId","edge","_from","_to","added","type","save","returnNew","buildGroupMutation","description","name","substring","addGroup","sessionDocId","id","insert","_id","startsWith","INVALID_INPUT","Error","resolvedTags","itemDocId","tags","updateGroup","deleteGroup","getGroupsByReaction","reaction","formatReaction","isGrouped","formatUserId","isValid","length"],"mappings":"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"}

package/lib/actions/higgsfield.d.ts

@@ -0,0 +1,20 @@
+import type { MarketingStudioImageInput, SeedanceReferenceVideoInput, SeedanceVideoInput, SoulImageInput } from '../adapters/higgsfieldAdapter.js';
+import type { ApiContext } from '../types/auth.types.js';
+export interface HiggsfieldRequestResult {
+    cancelUrl?: string;
+    requestId: string;
+    statusUrl: string;
+}
+export interface HiggsfieldStatusResult {
+    error?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    requestId: string;
+    status: string;
+}
+export declare const generateSoulImage: (context: ApiContext, input: SoulImageInput, webhookUrl?: string) => Promise<HiggsfieldRequestResult>;
+export declare const generateSeedanceVideo: (context: ApiContext, input: SeedanceVideoInput, webhookUrl?: string) => Promise<HiggsfieldRequestResult>;
+export declare const generateSeedanceReferenceVideo: (context: ApiContext, input: SeedanceReferenceVideoInput, webhookUrl?: string) => Promise<HiggsfieldRequestResult>;
+export declare const generateMarketingStudioImage: (context: ApiContext, input: MarketingStudioImageInput, webhookUrl?: string) => Promise<HiggsfieldRequestResult>;
+export declare const getHiggsfieldRequestStatus: (context: ApiContext, requestId: string) => Promise<HiggsfieldStatusResult>;
+export declare const cancelHiggsfieldRequest: (context: ApiContext, requestId: string) => Promise<boolean>;

package/lib/actions/higgsfield.js

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * All rights reserved. Use is subject to the accompanying commercial LICENSE.
+ */ import { get, post } from '@nlabs/rip-hunter';
+import { validateMarketingStudioImageInput, validateSeedanceReferenceVideoInput, validateSeedanceVideoInput, validateSoulImageInput } from '../adapters/higgsfieldAdapter.js';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+const eventCategory = 'higgsfield';
+const HIGGSFIELD_ORIGIN = 'https://api.higgsfield.ai';
+const SOUL_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/higgsfield-ai/soul/v2/standard`;
+const SEEDANCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/image-to-video`;
+const SEEDANCE_REFERENCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/reference-to-video`;
+const MARKETING_STUDIO_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/marketing-studio/image`;
+/** Never send API credentials to a provider-supplied third-party polling/cancel URL. */ const validateHiggsfieldUrl = (value, requestId, action)=>{
+    const url = new URL(value);
+    if (url.origin !== HIGGSFIELD_ORIGIN || url.username || url.password || url.pathname !== `/requests/${requestId}/${action}` || url.search || url.hash) {
+        throw new Error(`Higgsfield returned an invalid ${action} URL. Reconcile the request manually.`);
+    }
+    return url.href;
+};
+const authHeaders = ()=>{
+    const keyId = Config.get('higgsfield.keyId');
+    const keySecret = Config.get('higgsfield.keySecret');
+    if (!keyId || !keySecret) {
+        throw new Error('Higgsfield is not configured. Set HIGGSFIELD_KEY_ID and HIGGSFIELD_KEY_SECRET.');
+    }
+    return new Headers({
+        Authorization: `Key ${keyId}:${keySecret}`,
+        'Content-Type': 'application/json'
+    });
+};
+const withWebhook = (endpoint, webhookUrl)=>webhookUrl ? `${endpoint}?hf_webhook=${encodeURIComponent(webhookUrl)}` : endpoint;
+const submit = async (context, action, endpoint, body)=>{
+    try {
+        const data = await post(endpoint, body, {
+            cache: false,
+            headers: authHeaders()
+        });
+        if (!data.request_id || !data.status_url) {
+            throw new Error('Higgsfield submission outcome is unknown: missing request_id or status_url.');
+        }
+        return {
+            cancelUrl: data.cancel_url ? validateHiggsfieldUrl(data.cancel_url, data.request_id, 'cancel') : undefined,
+            requestId: data.request_id,
+            statusUrl: validateHiggsfieldUrl(data.status_url, data.request_id, 'status')
+        };
+    } catch (error) {
+        return logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.EXTERNAL_API_ERROR
+        }, error, context);
+    }
+};
+export const generateSoulImage = (context, input, webhookUrl)=>{
+    const validated = validateSoulImageInput(input);
+    return submit(context, 'generateSoulImage', withWebhook(SOUL_IMAGE_ENDPOINT, webhookUrl), {
+        aspect_ratio: validated.aspectRatio,
+        batch_size: validated.batchSize,
+        enhance_prompt: validated.enhancePrompt,
+        prompt: validated.prompt,
+        resolution: validated.resolution,
+        seed: validated.seed,
+        style_id: validated.styleId
+    });
+};
+export const generateSeedanceVideo = (context, input, webhookUrl)=>{
+    const validated = validateSeedanceVideoInput(input);
+    return submit(context, 'generateSeedanceVideo', withWebhook(SEEDANCE_VIDEO_ENDPOINT, webhookUrl), {
+        duration: validated.duration,
+        end_image_url: validated.endImageUrl,
+        generate_audio: validated.generateAudio,
+        image_url: validated.imageUrl,
+        output_format: validated.outputFormat,
+        prompt: validated.prompt,
+        resolution: validated.resolution
+    });
+};
+export const generateSeedanceReferenceVideo = (context, input, webhookUrl)=>{
+    const validated = validateSeedanceReferenceVideoInput(input);
+    return submit(context, 'generateSeedanceReferenceVideo', withWebhook(SEEDANCE_REFERENCE_VIDEO_ENDPOINT, webhookUrl), {
+        aspect_ratio: validated.aspectRatio,
+        audio_urls: validated.audioUrls,
+        duration: validated.duration,
+        generate_audio: validated.generateAudio,
+        image_urls: validated.imageUrls,
+        output_format: validated.outputFormat,
+        prompt: validated.prompt,
+        resolution: validated.resolution,
+        video_urls: validated.videoUrls
+    });
+};
+export const generateMarketingStudioImage = (context, input, webhookUrl)=>{
+    const validated = validateMarketingStudioImageInput(input);
+    return submit(context, 'generateMarketingStudioImage', withWebhook(MARKETING_STUDIO_IMAGE_ENDPOINT, webhookUrl), {
+        aspect_ratio: validated.aspectRatio,
+        enhance_prompt: validated.enhancePrompt,
+        image_urls: validated.imageUrls,
+        preset_id: validated.presetId,
+        prompt: validated.prompt,
+        quality: validated.quality,
+        resolution: validated.resolution
+    });
+};
+export const getHiggsfieldRequestStatus = async (context, requestId)=>{
+    try {
+        const statusUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/status`, requestId, 'status');
+        const data = await get(statusUrl, {}, {
+            cache: false,
+            headers: authHeaders()
+        });
+        if (data.request_id !== requestId) {
+            throw new Error('Higgsfield status response returned an unexpected request identifier.');
+        }
+        return {
+            error: data.error,
+            mediaUrl: data.video?.url || data.images?.[0]?.url,
+            mediaUrls: data.images?.map((image)=>image.url).filter((url)=>Boolean(url)),
+            requestId,
+            status: data.status || 'unknown'
+        };
+    } catch (error) {
+        return logError({
+            action: 'getHiggsfieldRequestStatus',
+            category: eventCategory,
+            value: ErrorTypes.EXTERNAL_API_ERROR
+        }, error, context);
+    }
+};
+export const cancelHiggsfieldRequest = async (context, requestId)=>{
+    try {
+        const cancelUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/cancel`, requestId, 'cancel');
+        await post(cancelUrl, {}, {
+            cache: false,
+            headers: authHeaders()
+        });
+        return (await getHiggsfieldRequestStatus(context, requestId)).status === 'canceled';
+    } catch (error) {
+        return logError({
+            action: 'cancelHiggsfieldRequest',
+            category: eventCategory,
+            value: ErrorTypes.EXTERNAL_API_ERROR
+        }, error, context);
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/higgsfield.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {get, post} from '@nlabs/rip-hunter';\n\nimport {\n  validateMarketingStudioImageInput,\n  validateSeedanceReferenceVideoInput,\n  validateSeedanceVideoInput,\n  validateSoulImageInput\n} from '../adapters/higgsfieldAdapter.js';\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\n\nimport type {\n  MarketingStudioImageInput,\n  SeedanceReferenceVideoInput,\n  SeedanceVideoInput,\n  SoulImageInput\n} from '../adapters/higgsfieldAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\n\nconst eventCategory = 'higgsfield';\nconst HIGGSFIELD_ORIGIN = 'https://api.higgsfield.ai';\nconst SOUL_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/higgsfield-ai/soul/v2/standard`;\nconst SEEDANCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/image-to-video`;\nconst SEEDANCE_REFERENCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/reference-to-video`;\nconst MARKETING_STUDIO_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/marketing-studio/image`;\n\nexport interface HiggsfieldRequestResult {\n  cancelUrl?: string;\n  requestId: string;\n  statusUrl: string;\n}\n\nexport interface HiggsfieldStatusResult {\n  error?: string;\n  mediaUrl?: string;\n  mediaUrls?: string[];\n  requestId: string;\n  status: string;\n}\n\ninterface HiggsfieldResponseBody {\n  cancel_url?: string;\n  detail?: unknown;\n  error?: string;\n  images?: {url?: string}[];\n  request_id?: string;\n  status?: string;\n  status_url?: string;\n  video?: {url?: string};\n}\n\n/** Never send API credentials to a provider-supplied third-party polling/cancel URL. */\nconst validateHiggsfieldUrl = (value: string, requestId: string, action: 'status' | 'cancel'): string => {\n  const url = new URL(value);\n\n  if(url.origin !== HIGGSFIELD_ORIGIN || url.username || url.password ||\n    url.pathname !== `/requests/${requestId}/${action}` || url.search || url.hash) {\n    throw new Error(`Higgsfield returned an invalid ${action} URL. Reconcile the request manually.`);\n  }\n\n  return url.href;\n};\n\nconst authHeaders = (): Headers => {\n  const keyId = Config.get<string>('higgsfield.keyId');\n  const keySecret = Config.get<string>('higgsfield.keySecret');\n\n  if(!keyId || !keySecret) {\n    throw new Error('Higgsfield is not configured. Set HIGGSFIELD_KEY_ID and HIGGSFIELD_KEY_SECRET.');\n  }\n\n  return new Headers({\n    Authorization: `Key ${keyId}:${keySecret}`,\n    'Content-Type': 'application/json'\n  });\n};\n\nconst withWebhook = (endpoint: string, webhookUrl?: string): string =>\n  (webhookUrl ? `${endpoint}?hf_webhook=${encodeURIComponent(webhookUrl)}` : endpoint);\n\nconst submit = async (\n  context: ApiContext, action: string, endpoint: string, body: Record<string, unknown>\n): Promise<HiggsfieldRequestResult> => {\n  try {\n    const data = await post(endpoint, body, {cache: false, headers: authHeaders()}) as HiggsfieldResponseBody;\n\n    if(!data.request_id || !data.status_url) {\n      throw new Error('Higgsfield submission outcome is unknown: missing request_id or status_url.');\n    }\n\n    return {\n      cancelUrl: data.cancel_url ? validateHiggsfieldUrl(data.cancel_url, data.request_id, 'cancel') : undefined,\n      requestId: data.request_id,\n      statusUrl: validateHiggsfieldUrl(data.status_url, data.request_id, 'status')\n    };\n  } catch(error) {\n    return logError(\n      {action, category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\nexport const generateSoulImage = (\n  context: ApiContext, input: SoulImageInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSoulImageInput(input);\n\n  return submit(context, 'generateSoulImage', withWebhook(SOUL_IMAGE_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    batch_size: validated.batchSize,\n    enhance_prompt: validated.enhancePrompt,\n    prompt: validated.prompt,\n    resolution: validated.resolution,\n    seed: validated.seed,\n    style_id: validated.styleId\n  });\n};\n\nexport const generateSeedanceVideo = (\n  context: ApiContext, input: SeedanceVideoInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSeedanceVideoInput(input);\n\n  return submit(context, 'generateSeedanceVideo', withWebhook(SEEDANCE_VIDEO_ENDPOINT, webhookUrl), {\n    duration: validated.duration,\n    end_image_url: validated.endImageUrl,\n    generate_audio: validated.generateAudio,\n    image_url: validated.imageUrl,\n    output_format: validated.outputFormat,\n    prompt: validated.prompt,\n    resolution: validated.resolution\n  });\n};\n\nexport const generateSeedanceReferenceVideo = (\n  context: ApiContext, input: SeedanceReferenceVideoInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSeedanceReferenceVideoInput(input);\n\n  return submit(context, 'generateSeedanceReferenceVideo', withWebhook(SEEDANCE_REFERENCE_VIDEO_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    audio_urls: validated.audioUrls,\n    duration: validated.duration,\n    generate_audio: validated.generateAudio,\n    image_urls: validated.imageUrls,\n    output_format: validated.outputFormat,\n    prompt: validated.prompt,\n    resolution: validated.resolution,\n    video_urls: validated.videoUrls\n  });\n};\n\nexport const generateMarketingStudioImage = (\n  context: ApiContext, input: MarketingStudioImageInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateMarketingStudioImageInput(input);\n\n  return submit(context, 'generateMarketingStudioImage', withWebhook(MARKETING_STUDIO_IMAGE_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    enhance_prompt: validated.enhancePrompt,\n    image_urls: validated.imageUrls,\n    preset_id: validated.presetId,\n    prompt: validated.prompt,\n    quality: validated.quality,\n    resolution: validated.resolution\n  });\n};\n\nexport const getHiggsfieldRequestStatus = async (\n  context: ApiContext, requestId: string\n): Promise<HiggsfieldStatusResult> => {\n  try {\n    const statusUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/status`, requestId, 'status');\n    const data = await get(statusUrl, {}, {cache: false, headers: authHeaders()}) as HiggsfieldResponseBody;\n\n    if(data.request_id !== requestId) {\n      throw new Error('Higgsfield status response returned an unexpected request identifier.');\n    }\n\n    return {\n      error: data.error,\n      mediaUrl: data.video?.url || data.images?.[0]?.url,\n      mediaUrls: data.images?.map((image) => image.url).filter((url): url is string => Boolean(url)),\n      requestId,\n      status: data.status || 'unknown'\n    };\n  } catch(error) {\n    return logError(\n      {action: 'getHiggsfieldRequestStatus', category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\nexport const cancelHiggsfieldRequest = async (context: ApiContext, requestId: string): Promise<boolean> => {\n  try {\n    const cancelUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/cancel`, requestId, 'cancel');\n    await post(cancelUrl, {}, {cache: false, headers: authHeaders()});\n\n    return (await getHiggsfieldRequestStatus(context, requestId)).status === 'canceled';\n  } catch(error) {\n    return logError(\n      {action: 'cancelHiggsfieldRequest', category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n"],"names":["get","post","validateMarketingStudioImageInput","validateSeedanceReferenceVideoInput","validateSeedanceVideoInput","validateSoulImageInput","Config","ErrorTypes","logError","eventCategory","HIGGSFIELD_ORIGIN","SOUL_IMAGE_ENDPOINT","SEEDANCE_VIDEO_ENDPOINT","SEEDANCE_REFERENCE_VIDEO_ENDPOINT","MARKETING_STUDIO_IMAGE_ENDPOINT","validateHiggsfieldUrl","value","requestId","action","url","URL","origin","username","password","pathname","search","hash","Error","href","authHeaders","keyId","keySecret","Headers","Authorization","withWebhook","endpoint","webhookUrl","encodeURIComponent","submit","context","body","data","cache","headers","request_id","status_url","cancelUrl","cancel_url","undefined","statusUrl","error","category","EXTERNAL_API_ERROR","generateSoulImage","input","validated","aspect_ratio","aspectRatio","batch_size","batchSize","enhance_prompt","enhancePrompt","prompt","resolution","seed","style_id","styleId","generateSeedanceVideo","duration","end_image_url","endImageUrl","generate_audio","generateAudio","image_url","imageUrl","output_format","outputFormat","generateSeedanceReferenceVideo","audio_urls","audioUrls","image_urls","imageUrls","video_urls","videoUrls","generateMarketingStudioImage","preset_id","presetId","quality","getHiggsfieldRequestStatus","mediaUrl","video","images","mediaUrls","map","image","filter","Boolean","status","cancelHiggsfieldRequest"],"mappings":"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"}

package/lib/actions/imageGeneration.d.ts

@@ -0,0 +1,37 @@
+import type { GeminiImageInput } from '../adapters/geminiGenerationAdapter.js';
+import type { MarketingStudioImageInput, SoulImageInput } from '../adapters/higgsfieldAdapter.js';
+import type { OpenAIImageInput } from '../adapters/imageGenerationAdapter.js';
+import type { ApiContext } from '../types/auth.types.js';
+/** Only an explicit provider rejection proves it is safe to release a reservation. */
+export declare class ImageGenerationRejectedError extends Error {
+}
+export type GenerateImageInput = (GeminiImageInput & {
+    provider: 'gemini';
+}) | (OpenAIImageInput & {
+    provider: 'openai';
+}) | (SoulImageInput & {
+    provider: 'higgsfield';
+    imageUrls?: undefined;
+}) | (MarketingStudioImageInput & {
+    provider: 'higgsfield';
+});
+export interface ImageGenerationResult {
+    cancelUrl?: string;
+    imageBase64?: string;
+    mimeType?: 'image/jpeg' | 'image/png';
+    provider: 'gemini' | 'higgsfield' | 'openai';
+    requestId: string;
+    status: 'queued' | 'completed';
+    statusUrl?: string;
+}
+export declare const generateOpenAIImage: (_context: ApiContext, input: OpenAIImageInput, config?: {
+    key?: string;
+    model?: string;
+}) => Promise<ImageGenerationResult>;
+/** Provider selection is data; credentials and paid-job orchestration stay server-side. */
+export declare const generateImage: (context: ApiContext, input: GenerateImageInput) => Promise<ImageGenerationResult>;
+/** Reuses the Gemini content protocol while preserving the generic image result shape. */
+export declare const generateGeminiImage: (_context: ApiContext, input: GeminiImageInput, config?: {
+    key?: string;
+    model?: string;
+}) => Promise<ImageGenerationResult>;