@makaio/adapter-openai-node 1.0.0-dev-1779051654000

package/dist/index.mjs

@@ -0,0 +1,1790 @@
+import { AIAdapter, ProceduralConnectorTurn, ScopedToolApprovalSchema, UserMessageQueue, createAdapterNamespace, createToolApprovalHandler, formatContextBlocksAsText, isTextLikeMimeType, mergeScopedToolApproval, normalizeMimeType, resolveConformanceTestPreset, resolveTestConfig, serializeBlockToText, serializeTurnContext } from "@makaio/framework/adapters";
+import OpenAI from "openai";
+import { AgentCompleteEventSchema, AgentStartedEventSchema, BaseStreamAgent, BaseStreamConnector, BaseStreamSession, ErrorEventSchema, MessageCompleteEventSchema, ReasoningCompleteEventSchema, ReasoningDeltaEventSchema, ToolCallsEventSchema, ToolCompletedEventSchema, ToolStartedEventSchema, TurnStateChangedSchema, filterToolsWithSchema, handleToolCalls, loadToolsFromRegistry } from "@makaio/framework/adapters/stream-session";
+import { createAdapterConfigFactory, resolveConnectorCredentials } from "@makaio/framework/adapters/config";
+import { z } from "zod";
+import path from "node:path";
+import { AuthenticationError, ModelUnavailableError, QuotaExceededError, RateLimitError } from "@makaio/framework/core";
+
+//#region src/types/index.ts
+/**
+* OpenAI Node adapter namespace identifier
+*/
+const OPENAI_NODE_NAMESPACE = "adapter:openai-node";
+
+//#endregion
+//#region src/namespaces/schemas/chunk.ts
+/**
+* Schema for tool call deltas within streaming chunks.
+* Matches OpenAI ChatCompletionChunk.Choice.Delta.ToolCall structure.
+*/
+const ToolCallDeltaSchema = z.object({
+	index: z.number(),
+	id: z.string().optional(),
+	type: z.literal("function").optional(),
+	function: z.object({
+		name: z.string().optional(),
+		arguments: z.string().optional()
+	}).optional()
+});
+/**
+* Schema for streaming delta within a choice.
+* Matches OpenAI ChatCompletionChunk.Choice.Delta structure.
+*/
+const DeltaSchema = z.object({
+	content: z.string().nullish(),
+	role: z.enum([
+		"assistant",
+		"user",
+		"system",
+		"tool",
+		"developer"
+	]).optional(),
+	refusal: z.string().nullish(),
+	tool_calls: z.array(ToolCallDeltaSchema).optional()
+});
+/**
+* Schema for a single choice in a streaming chunk.
+* Matches OpenAI ChatCompletionChunk.Choice structure.
+*/
+const ChoiceSchema = z.object({
+	delta: DeltaSchema,
+	index: z.number(),
+	finish_reason: z.enum([
+		"stop",
+		"length",
+		"tool_calls",
+		"content_filter",
+		"function_call"
+	]).nullable(),
+	logprobs: z.unknown().nullish()
+});
+/**
+* Schema for streaming chunk event.
+* Based on OpenAI ChatCompletionChunk structure.
+* @see https://platform.openai.com/docs/api-reference/chat/streaming
+*/
+const ChunkEventSchema = z.object({
+	eventType: z.literal("chunk"),
+	/** Unique identifier for the chat completion */
+	id: z.string(),
+	/** Array of choices (typically one for streaming) */
+	choices: z.array(ChoiceSchema),
+	/** Unix timestamp when the chunk was created */
+	created: z.number(),
+	/** Model that generated the chunk */
+	model: z.string(),
+	/** Object type identifier */
+	object: z.literal("chat.completion.chunk"),
+	/** Service tier used for processing */
+	service_tier: z.enum([
+		"auto",
+		"default",
+		"flex",
+		"scale",
+		"priority"
+	]).nullish(),
+	/** System fingerprint for determinism tracking */
+	system_fingerprint: z.string().optional()
+});
+
+//#endregion
+//#region src/namespaces/schemas/usage.ts
+/**
+* Schema for completion tokens breakdown.
+* Matches OpenAI CompletionUsage.CompletionTokensDetails structure.
+*/
+const CompletionTokensDetailsSchema = z.object({
+	/** Tokens from predicted outputs that appeared in completion */
+	accepted_prediction_tokens: z.number().optional(),
+	/** Audio tokens generated by the model */
+	audio_tokens: z.number().optional(),
+	/** Tokens generated for reasoning */
+	reasoning_tokens: z.number().optional(),
+	/** Tokens from predicted outputs that did not appear */
+	rejected_prediction_tokens: z.number().optional()
+});
+/**
+* Schema for prompt tokens breakdown.
+* Matches OpenAI CompletionUsage.PromptTokensDetails structure.
+*/
+const PromptTokensDetailsSchema = z.object({
+	/** Audio tokens in the prompt */
+	audio_tokens: z.number().optional(),
+	/** Tokens read from cache */
+	cached_tokens: z.number().optional()
+});
+/**
+* Schema for token usage event.
+* Based on OpenAI CompletionUsage structure with additional cache fields.
+* @see https://platform.openai.com/docs/api-reference/chat/object#chat/object-usage
+*/
+const UsageEventSchema = z.object({
+	eventType: z.literal("usage"),
+	/** Number of tokens in the prompt */
+	prompt_tokens: z.number(),
+	/** Number of tokens in the generated completion */
+	completion_tokens: z.number(),
+	/** Total tokens used (prompt + completion) */
+	total_tokens: z.number(),
+	/** Breakdown of prompt tokens */
+	prompt_tokens_details: PromptTokensDetailsSchema.optional(),
+	/** Breakdown of completion tokens */
+	completion_tokens_details: CompletionTokensDetailsSchema.optional()
+});
+
+//#endregion
+//#region src/namespaces/schemas/message.ts
+/**
+* Schema for message complete event.
+* Emitted when a full assistant message has been assembled from streaming chunks.
+* Extends the base schema with OpenAI-specific `finish_reason` values.
+*/
+const MessageCompleteEventSchema$1 = MessageCompleteEventSchema.extend({ 
+/** Why generation stopped (OpenAI-specific values). */
+finish_reason: z.enum([
+	"stop",
+	"length",
+	"tool_calls",
+	"content_filter",
+	"function_call"
+]).nullable() });
+
+//#endregion
+//#region src/namespaces/index.ts
+/**
+* Discriminated union of all SDK event types.
+* Uses discriminatedUnion for type-safe event routing based on eventType.
+*/
+const SdkEventMessageSchema = z.discriminatedUnion("eventType", [
+	ChunkEventSchema,
+	UsageEventSchema,
+	ToolCallsEventSchema,
+	MessageCompleteEventSchema$1,
+	ReasoningDeltaEventSchema,
+	ReasoningCompleteEventSchema,
+	AgentStartedEventSchema,
+	AgentCompleteEventSchema,
+	ErrorEventSchema,
+	ToolStartedEventSchema,
+	ToolCompletedEventSchema
+]);
+/**
+* Envelope schema for sdk.event catch-all subject.
+* Wraps the discriminated union in an envelope for proper TypeScript narrowing at emit time.
+* Pattern matches codex-mcp's \{ id, msg \} envelope.
+*/
+const SdkEventSchema = z.object({
+	event: SdkEventMessageSchema,
+	adapterName: z.string().optional(),
+	agentId: z.string().optional(),
+	adapterId: z.string().optional(),
+	adapterSessionId: z.string().optional(),
+	sessionId: z.string().optional()
+});
+/**
+* Schema for raw OpenAI streaming chunks.
+* Passthrough schema for observability - captures raw API response.
+* Used by stream-bridge to emit unprocessed chunks before normalization.
+*/
+const RawChunkSchema = z.custom(() => true);
+/**
+* OpenAI Node Adapter Namespace with semantic subjects.
+*
+* Provides typed subjects for:
+* - sdk.event: Catch-all for raw SDK events (for observability/debugging)
+* - tool_approval: RPC for tool execution approval
+* - Semantic subjects: Individual typed events for agent layer processing
+*/
+const OpenAINodeConnectorNamespace = createAdapterNamespace(OPENAI_NODE_NAMESPACE, {
+	"sdk.raw": RawChunkSchema,
+	"sdk.event": SdkEventSchema,
+	tool_approval: ScopedToolApprovalSchema,
+	chunk: ChunkEventSchema,
+	usage: UsageEventSchema,
+	message_complete: MessageCompleteEventSchema$1,
+	reasoning_delta: ReasoningDeltaEventSchema,
+	reasoning_complete: ReasoningCompleteEventSchema,
+	tool_calls: ToolCallsEventSchema,
+	tool_started: ToolStartedEventSchema,
+	tool_completed: ToolCompletedEventSchema,
+	agent_started: AgentStartedEventSchema,
+	agent_complete: AgentCompleteEventSchema,
+	error: ErrorEventSchema,
+	"turn.state_changed": TurnStateChangedSchema,
+	"turn.turn_started": TurnStateChangedSchema,
+	"turn.step_started": TurnStateChangedSchema,
+	"turn.step_finished": TurnStateChangedSchema,
+	"turn.turn_finished": TurnStateChangedSchema
+});
+/**
+* Typed subject literals for OpenAI Node adapter.
+* Use these constants to subscribe to specific message types with full type safety.
+* @example
+* ```typescript
+* connector.on(OpenAINodeSubjects.chunk, (ctx) => {
+*   // ctx.payload is typed as ChunkEvent
+*   console.debug(ctx.payload.choices[0].delta.content);
+* });
+* ```
+*/
+const OpenAINodeConnectorSubjects = OpenAINodeConnectorNamespace.subjects;
+
+//#endregion
+//#region src/tool-handling.ts
+const ADAPTER_LABEL = "OpenAINodeAgent";
+/**
+* Register tool approval handler on scoped connector.
+*
+* Wires OpenAINodeConnectorSubjects.tool_approval → AgentSubjects.toolApprove.
+* Used by agent.ts wireToolApprovalRpc() for consistent approval flow.
+*
+* The handler receives `AgentToolApproveRequest` from the connector (already
+* transformed via toGlobalToolApproval), enriches with context if needed,
+* and forwards to global MakaioBus.
+* @param connector - OpenAI Node connector (needs only `on` method)
+* @param context - Adapter context for request enrichment (static or lazy callback)
+* @returns Unsubscribe function
+*/
+const registerToolApprovalHandler = createToolApprovalHandler(OpenAINodeConnectorSubjects.tool_approval, (payload, context) => mergeScopedToolApproval(payload, context, "openai-node"), (response) => response);
+/**
+* Convert ToolListItem[] to OpenAI ChatCompletionTool[] format.
+*
+* Filters to only tools with inputSchema (required for OpenAI function calling).
+* Maps name, description, and parameters to OpenAI's expected structure.
+* @param tools - Tools from ToolRegistry
+* @returns OpenAI-formatted tools
+*/
+function toOpenAIToolFormat(tools) {
+	return filterToolsWithSchema(tools).map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema
+		}
+	}));
+}
+/**
+* Convenience: Load tools and convert to OpenAI format in one call.
+* @param adapterId - Adapter instance ID
+* @param adapterName - Adapter type name
+* @returns OpenAI-formatted tools ready for chat completions
+*/
+async function fetchToolsForOpenAI(adapterId, adapterName) {
+	return toOpenAIToolFormat(await loadToolsFromRegistry(adapterId, adapterName));
+}
+/**
+* Process tool calls: request approval, execute, and add results to messages.
+*
+* Tool call arguments are already normalized by stream-bridge
+* (GLM \{\} fix, DeepSeek XML extraction).
+* @param toolCalls - Array of tool calls from the model response (normalized)
+* @param callbacks - Injected callbacks for event emission, approval requests, and optional ledger recording
+* @param contextOverrides - Execution context (cwd, env, sessionId, agentId, turnId)
+* @returns Tool result messages to append to conversation history
+*/
+async function handleToolCalls$1(toolCalls, callbacks, contextOverrides) {
+	return handleToolCalls(toolCalls, callbacks, contextOverrides, (toolCallId, content, _isError) => ({
+		role: "tool",
+		tool_call_id: toolCallId,
+		content
+	}), ADAPTER_LABEL);
+}
+
+//#endregion
+//#region src/utils/blockToContentPart.ts
+/** Minimal extension→MIME map used when attachments omit explicit MIME type metadata. */
+const ATTACHMENT_EXTENSION_MIME = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".pdf": "application/pdf",
+	".txt": "text/plain",
+	".md": "text/markdown",
+	".json": "application/json",
+	".xml": "application/xml",
+	".yaml": "application/x-yaml",
+	".yml": "application/x-yaml",
+	".csv": "text/csv",
+	".ts": "application/typescript",
+	".tsx": "application/typescript",
+	".js": "application/javascript",
+	".jsx": "application/javascript",
+	".mjs": "application/javascript",
+	".cjs": "application/javascript"
+};
+/**
+* Build a data URI string for inline base64 content.
+* @param mimeType - The MIME type of the content.
+* @param data - The base64-encoded data string.
+* @returns A `data:{mimeType};base64,{data}` URI string.
+*/
+function buildDataUri(mimeType, data) {
+	return `data:${mimeType};base64,${data}`;
+}
+/**
+* Infer MIME type from attachment filename when source metadata is absent.
+* @param fileName - Attachment file name.
+* @returns Inferred MIME type, or undefined when extension is unknown.
+*/
+function inferMimeTypeFromFileName(fileName) {
+	if (!fileName) return void 0;
+	const ext = path.extname(fileName).toLowerCase();
+	if (!ext) return void 0;
+	return ATTACHMENT_EXTENSION_MIME[ext];
+}
+/**
+* Convert a {@link MessageBlock} to an OpenAI {@link ChatCompletionContentPart}.
+*
+* Mapping rules:
+* - `text` → `{ type: 'text', text: block.content }`
+* - `image` (base64) → `{ type: 'image_url', image_url: { url: 'data:{mimeType};base64,{data}' } }`
+* - `image` (url) → `{ type: 'image_url', image_url: { url: block.source.url } }`
+* - `document` (base64) → `{ type: 'file', file: { file_data: 'data:{mimeType};base64,{data}', filename: 'document' } }`
+* - `attachment` with image MIME → `{ type: 'image_url', ... }`
+* - `attachment` with PDF MIME → `{ type: 'file', file: { file_data: ..., filename } }`
+* - `attachment` with text-like MIME (base64) → decoded UTF-8 as `{ type: 'text', text }`
+* - All other blocks → `{ type: 'text', text: serializeBlockToText(block) }`
+* @param block - The message block to convert.
+* @returns A `ChatCompletionContentPart` suitable for the OpenAI messages API.
+*/
+function blockToContentPart(block) {
+	switch (block.type) {
+		case "text": return {
+			type: "text",
+			text: block.content
+		};
+		case "image":
+			if (block.source.type === "base64") return {
+				type: "image_url",
+				image_url: { url: buildDataUri(block.source.mimeType ?? "image/png", block.source.data) }
+			};
+			return {
+				type: "image_url",
+				image_url: { url: block.source.url }
+			};
+		case "document":
+			if (block.source.type === "base64") return {
+				type: "file",
+				file: {
+					file_data: buildDataUri(block.source.mimeType ?? "application/pdf", block.source.data),
+					filename: "document"
+				}
+			};
+			return {
+				type: "text",
+				text: serializeBlockToText(block)
+			};
+		case "attachment": {
+			const { source, fileName } = block;
+			if (source.type === "base64") {
+				const normalizedMimeType = normalizeMimeType(source.mimeType ?? inferMimeTypeFromFileName(fileName));
+				if (normalizedMimeType.startsWith("image/")) return {
+					type: "image_url",
+					image_url: { url: buildDataUri(normalizedMimeType, source.data) }
+				};
+				if (normalizedMimeType === "application/pdf") return {
+					type: "file",
+					file: {
+						file_data: buildDataUri(normalizedMimeType, source.data),
+						filename: fileName
+					}
+				};
+				if (isTextLikeMimeType(normalizedMimeType)) {
+					let decodedText;
+					try {
+						decodedText = Buffer.from(source.data, "base64").toString("utf-8");
+					} catch {
+						decodedText = "";
+					}
+					return {
+						type: "text",
+						text: decodedText
+					};
+				}
+				return {
+					type: "text",
+					text: serializeBlockToText(block)
+				};
+			}
+			return {
+				type: "text",
+				text: serializeBlockToText(block)
+			};
+		}
+		default: return {
+			type: "text",
+			text: serializeBlockToText(block)
+		};
+	}
+}
+/**
+* Convert an array of {@link MessageBlock}s to `ChatCompletionContentPart[]`,
+* filtering out parts that produce empty text.
+* @param blocks - The blocks to convert.
+* @returns A non-empty array of content parts, or an empty array if all parts are empty.
+*/
+function blocksToContentParts(blocks) {
+	return blocks.map(blockToContentPart).filter((part) => {
+		if (part.type === "text") return part.text.length > 0;
+		return true;
+	});
+}
+
+//#endregion
+//#region src/turn.ts
+/**
+* Turn state machine for OpenAI SDK.
+*
+* Tracks state transitions for a single user message.
+* Unlike Claude, OpenAI has no true pause/resume - we abort and restart.
+*
+* State flow:
+* idle to turn_started to step_started to step_finished to turn_finished
+*
+* On immediate: abort current turn, merge content, start new turn.
+*/
+var OpenAIConnectorTurn = class extends ProceduralConnectorTurn {
+	abortController;
+	constructor(bus, adapterId, adapterName, agentId, messageHandle) {
+		super({
+			bus,
+			adapterId,
+			adapterName,
+			agentId,
+			messageHandle,
+			turnSubjects: OpenAINodeConnectorSubjects.turn
+		}, "idle");
+		this.abortController = new AbortController();
+	}
+	/**
+	* Get the AbortSignal for this turn.
+	* Pass to OpenAI client for cancellation.
+	* @returns The abort signal for this turn
+	*/
+	getAbortSignal() {
+		return this.abortController.signal;
+	}
+	/**
+	* Pause (abort) at next opportunity.
+	* OpenAI doesn't support true pause - we abort and caller restarts with
+	* merged content.
+	* @returns Pause result indicating turn state
+	*/
+	async pause() {
+		const result = await super.pause();
+		if (!result.turnEnded) this.abortController.abort();
+		return result;
+	}
+};
+
+//#endregion
+//#region src/stream-bridge.ts
+/**
+* Convert accumulators to complete tool calls.
+* @param accumulators - Tool call accumulators to convert
+* @returns Complete tool call objects
+*/
+function buildToolCalls(accumulators) {
+	return accumulators.map((acc) => ({
+		id: acc.id,
+		type: "function",
+		function: {
+			name: acc.name,
+			arguments: acc.arguments
+		}
+	}));
+}
+/**
+* Update tool call accumulator with delta data.
+* @param accumulators - Array of tool call accumulators
+* @param delta - Delta data from streaming chunk
+*/
+function updateToolCallAccumulator(accumulators, delta) {
+	const index = delta.index;
+	if (!accumulators[index]) accumulators[index] = {
+		id: delta.id ?? "",
+		name: delta.function?.name ?? "",
+		arguments: ""
+	};
+	const accumulator = accumulators[index];
+	if (delta.id) accumulator.id = delta.id;
+	if (delta.function?.name) accumulator.name = delta.function.name;
+	if (delta.function?.arguments) {
+		const current = accumulator.arguments;
+		const incoming = delta.function.arguments;
+		if (current.endsWith("}") && incoming.startsWith("{") && incoming !== "{}") accumulator.arguments = incoming;
+		else accumulator.arguments += incoming;
+	}
+}
+/**
+* Parse DeepSeek-style XML tool calls from content.
+* Format: `<function_calls><invoke name="..."><parameter name="..." string="true">value</parameter></invoke></function_calls>`
+* @param content - Raw content potentially containing XML tool calls
+* @returns Parsed tool calls or empty array if parsing fails
+*/
+function parseXmlToolCalls(content) {
+	const toolCalls = [];
+	const functionCallsMatch = content.match(/<function_calls>([\s\S]*?)<\/function_calls>/);
+	if (!functionCallsMatch) return [];
+	const functionCallsContent = functionCallsMatch[1];
+	const invokeRegex = /<invoke\s+name="([^"]+)">([\s\S]*?)<\/invoke>/g;
+	let invokeMatch;
+	let callIndex = 0;
+	while ((invokeMatch = invokeRegex.exec(functionCallsContent)) !== null) {
+		const functionName = invokeMatch[1];
+		const invokeContent = invokeMatch[2];
+		const params = {};
+		const paramRegex = /<parameter\s+name="([^"]+)"(?:\s+string="true")?>([^<]*)<\/parameter>/g;
+		let paramMatch;
+		while ((paramMatch = paramRegex.exec(invokeContent)) !== null) {
+			const paramName = paramMatch[1];
+			params[paramName] = paramMatch[2];
+		}
+		toolCalls.push({
+			id: `xml_call_${callIndex++}`,
+			type: "function",
+			function: {
+				name: functionName,
+				arguments: JSON.stringify(params)
+			}
+		});
+	}
+	return toolCalls;
+}
+/**
+* Parse GLM-4.5-Air-style XML tool calls from content.
+* Format: `<tool_call>function_name\n<arg_key>key</arg_key>\n<arg_value>value</arg_value>\n</tool_call>`
+* @param content - Raw content potentially containing XML tool calls
+* @returns Parsed tool calls or empty array if parsing fails
+*/
+function parseGlmAirXml(content) {
+	const toolCalls = [];
+	const toolCallRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+	let toolCallMatch;
+	let callIndex = 0;
+	while ((toolCallMatch = toolCallRegex.exec(content)) !== null) {
+		const toolCallContent = toolCallMatch[1];
+		const functionName = toolCallContent.trim().split("\n")[0]?.trim();
+		if (!functionName) continue;
+		const params = {};
+		const keys = Array.from(toolCallContent.matchAll(/<arg_key>([^<]*)<\/arg_key>/g), (m) => m[1]);
+		const values = Array.from(toolCallContent.matchAll(/<arg_value>([^<]*)<\/arg_value>/g), (m) => m[1]);
+		for (let i = 0; i < Math.min(keys.length, values.length); i++) params[keys[i]] = values[i];
+		toolCalls.push({
+			id: `glm_air_call_${callIndex++}`,
+			type: "function",
+			function: {
+				name: functionName,
+				arguments: JSON.stringify(params)
+			}
+		});
+	}
+	return toolCalls;
+}
+/**
+* Create initial stream processing state.
+* @returns Fresh state object
+*/
+function createStreamState() {
+	return {
+		content: "",
+		reasoning: "",
+		finishReason: null,
+		usage: null,
+		toolCallAccumulators: []
+	};
+}
+/**
+* Extract usage from chunk if present.
+* @param chunk - Chunk to extract usage from
+* @returns Usage object or null
+*/
+function extractUsage(chunk) {
+	if (!chunk.usage) return null;
+	return {
+		promptTokens: chunk.usage.prompt_tokens,
+		completionTokens: chunk.usage.completion_tokens
+	};
+}
+/**
+* Apply model-agnostic normalizations to tool calls and content.
+* Detects quirks by content patterns, not model names.
+* @param content - Raw content from stream
+* @param reasoning - Reasoning content from stream (e.g., from reasoning_delta events)
+* @param toolCalls - Aggregated tool calls from stream
+* @param finishReason - Finish reason from stream
+* @returns Normalized result with cleaned content, reasoning, and tool calls
+*/
+function normalizeResult(content, reasoning, toolCalls, finishReason) {
+	let normalizedContent = content;
+	let normalizedReasoning = reasoning;
+	let normalizedToolCalls = toolCalls;
+	let normalizedFinishReason = finishReason;
+	const thinkMatch = normalizedContent.match(/^<think(?:ing)?>([\s\S]*?)<\/think(?:ing)?>\s*/);
+	if (thinkMatch) {
+		const extractedReasoning = thinkMatch[1].trim();
+		normalizedContent = normalizedContent.slice(thinkMatch[0].length).trim();
+		normalizedReasoning = normalizedReasoning ? `${extractedReasoning}\n\n${normalizedReasoning}` : extractedReasoning;
+	}
+	normalizedToolCalls = normalizedToolCalls.map((tc) => {
+		if (/\}\s*\{\s*\}$/.test(tc.function.arguments)) return {
+			...tc,
+			function: {
+				...tc.function,
+				arguments: tc.function.arguments.replace(/\}\s*\{\s*\}$/, "}")
+			}
+		};
+		return tc;
+	});
+	if (normalizedContent.includes("<function_calls>") && normalizedFinishReason === "stop" && normalizedToolCalls.length === 0) {
+		const parsed = parseXmlToolCalls(normalizedContent);
+		if (parsed.length > 0) {
+			normalizedToolCalls = parsed;
+			normalizedFinishReason = "tool_calls";
+			normalizedContent = normalizedContent.replace(/<function_calls>[\s\S]*<\/function_calls>/, "").trim();
+		}
+	}
+	if (normalizedFinishReason === "tool_calls" && normalizedToolCalls.length > 0 && normalizedToolCalls.every((tc) => tc.function.arguments === "{}") && normalizedContent.includes("<tool_call>")) {
+		const parsed = parseGlmAirXml(normalizedContent);
+		if (parsed.length > 0) {
+			normalizedToolCalls = parsed;
+			normalizedContent = normalizedContent.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").trim();
+		}
+	}
+	return {
+		content: normalizedContent,
+		reasoning: normalizedReasoning,
+		toolCalls: normalizedToolCalls,
+		finishReason: normalizedFinishReason
+	};
+}
+/**
+* Process a choice delta and accumulate state.
+* @param choice - Stream choice containing delta
+* @param chunk - Full chunk for usage extraction
+* @param state - Mutable aggregation state
+* @param emitEvent - Event emitter function
+*/
+async function processChoiceDelta(choice, chunk, state, emitEvent) {
+	const delta = choice.delta;
+	if (choice.finish_reason !== null) state.finishReason = choice.finish_reason;
+	if (delta.content) state.content += delta.content;
+	const reasoningDelta = delta.reasoning || delta.reasoning_content;
+	if (reasoningDelta) {
+		state.reasoning += reasoningDelta;
+		await emitEvent({
+			eventType: "reasoning_delta",
+			content: reasoningDelta
+		});
+	}
+	if (delta.tool_calls) for (const toolCallDelta of delta.tool_calls) updateToolCallAccumulator(state.toolCallAccumulators, toolCallDelta);
+	if (chunk.usage && !state.usage) {
+		state.usage = extractUsage(chunk);
+		if (state.usage) await emitEvent({
+			eventType: "usage",
+			prompt_tokens: state.usage.promptTokens,
+			completion_tokens: state.usage.completionTokens,
+			total_tokens: state.usage.promptTokens + state.usage.completionTokens
+		});
+	}
+}
+/**
+* Emit final events after stream completes.
+* @param state - Final aggregation state
+* @param emitEvent - Event emitter function
+*/
+async function emitFinalEvents(state, emitEvent) {
+	const rawToolCalls = buildToolCalls(state.toolCallAccumulators);
+	const normalized = normalizeResult(state.content, state.reasoning, rawToolCalls, state.finishReason);
+	if (normalized.toolCalls.length > 0) await emitEvent({
+		eventType: "tool_calls",
+		toolCalls: normalized.toolCalls
+	});
+	await emitEvent({
+		eventType: "message_complete",
+		content: normalized.content || null,
+		reasoning: normalized.reasoning || void 0,
+		tool_calls: normalized.toolCalls.length > 0 ? normalized.toolCalls : void 0,
+		finish_reason: normalized.finishReason
+	});
+	if (normalized.reasoning) await emitEvent({
+		eventType: "reasoning_complete",
+		content: normalized.reasoning
+	});
+}
+/**
+* Process an OpenAI streaming response.
+*
+* Emits events to bus as stream progresses:
+* - sdk.raw: Each raw chunk (for observability)
+* - sdk.event: Semantic events (chunk, reasoning_delta, usage, tool_calls, message_complete)
+*
+* Applies normalizations before emitting final events:
+* - GLM: Strips trailing `\{\}` from tool call arguments
+* - DeepSeek: Extracts XML tool calls from content
+* @param stream - OpenAI streaming response
+* @param config - Bus and metadata configuration
+*/
+async function processStream(stream, config) {
+	const state = createStreamState();
+	const metadata = {
+		adapterName: config.adapterName,
+		agentId: config.agentId,
+		adapterId: config.adapterId,
+		...config.adapterSessionId ? { adapterSessionId: config.adapterSessionId } : {}
+	};
+	const emitRaw = async (chunk) => {
+		await config.bus.emit(OpenAINodeConnectorSubjects.sdk.raw, {
+			...chunk,
+			...metadata
+		});
+	};
+	const emitEvent = async (event) => {
+		await config.bus.emit(OpenAINodeConnectorSubjects.sdk.event, {
+			event,
+			...metadata
+		});
+	};
+	for await (const chunk of stream) {
+		config.logLowLevelEvent?.(chunk);
+		await emitRaw(chunk);
+		const choice = chunk.choices[0];
+		if (!choice) {
+			const usage = extractUsage(chunk);
+			if (usage && !state.usage) {
+				state.usage = usage;
+				await emitEvent({
+					eventType: "usage",
+					prompt_tokens: usage.promptTokens,
+					completion_tokens: usage.completionTokens,
+					total_tokens: usage.promptTokens + usage.completionTokens
+				});
+			}
+			continue;
+		}
+		await processChoiceDelta(choice, chunk, state, emitEvent);
+	}
+	await emitFinalEvents(state, emitEvent);
+}
+
+//#endregion
+//#region src/utils/convertMessageHistory.ts
+/**
+* Convert curated message history to OpenAI ChatCompletionMessageParam[].
+*
+* Transforms the shared Message format (with blocks) into OpenAI's expected format:
+* - Text/reasoning blocks become assistant message content
+* - tool_call blocks become `tool_calls` on assistant messages
+* - tool_output blocks become separate `role: 'tool'` messages
+* - Media blocks (image, document, attachment) are skipped for assistant messages
+* - User message blocks are converted to native content parts (image_url, file, text)
+* - System message blocks are serialized to text (OpenAI system messages only accept strings)
+* @param history - Curated messages from sessionContext.messageHistory
+* @returns Array of OpenAI ChatCompletionMessageParam
+*/
+function convertMessageHistory(history) {
+	const result = [];
+	for (const msg of history) {
+		const blocks = Array.isArray(msg.blocks) ? msg.blocks : [msg.blocks];
+		if (msg.role === "assistant") {
+			const textParts = [];
+			const toolCalls = [];
+			const toolOutputs = [];
+			for (const block of blocks) switch (block.type) {
+				case "text":
+					textParts.push(serializeBlockToText(block));
+					break;
+				case "reasoning":
+					textParts.push(serializeBlockToText(block));
+					break;
+				case "tool_call":
+					toolCalls.push({
+						id: block.toolCallId,
+						type: "function",
+						function: {
+							name: block.name,
+							arguments: JSON.stringify(block.args)
+						}
+					});
+					break;
+				case "tool_output":
+					toolOutputs.push({
+						toolCallId: block.toolCallId,
+						content: block.output,
+						isError: block.isError
+					});
+					break;
+			}
+			const validToolCallIds = new Set(toolCalls.map((call) => call.id));
+			const matchedToolOutputs = toolOutputs.filter((output) => validToolCallIds.has(output.toolCallId));
+			const orphanToolOutputs = toolOutputs.filter((output) => !validToolCallIds.has(output.toolCallId));
+			for (const orphanOutput of orphanToolOutputs) textParts.push(serializeBlockToText({
+				type: "tool_output",
+				toolCallId: orphanOutput.toolCallId,
+				output: orphanOutput.content,
+				isError: orphanOutput.isError
+			}));
+			const assistantContent = textParts.join("\n");
+			if (assistantContent.length > 0 || toolCalls.length > 0) {
+				const assistantMsg = {
+					role: "assistant",
+					content: assistantContent.length > 0 ? assistantContent : null
+				};
+				if (toolCalls.length > 0) assistantMsg.tool_calls = toolCalls;
+				result.push(assistantMsg);
+			}
+			for (const output of matchedToolOutputs) result.push({
+				role: "tool",
+				tool_call_id: output.toolCallId,
+				content: output.isError ? `[Tool Error]\n${output.content}` : output.content
+			});
+		} else if (msg.role === "system") {
+			const content = blocks.map(serializeBlockToText).join("\n");
+			if (content.length > 0) result.push({
+				role: "system",
+				content
+			});
+		} else {
+			const parts = blocksToContentParts(blocks);
+			if (parts.length > 0) {
+				const content = parts.every((p) => p.type === "text") ? parts.map((p) => p.text).join("\n") : parts;
+				result.push({
+					role: "user",
+					content
+				});
+			}
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/classifyOpenAIError.ts
+/**
+* Classify error from OpenAI SDK into appropriate MakaioError subclass.
+* OpenAI SDK throws typed APIError with status codes and error types.
+* @param error - Error from OpenAI SDK
+* @returns MakaioError subclass instance or the original error
+*/
+function classifyOpenAIError(error) {
+	if (!(error instanceof Error)) return new Error(String(error));
+	const errorWithProps = error;
+	const status = errorWithProps.status;
+	const message = error.message;
+	const messageLower = message.toLowerCase();
+	if (status === 401 || status === 403) return new AuthenticationError(message);
+	if (status === 404 && (messageLower.includes("model") || errorWithProps.code === "model_not_found")) return new ModelUnavailableError(message);
+	if (status === 429) {
+		if (messageLower.includes("quota") || messageLower.includes("insufficient_quota") || errorWithProps.code === "insufficient_quota") return new QuotaExceededError(message);
+		return new RateLimitError(message);
+	}
+	if (errorWithProps.type === "insufficient_quota" || messageLower.includes("quota exceeded")) return new QuotaExceededError(message);
+	if (messageLower.includes("rate limit") || errorWithProps.code === "rate_limit_exceeded") return new RateLimitError(message);
+	if (messageLower.includes("authentication") || messageLower.includes("unauthorized") || errorWithProps.code === "invalid_api_key") return new AuthenticationError(message);
+	return error;
+}
+
+//#endregion
+//#region src/utils/buildChatCompletionRequest.ts
+/**
+* Map normalized reasoning level to OpenAI `reasoning_effort`.
+* @param reasoningEffort - Makaio reasoning effort
+* @returns OpenAI-compatible reasoning effort
+*/
+function toOpenAIReasoningEffort(reasoningEffort) {
+	if (reasoningEffort === "extra-high") return "xhigh";
+	return reasoningEffort;
+}
+/**
+* Build chat.completions payload for OpenAI-compatible providers.
+* @param input - Payload inputs and reasoning capability metadata
+* @returns Request object for `chat.completions.create`
+*/
+function buildChatCompletionRequest(input) {
+	const reasoningEffort = input.supportsReasoningEffort && input.reasoningEffort && input.reasoningEffort !== "none" ? toOpenAIReasoningEffort(input.reasoningEffort) : void 0;
+	return {
+		model: input.model,
+		messages: input.messages,
+		tools: input.tools.length > 0 ? input.tools : void 0,
+		stream: true,
+		...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+		stream_options: { include_usage: true }
+	};
+}
+
+//#endregion
+//#region src/session.ts
+/**
+* Session for OpenAI SDK lifecycle management.
+*
+* Manages OpenAI client calls across multiple user messages:
+* - Creates Turn instances for each user message
+* - Handles immediate mode via abort+restart (no true pause)
+* - Processes message queue with merge support
+*
+* Key difference from Claude: OpenAI has no server-side session.
+* Each turn rebuilds the messages[] array with full history.
+*/
+var OpenAIConnectorSession = class extends BaseStreamSession {
+	messages = [];
+	/**
+	* Mutable tool list for this session.
+	* Rebuilt whenever either `nativeTools` or `mcpTools` changes.
+	*/
+	currentTools;
+	/** Latest native registry tools for this live session. */
+	nativeTools;
+	/**
+	* Latest MCP direct-inject tools converted to OpenAI format.
+	* Stored separately so that `replaceNativeTools` can rebuild `currentTools`
+	* without losing the MCP tool set.
+	*/
+	mcpTools = [];
+	/**
+	* Runtime reasoning effort level; updated by `updateReasoning()`.
+	* Initialized from `config.reasoningEffort` at session construction.
+	*/
+	currentReasoningEffort;
+	/**
+	* Create an OpenAI connector session.
+	* @param config - OpenAI session configuration (bus identity, model/cwd, SDK client, and lifecycle hooks).
+	*/
+	constructor(config) {
+		super(config);
+		this.nativeTools = config.openAITools;
+		this.currentTools = config.openAITools;
+		this.currentReasoningEffort = config.reasoningEffort;
+	}
+	/**
+	* Replace the native registry tool set used for subsequent turns.
+	*
+	* Rebuilds `currentTools` so that MCP tools registered via `updateTools`
+	* are preserved alongside the new native tools.
+	* @param tools - Fresh OpenAI-formatted native tools
+	*/
+	replaceNativeTools(tools) {
+		this.nativeTools = tools;
+		this.currentTools = [...this.nativeTools, ...this.mcpTools];
+	}
+	/**
+	* Update the session's tool set for the next API call.
+	*
+	* Converts generic `ToolListItem[]` (MCP direct-inject tools) to
+	* OpenAI `ChatCompletionTool[]` format and merges them with the existing native tools.
+	* @param tools - New MCP direct-inject tools in generic format
+	*/
+	updateTools(tools) {
+		this.mcpTools = toOpenAIToolFormat(tools);
+		this.currentTools = [...this.nativeTools, ...this.mcpTools];
+	}
+	/**
+	* Update the reasoning effort level used for subsequent API calls.
+	*
+	* Called by the connector's `changeReasoningInPlace()` to sync the session
+	* with the connector-level reasoning effort without requiring a full session
+	* swap. The updated value is picked up by `executeApiCall` on the next turn.
+	* @internal Direct calls bypass capability validation — only the mutation
+	*   manager should call this (via the connector's `changeReasoningInPlace`).
+	* @param level - New reasoning effort level
+	*/
+	updateReasoning(level) {
+		this.currentReasoningEffort = level;
+	}
+	/**
+	* Return the names of all tools that would be sent in the next API call.
+	*
+	* Reflects the merged set of native and MCP tools after any `replaceNativeTools`
+	* or `updateTools` calls.
+	* @returns Ordered list of tool names matching the next API request
+	*/
+	getEffectiveToolNames() {
+		return this.currentTools.map((tool) => tool.type === "function" ? tool.function.name : tool.custom.name);
+	}
+	/**
+	* Create an OpenAI connector turn for the given message handle.
+	* @param handle - The message handle this turn will process
+	* @returns A new `OpenAIConnectorTurn` instance
+	*/
+	createTurn(handle) {
+		return new OpenAIConnectorTurn(this.bus, this.config.adapterId, this.config.adapterName, this.config.agentId, handle);
+	}
+	/**
+	* Validate that content is non-empty after trim.
+	* Throws an Error with a descriptive message if content is empty.
+	* @param content - Content string to validate
+	* @param messageId - Message ID for error context
+	* @param context - Additional context for the error message
+	*/
+	throwIfEmptyContent(content, messageId, context) {
+		if (content.trim().length === 0) throw new Error(`[${context}] buildMessages produced empty user content (messageId=${messageId})`);
+	}
+	/**
+	* Build the messages array from handle history and optional merged content.
+	*
+	* Ensures the configured system prompt is always at index 0 without
+	* duplicating existing history system entries.
+	* @param handle - The message handle containing history
+	* @param mergedContent - Optional content from superseded/merged messages
+	*/
+	buildMessages(handle, mergedContent) {
+		if (handle.messageHistory) this.messages = convertMessageHistory(handle.messageHistory);
+		if (this.config.systemPrompt !== void 0) {
+			const firstSystemIndex = this.messages.findIndex((message) => message.role === "system");
+			if (firstSystemIndex >= 0) {
+				const [systemMessage] = this.messages.splice(firstSystemIndex, 1);
+				this.messages.unshift({
+					...systemMessage,
+					content: this.config.systemPrompt
+				});
+			} else this.messages.unshift({
+				role: "system",
+				content: this.config.systemPrompt
+			});
+		}
+		if (mergedContent && mergedContent.length > 0) for (const content of mergedContent) {
+			this.messages.push({
+				role: "user",
+				content
+			});
+			this.messages.push({
+				role: "assistant",
+				content: "Acknowledged."
+			});
+		}
+		const contextText = formatContextBlocksAsText(serializeTurnContext(handle.turnContext));
+		if (handle.message.message !== void 0) {
+			const content = contextText.length > 0 ? `${contextText}\n\n${handle.message.message}` : handle.message.message;
+			this.throwIfEmptyContent(content, handle.messageId, "OpenAIConnectorSession");
+			this.messages.push({
+				role: "user",
+				content
+			});
+		} else {
+			const parts = blocksToContentParts(handle.message.blocks);
+			if (contextText.length > 0) parts.unshift({
+				type: "text",
+				text: contextText
+			});
+			const textContent = parts.filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+			if (!parts.some((part) => part.type !== "text")) this.throwIfEmptyContent(textContent, handle.messageId, "OpenAIConnectorSession");
+			this.messages.push({
+				role: "user",
+				content: parts
+			});
+		}
+	}
+	/**
+	* Execute the OpenAI streaming API call.
+	*
+	* Calls `client.chat.completions.create` with the current messages array
+	* and pipes the resulting stream through the stream-bridge event emitter.
+	* @param turn - Captured turn instance for this run loop
+	* @param abortSignal - Combined abort signal (turn abort + stream timeout)
+	* @param adapterSessionId - Turn-scoped adapter session ID for event correlation
+	*/
+	async executeApiCall(turn, abortSignal, adapterSessionId) {
+		const supportsReasoningEffort = this.currentReasoningEffort !== void 0 && this.currentReasoningEffort !== "none";
+		const stream = await this.config.client.chat.completions.create(buildChatCompletionRequest({
+			model: this.currentModel,
+			messages: this.messages,
+			tools: this.currentTools,
+			reasoningEffort: this.currentReasoningEffort,
+			supportsReasoningEffort
+		}), { signal: abortSignal });
+		await turn.markStepStarted();
+		try {
+			await processStream(stream, {
+				bus: this.config.bus,
+				agentId: this.config.agentId,
+				adapterId: this.config.adapterId,
+				adapterName: this.config.adapterName,
+				adapterSessionId,
+				model: this.currentModel,
+				logLowLevelEvent: this.config.logLowLevelEvent
+			});
+		} finally {
+			await turn.markStepFinished();
+		}
+	}
+	/**
+	* Return the OpenAI Node event bus subject for `message_complete` waiting.
+	* @returns The `sdk.event` subject for the OpenAI adapter namespace
+	*/
+	getSdkEventSubject() {
+		return OpenAINodeConnectorSubjects.sdk.event;
+	}
+	/**
+	* Apply a `message_complete` event to the OpenAI messages array and recurse
+	* for tool calls.
+	*
+	* Appends the assistant response as a `ChatCompletionMessageParam`. When
+	* `finish_reason` is `'tool_calls'`, executes tools and continues the loop.
+	* @param result - The parsed OpenAI `message_complete` event
+	* @param currentHandle - The active message handle
+	* @param toolCallIteration - Current tool recursion depth
+	* @param turn - Captured turn instance for this run loop
+	*/
+	async applyMessageComplete(result, currentHandle, toolCallIteration, turn) {
+		if (this.shouldAbortTurnProcessing(turn, currentHandle)) return;
+		const messageContent = result.content || null;
+		const assistantMessage = {
+			role: "assistant",
+			content: messageContent
+		};
+		if (result.tool_calls && result.tool_calls.length > 0) assistantMessage.tool_calls = result.tool_calls;
+		this.messages.push(assistantMessage);
+		this.lastAssistantMessage = messageContent || "";
+		if (result.finish_reason === "tool_calls" && result.tool_calls && result.tool_calls.length > 0) {
+			if (toolCallIteration >= BaseStreamSession.MAX_TOOL_CALL_ITERATIONS) throw new Error(`Tool call iteration limit exceeded (${BaseStreamSession.MAX_TOOL_CALL_ITERATIONS}). Aborting to prevent context blowup.`);
+			const messagesFromToolCalls = await handleToolCalls$1(result.tool_calls, {
+				emitSdkEvent: this.config.emitSdkEvent,
+				requestToolApproval: this.config.requestToolApproval,
+				recordMcpCall: this.config.recordMcpCall
+			}, {
+				env: this.config.env,
+				cwd: this.currentCwd,
+				sessionId: this.config.sessionId,
+				agentId: this.config.agentId,
+				adapterId: this.config.adapterId,
+				adapterName: this.config.adapterName,
+				turnId: currentHandle.messageId,
+				turnContext: currentHandle.turnContext,
+				reasoning: result.reasoning,
+				constraints: this.buildToolConstraints()
+			});
+			this.messages.push(...messagesFromToolCalls);
+			await this.runTurnIteration(turn, currentHandle, toolCallIteration + 1);
+		}
+	}
+	/**
+	* Classify an OpenAI SDK error into the appropriate Makaio error type.
+	* @param error - The raw error from the OpenAI SDK
+	* @returns A classified `Error` instance
+	*/
+	classifyError(error) {
+		return classifyOpenAIError(error);
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+/** Adapter name constant for consistent identification */
+const OpenAINodeAdapterName = "openai-node";
+/** Default model to use if not specified in config */
+const DEFAULT_MODEL = "deepseek-ai/DeepSeek-V3.1:thinking";
+/** Default timeout configuration for OpenAI adapter */
+const DEFAULT_TIMEOUTS = {
+	initialization: 3e4,
+	acknowledgement: 12e4,
+	completion: 12e4,
+	toolApproval: 5e3,
+	eventWait: 3e4
+};
+/** Timeout for live OpenAI-compatible model discovery requests. */
+const MODEL_FETCH_TIMEOUT_MS = 15e3;
+
+//#endregion
+//#region src/connector.ts
+/** Default adapter identifier for standalone OpenAINodeAgent instances (without adapter layer) */
+const defaultAdapterId = crypto.randomUUID();
+/** Default scoped bus for OpenAI Node adapter */
+const defaultBus = await OpenAINodeConnectorNamespace.scopedBus();
+/**
+* OpenAI Node Agent - Wraps the OpenAI SDK for agentic chat completions.
+*
+* Implements the agentic loop pattern:
+* 1. Send user message to OpenAI
+* 2. Process streaming response
+* 3. If tool_calls present, execute tools via Bus RPC and recurse
+* 4. When no tool_calls, mark turn complete
+*
+* Tools are fetched from ToolRegistry via MakaioBus.request(ToolSubjects.list)
+* on the first turn. Tool execution routes through MakaioBus.request(ToolSubjects.execute)
+* to the ToolRegistry, which validates input and executes the tool handler.
+*
+* Credential resolution happens in `fetchTools()` (the first async lifecycle hook)
+* via `resolveConnectorCredentials()`. Plaintext credentials are stored in instance
+* fields and never leave the connector.
+*/
+var OpenAINodeConnector = class extends BaseStreamConnector {
+	/** Resolved API key (populated in fetchTools before createSession is called). */
+	resolvedApiKey = "";
+	client;
+	/** OpenAI-format tools for chat completions API (fetched from bus on first turn) */
+	openAITools = [];
+	/**
+	* Emit an SDK event wrapped in envelope for type-safe discriminated union handling.
+	* Pattern matches codex-mcp's \{ id, msg \} envelope.
+	* @param event - The typed SDK event message to emit
+	*/
+	async emitSdkEvent(event) {
+		await this.emit(OpenAINodeConnectorSubjects.sdk.event, { event });
+	}
+	constructor(config) {
+		super({
+			...config,
+			bus: config?.bus ?? defaultBus,
+			adapterId: config?.adapterId ?? defaultAdapterId,
+			adapterName: config?.adapterName ?? "openai-node"
+		});
+		this.model = config?.model ?? "deepseek-ai/DeepSeek-V3.1:thinking";
+		this.initAdapterSessionId();
+	}
+	/**
+	* Resolve credentials and fetch available tools from the bus.
+	*
+	* Resolves `apiKey` from `providerContext.credentialRefs` via the encrypted
+	* credential channel, then initializes the OpenAI SDK client. Called once
+	* by `BaseStreamConnector.initializeSession()` before `createSession()`.
+	*
+	* Also converts fetched tools to OpenAI format and caches them in
+	* `this.openAITools` for use in `createSession`.
+	*/
+	async fetchTools() {
+		const credentialRefs = this.config.providerContext?.credentialRefs ?? {};
+		const credentials = await resolveConnectorCredentials(this.config.bus, credentialRefs);
+		this.resolvedApiKey = credentials["apiKey"] ?? "";
+		const baseUrl = this.config.providerConfig?.baseUrl;
+		this.client = new OpenAI({
+			...this.resolvedApiKey ? { apiKey: this.resolvedApiKey } : {},
+			baseURL: baseUrl
+		});
+		this.openAITools = await fetchToolsForOpenAI(this.adapterId, this.adapterName);
+	}
+	/**
+	* Re-fetch native tools and re-resolve MCP direct-inject tools.
+	*
+	* Called at turn boundary when `hasPendingToolRefresh` is true.
+	* Re-fetches OpenAI-format tools from the registry, re-prepares MCP
+	* direct tools (and arms the ledger injection flag via `super.refreshTools()`),
+	* then notifies the active session so the next API call uses the updated
+	* merged tool list. The ledger `recordInjection` is deferred to
+	* `onTurnStarted` so it uses the canonical turn number.
+	*/
+	async refreshTools() {
+		this.openAITools = await fetchToolsForOpenAI(this.adapterId, this.adapterName);
+		await super.refreshTools();
+		const session = this.getSession();
+		session?.replaceNativeTools(this.openAITools);
+		session?.updateTools?.(this.mcpDirectTools);
+	}
+	/**
+	* Construct the OpenAI connector session with all required config.
+	*
+	* Called by `BaseStreamConnector.initializeSession()` after `fetchTools()`
+	* has resolved credentials and initialized `this.client`.
+	* @returns A new `OpenAIConnectorSession` instance
+	*/
+	createSession() {
+		if (!this.client) throw new Error("[OpenAINodeConnector] createSession() called before fetchTools() — client not initialized");
+		const systemPrompt = this.resolveSystemPrompt();
+		return new OpenAIConnectorSession({
+			bus: this.config.bus,
+			adapterId: this.config.adapterId ?? "",
+			adapterName: this.config.adapterName ?? "",
+			agentId: this.agentId,
+			sessionId: this.config.sessionId,
+			cwd: this.cwd,
+			model: this.model ?? "",
+			reasoningEffort: this.config.reasoningEffort,
+			streamStartTimeoutMs: this.getTimeoutMs("eventWait"),
+			env: this.config.env ?? {},
+			client: this.client,
+			openAITools: this.openAITools,
+			systemPrompt,
+			allowedDirectories: this.config.allowedDirectories,
+			supportedReasoningLevels: this.config.supportedReasoningLevels,
+			emitSdkEvent: this.emitSdkEvent.bind(this),
+			handleError: this.handleError.bind(this),
+			requestToolApproval: (payload) => this.requestToolApprovalWithHandling(OpenAINodeConnectorSubjects.tool_approval, payload),
+			logLowLevelEvent: this.logLowLevelEvent,
+			onTurnStart: (handle) => {
+				this.pendingMessageHandle = handle;
+			},
+			onTurnComplete: (_handle, result) => {
+				this.lastResult = result;
+				this.pendingMessageHandle = void 0;
+			},
+			recordMcpCall: this.config.toolLedger ? (toolFullName) => {
+				this.config.toolLedger?.recordCall(toolFullName, this.currentTurnNumber);
+			} : void 0
+		});
+	}
+	/**
+	* Get OpenAI namespace turn subjects.
+	* @returns Turn subject definitions
+	*/
+	getTurnSubjects() {
+		return OpenAINodeConnectorSubjects.turn;
+	}
+};
+
+//#endregion
+//#region src/agent.ts
+/**
+* OpenAI Agent - Middle layer between AIAdapter and OpenAINodeConnector.
+*
+* Responsibilities:
+* 1. Wire connector's scoped bus events to global agent.* subjects
+* 2. Auto-enrich payloads with AgentContext via emitGlobal()
+*
+* Event Flow:
+* - OpenAINodeConnector emits to semantic subjects (chunk, usage, etc.)
+* - OpenAIAgent subscribes to semantic subjects and emits to global bus (agent.*)
+* - Downstream consumers subscribe to normalized agent.* subjects
+*
+* Extends `BaseStreamAgent` which provides all shared wiring logic. This class only
+* implements the adapter-specific abstract hooks.
+*/
+var OpenAIAgent = class extends BaseStreamAgent {
+	/**
+	* Tier 1: Route sdk.event catch-all to typed semantic subjects.
+	*
+	* Uses `createConnectorEventMapping` for type-safe discriminated union routing.
+	* Pattern matches codex-mcp: envelope `{ id, event }` with nestedMessageProp 'event'.
+	*/
+	wireSdkEvents() {
+		this.createConnectorEventMapping(OpenAINodeConnectorSubjects.sdk.event, "eventType", {
+			chunk: OpenAINodeConnectorSubjects.chunk,
+			usage: OpenAINodeConnectorSubjects.usage,
+			tool_calls: OpenAINodeConnectorSubjects.tool_calls,
+			message_complete: OpenAINodeConnectorSubjects.message_complete,
+			reasoning_delta: OpenAINodeConnectorSubjects.reasoning_delta,
+			reasoning_complete: OpenAINodeConnectorSubjects.reasoning_complete,
+			agent_started: OpenAINodeConnectorSubjects.agent_started,
+			agent_complete: OpenAINodeConnectorSubjects.agent_complete,
+			error: OpenAINodeConnectorSubjects.error,
+			tool_started: OpenAINodeConnectorSubjects.tool_started,
+			tool_completed: OpenAINodeConnectorSubjects.tool_completed
+		}, "event");
+	}
+	/**
+	* Return the OpenAI Node adapter's connector subject spec.
+	*
+	* Maps adapter subject constants to the `StreamAdapterSubjectSpec` interface used
+	* by `BaseStreamAgent` to subscribe to semantic events.
+	* @returns OpenAI-specific subject spec
+	*/
+	getConnectorSubjects() {
+		return {
+			chunk: OpenAINodeConnectorSubjects.chunk,
+			usage: OpenAINodeConnectorSubjects.usage,
+			toolCalls: OpenAINodeConnectorSubjects.tool_calls,
+			reasoningComplete: OpenAINodeConnectorSubjects.reasoning_complete,
+			messageComplete: OpenAINodeConnectorSubjects.message_complete,
+			reasoningDelta: OpenAINodeConnectorSubjects.reasoning_delta,
+			toolStarted: OpenAINodeConnectorSubjects.tool_started,
+			toolCompleted: OpenAINodeConnectorSubjects.tool_completed,
+			agentStarted: OpenAINodeConnectorSubjects.agent_started,
+			agentComplete: OpenAINodeConnectorSubjects.agent_complete,
+			error: OpenAINodeConnectorSubjects.error
+		};
+	}
+	/**
+	* Extract plain text from an OpenAI chunk event payload.
+	*
+	* OpenAI chunk events use the ChatCompletionChunk structure where text content
+	* is at `choices[0].delta.content`.
+	* @param payload - OpenAI chunk event payload
+	* @returns The text content, or empty string when no content is present
+	*/
+	extractChunkText(payload) {
+		const { choices } = payload;
+		return choices?.[0]?.delta?.content ?? "";
+	}
+	/**
+	* Map an OpenAI usage event payload to the shared `NormalizedCallUsage` format.
+	*
+	* Reads OpenAI-specific nested fields: `prompt_tokens_details.cached_tokens`
+	* and `completion_tokens_details.reasoning_tokens`.
+	* @param payload - OpenAI usage event payload
+	* @returns Normalized usage metrics
+	*/
+	extractUsagePayload(payload) {
+		const usage = payload;
+		return {
+			provider: "openai",
+			inputTokens: usage.prompt_tokens,
+			inputCachedTokens: usage.prompt_tokens_details?.cached_tokens ?? 0,
+			outputTokens: usage.completion_tokens,
+			reasoningTokens: usage.completion_tokens_details?.reasoning_tokens ?? 0,
+			totalTokens: usage.total_tokens,
+			costUnits: usage.total_tokens,
+			costUnitType: "tokens"
+		};
+	}
+	/**
+	* Emit context window update after OpenAI usage tracking.
+	*
+	* Uses `prompt_tokens_details.cached_tokens` for the cached token count and
+	* defaults to 128,000 tokens (standard GPT-4o context window).
+	* @param payload - OpenAI usage event payload
+	*/
+	async emitUsageContextWindowUpdate(payload) {
+		const usage = payload;
+		await this.emitContextWindowUpdate({
+			currentTokens: usage.prompt_tokens + usage.completion_tokens,
+			maxTokens: this.getContextWindowSize() ?? 128e3,
+			cachedTokens: usage.prompt_tokens_details?.cached_tokens
+		});
+	}
+	/**
+	* Reserve a block index for a tool call using the local internal counter.
+	*
+	* OpenAI does not provide provider-native block indices on tool calls, so we
+	* allocate the current counter value and increment to reserve the slot.
+	* @param _tc - OpenAI tool call entry (blockIndex not used)
+	* @returns Current block index (incremented after return by base class via `afterToolCallStepEmitted`)
+	*/
+	reserveToolCallBlockIndex(_tc) {
+		return this.getBlockIndex();
+	}
+	/**
+	* Increment the block index after emitting a tool call step.
+	*
+	* OpenAI uses the local counter, so we must explicitly reserve the slot by
+	* incrementing after the step has been emitted.
+	* @param _blockIndex - The block index just emitted (unused; counter manages state)
+	*/
+	afterToolCallStepEmitted(_blockIndex) {
+		this.incrementBlockIndex();
+	}
+	/**
+	* Return `-1` as the fallback block index when no map entry exists for a toolCallId.
+	*
+	* OpenAI uses a sentinel value of `-1` to indicate an unknown index, which is
+	* distinguishable from any valid (non-negative) provider block index.
+	* @returns `-1` sentinel value
+	*/
+	getFallbackToolCompletedBlockIndex() {
+		return -1;
+	}
+	/**
+	* No-op: OpenAI does not need post-step index reconciliation.
+	*
+	* The internal block index was already incremented inside `afterToolCallStepEmitted`,
+	* so no reconciliation is needed after tool_completed.
+	* @param _resolvedBlockIndex - Unused
+	*/
+	afterToolCompletedStepEmitted(_resolvedBlockIndex) {}
+	/**
+	* Build the reasoning `SessionMessageBlock` from an OpenAI reasoning_complete payload.
+	*
+	* OpenAI reasoning events do not carry a `signature` field, so the block
+	* contains only `{ type, content }` without metadata.
+	* @param payload - OpenAI reasoning complete event payload
+	* @returns Plain reasoning block without signature metadata
+	*/
+	buildReasoningBlock(payload) {
+		const { content } = payload;
+		return {
+			type: "reasoning",
+			content
+		};
+	}
+	/**
+	* Wire tool approval RPC from connector's scoped bus to global AgentSubjects.toolApprove.
+	*
+	* Uses centralized tool-handling helper for consistent approval flow.
+	* Uses lazy callback to resolve adapterSessionId at request time (not constructor time).
+	* @param connector - The OpenAINodeConnector to wire RPC from
+	*/
+	wireToolApprovalRpc(connector) {
+		this.addConnectorWiringCleanup(registerToolApprovalHandler(connector, async () => {
+			if (this.sessionId == null) throw new Error("Agent sessionId is required for tool approval");
+			return {
+				adapterId: this.adapterId,
+				adapterName: this.adapterName,
+				agentId: this.agentId,
+				adapterSessionId: await this.getAdapterSessionId(),
+				sessionId: this.sessionId
+			};
+		}));
+	}
+};
+
+//#endregion
+//#region src/schemas.ts
+/**
+* Zod schema for OpenAI Node provider-specific configuration.
+*
+* Used for:
+* 1. Type-safe config resolution
+* 2. Serialization to JSON Schema for web-ui form generation
+* 3. Runtime validation
+*/
+const OpenAINodeProviderConfigSchema = z.object({ 
+/**
+* Base URL for OpenAI-compatible APIs.
+* Defaults to OpenAI's API. Use for alternatives like:
+* - NanoGPT: 'https://nano-gpt.com/api/v1'
+* - Azure OpenAI: 'https://\{resource\}.openai.azure.com/openai/deployments/\{deployment\}'
+* - Local LLMs: 'http://localhost:1234/v1'
+*/
+baseUrl: z.string().optional().meta({
+	title: "Base URL",
+	description: "API endpoint for OpenAI-compatible providers"
+}) });
+/**
+* Zod schema for OpenAI Node credential input.
+*
+* Used for:
+* 1. Write-only credential capture in settings UI
+* 2. Secure storage in credential service
+*/
+const OpenAINodeCredentialSchema = z.object({ 
+/**
+* API key for OpenAI.
+*/
+apiKey: z.string().optional().meta({
+	title: "API Key",
+	description: "Stored securely (not saved in config)",
+	format: "password"
+}) });
+
+//#endregion
+//#region src/config.ts
+const OpenAINodeConfig = createAdapterConfigFactory(() => ({
+	adapterName: OpenAINodeAdapterName,
+	adapterDefaults: {
+		reasoningEffort: "low",
+		providerConfig: {}
+	},
+	schema: OpenAINodeProviderConfigSchema,
+	adapterDefinition: { defaultTimeouts: DEFAULT_TIMEOUTS },
+	protocol: "openai"
+}));
+
+//#endregion
+//#region src/model-normalization.ts
+/**
+* Normalize OpenAI model response to AIModel format.
+*
+* Handles variance in field names across OpenAI-compatible providers:
+* - NanoGPT: context_length, name
+* - Z.AI: (no context_length)
+* - Moonshot: context_length
+* - Kimi: context_length, display_name
+* @param raw - Raw model data from provider API
+* @param labId - Lab identifier to assign (omit for multi-lab providers)
+* @returns Normalized model descriptor
+*/
+function normalizeOpenAIModel(raw, labId) {
+	return {
+		name: raw.id ?? raw.name ?? "unknown",
+		friendlyName: raw.name ?? raw.display_name,
+		contextWindowSize: raw.context_length ?? 0,
+		...labId ? { labId } : {}
+	};
+}
+/**
+* Normalize array of raw model data from OpenAI /v1/models endpoint.
+* @param rawModels - Array of raw model data
+* @param labId - Lab identifier to assign (omit for multi-lab providers)
+* @returns Array of normalized model objects
+*/
+function normalizeOpenAIModels(rawModels, labId) {
+	return rawModels.map((raw) => normalizeOpenAIModel(raw, labId));
+}
+
+//#endregion
+//#region src/adapter.ts
+/**
+* OpenAI Adapter - Domain-level adapter using the three-layer architecture.
+*
+* Architecture:
+* ```
+* OpenAIAdapter extends AIAdapter
+*     -> creates via agentFactory()
+* OpenAIAgent extends AIAgent
+*     -> creates via connectorFactory()
+* OpenAINodeConnector extends AIAgentConnector
+* ```
+*
+* Responsibilities:
+* - Handle adapter.startAgent RPC (inherited from AIAdapter)
+* - Create OpenAIAgent instances with proper configuration
+* - Emit adapter.initialized and adapter.session.created events
+* - Manage agent lifecycle (tracking, disposal)
+* @example
+* ```typescript
+* // Using the class directly
+* const adapter = new OpenAIAdapter();
+* await adapter.init();
+*
+* // Using the convenience factory
+* const adapter = await createOpenAINodeAdapter();
+* ```
+*/
+var OpenAIAdapter = class extends AIAdapter {
+	constructor(config) {
+		super({
+			name: OpenAINodeAdapterName,
+			capabilities: [
+				"tools",
+				"streaming",
+				"systemPrompt:override",
+				"systemPrompt:append"
+			],
+			...config,
+			namespace: OpenAINodeConnectorNamespace,
+			agentFactory: (agentConfig) => {
+				return new OpenAIAgent(agentConfig);
+			},
+			configFactory: OpenAINodeConfig.getConfig,
+			connectorFactory: (fullConfig) => new OpenAINodeConnector(fullConfig),
+			definitionProviders: config?.definitionProviders
+		});
+	}
+	/**
+	* Fetch available models from OpenAI-compatible /v1/models endpoint.
+	*
+	* Normalizes responses from various providers (OpenAI, NanoGPT, Z.AI, Kimi, etc.)
+	* to a consistent AIModel[] format.
+	* @param baseUrl - Optional base URL for the provider (defaults to OpenAI)
+	* @param credentials - Optional credentials object with apiKey
+	* @returns Array of normalized model objects
+	* @throws Error if the API request fails
+	*/
+	async fetchModels(baseUrl, credentials) {
+		const apiUrl = baseUrl ? `${baseUrl.replace(/\/$/, "")}/models` : "https://api.openai.com/v1/models";
+		const apiKey = credentials?.apiKey;
+		if (!apiKey) throw new Error("API key required for fetching models. Provide via provider configuration, credential storage, or the OPENAI_API_KEY environment variable.");
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), MODEL_FETCH_TIMEOUT_MS);
+		try {
+			const response = await fetch(apiUrl, {
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json"
+				},
+				signal: controller.signal
+			});
+			if (!response.ok) throw new Error(`Failed to fetch models from ${apiUrl}: ${response.status} ${response.statusText}`);
+			const data = await response.json();
+			if (!data.data || !Array.isArray(data.data)) throw new Error("Invalid response format from /v1/models endpoint - expected { data: [...] }");
+			return normalizeOpenAIModels(data.data);
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") throw new Error(`Failed to fetch models from ${apiUrl}: timed out after ${MODEL_FETCH_TIMEOUT_MS}ms`, { cause: error });
+			throw error;
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+};
+/**
+* Factory function to create and initialize an OpenAI adapter.
+*
+* Convenience wrapper that creates the adapter and calls init() for you.
+* @param config - Optional adapter configuration
+* @returns Initialized OpenAIAdapter instance
+* @example
+* ```typescript
+* const adapter = await createOpenAINodeAdapter();
+*
+* // Adapter is ready to handle requests via bus
+* // e.g., MakaioBus.request(AdapterSubjects.startAgent, { adapterId: adapter.adapterId, ... })
+* ```
+*/
+async function createOpenAINodeAdapter(config) {
+	const adapter = new OpenAIAdapter(config);
+	await adapter.init();
+	return adapter;
+}
+
+//#endregion
+//#region src/provider.ts
+/**
+* Provider IDs and preset configuration for the OpenAI Node adapter.
+*
+* The OpenAI adapter supports any OpenAI-compatible API.
+* Provider compatibility is declared by stable definition ID — the adapter
+* subsystem resolves each ID to a full ProviderDefinitionInput from the
+* provider registry at boot time.
+*
+* Add new provider IDs here when introducing an OpenAI-compatible provider.
+*/
+const providerIds = [
+	"openai",
+	"nanogpt",
+	"openrouter",
+	"z-ai",
+	"alibaba",
+	"opencode-go"
+];
+/**
+* Provider id used for conformance tests.
+*
+* Set to `opencode-go` (OpenCode Go gateway) to avoid expensive OpenAI API
+* calls during test runs while still exercising the OpenAI-compatible wire protocol.
+*/
+const testPresetId = "opencode-go";
+
+//#endregion
+//#region src/index.ts
+/**
+* OpenAI Node Adapter
+*
+* Provides a three-layer adapter implementation for the OpenAI SDK:
+* - OpenAIAdapter: Domain-level adapter, handles adapter.* subjects
+* - OpenAIAgent: Agent wrapper, handles agent.* subjects
+* - OpenAINodeAgent: SDK connector, handles provider communication
+* @example
+* ```typescript
+* import { OpenAIAdapter, createOpenAINodeAdapter } from '@makaio/adapter-openai-node';
+*
+* // Using the class-based adapter
+* const adapter = new OpenAIAdapter();
+* await adapter.init();
+*
+* // Or using the convenience factory
+* const adapter = await createOpenAINodeAdapter();
+*
+* // Adapter is ready to handle adapter.startAgent RPC via bus
+* // Start agents via MakaioBus.request(AdapterSubjects.startAgent, { adapterId, ... })
+* ```
+* @packageDocumentation
+*/
+/**
+* Creates test configuration for conformance test suite.
+* Sets up scoped bus and tool approval proxy.
+* @param options - Provider definitions supplied by the conformance harness
+* @returns Configuration for running conformance tests against this adapter
+*/
+const createTestConfig = async (options) => {
+	const { scopedBus } = OpenAINodeConnectorNamespace;
+	const bus = await scopedBus();
+	const testPreset = resolveConformanceTestPreset({
+		adapterName: OpenAINodeAdapterName,
+		defaultProviderId: testPresetId,
+		providerIds,
+		providerDefinitions: options?.providerDefinitions,
+		reasoningEffort: "low"
+	});
+	return {
+		createConnector: async (options) => new OpenAINodeConnector(await OpenAINodeConfig.getConfig(resolveTestConfig(options, bus, testPreset.provider, testPreset.providers))),
+		bus,
+		registerToolApprovalHandler,
+		capabilities: {
+			supportsReplace: true,
+			supportsInterrupt: true,
+			supportsUsageMetrics: true
+		},
+		options: {
+			defaultTimeout: 9e4,
+			concurrency: 8,
+			primaryModel: testPreset.primaryModel,
+			secondaryModel: testPreset.secondaryModel
+		},
+		createAdapter: async (options) => createOpenAINodeAdapter({ adapterId: options?.adapterId }),
+		adapterName: OpenAINodeAdapterName,
+		testProviderContext: testPreset.providerContext
+	};
+};
+
+//#endregion
+export { OPENAI_NODE_NAMESPACE, OpenAIAdapter, OpenAIAgent, OpenAIConnectorSession, OpenAIConnectorTurn, OpenAINodeAdapterName, OpenAINodeConnector, OpenAINodeConnectorNamespace, OpenAINodeConnectorSubjects, UserMessageQueue, createOpenAINodeAdapter, createTestConfig };