@nlabs/reaktor 1.10.0 → 1.12.0

package/lib/actions/imageGeneration.js

@@ -1,10 +1,11 @@
 import { post } from '@nlabs/rip-hunter';
 import { randomUUID } from 'node:crypto';
 import { validateGeminiImageInput } from '../adapters/geminiGenerationAdapter.js';
+import { getHiggsfieldModel } from '../adapters/higgsfieldModelCatalog.js';
 import { validateOpenAIImageInput } from '../adapters/imageGenerationAdapter.js';
 import { Config } from '../config.js';
 import { ContentGenerationRejectedError, generateContent } from './contentGeneration.js';
-import { generateMarketingStudioImage, generateSoulImage } from './higgsfield.js';
+import { generateHiggsfieldModel, generateMarketingStudioImage, generateSoulImage } from './higgsfield.js';
 /** Only an explicit provider rejection proves it is safe to release a reservation. */ export class ImageGenerationRejectedError extends Error {
 }
 export const generateOpenAIImage = async (_context, input, config)=>{
@@ -58,6 +59,16 @@ export const generateOpenAIImage = async (_context, input, config)=>{
     };
 };
 /** Provider selection is data; credentials and paid-job orchestration stay server-side. */ export const generateImage = async (context, input)=>{
+    if (input.provider === 'higgsfield' && 'modelInput' in input && typeof input.model === 'string') {
+        if (getHiggsfieldModel(input.model).kind !== 'image') {
+            throw new Error('Choose an image model.');
+        }
+        return {
+            ...await generateHiggsfieldModel(context, input.model, input.modelInput),
+            provider: 'higgsfield',
+            status: 'queued'
+        };
+    }
     const { provider, ...options } = input;
     if (provider === 'gemini') {
         return generateGeminiImage(context, options);
@@ -118,4 +129,4 @@ export const generateOpenAIImage = async (_context, input, config)=>{
     }
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/imageGeneration.ts"],"sourcesContent":["import {post} from '@nlabs/rip-hunter';\nimport {randomUUID} from 'node:crypto';\n\nimport {validateGeminiImageInput} from '../adapters/geminiGenerationAdapter.js';\nimport {validateOpenAIImageInput} from '../adapters/imageGenerationAdapter.js';\nimport {Config} from '../config.js';\nimport {ContentGenerationRejectedError, generateContent} from './contentGeneration.js';\nimport {generateMarketingStudioImage, generateSoulImage} from './higgsfield.js';\n\nimport type {GeminiImageInput} from '../adapters/geminiGenerationAdapter.js';\nimport type {MarketingStudioImageInput, SoulImageInput} from '../adapters/higgsfieldAdapter.js';\nimport type {OpenAIImageInput} from '../adapters/imageGenerationAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\n\n/** Only an explicit provider rejection proves it is safe to release a reservation. */\nexport class ImageGenerationRejectedError extends Error {}\n\nexport type GenerateImageInput =\n  | (GeminiImageInput & {provider: 'gemini'})\n  | (OpenAIImageInput & {provider: 'openai'})\n  | (SoulImageInput & {provider: 'higgsfield'; imageUrls?: undefined})\n  | (MarketingStudioImageInput & {provider: 'higgsfield'});\n\nexport interface ImageGenerationResult {\n  cancelUrl?: string;\n  imageBase64?: string;\n  mimeType?: 'image/jpeg' | 'image/png';\n  provider: 'gemini' | 'higgsfield' | 'openai';\n  requestId: string;\n  status: 'queued' | 'completed';\n  statusUrl?: string;\n}\n\nexport const generateOpenAIImage = async (\n  _context: ApiContext, input: OpenAIImageInput, config?: {key?: string; model?: string}\n): Promise<ImageGenerationResult> => {\n  const validated = validateOpenAIImageInput(input);\n  const key = config?.key || Config.get<string>('openai.apiKey');\n  if(!key) {\n    throw new Error('OpenAI image generation is not configured.');\n  }\n  const response = await post('https://api.openai.com/v1/images/generations', {\n    model: validated.model || config?.model || Config.get<string>('openai.imageModel') || 'gpt-image-1.5',\n    n: 1,\n    output_format: 'png',\n    prompt: validated.prompt,\n    quality: validated.quality,\n    size: validated.size\n  }, {cache: false, headers: new Headers({Authorization: `Bearer ${key}`}), timeout: 180_000}) as {\n    data?: {b64_json?: string}[];\n    error?: {type?: string};\n  };\n  if(response.error && ['invalid_request_error', 'authentication_error', 'permission_error'].includes(response.error.type || '')) {\n    throw new ImageGenerationRejectedError('OpenAI rejected the image request. Check model access and prompt.');\n  }\n  const encoded = response.data?.[0]?.b64_json;\n  if(response.error || !encoded || encoded.length > 40 * 1024 * 1024 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {\n    throw new Error('OpenAI image output could not be verified.');\n  }\n  if(!Buffer.from(encoded, 'base64').subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {\n    throw new Error('OpenAI did not return PNG image bytes.');\n  }\n  return {imageBase64: encoded, provider: 'openai', requestId: `openai-${randomUUID()}`, status: 'completed'};\n};\n\n/** Provider selection is data; credentials and paid-job orchestration stay server-side. */\nexport const generateImage = async (context: ApiContext, input: GenerateImageInput): Promise<ImageGenerationResult> => {\n  const {provider, ...options} = input;\n  if(provider === 'gemini') {\n    return generateGeminiImage(context, options as GeminiImageInput);\n  }\n  if(provider === 'openai') {\n    return generateOpenAIImage(context, options as OpenAIImageInput);\n  }\n  if(provider !== 'higgsfield') {\n    throw new Error('Unsupported image provider.');\n  }\n  const request = 'imageUrls' in options && options.imageUrls?.length\n    ? await generateMarketingStudioImage(context, options as MarketingStudioImageInput)\n    : await generateSoulImage(context, options as SoulImageInput);\n  return {...request, provider, status: 'queued'};\n};\n\n/** Reuses the Gemini content protocol while preserving the generic image result shape. */\nexport const generateGeminiImage = async (\n  _context: ApiContext, input: GeminiImageInput, config?: {key?: string; model?: string}\n): Promise<ImageGenerationResult> => {\n  const validated = validateGeminiImageInput(input);\n  try {\n    const result = await generateContent({...validated, modality: 'image', provider: 'gemini'}, {\n      geminiImageModel: config?.model || Config.get<string>('contentGeneration.geminiImageModel'),\n      geminiKey: config?.key || Config.get<string>('contentGeneration.geminiKey')\n    });\n    const {image} = result;\n    if(!image || !(image.mime === 'image/png'\n      ? image.bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))\n      : image.bytes.subarray(0, 3).equals(Buffer.from([255, 216, 255])))) {\n      throw new Error('Gemini image output could not be verified.');\n    }\n    return {imageBase64: image.bytes.toString('base64'), mimeType: image.mime, provider: 'gemini', requestId: `gemini-${randomUUID()}`, status: 'completed'};\n  } catch(error) {\n    if(error instanceof ContentGenerationRejectedError) {\n      throw new ImageGenerationRejectedError(error.message);\n    }\n    throw error;\n  }\n};\n"],"names":["post","randomUUID","validateGeminiImageInput","validateOpenAIImageInput","Config","ContentGenerationRejectedError","generateContent","generateMarketingStudioImage","generateSoulImage","ImageGenerationRejectedError","Error","generateOpenAIImage","_context","input","config","validated","key","get","response","model","n","output_format","prompt","quality","size","cache","headers","Headers","Authorization","timeout","error","includes","type","encoded","data","b64_json","length","test","Buffer","from","subarray","equals","imageBase64","provider","requestId","status","generateImage","context","options","generateGeminiImage","request","imageUrls","result","modality","geminiImageModel","geminiKey","image","mime","bytes","toString","mimeType","message"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/imageGeneration.ts"],"sourcesContent":["import {post} from '@nlabs/rip-hunter';\nimport {randomUUID} from 'node:crypto';\n\nimport {validateGeminiImageInput} from '../adapters/geminiGenerationAdapter.js';\nimport {getHiggsfieldModel} from '../adapters/higgsfieldModelCatalog.js';\nimport {validateOpenAIImageInput} from '../adapters/imageGenerationAdapter.js';\nimport {Config} from '../config.js';\nimport {ContentGenerationRejectedError, generateContent} from './contentGeneration.js';\nimport {generateHiggsfieldModel, generateMarketingStudioImage, generateSoulImage} from './higgsfield.js';\n\nimport type {GeminiImageInput} from '../adapters/geminiGenerationAdapter.js';\nimport type {MarketingStudioImageInput, SoulImageInput} from '../adapters/higgsfieldAdapter.js';\nimport type {OpenAIImageInput} from '../adapters/imageGenerationAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\n\n/** Only an explicit provider rejection proves it is safe to release a reservation. */\nexport class ImageGenerationRejectedError extends Error {}\n\nexport type GenerateImageInput =\n  | {model: string; modelInput: Record<string, unknown>; provider: 'higgsfield'}\n  | (GeminiImageInput & {provider: 'gemini'})\n  | (OpenAIImageInput & {provider: 'openai'})\n  | (SoulImageInput & {provider: 'higgsfield'; imageUrls?: undefined})\n  | (MarketingStudioImageInput & {provider: 'higgsfield'});\n\nexport interface ImageGenerationResult {\n  cancelUrl?: string;\n  imageBase64?: string;\n  mimeType?: 'image/jpeg' | 'image/png';\n  provider: 'gemini' | 'higgsfield' | 'openai';\n  requestId: string;\n  status: 'queued' | 'completed';\n  statusUrl?: string;\n}\n\nexport const generateOpenAIImage = async (\n  _context: ApiContext, input: OpenAIImageInput, config?: {key?: string; model?: string}\n): Promise<ImageGenerationResult> => {\n  const validated = validateOpenAIImageInput(input);\n  const key = config?.key || Config.get<string>('openai.apiKey');\n  if(!key) {\n    throw new Error('OpenAI image generation is not configured.');\n  }\n  const response = await post('https://api.openai.com/v1/images/generations', {\n    model: validated.model || config?.model || Config.get<string>('openai.imageModel') || 'gpt-image-1.5',\n    n: 1,\n    output_format: 'png',\n    prompt: validated.prompt,\n    quality: validated.quality,\n    size: validated.size\n  }, {cache: false, headers: new Headers({Authorization: `Bearer ${key}`}), timeout: 180_000}) as {\n    data?: {b64_json?: string}[];\n    error?: {type?: string};\n  };\n  if(response.error && ['invalid_request_error', 'authentication_error', 'permission_error'].includes(response.error.type || '')) {\n    throw new ImageGenerationRejectedError('OpenAI rejected the image request. Check model access and prompt.');\n  }\n  const encoded = response.data?.[0]?.b64_json;\n  if(response.error || !encoded || encoded.length > 40 * 1024 * 1024 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {\n    throw new Error('OpenAI image output could not be verified.');\n  }\n  if(!Buffer.from(encoded, 'base64').subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {\n    throw new Error('OpenAI did not return PNG image bytes.');\n  }\n  return {imageBase64: encoded, provider: 'openai', requestId: `openai-${randomUUID()}`, status: 'completed'};\n};\n\n/** Provider selection is data; credentials and paid-job orchestration stay server-side. */\nexport const generateImage = async (context: ApiContext, input: GenerateImageInput): Promise<ImageGenerationResult> => {\n  if(input.provider === 'higgsfield' && 'modelInput' in input && typeof input.model === 'string') {\n    if(getHiggsfieldModel(input.model).kind !== 'image') {\n      throw new Error('Choose an image model.');\n    }\n    return {...await generateHiggsfieldModel(context, input.model, input.modelInput as Record<string, unknown>), provider: 'higgsfield', status: 'queued'};\n  }\n  const {provider, ...options} = input;\n  if(provider === 'gemini') {\n    return generateGeminiImage(context, options as GeminiImageInput);\n  }\n  if(provider === 'openai') {\n    return generateOpenAIImage(context, options as OpenAIImageInput);\n  }\n  if(provider !== 'higgsfield') {\n    throw new Error('Unsupported image provider.');\n  }\n  const request = 'imageUrls' in options && options.imageUrls?.length\n    ? await generateMarketingStudioImage(context, options as MarketingStudioImageInput)\n    : await generateSoulImage(context, options as SoulImageInput);\n  return {...request, provider, status: 'queued'};\n};\n\n/** Reuses the Gemini content protocol while preserving the generic image result shape. */\nexport const generateGeminiImage = async (\n  _context: ApiContext, input: GeminiImageInput, config?: {key?: string; model?: string}\n): Promise<ImageGenerationResult> => {\n  const validated = validateGeminiImageInput(input);\n  try {\n    const result = await generateContent({...validated, modality: 'image', provider: 'gemini'}, {\n      geminiImageModel: config?.model || Config.get<string>('contentGeneration.geminiImageModel'),\n      geminiKey: config?.key || Config.get<string>('contentGeneration.geminiKey')\n    });\n    const {image} = result;\n    if(!image || !(image.mime === 'image/png'\n      ? image.bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))\n      : image.bytes.subarray(0, 3).equals(Buffer.from([255, 216, 255])))) {\n      throw new Error('Gemini image output could not be verified.');\n    }\n    return {imageBase64: image.bytes.toString('base64'), mimeType: image.mime, provider: 'gemini', requestId: `gemini-${randomUUID()}`, status: 'completed'};\n  } catch(error) {\n    if(error instanceof ContentGenerationRejectedError) {\n      throw new ImageGenerationRejectedError(error.message);\n    }\n    throw error;\n  }\n};\n"],"names":["post","randomUUID","validateGeminiImageInput","getHiggsfieldModel","validateOpenAIImageInput","Config","ContentGenerationRejectedError","generateContent","generateHiggsfieldModel","generateMarketingStudioImage","generateSoulImage","ImageGenerationRejectedError","Error","generateOpenAIImage","_context","input","config","validated","key","get","response","model","n","output_format","prompt","quality","size","cache","headers","Headers","Authorization","timeout","error","includes","type","encoded","data","b64_json","length","test","Buffer","from","subarray","equals","imageBase64","provider","requestId","status","generateImage","context","kind","modelInput","options","generateGeminiImage","request","imageUrls","result","modality","geminiImageModel","geminiKey","image","mime","bytes","toString","mimeType","message"],"mappings":"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"}

package/lib/actions/index.d.ts

@@ -5,6 +5,8 @@
 export * from './apps.js';
 export * from './analytics.js';
 export * from './connections.js';
+export * from './databaseProvisioningLease.js';
+export * from './databaseAccounts.js';
 export * from './conversations.js';
 export * from './crm.js';
 export * from './dynamodb.js';
@@ -35,3 +37,4 @@ export * from './imageGeneration.js';
 export * from './contentGeneration.js';
 export * from './videoGeneration.js';
 export * from './geminiVideo.js';
+export * from './openaiResponseSession.js';

package/lib/actions/index.js

@@ -4,6 +4,8 @@
  */ export * from './apps.js';
 export * from './analytics.js';
 export * from './connections.js';
+export * from './databaseProvisioningLease.js';
+export * from './databaseAccounts.js';
 export * from './conversations.js';
 export * from './crm.js';
 export * from './dynamodb.js';
@@ -34,5 +36,6 @@ export * from './imageGeneration.js';
 export * from './contentGeneration.js';
 export * from './videoGeneration.js';
 export * from './geminiVideo.js';
+export * from './openaiResponseSession.js';
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/openaiResponseSession.d.ts

@@ -0,0 +1,60 @@
+import WebSocket from 'ws';
+import { z } from 'zod';
+declare const reasoningEffort: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    max: "max";
+    medium: "medium";
+    minimal: "minimal";
+    none: "none";
+    xhigh: "xhigh";
+}>;
+export type OpenAIResponseReasoningEffort = z.infer<typeof reasoningEffort>;
+type Item = Record<string, unknown>;
+export type OpenAIResponseEvent = {
+    type: string;
+    [key: string]: unknown;
+};
+export type OpenAIResponseSessionOptions = {
+    input: Item[];
+    instructions?: string;
+    max_output_tokens: number;
+    model: string;
+    reasoning?: {
+        effort: OpenAIResponseReasoningEffort;
+    };
+    text?: {
+        format: Item;
+    };
+    tools?: Item[];
+};
+export type OpenAIResponseOutput = {
+    id: string;
+    incomplete_details?: {
+        reason?: string;
+    };
+    output?: Array<{
+        content?: Array<{
+            text?: string;
+            type: string;
+        }>;
+        status?: string;
+        type: string;
+    }>;
+    status: string;
+};
+export declare const readOpenAIResponseText: (response: OpenAIResponseOutput) => string;
+export declare const createOpenAIResponseSession: (options: OpenAIResponseSessionOptions, onEvent: (event: OpenAIResponseEvent) => void, config: {
+    apiKey: string;
+    connect?: () => WebSocket;
+    maxToolCalls: number;
+    signal?: AbortSignal;
+    timeoutMs: number;
+}) => {
+    close: () => void;
+    continue: (text: string) => void;
+    reasoning: (effort: OpenAIResponseReasoningEffort) => void;
+    steer: (text: string) => void;
+    toolResult: (callId: string, output: string) => void;
+};
+export {};

package/lib/actions/openaiResponseSession.js

@@ -0,0 +1,248 @@
+import WebSocket from 'ws';
+import { z } from 'zod';
+const reasoningEffort = z.enum([
+    'none',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max'
+]);
+export const readOpenAIResponseText = (response)=>{
+    if (response.status !== 'completed' || response.output?.some((item)=>item.status === 'incomplete')) {
+        throw new Error(`OpenAI response did not complete: ${response.incomplete_details?.reason || response.status}`);
+    }
+    if (response.output?.some((item)=>item.content?.some((part)=>part.type === 'refusal'))) {
+        throw new Error('OpenAI declined the request.');
+    }
+    const text = (response.output || []).flatMap((item)=>item.type === 'message' ? item.content || [] : []).filter((part)=>part.type === 'output_text').map((part)=>part.text || '').join('');
+    if (!text.trim()) {
+        throw new Error('OpenAI returned empty output.');
+    }
+    return text;
+};
+// One owner and one conversation per socket. Never replay requests after a disconnect:
+// tools may already have run, and accepted steering is connection-local.
+export const createOpenAIResponseSession = (options, onEvent, config)=>{
+    if (!config.apiKey.trim()) throw new Error('OpenAI API key is not configured.');
+    if (!options.model.trim() || !Number.isInteger(options.max_output_tokens) || options.max_output_tokens < 1) {
+        throw new Error('A model and positive output token budget are required.');
+    }
+    if (!Number.isInteger(config.timeoutMs) || config.timeoutMs < 1 || config.timeoutMs > 2_147_483_647 || !Number.isInteger(config.maxToolCalls) || config.maxToolCalls < 0) {
+        throw new Error('Invalid session timeout or tool-call limit.');
+    }
+    if (config.signal?.aborted) throw new Error('OpenAI session was aborted.');
+    if (options.reasoning) reasoningEffort.parse(options.reasoning.effort);
+    const settings = {
+        ...options,
+        input: undefined,
+        store: false,
+        truncation: 'disabled'
+    };
+    const connect = config.connect || (()=>new WebSocket('wss://api.openai.com/v1/responses', {
+            handshakeTimeout: Math.min(10000, config.timeoutMs),
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`
+            },
+            maxPayload: 16 * 1024 * 1024
+        }));
+    const socket = connect();
+    const seenCalls = new Set();
+    const calls = new Map();
+    let active = true;
+    let closed = false;
+    let currentId;
+    let pendingSteer;
+    let nextEffort;
+    let timer;
+    const close = ()=>{
+        if (closed) return;
+        closed = true;
+        clearTimeout(timer);
+        config.signal?.removeEventListener('abort', close);
+        calls.clear();
+        seenCalls.clear();
+        socket.close();
+    };
+    const fail = (message)=>{
+        if (closed) return;
+        close();
+        onEvent({
+            message,
+            type: 'session.error'
+        });
+    };
+    const armTimeout = ()=>{
+        clearTimeout(timer);
+        timer = setTimeout(()=>fail('OpenAI session timed out. Start a new session; requests were not replayed.'), config.timeoutMs);
+        timer.unref?.();
+    };
+    const send = (event)=>{
+        if (closed || socket.readyState !== WebSocket.OPEN) throw new Error('OpenAI connection is not open.');
+        socket.send(JSON.stringify(event));
+    };
+    const create = (input)=>{
+        active = true;
+        armTimeout();
+        send({
+            ...settings,
+            input,
+            ...currentId ? {
+                previous_response_id: currentId
+            } : {},
+            type: 'response.create'
+        });
+    };
+    const flushTools = ()=>{
+        if (active || !currentId) return;
+        // Synchronous calls must all be satisfied before starting another response.
+        if ([
+            ...calls.values()
+        ].some(({ item, output })=>!item.async && output === undefined)) return;
+        const ready = [
+            ...calls.entries()
+        ].filter(([, call])=>call.output !== undefined);
+        if (!ready.length) return;
+        create(ready.map(([callId, { item, output }])=>({
+                call_id: callId,
+                output,
+                type: item.type === 'custom_tool_call' ? 'custom_tool_call_output' : 'function_call_output'
+            })));
+        for (const [id] of ready)calls.delete(id);
+    };
+    const registerCall = (item)=>{
+        if (![
+            'function_call',
+            'custom_tool_call'
+        ].includes(String(item.type))) return;
+        const id = String(item.call_id || '');
+        if (!id) throw new Error('OpenAI tool call is missing its call_id.');
+        if (seenCalls.has(id)) return;
+        if (seenCalls.size >= config.maxToolCalls) throw new Error('Session tool-call limit exceeded.');
+        if (item.status === 'incomplete') throw new Error('OpenAI returned an incomplete tool call.');
+        if (!options.tools?.some((tool)=>tool.name === item.name && tool.type === (item.type === 'function_call' ? 'function' : 'custom'))) throw new Error('OpenAI requested an unregistered tool.');
+        seenCalls.add(id);
+        calls.set(id, {
+            item
+        });
+        onEvent({
+            item,
+            type: 'session.tool_call'
+        });
+    };
+    socket.on('open', ()=>{
+        if (closed) return;
+        try {
+            create(options.input);
+        } catch (error) {
+            fail(error.message);
+        }
+    });
+    socket.on('message', (data)=>{
+        if (closed) return;
+        try {
+            const event = JSON.parse(data.toString());
+            const response = event.response;
+            if (event.type === 'response.created' && response) {
+                if (pendingSteer && response.id !== pendingSteer) pendingSteer = undefined;
+                currentId = response.id;
+                active = true;
+            }
+            if (event.type === 'response.output_item.done') registerCall(event.item);
+            onEvent(event);
+            if (closed) return;
+            if ([
+                'error',
+                'response.failed',
+                'response.steer.failed'
+            ].includes(event.type)) {
+                const detail = event.error || event.response?.error;
+                fail(detail?.message?.slice(0, 2000) || 'OpenAI response or steering failed. See the preceding provider event.');
+            } else if (event.type === 'response.incomplete') {
+                if (response?.incomplete_details?.reason !== 'steered' || !pendingSteer) {
+                    fail(`OpenAI response did not complete: ${response?.incomplete_details?.reason || 'unknown'}`);
+                }
+            } else if (event.type === 'response.completed' && response) {
+                if (response.status !== 'completed') throw new Error('Invalid completed response.');
+                for (const item of response.output || [])registerCall(item);
+                active = false;
+                if (calls.size) {
+                    onEvent({
+                        pending: [
+                            ...calls.keys()
+                        ],
+                        type: 'session.tools_pending'
+                    });
+                    flushTools();
+                } else if (!pendingSteer) {
+                    onEvent({
+                        response,
+                        text: readOpenAIResponseText(response),
+                        type: 'session.turn.completed'
+                    });
+                }
+            } else if (event.type === 'response.steer.pending') {
+                active = false;
+                flushTools();
+            }
+        } catch (error) {
+            fail(error.message);
+        }
+    });
+    socket.on('error', ()=>fail('OpenAI WebSocket connection failed.'));
+    socket.on('close', ()=>fail('OpenAI connection closed. Pending work was not replayed.'));
+    config.signal?.addEventListener('abort', close, {
+        once: true
+    });
+    armTimeout();
+    return {
+        close,
+        continue: (text)=>{
+            if (closed) throw new Error('OpenAI connection is not open.');
+            if (active || pendingSteer || [
+                ...calls.values()
+            ].some(({ item })=>!item.async)) {
+                throw new Error('Wait for the current response or required tool results before continuing.');
+            }
+            const input = [];
+            if (nextEffort) input.push({
+                reasoning: {
+                    effort: nextEffort
+                },
+                type: 'configuration_update'
+            });
+            input.push({
+                content: text,
+                role: 'user'
+            });
+            create(input);
+            nextEffort = undefined;
+        },
+        reasoning: (effort)=>{
+            if (closed) throw new Error('OpenAI connection is not open.');
+            nextEffort = reasoningEffort.parse(effort);
+            onEvent({
+                effort: nextEffort,
+                type: 'session.reasoning.queued'
+            });
+        },
+        steer: (text)=>{
+            if (!active || !currentId || pendingSteer) throw new Error('Steering requires an active response with no pending steering.');
+            send({
+                input: text,
+                previous_response_id: currentId,
+                type: 'response.steer'
+            });
+            pendingSteer = currentId;
+        },
+        toolResult: (callId, output)=>{
+            const call = calls.get(callId);
+            if (!call || call.output !== undefined) throw new Error('Unknown or duplicate tool result.');
+            call.output = output;
+            flushTools();
+        }
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/openaiResponseSession.ts"],"sourcesContent":["import WebSocket from 'ws';\nimport {z} from 'zod';\n\nconst reasoningEffort = z.enum(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);\nexport type OpenAIResponseReasoningEffort = z.infer<typeof reasoningEffort>;\ntype Item = Record<string, unknown>;\nexport type OpenAIResponseEvent = {type: string; [key: string]: unknown};\nexport type OpenAIResponseSessionOptions = {\n  input: Item[];\n  instructions?: string;\n  max_output_tokens: number;\n  model: string;\n  reasoning?: {effort: OpenAIResponseReasoningEffort};\n  text?: {format: Item};\n  tools?: Item[];\n};\nexport type OpenAIResponseOutput = {\n  id: string;\n  incomplete_details?: {reason?: string};\n  output?: Array<{content?: Array<{text?: string; type: string}>; status?: string; type: string}>;\n  status: string;\n};\n\nexport const readOpenAIResponseText = (response: OpenAIResponseOutput): string => {\n  if(response.status !== 'completed' || response.output?.some((item) => item.status === 'incomplete')) {\n    throw new Error(`OpenAI response did not complete: ${response.incomplete_details?.reason || response.status}`);\n  }\n  if(response.output?.some((item) => item.content?.some((part) => part.type === 'refusal'))) {\n    throw new Error('OpenAI declined the request.');\n  }\n  const text = (response.output || []).flatMap((item) => item.type === 'message' ? item.content || [] : [])\n    .filter((part) => part.type === 'output_text').map((part) => part.text || '').join('');\n  if(!text.trim()) {\n    throw new Error('OpenAI returned empty output.');\n  }\n  return text;\n};\n\n// One owner and one conversation per socket. Never replay requests after a disconnect:\n// tools may already have run, and accepted steering is connection-local.\nexport const createOpenAIResponseSession = (\n  options: OpenAIResponseSessionOptions,\n  onEvent: (event: OpenAIResponseEvent) => void,\n  config: {\n    apiKey: string;\n    connect?: () => WebSocket;\n    maxToolCalls: number;\n    signal?: AbortSignal;\n    timeoutMs: number;\n  }\n) => {\n  if(!config.apiKey.trim()) throw new Error('OpenAI API key is not configured.');\n  if(!options.model.trim() || !Number.isInteger(options.max_output_tokens) || options.max_output_tokens < 1) {\n    throw new Error('A model and positive output token budget are required.');\n  }\n  if(!Number.isInteger(config.timeoutMs) || config.timeoutMs < 1 || config.timeoutMs > 2_147_483_647\n    || !Number.isInteger(config.maxToolCalls) || config.maxToolCalls < 0) {\n    throw new Error('Invalid session timeout or tool-call limit.');\n  }\n  if(config.signal?.aborted) throw new Error('OpenAI session was aborted.');\n  if(options.reasoning) reasoningEffort.parse(options.reasoning.effort);\n  const settings = {...options, input: undefined, store: false, truncation: 'disabled'};\n  const connect = config.connect || (() => new WebSocket('wss://api.openai.com/v1/responses', {\n    handshakeTimeout: Math.min(10000, config.timeoutMs),\n    headers: {Authorization: `Bearer ${config.apiKey}`},\n    maxPayload: 16 * 1024 * 1024\n  }));\n  const socket = connect();\n  const seenCalls = new Set<string>();\n  const calls = new Map<string, {item: Item; output?: string}>();\n  let active = true;\n  let closed = false;\n  let currentId: string | undefined;\n  let pendingSteer: string | undefined;\n  let nextEffort: OpenAIResponseReasoningEffort | undefined;\n  let timer: ReturnType<typeof setTimeout>;\n  const close = () => {\n    if(closed) return;\n    closed = true;\n    clearTimeout(timer);\n    config.signal?.removeEventListener('abort', close);\n    calls.clear();\n    seenCalls.clear();\n    socket.close();\n  };\n  const fail = (message: string) => {\n    if(closed) return;\n    close();\n    onEvent({message, type: 'session.error'});\n  };\n  const armTimeout = () => {\n    clearTimeout(timer);\n    timer = setTimeout(() => fail('OpenAI session timed out. Start a new session; requests were not replayed.'), config.timeoutMs);\n    timer.unref?.();\n  };\n  const send = (event: Item) => {\n    if(closed || socket.readyState !== WebSocket.OPEN) throw new Error('OpenAI connection is not open.');\n    socket.send(JSON.stringify(event));\n  };\n  const create = (input: Item[]) => {\n    active = true;\n    armTimeout();\n    send({...settings, input, ...(currentId ? {previous_response_id: currentId} : {}), type: 'response.create'});\n  };\n  const flushTools = () => {\n    if(active || !currentId) return;\n    // Synchronous calls must all be satisfied before starting another response.\n    if([...calls.values()].some(({item, output}) => !item.async && output === undefined)) return;\n    const ready = [...calls.entries()].filter(([, call]) => call.output !== undefined);\n    if(!ready.length) return;\n    create(ready.map(([callId, {item, output}]) => ({\n      call_id: callId,\n      output,\n      type: item.type === 'custom_tool_call' ? 'custom_tool_call_output' : 'function_call_output'\n    })));\n    for(const [id] of ready) calls.delete(id);\n  };\n  const registerCall = (item: Item) => {\n    if(!['function_call', 'custom_tool_call'].includes(String(item.type))) return;\n    const id = String(item.call_id || '');\n    if(!id) throw new Error('OpenAI tool call is missing its call_id.');\n    if(seenCalls.has(id)) return;\n    if(seenCalls.size >= config.maxToolCalls) throw new Error('Session tool-call limit exceeded.');\n    if(item.status === 'incomplete') throw new Error('OpenAI returned an incomplete tool call.');\n    if(!options.tools?.some((tool) => tool.name === item.name && tool.type === (item.type === 'function_call' ? 'function' : 'custom'))) throw new Error('OpenAI requested an unregistered tool.');\n    seenCalls.add(id);\n    calls.set(id, {item});\n    onEvent({item, type: 'session.tool_call'});\n  };\n  socket.on('open', () => {\n    if(closed) return;\n    try { create(options.input); } catch(error) { fail((error as Error).message); }\n  });\n  socket.on('message', (data) => {\n    if(closed) return;\n    try {\n      const event = JSON.parse(data.toString()) as OpenAIResponseEvent;\n      const response = event.response as OpenAIResponseOutput | undefined;\n      if(event.type === 'response.created' && response) {\n        if(pendingSteer && response.id !== pendingSteer) pendingSteer = undefined;\n        currentId = response.id;\n        active = true;\n      }\n      if(event.type === 'response.output_item.done') registerCall(event.item as Item);\n      onEvent(event);\n      if(closed) return;\n      if(['error', 'response.failed', 'response.steer.failed'].includes(event.type)) {\n        const detail = (event.error || (event.response as {error?: {message?: string}})?.error) as {message?: string} | undefined;\n        fail(detail?.message?.slice(0, 2000) || 'OpenAI response or steering failed. See the preceding provider event.');\n      } else if(event.type === 'response.incomplete') {\n        if(response?.incomplete_details?.reason !== 'steered' || !pendingSteer) {\n          fail(`OpenAI response did not complete: ${response?.incomplete_details?.reason || 'unknown'}`);\n        }\n      } else if(event.type === 'response.completed' && response) {\n        if(response.status !== 'completed') throw new Error('Invalid completed response.');\n        for(const item of response.output || []) registerCall(item as Item);\n        active = false;\n        if(calls.size) {\n          onEvent({pending: [...calls.keys()], type: 'session.tools_pending'});\n          flushTools();\n        } else if(!pendingSteer) {\n          onEvent({response, text: readOpenAIResponseText(response), type: 'session.turn.completed'});\n        }\n      } else if(event.type === 'response.steer.pending') {\n        active = false;\n        flushTools();\n      }\n    } catch(error) { fail((error as Error).message); }\n  });\n  socket.on('error', () => fail('OpenAI WebSocket connection failed.'));\n  socket.on('close', () => fail('OpenAI connection closed. Pending work was not replayed.'));\n  config.signal?.addEventListener('abort', close, {once: true});\n  armTimeout();\n  return {\n    close,\n    continue: (text: string) => {\n      if(closed) throw new Error('OpenAI connection is not open.');\n      if(active || pendingSteer || [...calls.values()].some(({item}) => !item.async)) {\n        throw new Error('Wait for the current response or required tool results before continuing.');\n      }\n      const input: Item[] = [];\n      if(nextEffort) input.push({reasoning: {effort: nextEffort}, type: 'configuration_update'});\n      input.push({content: text, role: 'user'});\n      create(input);\n      nextEffort = undefined;\n    },\n    reasoning: (effort: OpenAIResponseReasoningEffort) => {\n      if(closed) throw new Error('OpenAI connection is not open.');\n      nextEffort = reasoningEffort.parse(effort);\n      onEvent({effort: nextEffort, type: 'session.reasoning.queued'});\n    },\n    steer: (text: string) => {\n      if(!active || !currentId || pendingSteer) throw new Error('Steering requires an active response with no pending steering.');\n      send({input: text, previous_response_id: currentId, type: 'response.steer'});\n      pendingSteer = currentId;\n    },\n    toolResult: (callId: string, output: string) => {\n      const call = calls.get(callId);\n      if(!call || call.output !== undefined) throw new Error('Unknown or duplicate tool result.');\n      call.output = output;\n      flushTools();\n    }\n  };\n};\n"],"names":["WebSocket","z","reasoningEffort","enum","readOpenAIResponseText","response","status","output","some","item","Error","incomplete_details","reason","content","part","type","text","flatMap","filter","map","join","trim","createOpenAIResponseSession","options","onEvent","config","apiKey","model","Number","isInteger","max_output_tokens","timeoutMs","maxToolCalls","signal","aborted","reasoning","parse","effort","settings","input","undefined","store","truncation","connect","handshakeTimeout","Math","min","headers","Authorization","maxPayload","socket","seenCalls","Set","calls","Map","active","closed","currentId","pendingSteer","nextEffort","timer","close","clearTimeout","removeEventListener","clear","fail","message","armTimeout","setTimeout","unref","send","event","readyState","OPEN","JSON","stringify","create","previous_response_id","flushTools","values","async","ready","entries","call","length","callId","call_id","id","delete","registerCall","includes","String","has","size","tools","tool","name","add","set","on","error","data","toString","detail","slice","pending","keys","addEventListener","once","continue","push","role","steer","toolResult","get"],"mappings":"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"}

package/lib/actions/videoGeneration.d.ts

@@ -1,8 +1,12 @@
 import type { GeminiVideoInput } from '../adapters/geminiGenerationAdapter.js';
 import type { SeedanceReferenceVideoInput, SeedanceVideoInput } from '../adapters/higgsfieldAdapter.js';
 import type { ApiContext } from '../types/auth.types.js';
-export type VideoGenerationInput = (GeminiVideoInput | SeedanceVideoInput | SeedanceReferenceVideoInput) & {
+export type VideoGenerationInput = ((GeminiVideoInput | SeedanceVideoInput | SeedanceReferenceVideoInput) & {
     provider?: string;
+}) | {
+    model: string;
+    modelInput: Record<string, unknown>;
+    provider: 'higgsfield';
 };
 export interface VideoGenerationResult {
     cancelUrl?: string;

package/lib/actions/videoGeneration.js

@@ -1,6 +1,7 @@
+import { getHiggsfieldModel } from '../adapters/higgsfieldModelCatalog.js';
 import { Config } from '../config.js';
 import { generateGeminiVideo } from './geminiVideo.js';
-import { generateSeedanceReferenceVideo, generateSeedanceVideo } from './higgsfield.js';
+import { generateHiggsfieldModel, generateSeedanceReferenceVideo, generateSeedanceVideo } from './higgsfield.js';
 /** Generic video submission; providers must be explicitly selected in the input or configuration. */ export const generateVideo = async (context, input, config = context.config?.videoGeneration || Config.get('videoGeneration') || {}, webhookUrl)=>{
     const { provider = config.provider, ...options } = input;
     if (!provider) {
@@ -15,6 +16,16 @@ import { generateSeedanceReferenceVideo, generateSeedanceVideo } from './higgsfi
     if (provider !== 'higgsfield') {
         throw new Error('Unsupported video provider.');
     }
+    if ('modelInput' in input && typeof input.model === 'string') {
+        if (getHiggsfieldModel(input.model).kind !== 'video') {
+            throw new Error('Choose a video model.');
+        }
+        return {
+            ...await generateHiggsfieldModel(context, input.model, input.modelInput, webhookUrl),
+            provider,
+            status: 'queued'
+        };
+    }
     const mediaOptions = options;
     const references = [
         mediaOptions.imageUrls,
@@ -29,4 +40,4 @@ import { generateSeedanceReferenceVideo, generateSeedanceVideo } from './higgsfi
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/adapters/higgsfieldAdapter.d.ts

@@ -101,20 +101,26 @@ export declare const validateSoulImageInput: (input: unknown) => SoulImageInput;
 export declare const validateSeedanceVideoInput: (input: unknown) => SeedanceVideoInput;
 export declare const validateSeedanceReferenceVideoInput: (input: unknown) => SeedanceReferenceVideoInput;
 export declare const validateMarketingStudioImageInput: (input: unknown) => MarketingStudioImageInput;
-export interface HiggsfieldWebhookPayload {
-    error?: string | null;
-    payload?: {
-        images?: {
-            url?: string;
-            content_type?: string;
-        }[];
-        video?: {
-            url?: string;
-            content_type?: string;
-        };
-    };
-    request_id: string;
-    status: string;
-}
+declare const HiggsfieldWebhookSchema: z.ZodObject<{
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    payload: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            content_type: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        video: z.ZodOptional<z.ZodObject<{
+            content_type: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    request_id: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        nsfw: "nsfw";
+    }>;
+}, z.core.$strip>;
+export type HiggsfieldWebhookPayload = z.output<typeof HiggsfieldWebhookSchema>;
+/** Validates the documented envelope only; callers must authenticate and reconcile before settlement. */
 export declare const parseHiggsfieldWebhookPayload: (body: unknown) => HiggsfieldWebhookPayload;
 export {};