@nlabs/reaktor 1.10.0 → 1.12.0

package/README.md

@@ -1458,6 +1458,8 @@ package. See [LICENSE](./LICENSE) for the governing terms.
 
 See the [complete generation and sessions guide](docs/GENERATION.md) for the provider matrix, server configuration, results, storage, rejection handling, and release policy.
 
+`verifyGenerationCallbackToken` validates an expiring per-job callback capability; `parseGenerationCallback` normalizes bounded Higgsfield callback bodies into stable reconciliation events. Confirm outcomes through authenticated provider polling before media retention or credit settlement. See the guide for durable deduplication and callback security requirements.
+
 ### Provider-driven content generation
 
 `generateContent(input, config?)` submits a single server-side request through Rip-Hunter to
@@ -1512,3 +1514,5 @@ The initial Veo adapter accepts 4, 6, or 8 seconds, with 1080p requiring 8 secon
 reference inputs are rejected. Helpers perform no database or filesystem writes.
 Keep durable jobs and reconciliation in the application: unknown submission outcomes
 must not be automatically retried. Gemini image results include `mimeType` for PNG/JPEG.
+
+Higgsfield generation includes a typed catalog of 80 verified image/video API variants, model-specific JSON Schema validation, allowlisted submission, and optional callbacks. See [generation](docs/GENERATION.md).

package/docs/GENERATION.md

@@ -46,6 +46,37 @@ Use `getGeminiVideoStatus(requestId, {key})` to poll an existing operation. When
 
 Use `s3Put`, `s3Get`, and `s3GetSignedUrl` with their optional `S3Client` parameter for application-specific connections, or omit it for Config-based behavior. Commit metadata and graph edges in ArangoDB only after retaining the media. Persist an output pointer before retrying settlement so recovery does not download or bill twice.
 
