@nodetool-ai/llm-nodes 0.8.1

package/dist/nodes/openai.js

@@ -0,0 +1,1806 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+import { fetchExternalMedia } from "@nodetool-ai/runtime";
+import { tagAsServer } from "@nodetool-ai/nodes-utils";
+import { createLogger } from "@nodetool-ai/config";
+import { encodeWav } from "./gemini.js";
+import { isCallable, isString } from "@nodetool-ai/node-sdk";
+const OPENAI_API_BASE = "https://api.openai.com/v1";
+const log = createLogger("nodetool.llm-nodes.openai");
+function getApiKey(secrets) {
+    const key = secrets.OPENAI_API_KEY || process.env.OPENAI_API_KEY || "";
+    if (!key)
+        throw new Error("OPENAI_API_KEY is not configured");
+    return key;
+}
+function authHeaders(apiKey) {
+    return {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+    };
+}
+// ---------------------------------------------------------------------------
+// 1. Embedding
+// ---------------------------------------------------------------------------
+export class EmbeddingNode extends BaseNode {
+    static nodeType = "openai.text.Embedding";
+    static title = "Embedding";
+    static inlineFields = ["input"];
+    static inputFields = [];
+    static description = "Generate vector representations of text for semantic analysis.\n    embeddings, similarity, search, clustering, classification\n\n    Uses OpenAI's embedding models to create dense vector representations of text.\n    These vectors capture semantic meaning, enabling:\n    - Semantic search\n    - Text clustering\n    - Document classification\n    - Recommendation systems\n    - Anomaly detection\n    - Measuring text similarity and diversity";
+    static metadataOutputTypes = {
+        output: "list"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const text = this.input;
+        const model = this.model;
+        const chunkSize = this.chunk_size;
+        const chunks = [];
+        for (let i = 0; i < text.length; i += chunkSize) {
+            chunks.push(text.slice(i, i + chunkSize));
+        }
+        if (chunks.length === 0)
+            chunks.push("");
+        const res = await fetch(`${OPENAI_API_BASE}/embeddings`, {
+            method: "POST",
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ input: chunks, model })
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI Embedding API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        const allEmbeddings = data.data.map((d) => d.embedding);
+        const dim = allEmbeddings[0]?.length ?? 0;
+        const avg = new Array(dim).fill(0);
+        for (const emb of allEmbeddings) {
+            for (let i = 0; i < dim; i++) {
+                avg[i] += emb[i] / allEmbeddings.length;
+            }
+        }
+        return { output: avg };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Input" })
+], EmbeddingNode.prototype, "input", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "text-embedding-3-small",
+        title: "Model",
+        values: ["text-embedding-3-large", "text-embedding-3-small"]
+    })
+], EmbeddingNode.prototype, "model", void 0);
+__decorate([
+    prop({ type: "int", default: 4096, title: "Chunk Size" })
+], EmbeddingNode.prototype, "chunk_size", void 0);
+export class WebSearchNode extends BaseNode {
+    static nodeType = "openai.text.WebSearch";
+    static title = "Web Search";
+    static inlineFields = ["query"];
+    static inputFields = [];
+    static description = "Search the web with OpenAI's web-search models to answer queries from current information.\n    openai, web, search, internet, browsing, current, realtime";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const query = this.query;
+        if (!query)
+            throw new Error("Search query cannot be empty");
+        const res = await fetch(`${OPENAI_API_BASE}/chat/completions`, {
+            method: "POST",
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({
+                model: "gpt-4o-search-preview",
+                web_search_options: {},
+                messages: [{ role: "user", content: query }]
+            })
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI WebSearch API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        let content;
+        if (data.choices && Array.isArray(data.choices)) {
+            const first = data.choices[0];
+            const msg = first?.message;
+            content = String(msg?.content ?? JSON.stringify(data));
+        }
+        else {
+            content = JSON.stringify(data);
+        }
+        return { output: content };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Query",
+        description: "The search query to execute."
+    })
+], WebSearchNode.prototype, "query", void 0);
+// ---------------------------------------------------------------------------
+// 3. Moderation
+// ---------------------------------------------------------------------------
+export class ModerationNode extends BaseNode {
+    static nodeType = "openai.text.Moderation";
+    static title = "Moderation";
+    static description = "Check text content for potential policy violations using OpenAI's moderation API.\n    moderation, safety, content, filter, policy, harmful, toxic\n\n    Uses OpenAI's moderation models to detect potentially harmful content including:\n    - Hate speech\n    - Harassment\n    - Self-harm content\n    - Sexual content\n    - Violence\n    - Graphic violence\n\n    Returns flagged status and category scores for comprehensive content analysis.";
+    static metadataOutputTypes = {
+        flagged: "bool",
+        categories: "dict[str, bool]",
+        category_scores: "dict[str, float]"
+    };
+    static inlineFields = ["input"];
+    static inputFields = [];
+    static requiredSettings = ["OPENAI_API_KEY"];
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const text = this.input;
+        const model = this.model;
+        if (!text)
+            throw new Error("Input text cannot be empty");
+        const res = await fetch(`${OPENAI_API_BASE}/moderations`, {
+            method: "POST",
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({ input: text, model })
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI Moderation API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        const results = data.results;
+        if (results && results.length > 0) {
+            const result = results[0];
+            return {
+                flagged: result.flagged ?? false,
+                categories: result.categories ?? {},
+                category_scores: result.category_scores ?? {}
+            };
+        }
+        return { flagged: false, categories: {}, category_scores: {} };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Input",
+        description: "The text content to check for policy violations."
+    })
+], ModerationNode.prototype, "input", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "omni-moderation-latest",
+        title: "Model",
+        description: "The moderation model to use.",
+        values: [
+            "omni-moderation-latest",
+            "omni-moderation-2024-09-26",
+            "text-moderation-latest",
+            "text-moderation-stable"
+        ]
+    })
+], ModerationNode.prototype, "model", void 0);
+export class CreateImageNode extends BaseNode {
+    static nodeType = "openai.image.CreateImage";
+    static body = "content_card";
+    static title = "Create Image";
+    static inlineFields = [];
+    static inputFields = ["prompt"];
+    static description = "Generates images from textual descriptions.\n    image, t2i, tti, text-to-image, create, generate, picture, photo, art, drawing, illustration";
+    static metadataOutputTypes = {
+        output: "image"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static autoSaveAsset = true;
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const prompt = this.prompt;
+        if (!prompt)
+            throw new Error("Prompt cannot be empty");
+        const model = this.model;
+        const size = this.size;
+        const quality = this.quality;
+        const background = this.background;
+        const res = await fetch(`${OPENAI_API_BASE}/images/generations`, {
+            method: "POST",
+            headers: authHeaders(apiKey),
+            body: JSON.stringify({
+                prompt,
+                model,
+                n: 1,
+                size,
+                quality,
+                background
+            })
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI CreateImage API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        const item = data.data?.[0];
+        if (!item)
+            throw new Error("No image data in response");
+        if (item.b64_json) {
+            return { output: imageRefFromB64(item.b64_json) };
+        }
+        else if (item.url) {
+            return { output: { type: "image", uri: item.url } };
+        }
+        throw new Error("No image data in response");
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "The prompt to use."
+    })
+], CreateImageNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "gpt-image-1",
+        title: "Model",
+        description: "The model to use for image generation.",
+        values: ["gpt-image-1"]
+    })
+], CreateImageNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "1024x1024",
+        title: "Size",
+        description: "The size of the image to generate.",
+        values: ["1024x1024", "1536x1024", "1024x1536"]
+    })
+], CreateImageNode.prototype, "size", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "auto",
+        title: "Background",
+        description: "The background of the image to generate.",
+        values: ["transparent", "opaque", "auto"]
+    })
+], CreateImageNode.prototype, "background", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "high",
+        title: "Quality",
+        description: "The quality of the image to generate.",
+        values: ["high", "medium", "low"]
+    })
+], CreateImageNode.prototype, "quality", void 0);
+export class EditImageNode extends BaseNode {
+    static nodeType = "openai.image.EditImage";
+    static body = "content_card";
+    static title = "Edit Image";
+    static inlineFields = [];
+    static inputFields = ["prompt", "image", "mask"];
+    static description = "Edit images using OpenAI's gpt-image-1 model.\n    image, edit, modify, transform, inpaint, outpaint, variation\n\n    Takes an input image and a text prompt to generate a modified version.\n    Can be used for inpainting, outpainting, style transfer, and image modification.\n    Optionally accepts a mask to specify which areas to edit.";
+    static metadataOutputTypes = {
+        output: "image"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static autoSaveAsset = true;
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const prompt = this.prompt;
+        if (!prompt)
+            throw new Error("Edit prompt cannot be empty");
+        const image = this.image;
+        if (!image || (!image.data && !image.uri)) {
+            throw new Error("Input image is required");
+        }
+        const model = this.model;
+        const size = this.size;
+        const quality = this.quality;
+        // gpt-image-1 always returns base64 and rejects `response_format`, so it
+        // must not be sent (unlike the legacy dall-e-2 edits endpoint).
+        const formData = new FormData();
+        formData.append("prompt", prompt);
+        formData.append("model", model);
+        formData.append("size", size);
+        formData.append("quality", quality);
+        // Convert image ref to blob
+        const imageBlob = await refToBlob(image);
+        formData.append("image", imageBlob, "image.png");
+        // Optional mask
+        const mask = this.mask;
+        if (mask && (mask.data || mask.uri)) {
+            const maskBlob = await refToBlob(mask);
+            formData.append("mask", maskBlob, "mask.png");
+        }
+        const res = await fetch(`${OPENAI_API_BASE}/images/edits`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: formData
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI EditImage API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        const item = data.data?.[0];
+        if (!item)
+            throw new Error("No image data in response");
+        if (item.b64_json) {
+            return { output: imageRefFromB64(item.b64_json) };
+        }
+        else if (item.url) {
+            return { output: { type: "image", uri: item.url } };
+        }
+        throw new Error("No image data in response");
+    }
+}
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Image",
+        description: "The image to edit."
+    })
+], EditImageNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Mask",
+        description: "Optional mask image. White areas will be edited, black areas preserved."
+    })
+], EditImageNode.prototype, "mask", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "The prompt describing the desired edit."
+    })
+], EditImageNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "gpt-image-1",
+        title: "Model",
+        description: "The model to use for image editing.",
+        values: ["gpt-image-1"]
+    })
+], EditImageNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "1024x1024",
+        title: "Size",
+        description: "The size of the output image.",
+        values: ["1024x1024", "1536x1024", "1024x1536"]
+    })
+], EditImageNode.prototype, "size", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "high",
+        title: "Quality",
+        description: "The quality of the generated image.",
+        values: ["high", "medium", "low"]
+    })
+], EditImageNode.prototype, "quality", void 0);
+export class ImageVariationNode extends BaseNode {
+    static nodeType = "openai.image.ImageVariation";
+    static body = "content_card";
+    static title = "Image Variation";
+    static inlineFields = [];
+    static inputFields = ["image"];
+    static description = "Generate variations of an input image using OpenAI's image variations API.\n    image, variation, remix, generate, alternative, dall-e\n\n    Takes a square PNG image and produces a new image that is a variation of it.\n    No text prompt is used — the model riffs on the source image directly.";
+    static metadataOutputTypes = {
+        output: "image"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static autoSaveAsset = true;
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const image = this.image;
+        if (!image || (!image.data && !image.uri)) {
+            throw new Error("Input image is required");
+        }
+        const size = this.size;
+        // The variations endpoint only supports dall-e-2, which requires the
+        // `response_format` to request base64 output.
+        const formData = new FormData();
+        formData.append("model", "dall-e-2");
+        formData.append("n", "1");
+        formData.append("size", size);
+        formData.append("response_format", "b64_json");
+        const imageBlob = await refToBlob(image);
+        formData.append("image", imageBlob, "image.png");
+        const res = await fetch(`${OPENAI_API_BASE}/images/variations`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: formData
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI ImageVariation API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        const item = data.data[0];
+        if (item.b64_json) {
+            return { output: imageRefFromB64(item.b64_json) };
+        }
+        else if (item.url) {
+            return { output: { type: "image", uri: item.url } };
+        }
+        throw new Error("No image data in response");
+    }
+}
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Image",
+        description: "The source image to generate variations from (square PNG)."
+    })
+], ImageVariationNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "1024x1024",
+        title: "Size",
+        description: "The size of the generated image.",
+        values: ["256x256", "512x512", "1024x1024"]
+    })
+], ImageVariationNode.prototype, "size", void 0);
+/**
+ * Build an image ref from raw base64. NodeTool's media refs carry **raw**
+ * base64 in `data` (matching `audioRefFromBytes` and the Gemini nodes); the
+ * asset-saving path (`decodeAssetBytes`) and downstream providers decode the
+ * field directly, so a `data:` prefix would corrupt the bytes.
+ */
+function imageRefFromB64(b64) {
+    return { type: "image", data: b64, content_type: "image/png" };
+}
+/** Build an audio ref from raw base64 with an explicit mime type. */
+function audioRefFromB64(b64, contentType) {
+    return { type: "audio", data: b64, content_type: contentType };
+}
+async function refToBlob(ref) {
+    if (ref.data && isString(ref.data)) {
+        const dataStr = ref.data;
+        // Handle data: URI
+        if (dataStr.startsWith("data:")) {
+            const commaIdx = dataStr.indexOf(",");
+            const b64 = dataStr.slice(commaIdx + 1);
+            const buf = Buffer.from(b64, "base64");
+            return new Blob([buf]);
+        }
+        // Assume raw base64
+        const buf = Buffer.from(dataStr, "base64");
+        return new Blob([buf]);
+    }
+    if (ref.uri && isString(ref.uri)) {
+        // Workflow data — the media-ref egress policy decides.
+        const r = await fetchExternalMedia(ref.uri);
+        return await r.blob();
+    }
+    throw new Error("Cannot convert ref to blob: no data or uri");
+}
+export class TextToSpeechNode extends BaseNode {
+    static nodeType = "openai.audio.TextToSpeech";
+    static body = "content_card";
+    static title = "Text To Speech";
+    static description = "Converts text to speech using OpenAI TTS models.\n    audio, tts, text-to-speech, voice, synthesis";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    static inlineFields = ["input"];
+    static inputFields = [];
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static autoSaveAsset = true;
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const text = this.input;
+        if (!text)
+            throw new Error("Input text cannot be empty");
+        const model = this.model;
+        const voice = this.voice;
+        const speed = this.speed;
+        const instructions = this.instructions;
+        const isMiniTts = model === "gpt-4o-mini-tts";
+        const body = {
+            model,
+            input: text,
+            voice,
+            response_format: "mp3"
+        };
+        // `speed` is supported by tts-1 / tts-1-hd but not gpt-4o-mini-tts, while
+        // `instructions` is the inverse — only honored by gpt-4o-mini-tts. Sending
+        // the wrong one to a model returns a 400.
+        if (isMiniTts) {
+            if (instructions)
+                body.instructions = instructions;
+        }
+        else {
+            body.speed = speed;
+        }
+        const res = await fetch(`${OPENAI_API_BASE}/audio/speech`, {
+            method: "POST",
+            headers: authHeaders(apiKey),
+            body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI TTS API error ${res.status}: ${err}`);
+        }
+        const arrayBuf = await res.arrayBuffer();
+        const b64 = Buffer.from(arrayBuf).toString("base64");
+        return { output: audioRefFromB64(b64, "audio/mpeg") };
+    }
+}
+__decorate([
+    prop({
+        type: "enum",
+        default: "tts-1",
+        title: "Model",
+        values: ["tts-1", "tts-1-hd", "gpt-4o-mini-tts"]
+    })
+], TextToSpeechNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "alloy",
+        title: "Voice",
+        values: [
+            "alloy",
+            "ash",
+            "ballad",
+            "coral",
+            "echo",
+            "fable",
+            "onyx",
+            "nova",
+            "sage",
+            "shimmer",
+            "verse"
+        ]
+    })
+], TextToSpeechNode.prototype, "voice", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Input" })
+], TextToSpeechNode.prototype, "input", void 0);
+__decorate([
+    prop({ type: "float", default: 1, title: "Speed", min: 0.25, max: 4 })
+], TextToSpeechNode.prototype, "speed", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Instructions",
+        description: "Steer the voice's tone, emotion, and delivery (gpt-4o-mini-tts only)."
+    })
+], TextToSpeechNode.prototype, "instructions", void 0);
+export class TranslateNode extends BaseNode {
+    static nodeType = "openai.audio.Translate";
+    static body = "content_card";
+    static title = "Translate";
+    static inlineFields = [];
+    static inputFields = ["audio"];
+    static description = "Translates speech in audio to English text.\n    audio, translation, speech-to-text, localization";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const audio = this.audio;
+        if (!audio || (!audio.data && !audio.uri)) {
+            throw new Error("Audio input is required");
+        }
+        const temperature = this.temperature;
+        const audioBlob = await refToBlob(audio);
+        const formData = new FormData();
+        formData.append("file", audioBlob, "audio.mp3");
+        formData.append("model", "whisper-1");
+        formData.append("temperature", String(temperature));
+        const res = await fetch(`${OPENAI_API_BASE}/audio/translations`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: formData
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI Translate API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        return { output: data.text };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to translate."
+    })
+], TranslateNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Temperature",
+        description: "The temperature to use for the translation."
+    })
+], TranslateNode.prototype, "temperature", void 0);
+export class TranscribeNode extends BaseNode {
+    static nodeType = "openai.audio.Transcribe";
+    static body = "content_card";
+    static title = "Transcribe";
+    static description = "Converts speech to text using OpenAI's speech-to-text API.\n    audio, transcription, speech-to-text, stt, whisper";
+    static metadataOutputTypes = {
+        text: "str",
+        words: "list[audio_chunk]",
+        segments: "list[audio_chunk]"
+    };
+    static inlineFields = [];
+    static inputFields = ["audio", "prompt"];
+    static requiredSettings = ["OPENAI_API_KEY"];
+    async process() {
+        const apiKey = getApiKey(this._secrets);
+        const audio = this.audio;
+        if (!audio || (!audio.data && !audio.uri)) {
+            throw new Error("Audio input is required");
+        }
+        const model = this.model;
+        const language = this.language;
+        const timestamps = this.timestamps;
+        const promptText = this.prompt;
+        const temperature = this.temperature;
+        const isNewModel = model === "gpt-4o-transcribe" || model === "gpt-4o-mini-transcribe";
+        const audioBlob = await refToBlob(audio);
+        const formData = new FormData();
+        formData.append("file", audioBlob, "audio.mp3");
+        formData.append("model", model);
+        formData.append("temperature", String(temperature));
+        if (timestamps) {
+            if (isNewModel) {
+                throw new Error("New transcription models do not support verbose_json timestamps");
+            }
+            formData.append("response_format", "verbose_json");
+            formData.append("timestamp_granularities[]", "segment");
+            formData.append("timestamp_granularities[]", "word");
+        }
+        else {
+            formData.append("response_format", "json");
+        }
+        if (language !== "auto_detect") {
+            formData.append("language", language);
+        }
+        if (promptText) {
+            formData.append("prompt", promptText);
+        }
+        const res = await fetch(`${OPENAI_API_BASE}/audio/transcriptions`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: formData
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`OpenAI Transcribe API error ${res.status}: ${err}`);
+        }
+        const data = (await res.json());
+        const text = String(data.text ?? "");
+        const words = [];
+        const segments = [];
+        if (timestamps && !isNewModel) {
+            const rawSegments = data.segments;
+            if (rawSegments) {
+                for (const seg of rawSegments) {
+                    segments.push({
+                        timestamp: [Number(seg.start), Number(seg.end)],
+                        text: String(seg.text)
+                    });
+                }
+            }
+            const rawWords = data.words;
+            if (rawWords) {
+                for (const w of rawWords) {
+                    words.push({
+                        timestamp: [Number(w.start), Number(w.end)],
+                        text: String(w.word)
+                    });
+                }
+            }
+        }
+        return { text, words, segments };
+    }
+}
+__decorate([
+    prop({
+        type: "enum",
+        default: "whisper-1",
+        title: "Model",
+        description: "The model to use for transcription.",
+        values: ["whisper-1", "gpt-4o-transcribe", "gpt-4o-mini-transcribe"]
+    })
+], TranscribeNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to transcribe (max 25 MB)."
+    })
+], TranscribeNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "auto_detect",
+        title: "Language",
+        description: "The language of the input audio",
+        values: [
+            "auto_detect",
+            "af",
+            "ar",
+            "hy",
+            "az",
+            "be",
+            "bn",
+            "bs",
+            "bg",
+            "ca",
+            "hr",
+            "cs",
+            "da",
+            "nl",
+            "en",
+            "et",
+            "tl",
+            "fi",
+            "fr",
+            "gl",
+            "de",
+            "el",
+            "gu",
+            "he",
+            "hi",
+            "hu",
+            "is",
+            "id",
+            "it",
+            "ja",
+            "kn",
+            "kk",
+            "ko",
+            "lv",
+            "lt",
+            "mk",
+            "ms",
+            "zh",
+            "mi",
+            "mr",
+            "ne",
+            "no",
+            "fa",
+            "pl",
+            "pt",
+            "pa",
+            "ro",
+            "ru",
+            "sr",
+            "sk",
+            "sl",
+            "es",
+            "sw",
+            "sv",
+            "ta",
+            "te",
+            "th",
+            "tr",
+            "uk",
+            "ur",
+            "vi",
+            "cy"
+        ]
+    })
+], TranscribeNode.prototype, "language", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Timestamps",
+        description: "Whether to return timestamps for the generated text."
+    })
+], TranscribeNode.prototype, "timestamps", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "Optional text to guide the model's style or continue a previous audio segment."
+    })
+], TranscribeNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Temperature",
+        description: "The sampling temperature between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.",
+        min: 0,
+        max: 1
+    })
+], TranscribeNode.prototype, "temperature", void 0);
+// ---------------------------------------------------------------------------
+// 9. RealtimeAgent
+// ---------------------------------------------------------------------------
+export class RealtimeAgentNode extends BaseNode {
+    static nodeType = "openai.agents.RealtimeAgent";
+    static body = "content_card";
+    static title = "Realtime Agent";
+    static description = "Realtime conversational agent over OpenAI's WebSocket Realtime API, streaming audio/text in and text/audio responses out at low latency.\n" +
+        "    realtime, streaming, openai, audio-input, text-output, websocket";
+    static metadataOutputTypes = {
+        chunk: "chunk",
+        audio: "audio",
+        text: "str"
+    };
+    static inlineFields = ["system"];
+    static inputFields = ["chunk"];
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static supportsDynamicOutputs = true;
+    static isStreamingInput = true;
+    async process() {
+        return {};
+    }
+    async run(inputs, outputs, context) {
+        let apiKey = "";
+        if (context && isCallable(context.getSecret)) {
+            apiKey = (await context.getSecret("OPENAI_API_KEY")) ?? "";
+        }
+        if (!apiKey)
+            apiKey = process.env.OPENAI_API_KEY ?? "";
+        if (!apiKey)
+            throw new Error("OPENAI_API_KEY is not configured");
+        const model = this.model;
+        const voice = this.voice;
+        const system = this.system;
+        const temperature = this.temperature;
+        const speed = this.speed;
+        const wantAudio = voice !== "none";
+        const { WebSocket } = await import("ws");
+        const wsUrl = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(model)}`;
+        const ws = new WebSocket(wsUrl, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "OpenAI-Beta": "realtime=v1"
+            }
+        });
+        await new Promise((resolve, reject) => {
+            ws.on("open", resolve);
+            ws.on("error", reject);
+        });
+        // Configure session
+        ws.send(JSON.stringify({
+            type: "session.update",
+            session: {
+                modalities: wantAudio ? ["text", "audio"] : ["text"],
+                instructions: system || undefined,
+                voice: wantAudio ? voice : undefined,
+                input_audio_format: "pcm16",
+                output_audio_format: "pcm16",
+                input_audio_transcription: { model: "gpt-4o-mini-transcribe" },
+                turn_detection: {
+                    type: "server_vad",
+                    silence_duration_ms: 200
+                },
+                temperature,
+                speed
+            }
+        }));
+        // Consumer: listen for response events
+        let fullText = "";
+        let consumerDone = false;
+        let resolveResponseDone;
+        const responseDonePromise = new Promise((resolve) => {
+            resolveResponseDone = resolve;
+        });
+        const consumerPromise = new Promise((resolve, reject) => {
+            ws.on("message", async (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    const msgType = String(msg.type ?? "");
+                    if (msgType === "response.text.delta") {
+                        const delta = String(msg.delta ?? "");
+                        if (delta) {
+                            fullText += delta;
+                            await outputs.emit("chunk", {
+                                type: "chunk",
+                                content: delta,
+                                done: false,
+                                content_type: "text"
+                            });
+                        }
+                    }
+                    else if (msgType === "response.audio.delta") {
+                        const audioB64 = String(msg.delta ?? "");
+                        if (audioB64) {
+                            await outputs.emit("chunk", {
+                                type: "chunk",
+                                content: audioB64,
+                                done: false,
+                                content_type: "audio",
+                                content_metadata: {
+                                    format: "pcm16",
+                                    encoding: "pcm16",
+                                    sample_rate: 24000,
+                                    channels: 1
+                                }
+                            });
+                            // Also surface decoded PCM16 on the dedicated `audio` output so
+                            // the declared handle isn't dead. PCM frames concatenate cleanly
+                            // in arrival order downstream.
+                            await outputs.emit("audio", {
+                                data: new Uint8Array(Buffer.from(audioB64, "base64"))
+                            });
+                        }
+                    }
+                    else if (msgType === "response.audio_transcript.delta") {
+                        const delta = String(msg.delta ?? "");
+                        if (delta)
+                            fullText += delta;
+                    }
+                    else if (msgType === "response.done") {
+                        resolveResponseDone();
+                    }
+                    else if (msgType === "error") {
+                        const errMsg = msg.error?.message ??
+                            "Unknown realtime error";
+                        reject(new Error(`OpenAI Realtime error: ${errMsg}`));
+                    }
+                }
+                catch (err) {
+                    if (!consumerDone)
+                        reject(err);
+                }
+            });
+            ws.on("error", (err) => {
+                if (!consumerDone)
+                    reject(err);
+            });
+            ws.on("close", () => {
+                consumerDone = true;
+                resolve();
+            });
+        });
+        // Producer: read streaming input and forward to WebSocket
+        try {
+            for await (const [handle, item] of inputs.any()) {
+                if (handle === "__control__")
+                    continue;
+                const chunk = item;
+                let done = false;
+                if (isString(chunk)) {
+                    // Raw base64 audio
+                    if (chunk && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: "input_audio_buffer.append",
+                            audio: chunk
+                        }));
+                    }
+                    continue;
+                }
+                done = Boolean(chunk.done ?? false);
+                if (done)
+                    break;
+                const contentType = String(chunk.content_type ?? "text");
+                const content = String(chunk.content ?? "");
+                if (!content)
+                    continue;
+                if (contentType === "audio") {
+                    // Audio chunk → append to audio buffer
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: "input_audio_buffer.append",
+                            audio: content
+                        }));
+                    }
+                }
+                else {
+                    // Text chunk → create conversation item and trigger response
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: "conversation.item.create",
+                            item: {
+                                type: "message",
+                                role: "user",
+                                content: [{ type: "input_text", text: content }]
+                            }
+                        }));
+                        ws.send(JSON.stringify({ type: "response.create" }));
+                    }
+                }
+            }
+            // Commit any remaining audio buffer
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "input_audio_buffer.commit" }));
+            }
+            // Wait for response.done with timeout
+            await Promise.race([
+                responseDonePromise,
+                consumerPromise,
+                new Promise((resolve) => setTimeout(resolve, 10000))
+            ]);
+        }
+        finally {
+            if (ws.readyState === WebSocket.OPEN ||
+                ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+            }
+            consumerDone = true;
+        }
+        await consumerPromise;
+        // Emit final done chunks
+        await outputs.emit("chunk", {
+            type: "chunk",
+            content: "",
+            done: true,
+            content_type: "text"
+        });
+        await outputs.emit("text", fullText);
+    }
+}
+__decorate([
+    prop({
+        type: "enum",
+        default: "gpt-4o-mini-realtime-preview",
+        title: "Model",
+        values: ["gpt-4o-realtime-preview", "gpt-4o-mini-realtime-preview"]
+    })
+], RealtimeAgentNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "You are an AI assistant interacting in real-time. " +
+            "Be concise but clear. Prioritize key information first. " +
+            "Ask clarifying questions when needed.",
+        title: "System",
+        description: "System instructions for the realtime session"
+    })
+], RealtimeAgentNode.prototype, "system", void 0);
+__decorate([
+    prop({
+        type: "chunk",
+        default: {
+            type: "chunk",
+            node_id: null,
+            thread_id: null,
+            workflow_id: null,
+            content_type: "text",
+            content: "",
+            content_metadata: {},
+            done: false,
+            thinking: false
+        },
+        title: "Chunk",
+        description: "The audio chunk to use as input."
+    })
+], RealtimeAgentNode.prototype, "chunk", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "alloy",
+        title: "Voice",
+        description: "The voice for the audio output",
+        values: [
+            "none",
+            "ash",
+            "alloy",
+            "ballad",
+            "coral",
+            "echo",
+            "fable",
+            "onyx",
+            "nova",
+            "shimmer",
+            "sage",
+            "verse"
+        ]
+    })
+], RealtimeAgentNode.prototype, "voice", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Speed",
+        description: "The speed of the model’s spoken response",
+        min: 0.25,
+        max: 1.5
+    })
+], RealtimeAgentNode.prototype, "speed", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.8,
+        title: "Temperature",
+        description: "The temperature for the response",
+        min: 0.6,
+        max: 1.2
+    })
+], RealtimeAgentNode.prototype, "temperature", void 0);
+// ---------------------------------------------------------------------------
+// 10. RealtimeTranscription
+// ---------------------------------------------------------------------------
+export class RealtimeTranscriptionNode extends BaseNode {
+    static nodeType = "openai.agents.RealtimeTranscription";
+    static title = "Realtime Transcription";
+    static inlineFields = [];
+    static inputFields = ["chunk"];
+    static description = "Realtime speech-to-text over OpenAI's WebSocket Realtime API, streaming audio chunks in and transcription results out as they arrive.\n" +
+        "    audio, transcription, stt, streaming, realtime, websocket, openai";
+    static metadataOutputTypes = {
+        text: "str",
+        chunk: "chunk"
+    };
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static isStreamingInput = true;
+    async process() {
+        return {};
+    }
+    async run(inputs, outputs, context) {
+        let apiKey = "";
+        if (context && isCallable(context.getSecret)) {
+            apiKey = (await context.getSecret("OPENAI_API_KEY")) ?? "";
+        }
+        if (!apiKey)
+            apiKey = process.env.OPENAI_API_KEY ?? "";
+        if (!apiKey)
+            throw new Error("OPENAI_API_KEY is not configured");
+        const model = this.model;
+        const temperature = this.temperature;
+        const { WebSocket } = await import("ws");
+        const wsUrl = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(model)}`;
+        const ws = new WebSocket(wsUrl, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "OpenAI-Beta": "realtime=v1"
+            }
+        });
+        await new Promise((resolve, reject) => {
+            ws.on("open", resolve);
+            ws.on("error", reject);
+        });
+        // Configure session for transcription only (no audio output)
+        ws.send(JSON.stringify({
+            type: "session.update",
+            session: {
+                modalities: ["text"],
+                instructions: this.system || undefined,
+                input_audio_format: "pcm16",
+                input_audio_transcription: { model: "gpt-4o-mini-transcribe" },
+                turn_detection: {
+                    type: "server_vad",
+                    silence_duration_ms: 500
+                },
+                temperature
+            }
+        }));
+        // Consumer: listen for transcription events
+        let fullText = "";
+        let consumerDone = false;
+        let resolveLastTranscript;
+        const lastTranscriptPromise = new Promise((resolve) => {
+            resolveLastTranscript = resolve;
+        });
+        let finalizeRequested = false;
+        const consumerPromise = new Promise((resolve, reject) => {
+            ws.on("message", async (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    const msgType = String(msg.type ?? "");
+                    if (msgType ===
+                        "conversation.item.input_audio_transcription.completed") {
+                        const text = String(msg.transcript ?? "");
+                        if (text) {
+                            fullText += (fullText ? " " : "") + text;
+                            await outputs.emit("chunk", {
+                                type: "chunk",
+                                content: text,
+                                done: false,
+                                content_type: "text"
+                            });
+                            if (finalizeRequested) {
+                                resolveLastTranscript();
+                            }
+                        }
+                    }
+                    else if (msgType === "response.done") {
+                        if (finalizeRequested) {
+                            resolveLastTranscript();
+                        }
+                    }
+                    else if (msgType === "error") {
+                        const errMsg = msg.error?.message ??
+                            "Unknown realtime error";
+                        reject(new Error(`OpenAI Realtime error: ${errMsg}`));
+                    }
+                }
+                catch (err) {
+                    if (!consumerDone)
+                        reject(err);
+                }
+            });
+            ws.on("error", (err) => {
+                if (!consumerDone)
+                    reject(err);
+            });
+            ws.on("close", () => {
+                consumerDone = true;
+                resolve();
+            });
+        });
+        // Producer: read streaming audio input and forward to WebSocket
+        try {
+            for await (const [handle, item] of inputs.any()) {
+                if (handle === "__control__")
+                    continue;
+                const chunk = item;
+                let audioB64;
+                let done = false;
+                if (isString(chunk)) {
+                    audioB64 = chunk;
+                }
+                else {
+                    if (chunk.content_type && chunk.content_type !== "audio")
+                        continue;
+                    audioB64 = String(chunk.content ?? "");
+                    done = Boolean(chunk.done ?? false);
+                }
+                if (done)
+                    break;
+                if (!audioB64)
+                    continue;
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: "input_audio_buffer.append",
+                        audio: audioB64
+                    }));
+                }
+            }
+            // Commit remaining audio
+            finalizeRequested = true;
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "input_audio_buffer.commit" }));
+            }
+            // Wait for final transcript
+            await Promise.race([
+                lastTranscriptPromise,
+                consumerPromise,
+                new Promise((resolve) => setTimeout(resolve, 5000))
+            ]);
+        }
+        finally {
+            if (ws.readyState === WebSocket.OPEN ||
+                ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+            }
+            consumerDone = true;
+        }
+        await consumerPromise;
+        // Emit final done chunk and full text
+        await outputs.emit("chunk", {
+            type: "chunk",
+            content: "",
+            done: true,
+            content_type: "text"
+        });
+        await outputs.emit("text", fullText);
+    }
+}
+__decorate([
+    prop({
+        type: "enum",
+        default: "gpt-4o-mini-realtime-preview",
+        title: "Model",
+        description: "The realtime model to use.",
+        values: ["gpt-4o-realtime-preview", "gpt-4o-mini-realtime-preview"]
+    })
+], RealtimeTranscriptionNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "chunk",
+        default: {
+            type: "chunk",
+            node_id: null,
+            thread_id: null,
+            workflow_id: null,
+            content_type: "audio",
+            content: "",
+            content_metadata: {},
+            done: false,
+            thinking: false
+        },
+        title: "Chunk",
+        description: "Audio chunk input stream (base64-encoded PCM16 audio)."
+    })
+], RealtimeTranscriptionNode.prototype, "chunk", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "System",
+        description: "System instructions (optional)"
+    })
+], RealtimeTranscriptionNode.prototype, "system", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.8,
+        title: "Temperature",
+        description: "Decoding temperature"
+    })
+], RealtimeTranscriptionNode.prototype, "temperature", void 0);
+// ---------------------------------------------------------------------------
+// 11. LiveAgent (GPT-Live)
+// ---------------------------------------------------------------------------
+export const LIVE_SESSIONS_URL = "wss://api.openai.com/v1/live/sessions";
+const LIVE_SAMPLE_RATE = 24000;
+/** 100 ms of PCM16 mono silence at 24 kHz. */
+const LIVE_SILENCE_FRAME = Buffer.alloc((LIVE_SAMPLE_RATE / 10) * 2).toString("base64");
+const LIVE_SILENCE_INTERVAL_MS = 100;
+/** Quiet time after input ends before the session is closed. */
+const LIVE_IDLE_CLOSE_MS = 3000;
+/** Upper bound on the drain phase after input ends. */
+const LIVE_MAX_DRAIN_MS = 120_000;
+/** The API docs recommend waiting up to 15 s for `session.closed`. */
+const LIVE_CLOSE_TIMEOUT_MS = 15_000;
+const LIVE_RESPONSE_TERMINAL_EVENTS = new Set([
+    "response.completed",
+    "response.failed",
+    "response.incomplete",
+    "response.cancelled"
+]);
+export class LiveAgentNode extends BaseNode {
+    static nodeType = "openai.agents.LiveAgent";
+    static body = "content_card";
+    static title = "Live Agent";
+    static description = "Full-duplex voice agent over OpenAI's GPT-Live WebSocket API. Streams microphone audio in and spoken audio plus transcripts out, delegating lookups and reasoning to a Responses backend model.\n" +
+        "    live, gpt-live, realtime, voice, streaming, openai, audio-input, audio-output, websocket";
+    static metadataOutputTypes = {
+        chunk: "chunk",
+        audio: "audio",
+        text: "str",
+        input_transcript: "str"
+    };
+    static inlineFields = ["instructions"];
+    static inputFields = ["chunk"];
+    static requiredSettings = ["OPENAI_API_KEY"];
+    static isStreamingInput = true;
+    async process() {
+        return {};
+    }
+    async run(inputs, outputs, context) {
+        let apiKey = "";
+        if (context && isCallable(context.getSecret)) {
+            apiKey = (await context.getSecret("OPENAI_API_KEY")) ?? "";
+        }
+        if (!apiKey)
+            apiKey = process.env.OPENAI_API_KEY ?? "";
+        if (!apiKey)
+            throw new Error("OPENAI_API_KEY is not configured");
+        const backendModel = this.backend_model.trim();
+        if (!backendModel) {
+            throw new Error("Backend Model is required for GPT-Live delegation");
+        }
+        const responses = { model: backendModel };
+        if (this.backend_instructions.trim()) {
+            responses.instructions = this.backend_instructions;
+        }
+        if (this.web_search) {
+            responses.tools = [{ type: "web_search" }];
+            responses.tool_choice = "auto";
+        }
+        const { WebSocket } = await import("ws");
+        const ws = new WebSocket(LIVE_SESSIONS_URL, {
+            headers: { Authorization: `Bearer ${apiKey}` }
+        });
+        const send = (event) => {
+            if (ws.readyState === WebSocket.OPEN)
+                ws.send(JSON.stringify(event));
+        };
+        let outputText = "";
+        let inputText = "";
+        const outputAudio = [];
+        let lastActivity;
+        const openDelegations = new Set();
+        let started = false;
+        let finalized = false;
+        let failure = null;
+        let resolveStarted;
+        let resolveEnded;
+        const startedPromise = new Promise((resolve) => {
+            resolveStarted = resolve;
+        });
+        // Settles on session.closed, socket close, or a fatal error.
+        const endedPromise = new Promise((resolve) => {
+            resolveEnded = resolve;
+        });
+        const fail = (err) => {
+            failure ??= err;
+            resolveStarted();
+            resolveEnded();
+        };
+        ws.on("open", () => {
+            send({
+                type: "session.start",
+                event_id: "event_start",
+                session: {
+                    model: this.model,
+                    instructions: this.instructions || undefined,
+                    audio: {
+                        format: { type: "audio/pcm", rate: LIVE_SAMPLE_RATE },
+                        output: { voice: this.voice }
+                    },
+                    delegation: { type: "responses", responses }
+                }
+            });
+        });
+        // Emits run sequentially so chunk order matches arrival order.
+        let emitQueue = Promise.resolve();
+        const enqueueEmit = (fn) => {
+            emitQueue = emitQueue.then(fn).catch((err) => {
+                fail(err instanceof Error ? err : new Error(String(err)));
+            });
+        };
+        ws.on("message", (data) => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            const type = String(msg.type ?? "");
+            if (type === "session.started") {
+                started = true;
+                resolveStarted();
+            }
+            else if (type === "session.output_audio.delta") {
+                const audioB64 = String(msg.delta ?? "");
+                if (!audioB64)
+                    return;
+                lastActivity = Date.now();
+                outputAudio.push(Buffer.from(audioB64, "base64"));
+                enqueueEmit(async () => {
+                    await outputs.emit("chunk", {
+                        type: "chunk",
+                        content: audioB64,
+                        done: false,
+                        content_type: "audio",
+                        content_metadata: {
+                            format: "pcm16le",
+                            encoding: "pcm16le",
+                            sample_rate: LIVE_SAMPLE_RATE,
+                            channels: 1
+                        }
+                    });
+                });
+            }
+            else if (type === "session.output_transcript.delta") {
+                const delta = String(msg.delta ?? "");
+                if (!delta)
+                    return;
+                lastActivity = Date.now();
+                outputText += delta;
+                enqueueEmit(async () => {
+                    await outputs.emit("chunk", {
+                        type: "chunk",
+                        content: delta,
+                        done: false,
+                        content_type: "text"
+                    });
+                });
+            }
+            else if (type === "session.input_transcript.delta") {
+                inputText += String(msg.delta ?? "");
+                lastActivity = Date.now();
+            }
+            else if (type === "session.delegation.created") {
+                const delegation = msg.delegation;
+                if (delegation?.id)
+                    openDelegations.add(String(delegation.id));
+                lastActivity = Date.now();
+            }
+            else if (type === "response.event") {
+                lastActivity = Date.now();
+                const nested = msg.event;
+                if (LIVE_RESPONSE_TERMINAL_EVENTS.has(String(nested?.type ?? ""))) {
+                    openDelegations.delete(String(msg.delegation_id ?? ""));
+                }
+            }
+            else if (type === "session.closed") {
+                finalized = true;
+                resolveEnded();
+            }
+            else if (type === "error") {
+                const error = msg.error;
+                const message = String(error?.message ?? "Unknown GPT-Live error");
+                // Before startup every error is fatal. Afterwards, moderation and
+                // rejected commands are reported without ending the session.
+                if (!started) {
+                    fail(new Error(`OpenAI GPT-Live error: ${message}`));
+                }
+                else {
+                    log.warn(`OpenAI GPT-Live error: ${message}`);
+                }
+            }
+        });
+        ws.on("error", (err) => fail(err));
+        ws.on("close", () => {
+            if (!started) {
+                fail(new Error("GPT-Live connection closed before session.started"));
+            }
+            resolveEnded();
+        });
+        let silenceTimer;
+        try {
+            await startedPromise;
+            if (failure)
+                throw failure;
+            for await (const [handle, item] of inputs.any()) {
+                if (handle === "__control__")
+                    continue;
+                if (failure)
+                    break;
+                if (isString(item)) {
+                    if (item)
+                        send({ type: "session.input_audio.append", audio: item });
+                    continue;
+                }
+                const chunk = item;
+                if (chunk.done)
+                    break;
+                const content = String(chunk.content ?? "");
+                if (!content)
+                    continue;
+                if (String(chunk.content_type ?? "text") === "audio") {
+                    const meta = chunk.content_metadata;
+                    const rate = meta?.sample_rate;
+                    if (rate !== undefined && Number(rate) !== LIVE_SAMPLE_RATE) {
+                        throw new Error(`GPT-Live expects ${LIVE_SAMPLE_RATE} Hz PCM16 audio, got ${String(rate)} Hz`);
+                    }
+                    send({ type: "session.input_audio.append", audio: content });
+                }
+                else {
+                    send({
+                        type: "response.item.create",
+                        item: {
+                            type: "message",
+                            role: "user",
+                            content: [{ type: "input_text", text: content }]
+                        }
+                    });
+                    send({ type: "response.create" });
+                }
+            }
+            if (failure)
+                throw failure;
+            // Input has ended, but the reply may still be in progress. The session
+            // timeline advances with input audio, so keep sending silence until
+            // the model and its delegations go quiet, then close gracefully.
+            lastActivity = Date.now();
+            silenceTimer = setInterval(() => {
+                send({
+                    type: "session.input_audio.append",
+                    audio: LIVE_SILENCE_FRAME
+                });
+            }, LIVE_SILENCE_INTERVAL_MS);
+            const drainStart = Date.now();
+            while (!failure &&
+                ws.readyState === WebSocket.OPEN &&
+                Date.now() - drainStart < LIVE_MAX_DRAIN_MS &&
+                (openDelegations.size > 0 ||
+                    Date.now() - lastActivity < LIVE_IDLE_CLOSE_MS)) {
+                await new Promise((resolve) => setTimeout(resolve, LIVE_SILENCE_INTERVAL_MS));
+            }
+            clearInterval(silenceTimer);
+            silenceTimer = undefined;
+            if (ws.readyState === WebSocket.OPEN) {
+                send({ type: "session.close" });
+                let closeTimer;
+                await Promise.race([
+                    endedPromise,
+                    new Promise((resolve) => {
+                        closeTimer = setTimeout(resolve, LIVE_CLOSE_TIMEOUT_MS);
+                    })
+                ]);
+                clearTimeout(closeTimer);
+                if (!finalized) {
+                    log.warn("GPT-Live session.closed was not received; final usage is unconfirmed");
+                }
+            }
+            await emitQueue;
+            if (failure)
+                throw failure;
+        }
+        finally {
+            if (silenceTimer)
+                clearInterval(silenceTimer);
+            if (ws.readyState === WebSocket.OPEN ||
+                ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+            }
+        }
+        await outputs.emit("chunk", {
+            type: "chunk",
+            content: "",
+            done: true,
+            content_type: "text"
+        });
+        if (outputAudio.length > 0) {
+            const pcm = Buffer.concat(outputAudio);
+            const wav = encodeWav(pcm, LIVE_SAMPLE_RATE, 1, 16);
+            await outputs.emit("audio", {
+                type: "audio",
+                data: Buffer.from(wav).toString("base64"),
+                content_type: "audio/wav"
+            });
+        }
+        await outputs.emit("text", outputText);
+        await outputs.emit("input_transcript", inputText);
+    }
+}
+__decorate([
+    prop({
+        type: "enum",
+        default: "gpt-live-1",
+        title: "Model",
+        values: ["gpt-live-1"]
+    })
+], LiveAgentNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "Be concise. Delegate requests needing current information or lookups to the backend.",
+        title: "Instructions",
+        description: "Conversation instructions for the voice model: style, and when to delegate to the backend"
+    })
+], LiveAgentNode.prototype, "instructions", void 0);
+__decorate([
+    prop({
+        type: "chunk",
+        default: {
+            type: "chunk",
+            node_id: null,
+            thread_id: null,
+            workflow_id: null,
+            content_type: "audio",
+            content: "",
+            content_metadata: {},
+            done: false,
+            thinking: false
+        },
+        title: "Chunk",
+        description: "Streaming input. Audio chunks are base64 mono PCM16 at 24 kHz. Text chunks are queued for the backend as user messages."
+    })
+], LiveAgentNode.prototype, "chunk", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "marin",
+        title: "Voice",
+        description: "The voice for spoken output. Fixed for the session.",
+        values: [
+            "marin",
+            "cedar",
+            "alloy",
+            "ash",
+            "ballad",
+            "coral",
+            "echo",
+            "sage",
+            "shimmer",
+            "verse",
+            "quartz",
+            "ripple",
+            "vesper",
+            "willow",
+            "stone",
+            "gleam",
+            "meridian",
+            "bossa",
+            "tempo",
+            "beacon",
+            "delta",
+            "cinder"
+        ]
+    })
+], LiveAgentNode.prototype, "voice", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "gpt-5.6-luna",
+        title: "Backend Model",
+        description: "Responses model that handles delegated reasoning and tools"
+    })
+], LiveAgentNode.prototype, "backend_model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Backend Instructions",
+        description: "Prompt for the backend model: task rules and how to return results"
+    })
+], LiveAgentNode.prototype, "backend_instructions", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Web Search",
+        description: "Let the backend model search the web"
+    })
+], LiveAgentNode.prototype, "web_search", void 0);
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const OPENAI_NODES = tagAsServer([
+    EmbeddingNode,
+    WebSearchNode,
+    ModerationNode,
+    CreateImageNode,
+    EditImageNode,
+    ImageVariationNode,
+    TextToSpeechNode,
+    TranslateNode,
+    TranscribeNode,
+    RealtimeAgentNode,
+    RealtimeTranscriptionNode,
+    LiveAgentNode
+]);
+//# sourceMappingURL=openai.js.map