@nlabs/reaktor 1.11.0 → 1.12.0

package/docs/GENERATION.md

@@ -147,3 +147,52 @@ 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,8 +7,16 @@ 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;
+    content: string | ContentGenerationPart[];
     role: 'assistant' | 'developer' | 'system' | 'user';
 }
 export type ContentGenerationResponseFormat = {

package/lib/actions/contentGeneration.js

@@ -4,6 +4,18 @@ import { Config } from '../config.js';
 }
 /** 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',
@@ -18,7 +30,7 @@ import { Config } from '../config.js';
                 'developer',
                 'system',
                 'user'
-            ].includes(message.role) || typeof message.content !== 'string' || !message.content.trim())) {
+            ].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()) {
@@ -101,7 +113,14 @@ import { Config } from '../config.js';
         }
         const response = await post('https://api.openai.com/v1/responses', {
             input: input.messages?.map((message)=>({
-                    content: message.content,
+                    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,
@@ -271,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 ContentGenerationMessage {\n  content: string;\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\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) || typeof message.content !== 'string' || !message.content.trim())) {\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: message.content, 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","generateContent","input","config","get","includes","provider","messages","undefined","prompt","Array","isArray","length","some","message","role","content","trim","reasoningEffort","responseFormat","timeoutMs","Number","isInteger","format","type","name","test","schema","strict","maxTokens","images","modality","search","claudeKey","response","max_tokens","model","claudeModel","system","cache","headers","Headers","timeout","error","text","filter","part","map","join","stop_reason","sources","openaiKey","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","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/index.d.ts

@@ -37,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

@@ -36,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/reaktor",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "GraphQL and ArangoDB application platform for typed actions, authentication, billing, media, messaging, and realtime services.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",