+## Generation callbacks
+
+Higgsfield documents terminal JSON callbacks but does not currently document a webhook signature
+protocol. Reaktor does not invent an HMAC signature contract. Use `createOpaqueToken` to issue a
+separate callback capability for each job; persist `hashOpaqueToken(token)` and its expiry before
+submitting the generation request. Include the token only in that job's HTTPS callback URL, and
+redact it from access logs. Scope the stored capability lookup to the owning account and job.
+
+`verifyGenerationCallbackToken(token, expectedHash, expiresAt, now?)` returns a boolean. Expiry and
+`now` use Unix milliseconds; comparison uses constant-time SHA-256 hashes. This proves possession
+of the application capability, not a Higgsfield signature. It intentionally allows valid redelivery
+until expiry; the application must persist and deduplicate events transactionally.
+
+After authentication, `parseGenerationCallback('higgsfield', rawBody, {maxBytes?})` accepts a Buffer
+or JSON string and returns `{eventId, provider, requestId, status}`. The default limit is 64 KiB,
+with a configurable ceiling of 1 MiB; enforce the same limit while reading the HTTP request.
+Malformed JSON, invalid envelopes, unsupported providers, and nonterminal states are rejected.
+`eventId` identifies the provider, request ID, and terminal status, so delivery retries have a
+stable key. Payload media URLs and error text are deliberately excluded from this event.
+
+Treat the callback as a reconciliation hint. Verify its request ID against the durable submission
+and fetch the result through the provider's authenticated status API before saving media or
+settling credits. Early callbacks require durable correlation with a pending job; they must never
+create a job or charge from callback data alone. Retain media in S3, commit metadata/accounting
+in ArangoDB, and publish WebSocket events only after those operations succeed. Keep polling as a
+fallback. Store duplicates durably or recognize an existing committed event before returning 2xx.
+
+The [official delivery contract](https://docs.higgsfield.ai/docs/how-to/webhooks) retries network/5xx
+failures for up to two hours, treats 4xx as permanent, and requires responses within ten seconds.
+Keep HTTP acknowledgement separate from long-running downloads and settlement.
+
 ## Opaque sessions and private media
 
 `createOpaqueToken`, `hashOpaqueToken`, `isOpaqueToken`, and `readOpaqueBearerToken` are opt-in primitives alongside existing JWT authentication. Store the token hash and expiry server-side; return the raw token only to the authenticated client. The application owns expiry checks, revocation, session persistence, and resource authorization.
@@ -61,3 +92,107 @@ Publish account-scoped events only after database commit. Clients should refresh
 ## Release policy
 
 Publish only plain `major.minor.patch` versions. Build with Lex, run tests and package verification, and inspect `npm pack --dry-run` before release. The `publish:*` convenience scripts also push Git branches/tags; publishing an audited tarball with `npm publish <archive> --access public` does not implicitly push a dirty working tree.
+
+## Full Higgsfield API catalog
+
+`HIGGSFIELD_MODELS` contains the 80 public image/video endpoint variants verified on 2026-09-22 (14 image, 66 video). Every entry includes `id`, `kind`, `name`, its JSON `schema`, and the exact public documentation `source`. `getHiggsfieldModel(id)` rejects unknown routes. `validateHiggsfieldModelInput(id, input)` validates nested/conditional model inputs using Ajv.
+
+Use `generateHiggsfieldModel(context, modelId, modelInput, callbackUrl)` for direct submission. The generic `generateImage` and `generateVideo` actions also accept `provider: 'higgsfield'`, `model`, and `modelInput`; GraphQL exposes the nested payload as JSON. Model inputs use the documented snake_case field names. No paid submission is automatically retried. Credentials stay in server Config; polling and cancellation continue to validate their fixed provider origin.
+
+This catalog is a reviewed snapshot of https://open.higgsfield.ai/explore/image and /explore/video plus each endpoint's model-specific documentation. The older shared OpenAPI file and consumer website do not define the complete public API selection. Verify account access, output retention, and model-specific billing in the integrating application. Refresh this source snapshot and its schema tests when the published API catalog changes.
+
+
+## Advanced text generation (1.11.0)
+
+OpenAI accepts either `prompt` or ordered text `messages` (never both). Message roles are
+`system`, `developer`, `user`, and `assistant`; system messages become developer messages
+without flattening or reordering the conversation. Existing prompt callers remain supported.
+
+```ts
+const result = await generateContent({
+  maxTokens: 16000,
+  messages: [
+    {content: 'Return JSON containing a memories array.', role: 'system'},
+    {content: chapterText, role: 'user'}
+  ],
+  model: configuredModel,
+  provider: 'openai',
+  reasoningEffort: 'low',
+  responseFormat: {type: 'json_object'},
+  timeoutMs: 180000
+}, {openaiKey: process.env.OPENAI_API_KEY});
+const memories = JSON.parse(result.text); // Validate application-specific data before saving.
+```
+
+`responseFormat` supports `{type: 'text'}`, `{type: 'json_object'}`, or
+`{type: 'json_schema', name, schema, strict?, description?}`. `reasoningEffort` accepts
+`none`, `minimal`, `low`, `medium`, `high`, `xhigh`, or `max`; model support is checked by the
+provider. These fields and `messages` are currently OpenAI-only; other providers reject
+them before submitting instead of silently dropping them. Image messages and tools are not
+supported by this text action. Gemini's existing `images` input remains available.
+
+`timeoutMs` applies to all providers and defaults to 120000. It must be a positive
+32-bit integer. A timeout does not prove the provider stopped working or did not charge.
+There is no automatic retry or transport fallback. OpenAI requests disable storage and
+input truncation. The authenticated `contents.generateContent` GraphQL mutation exposes
+messages, response format, reasoning effort, and timeout as well.
+
+The action returns only completed, non-empty output. OpenAI refusal, incomplete output
+items, unsupported tool output, Claude unfinished turns, and Gemini blocked or unfinished
+candidates raise `ContentGenerationResponseError`. Gemini requires `finishReason: 'STOP'`.
+This error represents unusable output from a potentially paid request, not a confirmed
+submission rejection. Transport errors propagate unchanged. Preserve jobs for reconciliation;
+do not automatically repeat a paid POST. Interactive streaming, tools, and steering remain
+application-owned.
+
+The OpenAI mapping follows the [Responses API](https://developers.openai.com/api/reference/cli/resources/responses/methods/create)
+and [structured output contract](https://developers.openai.com/api/docs/guides/structured-outputs).
+
+## Interactive OpenAI sessions (1.12.0)
+
+`createOpenAIResponseSession(options, onEvent, config)` manages one Responses
+WebSocket conversation. The caller supplies `model`, `max_output_tokens`, `input`,
+optional instructions/reasoning/tool definitions, and explicit `apiKey`,
+`timeoutMs`, and `maxToolCalls` in config. It does not read environment variables,
+choose application prompts, authenticate end users, execute tools, or save results.
+Applications own those policies and must authorize every tool they expose.
+
+The returned handle offers `continue(text)`, `steer(text)`, `reasoning(effort)`,
+`toolResult(callId, output)`, and idempotent `close()`. Pass an optional AbortSignal
+as `config.signal` for local cancellation. Closing/aborting releases the timer,
+discards queued tool results, and closes the connection; it does not roll back
+external tools or guarantee that provider billing stops immediately. No requests
+are automatically retried or replayed after errors or disconnection.
+
+Provider events are forwarded to `onEvent`. Application-facing events are
+`session.tool_call`, `session.tools_pending`, `session.reasoning.queued`,
+`session.turn.completed`, and `session.error`. Only `session.turn.completed`
+contains validated final text. Tool results are buffered while generating;
+synchronous tools must all finish before a continuation. Steering waits for its
+successor response and retains connection-local state. Storage and truncation are
+disabled. `timeoutMs` bounds each turn and the following idle/tool-wait period.
+An optional `config.connect` factory supports test sockets.
+
+The TypeScript `generateContent` action also accepts multipart OpenAI messages:
+
+```ts
+const result = await generateContent({
+  messages: [{
+    content: [
+      {text: 'Describe the visible colors.', type: 'text'},
+      {detail: 'auto', type: 'image', url: imageUrl}
+    ],
+    role: 'user'
+  }],
+  model,
+  provider: 'openai'
+}, {openaiKey});
+```
+
+Image URLs may be HTTP(S) URLs or base64 PNG/JPEG/WebP/GIF data URLs. Image parts
+are accepted only in user messages. Other providers and the existing GraphQL
+message input remain text-only for `messages`; Gemini's separate byte-image
+input remains supported by the TypeScript action.
+
+Protocol references: [WebSocket mode](https://developers.openai.com/api/docs/guides/websocket-mode)
+and [mid-turn steering](https://developers.openai.com/api/docs/guides/steering).

package/lib/actions/contentGeneration.d.ts

@@ -7,6 +7,28 @@ export interface ContentGenerationConfig {
     openaiKey?: string;
     openaiModel?: string;
 }
+export type ContentGenerationPart = {
+    text: string;
+    type: 'text';
+} | {
+    detail?: 'auto' | 'high' | 'low';
+    type: 'image';
+    url: string;
+};
+export interface ContentGenerationMessage {
+    content: string | ContentGenerationPart[];
+    role: 'assistant' | 'developer' | 'system' | 'user';
+}
+export type ContentGenerationResponseFormat = {
+    type: 'json_object' | 'text';
+} | {
+    description?: string;
+    name: string;
+    schema: Record<string, unknown>;
+    strict?: boolean;
+    type: 'json_schema';
+};
+export type ContentGenerationReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export interface ContentGenerationInput {
     aspectRatio?: string;
     images?: {
@@ -14,12 +36,16 @@ export interface ContentGenerationInput {
         mime: string;
     }[];
     maxTokens?: number;
+    messages?: ContentGenerationMessage[];
     modality?: 'image' | 'text';
     model?: string;
-    prompt: string;
+    prompt?: string;
     provider: 'claude' | 'gemini' | 'openai';
+    reasoningEffort?: ContentGenerationReasoningEffort;
+    responseFormat?: ContentGenerationResponseFormat;
     search?: boolean;
     system?: string;
+    timeoutMs?: number;
 }
 export interface GeneratedContent {
     image?: {
@@ -36,5 +62,8 @@ export interface GeneratedContent {
 /** A confirmed rejection is distinct from an unknown paid submission outcome. */
 export declare class ContentGenerationRejectedError extends Error {
 }
+/** An accepted generation did not produce usable output; do not automatically resubmit it. */
+export declare class ContentGenerationResponseError extends Error {
+}
 /** Single submission through Rip-Hunter; callers own durable jobs and reconciliation. */
 export declare const generateContent: (input: ContentGenerationInput, config?: ContentGenerationConfig) => Promise<GeneratedContent>;

package/lib/actions/contentGeneration.js

@@ -2,13 +2,64 @@ import { post } from '@nlabs/rip-hunter';
 import { Config } from '../config.js';
 /** A confirmed rejection is distinct from an unknown paid submission outcome. */ export class ContentGenerationRejectedError extends Error {
 }
+/** An accepted generation did not produce usable output; do not automatically resubmit it. */ export class ContentGenerationResponseError extends Error {
+}
+const validMessageContent = (message)=>{
+    if (typeof message.content === 'string') return !!message.content.trim();
+    return Array.isArray(message.content) && message.content.length > 0 && message.content.every((part)=>{
+        if (!part) return false;
+        if (part.type === 'text') return typeof part.text === 'string' && !!part.text.trim();
+        return part.type === 'image' && message.role === 'user' && typeof part.url === 'string' && /^(https?:\/\/[^\s]+|data:image\/(png|jpeg|webp|gif);base64,[A-Za-z0-9+/]+={0,2})$/.test(part.url) && (part.detail === undefined || [
+            'auto',
+            'high',
+            'low'
+        ].includes(part.detail));
+    });
+};
 /** Single submission through Rip-Hunter; callers own durable jobs and reconciliation. */ export const generateContent = async (input, config = Config.get('contentGeneration') || {})=>{
     if (![
         'claude',
         'gemini',
         'openai'
-    ].includes(input.provider) || !input.prompt?.trim()) {
-        throw new ContentGenerationRejectedError('A supported provider and non-empty prompt are required.');
+    ].includes(input.provider)) {
+        throw new ContentGenerationRejectedError('A supported provider is required.');
+    }
+    if (input.messages !== undefined) {
+        if (input.prompt !== undefined || !Array.isArray(input.messages) || !input.messages.length || input.messages.some((message)=>!message || ![
+                'assistant',
+                'developer',
+                'system',
+                'user'
+            ].includes(message.role) || !validMessageContent(message))) {
+            throw new ContentGenerationRejectedError('Supply either a non-empty prompt or non-empty text messages with supported roles.');
+        }
+    } else if (typeof input.prompt !== 'string' || !input.prompt.trim()) {
+        throw new ContentGenerationRejectedError('A non-empty prompt is required.');
+    }
+    if (input.provider !== 'openai' && (input.messages !== undefined || input.reasoningEffort !== undefined || input.responseFormat !== undefined)) {
+        throw new ContentGenerationRejectedError('Messages, reasoning effort, and response format are currently supported only by OpenAI.');
+    }
+    if (input.timeoutMs !== undefined && (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 2_147_483_647)) {
+        throw new ContentGenerationRejectedError('timeoutMs must be a positive 32-bit integer.');
+    }
+    if (input.reasoningEffort !== undefined && ![
+        'none',
+        'minimal',
+        'low',
+        'medium',
+        'high',
+        'xhigh',
+        'max'
+    ].includes(input.reasoningEffort)) {
+        throw new ContentGenerationRejectedError('Unsupported reasoning effort.');
+    }
+    const format = input.responseFormat;
+    if (format !== undefined && (!format || ![
+        'text',
+        'json_object',
+        'json_schema'
+    ].includes(format.type) || format.type === 'json_schema' && (typeof format.name !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(format.name) || !format.schema || typeof format.schema !== 'object' || Array.isArray(format.schema) || format.strict !== undefined && typeof format.strict !== 'boolean'))) {
+        throw new ContentGenerationRejectedError('Invalid response format. JSON schemas require a name and schema object.');
     }
     if (input.maxTokens !== undefined && (!Number.isInteger(input.maxTokens) || input.maxTokens < 1)) {
         throw new ContentGenerationRejectedError('maxTokens must be a positive integer.');
@@ -37,7 +88,7 @@ import { Config } from '../config.js';
                 'anthropic-version': '2023-06-01',
                 'x-api-key': config.claudeKey
             }),
-            timeout: 120_000
+            timeout: input.timeoutMs ?? 120_000
         });
         if (response.error && [
             'authentication_error',
@@ -49,7 +100,7 @@ import { Config } from '../config.js';
         }
         const text = response.content?.filter((part)=>part.type === 'text').map((part)=>part.text || '').join('\n').trim();
         if (response.error || response.type !== 'message' || response.stop_reason !== 'end_turn' || !text) {
-            throw new Error('Claude response could not be confirmed.');
+            throw new ContentGenerationResponseError('Claude response could not be confirmed.');
         }
         return {
             sources: [],
@@ -61,17 +112,38 @@ import { Config } from '../config.js';
             throw new ContentGenerationRejectedError('OpenAI is not configured on this server.');
         }
         const response = await post('https://api.openai.com/v1/responses', {
-            input: prompt,
+            input: input.messages?.map((message)=>({
+                    content: typeof message.content === 'string' ? message.content : message.content.map((part)=>part.type === 'text' ? {
+                            text: part.text,
+                            type: 'input_text'
+                        } : {
+                            detail: part.detail ?? 'auto',
+                            image_url: part.url,
+                            type: 'input_image'
+                        }),
+                    role: message.role === 'system' ? 'developer' : message.role
+                })) ?? prompt,
             instructions: input.system,
             max_output_tokens: input.maxTokens ?? 4096,
             model: input.model || config.openaiModel || 'gpt-6-astra',
-            store: false
+            ...input.reasoningEffort ? {
+                reasoning: {
+                    effort: input.reasoningEffort
+                }
+            } : {},
+            store: false,
+            ...format ? {
+                text: {
+                    format
+                }
+            } : {},
+            truncation: 'disabled'
         }, {
             cache: false,
             headers: new Headers({
                 Authorization: `Bearer ${config.openaiKey}`
             }),
-            timeout: 120_000
+            timeout: input.timeoutMs ?? 120_000
         });
         if (response.error && [
             'invalid_request_error',
@@ -80,9 +152,21 @@ import { Config } from '../config.js';
         ].includes(response.error.type || '')) {
             throw new ContentGenerationRejectedError('OpenAI rejected the request. Check the model and account access.');
         }
-        const text = response.output?.flatMap((output)=>output.content || []).filter((part)=>part.type === 'output_text').map((part)=>part.text || '').join('\n').trim();
-        if (response.error || response.status !== 'completed' || !text) {
-            throw new Error('OpenAI response could not be confirmed.');
+        if (response.error || response.status !== 'completed' || response.output?.some((item)=>item.status === 'incomplete')) {
+            throw new ContentGenerationResponseError('OpenAI response could not be confirmed: generation did not complete.');
+        }
+        if (response.output?.some((item)=>item.content?.some((part)=>part.type === 'refusal'))) {
+            throw new ContentGenerationResponseError('OpenAI declined the request.');
+        }
+        if (response.output?.some((item)=>item.type && ![
+                'message',
+                'reasoning'
+            ].includes(item.type))) {
+            throw new ContentGenerationResponseError('OpenAI returned an unsupported output item.');
+        }
+        const text = response.output?.filter((item)=>item.type === 'message').flatMap((item)=>item.content || []).filter((part)=>part.type === 'output_text').map((part)=>part.text || '').join('').trim();
+        if (!text) {
+            throw new ContentGenerationResponseError('OpenAI returned empty output.');
         }
         return {
             sources: [],
@@ -148,7 +232,7 @@ import { Config } from '../config.js';
         headers: new Headers({
             'x-goog-api-key': config.geminiKey
         }),
-        timeout: 120_000
+        timeout: input.timeoutMs ?? 120_000
     });
     if (response.error && [
         400,
@@ -158,10 +242,13 @@ import { Config } from '../config.js';
     ].includes(response.error.code || 0)) {
         throw new ContentGenerationRejectedError('Gemini rejected the request. Check the reference format and model access.');
     }
-    if (response.error || !response.candidates?.length) {
-        throw new Error('Gemini response could not be confirmed.');
+    if (response.promptFeedback?.blockReason || response.error || !response.candidates?.length) {
+        throw new ContentGenerationResponseError('Gemini response could not be confirmed.');
     }
     const candidate = response.candidates[0];
+    if (candidate.finishReason !== 'STOP') {
+        throw new ContentGenerationResponseError('Gemini response could not be confirmed: generation did not complete.');
+    }
     const output = (candidate.content?.parts || []).filter((part)=>!part.thought);
     const inline = output.find((part)=>part.inlineData)?.inlineData;
     let image;
@@ -171,7 +258,7 @@ import { Config } from '../config.js';
     ].includes(inline.mimeType)) {
         const bytes = Buffer.from(inline.data, 'base64');
         if (!bytes.length || bytes.length > 20 * 1024 * 1024) {
-            throw new Error('Invalid image output.');
+            throw new ContentGenerationResponseError('Invalid image output.');
         }
         image = {
             bytes,
@@ -180,7 +267,7 @@ import { Config } from '../config.js';
     }
     const text = output.map((part)=>part.text || '').join('\n').trim();
     if (input.modality === 'image' ? !image : !text) {
-        throw new Error('The requested output was not returned.');
+        throw new ContentGenerationResponseError('The requested output was not returned.');
     }
     const sources = (candidate.groundingMetadata?.groundingChunks || []).flatMap(({ web })=>{
         try {
@@ -203,4 +290,4 @@ import { Config } from '../config.js';
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/contentGeneration.ts"],"sourcesContent":["import {post} from '@nlabs/rip-hunter';\n\nimport {Config} from '../config.js';\n\nexport interface ContentGenerationConfig {\n  claudeKey?: string;\n  claudeModel?: string;\n  geminiImageModel?: string;\n  geminiKey?: string;\n  geminiModel?: string;\n  openaiKey?: string;\n  openaiModel?: string;\n}\nexport interface ContentGenerationInput {\n  aspectRatio?: string;\n  images?: {bytes: Buffer; mime: string}[];\n  maxTokens?: number;\n  modality?: 'image' | 'text';\n  model?: string;\n  prompt: string;\n  provider: 'claude' | 'gemini' | 'openai';\n  search?: boolean;\n  system?: string;\n}\nexport interface GeneratedContent {\n  image?: {bytes: Buffer; mime: 'image/jpeg' | 'image/png'};\n  searchSuggestionsHtml?: string;\n  sources: {title: string; url: string}[];\n  text: string;\n}\n/** A confirmed rejection is distinct from an unknown paid submission outcome. */\nexport class ContentGenerationRejectedError extends Error {}\n\ninterface GeminiPart {inlineData?: {data: string; mimeType: string}; text?: string; thought?: boolean}\ninterface GeminiResponse {\n  candidates?: {\n    content?: {parts?: GeminiPart[]};\n    groundingMetadata?: {\n      groundingChunks?: {web?: {title?: string; uri?: string}}[];\n      searchEntryPoint?: {renderedContent?: string};\n    };\n  }[];\n  error?: {code?: number};\n  promptFeedback?: {blockReason?: string};\n}\n\n/** Single submission through Rip-Hunter; callers own durable jobs and reconciliation. */\nexport const generateContent = async (\n  input: ContentGenerationInput,\n  config: ContentGenerationConfig = Config.get<ContentGenerationConfig>('contentGeneration') || {}\n): Promise<GeneratedContent> => {\n  if(!['claude', 'gemini', 'openai'].includes(input.provider) || !input.prompt?.trim()) {\n    throw new ContentGenerationRejectedError('A supported provider and non-empty prompt are required.');\n  }\n  if(input.maxTokens !== undefined && (!Number.isInteger(input.maxTokens) || input.maxTokens < 1)) {\n    throw new ContentGenerationRejectedError('maxTokens must be a positive integer.');\n  }\n  if(input.provider !== 'gemini' && (input.images?.length || input.modality === 'image' || input.search)) {\n    throw new ContentGenerationRejectedError('This provider operation supports text input and output only.');\n  }\n  const {prompt, images = []} = input;\n  if(input.provider === 'claude') {\n    if(!config.claudeKey) {\n      throw new ContentGenerationRejectedError('Claude is not configured on this server.');\n    }\n    const response = await post('https://api.anthropic.com/v1/messages', {\n      max_tokens: input.maxTokens ?? 4096,\n      messages: [{content: prompt, role: 'user'}],\n      model: input.model || config.claudeModel || 'claude-sonnet-5',\n      system: input.system\n    }, {cache: false, headers: new Headers({'anthropic-version': '2023-06-01', 'x-api-key': config.claudeKey}), timeout: 120_000}) as {\n      content?: {text?: string; type?: string}[];\n      error?: {type?: string};\n      stop_reason?: string;\n      type?: string;\n    };\n    if(response.error && ['authentication_error', 'invalid_request_error', 'not_found_error', 'permission_error'].includes(response.error.type || '')) {\n      throw new ContentGenerationRejectedError('Claude rejected the request. Check the model and account access.');\n    }\n    const text = response.content?.filter((part) => part.type === 'text').map((part) => part.text || '').join('\\n').trim();\n    if(response.error || response.type !== 'message' || response.stop_reason !== 'end_turn' || !text) {\n      throw new Error('Claude response could not be confirmed.');\n    }\n    return {sources: [], text};\n  }\n  if(input.provider === 'openai') {\n    if(!config.openaiKey) {\n      throw new ContentGenerationRejectedError('OpenAI is not configured on this server.');\n    }\n    const response = await post('https://api.openai.com/v1/responses', {\n      input: prompt,\n      instructions: input.system,\n      max_output_tokens: input.maxTokens ?? 4096,\n      model: input.model || config.openaiModel || 'gpt-6-astra',\n      store: false\n    }, {cache: false, headers: new Headers({Authorization: `Bearer ${config.openaiKey}`}), timeout: 120_000}) as {\n      error?: {code?: string; type?: string};\n      output?: {content?: {text?: string; type?: string}[]}[];\n      status?: string;\n    };\n    if(response.error && ['invalid_request_error', 'authentication_error', 'permission_error'].includes(response.error.type || '')) {\n      throw new ContentGenerationRejectedError('OpenAI rejected the request. Check the model and account access.');\n    }\n    const text = response.output?.flatMap((output) => output.content || []).filter((part) => part.type === 'output_text').map((part) => part.text || '').join('\\n').trim();\n    if(response.error || response.status !== 'completed' || !text) {\n      throw new Error('OpenAI response could not be confirmed.');\n    }\n    return {sources: [], text};\n  }\n  if(!config.geminiKey) {\n    throw new ContentGenerationRejectedError('Gemini is not configured on this server.');\n  }\n  const parts: unknown[] = [{text: prompt}, ...images.map((image) => ({inlineData: {data: image.bytes.toString('base64'), mimeType: image.mime}}))];\n  const model = input.model || (input.modality === 'image' ? config.geminiImageModel || 'gemini-3.1-flash-image' : config.geminiModel || 'gemini-3.8-flash');\n  if(!/^[a-zA-Z0-9._-]+$/.test(model)) {\n    throw new ContentGenerationRejectedError('Invalid Gemini model configuration.');\n  }\n  const response = await post(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {\n    contents: [{parts, role: 'user'}],\n    ...(input.system ? {systemInstruction: {parts: [{text: input.system}]}} : {}),\n    generationConfig: input.modality === 'image' ? {...(input.aspectRatio ? {imageConfig: {aspectRatio: input.aspectRatio}} : {}), responseModalities: ['TEXT', 'IMAGE']} : {maxOutputTokens: input.maxTokens ?? 4096},\n    ...(input.search ? {tools: [{googleSearch: {}}]} : {})\n  }, {cache: false, headers: new Headers({'x-goog-api-key': config.geminiKey}), timeout: 120_000}) as GeminiResponse;\n  if(response.error && [400, 401, 403, 404].includes(response.error.code || 0)) {\n    throw new ContentGenerationRejectedError('Gemini rejected the request. Check the reference format and model access.');\n  }\n  if(response.error || !response.candidates?.length) {\n    throw new Error('Gemini response could not be confirmed.');\n  }\n  const candidate = response.candidates[0]!;\n  const output = (candidate.content?.parts || []).filter((part) => !part.thought);\n  const inline = output.find((part) => part.inlineData)?.inlineData;\n  let image: GeneratedContent['image'];\n  if(inline && ['image/png', 'image/jpeg'].includes(inline.mimeType)) {\n    const bytes = Buffer.from(inline.data, 'base64');\n    if(!bytes.length || bytes.length > 20 * 1024 * 1024) {\n      throw new Error('Invalid image output.');\n    }\n    image = {bytes, mime: inline.mimeType as 'image/png' | 'image/jpeg'};\n  }\n  const text = output.map((part) => part.text || '').join('\\n').trim();\n  if(input.modality === 'image' ? !image : !text) {\n    throw new Error('The requested output was not returned.');\n  }\n  const sources = (candidate.groundingMetadata?.groundingChunks || []).flatMap(({web}) => {\n    try {\n      const url = new URL(web?.uri || '');\n      return url.protocol === 'https:' ? [{title: web?.title || url.hostname, url: url.href}] : [];\n    } catch{\n      return [];\n    }\n  });\n  return {\n    image, searchSuggestionsHtml: candidate.groundingMetadata?.searchEntryPoint?.renderedContent, sources, text\n  };\n};\n"],"names":["post","Config","ContentGenerationRejectedError","Error","generateContent","input","config","get","includes","provider","prompt","trim","maxTokens","undefined","Number","isInteger","images","length","modality","search","claudeKey","response","max_tokens","messages","content","role","model","claudeModel","system","cache","headers","Headers","timeout","error","type","text","filter","part","map","join","stop_reason","sources","openaiKey","instructions","max_output_tokens","openaiModel","store","Authorization","output","flatMap","status","geminiKey","parts","image","inlineData","data","bytes","toString","mimeType","mime","geminiImageModel","geminiModel","test","contents","systemInstruction","generationConfig","aspectRatio","imageConfig","responseModalities","maxOutputTokens","tools","googleSearch","code","candidates","candidate","thought","inline","find","Buffer","from","groundingMetadata","groundingChunks","web","url","URL","uri","protocol","title","hostname","href","searchSuggestionsHtml","searchEntryPoint","renderedContent"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/contentGeneration.ts"],"sourcesContent":["import {post} from '@nlabs/rip-hunter';\n\nimport {Config} from '../config.js';\n\nexport interface ContentGenerationConfig {\n  claudeKey?: string;\n  claudeModel?: string;\n  geminiImageModel?: string;\n  geminiKey?: string;\n  geminiModel?: string;\n  openaiKey?: string;\n  openaiModel?: string;\n}\nexport type ContentGenerationPart = {text: string; type: 'text'} | {\n  detail?: 'auto' | 'high' | 'low';\n  type: 'image';\n  url: string;\n};\nexport interface ContentGenerationMessage {\n  content: string | ContentGenerationPart[];\n  role: 'assistant' | 'developer' | 'system' | 'user';\n}\nexport type ContentGenerationResponseFormat = {type: 'json_object' | 'text'} | {\n  description?: string;\n  name: string;\n  schema: Record<string, unknown>;\n  strict?: boolean;\n  type: 'json_schema';\n};\nexport type ContentGenerationReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';\n\nexport interface ContentGenerationInput {\n  aspectRatio?: string;\n  images?: {bytes: Buffer; mime: string}[];\n  maxTokens?: number;\n  messages?: ContentGenerationMessage[];\n  modality?: 'image' | 'text';\n  model?: string;\n  prompt?: string;\n  provider: 'claude' | 'gemini' | 'openai';\n  reasoningEffort?: ContentGenerationReasoningEffort;\n  responseFormat?: ContentGenerationResponseFormat;\n  search?: boolean;\n  system?: string;\n  timeoutMs?: number;\n}\nexport interface GeneratedContent {\n  image?: {bytes: Buffer; mime: 'image/jpeg' | 'image/png'};\n  searchSuggestionsHtml?: string;\n  sources: {title: string; url: string}[];\n  text: string;\n}\n/** A confirmed rejection is distinct from an unknown paid submission outcome. */\nexport class ContentGenerationRejectedError extends Error {}\n/** An accepted generation did not produce usable output; do not automatically resubmit it. */\nexport class ContentGenerationResponseError extends Error {}\n\ninterface GeminiPart {inlineData?: {data: string; mimeType: string}; text?: string; thought?: boolean}\ninterface GeminiResponse {\n  candidates?: {\n    content?: {parts?: GeminiPart[]};\n    finishReason?: string;\n    groundingMetadata?: {\n      groundingChunks?: {web?: {title?: string; uri?: string}}[];\n      searchEntryPoint?: {renderedContent?: string};\n    };\n  }[];\n  error?: {code?: number};\n  promptFeedback?: {blockReason?: string};\n}\n\nconst validMessageContent = (message: ContentGenerationMessage): boolean => {\n  if(typeof message.content === 'string') return !!message.content.trim();\n  return Array.isArray(message.content) && message.content.length > 0 && message.content.every((part) => {\n    if(!part) return false;\n    if(part.type === 'text') return typeof part.text === 'string' && !!part.text.trim();\n    return part.type === 'image' && message.role === 'user' && typeof part.url === 'string'\n      && /^(https?:\\/\\/[^\\s]+|data:image\\/(png|jpeg|webp|gif);base64,[A-Za-z0-9+/]+={0,2})$/.test(part.url)\n      && (part.detail === undefined || ['auto', 'high', 'low'].includes(part.detail));\n  });\n};\n\n/** Single submission through Rip-Hunter; callers own durable jobs and reconciliation. */\nexport const generateContent = async (\n  input: ContentGenerationInput,\n  config: ContentGenerationConfig = Config.get<ContentGenerationConfig>('contentGeneration') || {}\n): Promise<GeneratedContent> => {\n  if(!['claude', 'gemini', 'openai'].includes(input.provider)) {\n    throw new ContentGenerationRejectedError('A supported provider is required.');\n  }\n  if(input.messages !== undefined) {\n    if(input.prompt !== undefined || !Array.isArray(input.messages) || !input.messages.length || input.messages.some((message) =>\n      !message || !['assistant', 'developer', 'system', 'user'].includes(message.role) || !validMessageContent(message))) {\n      throw new ContentGenerationRejectedError('Supply either a non-empty prompt or non-empty text messages with supported roles.');\n    }\n  } else if(typeof input.prompt !== 'string' || !input.prompt.trim()) {\n    throw new ContentGenerationRejectedError('A non-empty prompt is required.');\n  }\n  if(input.provider !== 'openai' && (input.messages !== undefined || input.reasoningEffort !== undefined || input.responseFormat !== undefined)) {\n    throw new ContentGenerationRejectedError('Messages, reasoning effort, and response format are currently supported only by OpenAI.');\n  }\n  if(input.timeoutMs !== undefined && (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 2_147_483_647)) {\n    throw new ContentGenerationRejectedError('timeoutMs must be a positive 32-bit integer.');\n  }\n  if(input.reasoningEffort !== undefined && !['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(input.reasoningEffort)) {\n    throw new ContentGenerationRejectedError('Unsupported reasoning effort.');\n  }\n  const format = input.responseFormat;\n  if(format !== undefined && (!format || !['text', 'json_object', 'json_schema'].includes(format.type) || (format.type === 'json_schema' && (\n    typeof format.name !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(format.name) || !format.schema || typeof format.schema !== 'object' || Array.isArray(format.schema)\n    || (format.strict !== undefined && typeof format.strict !== 'boolean')\n  )))) {\n    throw new ContentGenerationRejectedError('Invalid response format. JSON schemas require a name and schema object.');\n  }\n  if(input.maxTokens !== undefined && (!Number.isInteger(input.maxTokens) || input.maxTokens < 1)) {\n    throw new ContentGenerationRejectedError('maxTokens must be a positive integer.');\n  }\n  if(input.provider !== 'gemini' && (input.images?.length || input.modality === 'image' || input.search)) {\n    throw new ContentGenerationRejectedError('This provider operation supports text input and output only.');\n  }\n  const {prompt, images = []} = input;\n  if(input.provider === 'claude') {\n    if(!config.claudeKey) {\n      throw new ContentGenerationRejectedError('Claude is not configured on this server.');\n    }\n    const response = await post('https://api.anthropic.com/v1/messages', {\n      max_tokens: input.maxTokens ?? 4096,\n      messages: [{content: prompt, role: 'user'}],\n      model: input.model || config.claudeModel || 'claude-sonnet-5',\n      system: input.system\n    }, {cache: false, headers: new Headers({'anthropic-version': '2023-06-01', 'x-api-key': config.claudeKey}), timeout: input.timeoutMs ?? 120_000}) as {\n      content?: {text?: string; type?: string}[];\n      error?: {type?: string};\n      stop_reason?: string;\n      type?: string;\n    };\n    if(response.error && ['authentication_error', 'invalid_request_error', 'not_found_error', 'permission_error'].includes(response.error.type || '')) {\n      throw new ContentGenerationRejectedError('Claude rejected the request. Check the model and account access.');\n    }\n    const text = response.content?.filter((part) => part.type === 'text').map((part) => part.text || '').join('\\n').trim();\n    if(response.error || response.type !== 'message' || response.stop_reason !== 'end_turn' || !text) {\n      throw new ContentGenerationResponseError('Claude response could not be confirmed.');\n    }\n    return {sources: [], text};\n  }\n  if(input.provider === 'openai') {\n    if(!config.openaiKey) {\n      throw new ContentGenerationRejectedError('OpenAI is not configured on this server.');\n    }\n    const response = await post('https://api.openai.com/v1/responses', {\n      input: input.messages?.map((message) => ({content: typeof message.content === 'string' ? message.content : message.content.map((part) => part.type === 'text'\n        ? {text: part.text, type: 'input_text'} : {detail: part.detail ?? 'auto', image_url: part.url, type: 'input_image'}), role: message.role === 'system' ? 'developer' : message.role})) ?? prompt,\n      instructions: input.system,\n      max_output_tokens: input.maxTokens ?? 4096,\n      model: input.model || config.openaiModel || 'gpt-6-astra',\n      ...(input.reasoningEffort ? {reasoning: {effort: input.reasoningEffort}} : {}),\n      store: false,\n      ...(format ? {text: {format}} : {}),\n      truncation: 'disabled'\n    }, {cache: false, headers: new Headers({Authorization: `Bearer ${config.openaiKey}`}), timeout: input.timeoutMs ?? 120_000}) as {\n      error?: {code?: string; type?: string};\n      output?: {content?: {text?: string; type?: string}[]; status?: string; type?: string}[];\n      status?: string;\n    };\n    if(response.error && ['invalid_request_error', 'authentication_error', 'permission_error'].includes(response.error.type || '')) {\n      throw new ContentGenerationRejectedError('OpenAI rejected the request. Check the model and account access.');\n    }\n    if(response.error || response.status !== 'completed' || response.output?.some((item) => item.status === 'incomplete')) {\n      throw new ContentGenerationResponseError('OpenAI response could not be confirmed: generation did not complete.');\n    }\n    if(response.output?.some((item) => item.content?.some((part) => part.type === 'refusal'))) {\n      throw new ContentGenerationResponseError('OpenAI declined the request.');\n    }\n    if(response.output?.some((item) => item.type && !['message', 'reasoning'].includes(item.type))) {\n      throw new ContentGenerationResponseError('OpenAI returned an unsupported output item.');\n    }\n    const text = response.output?.filter((item) => item.type === 'message').flatMap((item) => item.content || [])\n      .filter((part) => part.type === 'output_text').map((part) => part.text || '').join('').trim();\n    if(!text) {\n      throw new ContentGenerationResponseError('OpenAI returned empty output.');\n    }\n    return {sources: [], text};\n  }\n  if(!config.geminiKey) {\n    throw new ContentGenerationRejectedError('Gemini is not configured on this server.');\n  }\n  const parts: unknown[] = [{text: prompt}, ...images.map((image) => ({inlineData: {data: image.bytes.toString('base64'), mimeType: image.mime}}))];\n  const model = input.model || (input.modality === 'image' ? config.geminiImageModel || 'gemini-3.1-flash-image' : config.geminiModel || 'gemini-3.8-flash');\n  if(!/^[a-zA-Z0-9._-]+$/.test(model)) {\n    throw new ContentGenerationRejectedError('Invalid Gemini model configuration.');\n  }\n  const response = await post(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {\n    contents: [{parts, role: 'user'}],\n    ...(input.system ? {systemInstruction: {parts: [{text: input.system}]}} : {}),\n    generationConfig: input.modality === 'image' ? {...(input.aspectRatio ? {imageConfig: {aspectRatio: input.aspectRatio}} : {}), responseModalities: ['TEXT', 'IMAGE']} : {maxOutputTokens: input.maxTokens ?? 4096},\n    ...(input.search ? {tools: [{googleSearch: {}}]} : {})\n  }, {cache: false, headers: new Headers({'x-goog-api-key': config.geminiKey}), timeout: input.timeoutMs ?? 120_000}) as GeminiResponse;\n  if(response.error && [400, 401, 403, 404].includes(response.error.code || 0)) {\n    throw new ContentGenerationRejectedError('Gemini rejected the request. Check the reference format and model access.');\n  }\n  if(response.promptFeedback?.blockReason || response.error || !response.candidates?.length) {\n    throw new ContentGenerationResponseError('Gemini response could not be confirmed.');\n  }\n  const candidate = response.candidates[0]!;\n  if(candidate.finishReason !== 'STOP') {\n    throw new ContentGenerationResponseError('Gemini response could not be confirmed: generation did not complete.');\n  }\n  const output = (candidate.content?.parts || []).filter((part) => !part.thought);\n  const inline = output.find((part) => part.inlineData)?.inlineData;\n  let image: GeneratedContent['image'];\n  if(inline && ['image/png', 'image/jpeg'].includes(inline.mimeType)) {\n    const bytes = Buffer.from(inline.data, 'base64');\n    if(!bytes.length || bytes.length > 20 * 1024 * 1024) {\n      throw new ContentGenerationResponseError('Invalid image output.');\n    }\n    image = {bytes, mime: inline.mimeType as 'image/png' | 'image/jpeg'};\n  }\n  const text = output.map((part) => part.text || '').join('\\n').trim();\n  if(input.modality === 'image' ? !image : !text) {\n    throw new ContentGenerationResponseError('The requested output was not returned.');\n  }\n  const sources = (candidate.groundingMetadata?.groundingChunks || []).flatMap(({web}) => {\n    try {\n      const url = new URL(web?.uri || '');\n      return url.protocol === 'https:' ? [{title: web?.title || url.hostname, url: url.href}] : [];\n    } catch{\n      return [];\n    }\n  });\n  return {\n    image, searchSuggestionsHtml: candidate.groundingMetadata?.searchEntryPoint?.renderedContent, sources, text\n  };\n};\n"],"names":["post","Config","ContentGenerationRejectedError","Error","ContentGenerationResponseError","validMessageContent","message","content","trim","Array","isArray","length","every","part","type","text","role","url","test","detail","undefined","includes","generateContent","input","config","get","provider","messages","prompt","some","reasoningEffort","responseFormat","timeoutMs","Number","isInteger","format","name","schema","strict","maxTokens","images","modality","search","claudeKey","response","max_tokens","model","claudeModel","system","cache","headers","Headers","timeout","error","filter","map","join","stop_reason","sources","openaiKey","image_url","instructions","max_output_tokens","openaiModel","reasoning","effort","store","truncation","Authorization","status","output","item","flatMap","geminiKey","parts","image","inlineData","data","bytes","toString","mimeType","mime","geminiImageModel","geminiModel","contents","systemInstruction","generationConfig","aspectRatio","imageConfig","responseModalities","maxOutputTokens","tools","googleSearch","code","promptFeedback","blockReason","candidates","candidate","finishReason","thought","inline","find","Buffer","from","groundingMetadata","groundingChunks","web","URL","uri","protocol","title","hostname","href","searchSuggestionsHtml","searchEntryPoint","renderedContent"],"mappings":"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"}

package/lib/actions/databaseAccounts.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseCredentialIdentity, DatabaseCredentialSecret } from '../types/databaseCredentials.types.js';
+type Access = 'none' | 'ro' | 'rw';
+type BeforeWrite = () => Promise<void>;
+type Account = {
+    grants: Readonly<Record<string, Access>>;
+    identity: DatabaseCredentialIdentity;
+    managed: boolean;
+};
+export declare const inspectDatabaseAccount: (identity: DatabaseCredentialIdentity) => Promise<Account | undefined>;
+export declare const createManagedDatabaseAccount: (secret: DatabaseCredentialSecret, beforeWrite?: BeforeWrite) => Promise<void>;
+export declare const rotateManagedDatabaseAccountPassword: (secret: DatabaseCredentialSecret, beforeWrite?: BeforeWrite) => Promise<void>;
+export declare const restrictDatabaseAccount: (secret: DatabaseCredentialSecret, beforeWrite?: BeforeWrite) => Promise<void>;
+export declare const verifyDatabaseAccount: (secret: DatabaseCredentialSecret) => Promise<void>;
+export {};