@abot-ai/runtime 1.7.0 → 1.8.0

package/dist/src/model-gateway/providers/openai/message-output-policy.js

@@ -0,0 +1,16 @@
+/** Content authoring consumes one message even when its wire format is plain text. */
+export function requiresSingleMessageOutput(request, payload) {
+    if (request.modelStep === "tool_payload.raw")
+        return true;
+    return hasStructuredTextFormat(payload);
+}
+function hasStructuredTextFormat(payload) {
+    const text = readRecord(payload.text);
+    const format = readRecord(text?.format);
+    return format?.type === "json_schema" || format?.type === "json_object";
+}
+function readRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}

package/dist/src/model-gateway/providers/openai/payload.d.ts

@@ -1,9 +1,7 @@
 import { type OpenAISchemaProjectionDiagnostic } from "../../structured-output/projection.js";
 import type { ModelGatewayRequest } from "../../types.js";
-import type { ModelProviderInputTokenMeasurement } from "../contracts.js";
 export type OpenAIPayloadBuildOptions = Readonly<{
     onFormatProjection?: (diagnostics: readonly OpenAISchemaProjectionDiagnostic[]) => void;
-    inputTokenMeasurement?: ModelProviderInputTokenMeasurement;
 }>;
 export declare function buildOpenAIResponsesPayload(requestBody: ModelGatewayRequest, payloadOptions?: OpenAIPayloadBuildOptions): Record<string, unknown>;
 export declare function buildOpenAIInputTokenCountPayload(requestBody: ModelGatewayRequest): Record<string, unknown>;

package/dist/src/model-gateway/providers/openai/payload.js

@@ -1,9 +1,8 @@
-import { resolveModelStepOutputTokenLimit } from "../../../shared/model-step-registry.js";
 import { openAIImageContents, projectOpenAIImageMessage } from "./image-content.js";
 import { isAssistantToolCallMessage, isToolResultMessage, validateModelGatewayMessages, } from "../../protocol/message-contract.js";
 import { resolveModelInvocation } from "../../policy/invocation-policy.js";
 import { projectOpenAIResponsesFormat, resolveModelGatewayFormat, } from "../../structured-output/projection.js";
-import { resolveProviderEnvelopeInputTokens } from "../envelope-budget.js";
+import { projectOpenAIFunctionOutput } from "./function-output.js";
 function prependInstructionInput(params) {
     const instructions = (params.instructions ?? [])
         .map((line) => line.trim())
@@ -70,9 +69,6 @@ function readFiniteNumber(value) {
         ? value
         : undefined;
 }
-function hasExplicitlyDisabledOpenAIReasoning(invocation) {
-    return invocation.profile.supportsThinking === true && invocation.think === "none";
-}
 export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     validateModelGatewayMessages(requestBody.messages);
     const invocation = resolveModelInvocation(requestBody);
@@ -103,26 +99,14 @@ export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     if (shouldProjectOpenAIReasoning) {
         payload.reasoning = { effort: reasoningEffort };
     }
-    if (formatProjection.format) {
-        payload.text = { format: formatProjection.format };
-    }
-    // Without an explicit provider disable, hidden reasoning may consume output.
-    // A missing or false control declaration does not disable provider defaults.
-    if (!hasExplicitlyDisabledOpenAIReasoning(invocation)) {
+    const functionOutput = projectOpenAIFunctionOutput(requestBody.modelStep, formatProjection.format);
+    if (functionOutput) {
+        Object.assign(payload, functionOutput);
         return payload;
     }
-    const outputTokenLimit = resolveModelStepOutputTokenLimit(requestBody.modelStep);
-    if (outputTokenLimit === undefined) {
-        return payload;
+    if (formatProjection.format) {
+        payload.text = { format: formatProjection.format };
     }
-    const { inputTokens } = resolveProviderEnvelopeInputTokens({
-        payload,
-        tokenEstimation: invocation.profile.context.tokenEstimation,
-        ...(payloadOptions.inputTokenMeasurement
-            ? { measurement: payloadOptions.inputTokenMeasurement }
-            : {}),
-    });
-    payload.max_output_tokens = Math.max(1, Math.min(outputTokenLimit, invocation.profile.contextWindowTokens - inputTokens));
     return payload;
 }
 export function buildOpenAIInputTokenCountPayload(requestBody) {
@@ -130,6 +114,5 @@ export function buildOpenAIInputTokenCountPayload(requestBody) {
     delete payload.stream;
     delete payload.temperature;
     delete payload.top_p;
-    delete payload.max_output_tokens;
     return payload;
 }

package/dist/src/model-gateway/providers/openai/response-lifetime.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAIResponsesStreamOptions } from "./stream-normalizer.js";
+export declare function bindOpenAIResponseLifetime(response: Response, options?: Pick<OpenAIResponsesStreamOptions, "functionOutputName">): Response;

package/dist/src/model-gateway/providers/openai/response-lifetime.js

@@ -0,0 +1,64 @@
+import { OpenAISseDataDecoder } from "./sse-data.js";
+import { OpenAIResponsesStreamNormalizer } from "./stream-normalizer.js";
+function observeResponseFrame(data, normalizer) {
+    if (data === "[DONE]") {
+        normalizer.finish();
+        return;
+    }
+    let event;
+    try {
+        event = JSON.parse(data);
+    }
+    catch {
+        return;
+    }
+    normalizer.consume(event);
+}
+// End the one upstream body before tracing tees it. All consumers therefore
+// receive the terminal bytes and EOF, even if the provider keeps HTTP open.
+export function bindOpenAIResponseLifetime(response, options = {}) {
+    if (!response.ok || !response.body)
+        return response;
+    const reader = response.body.getReader();
+    const decoder = new OpenAISseDataDecoder();
+    const normalizer = new OpenAIResponsesStreamNormalizer(options);
+    let stopped = false;
+    const cancelUpstream = (reason) => {
+        stopped = true;
+        // Cleanup must not make protocol completion wait on transport teardown.
+        void reader.cancel(reason).catch(() => { });
+        reader.releaseLock();
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (stopped)
+                    return;
+                if (done) {
+                    stopped = true;
+                    controller.close();
+                    reader.releaseLock();
+                    return;
+                }
+                for (const data of decoder.accept(value))
+                    observeResponseFrame(data, normalizer);
+                controller.enqueue(value);
+                if (!normalizer.hasTerminated)
+                    return;
+                controller.close();
+                cancelUpstream();
+            }
+            catch (error) {
+                if (stopped)
+                    return;
+                controller.error(error);
+                cancelUpstream(error);
+            }
+        },
+        cancel: cancelUpstream,
+    });
+    return new Response(body, {
+        status: response.status, statusText: response.statusText, headers: response.headers,
+    });
+}

package/dist/src/model-gateway/providers/openai/sse-data.d.ts

@@ -0,0 +1,9 @@
+export declare class OpenAISseDataDecoder {
+    private readonly decoder;
+    private line;
+    private data;
+    private afterCr;
+    accept(bytes: Uint8Array): string[];
+    private acceptLine;
+}
+export declare function readOpenAIDataFrames(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;

package/dist/src/model-gateway/providers/openai/sse-data.js

@@ -0,0 +1,67 @@
+// Decode complete SSE data frames identically for response lifetime and output.
+// Event names are metadata; the Responses payload owns its typed event.
+export class OpenAISseDataDecoder {
+    decoder = new TextDecoder();
+    line = "";
+    data = [];
+    afterCr = false;
+    accept(bytes) {
+        const text = this.decoder.decode(bytes, { stream: true });
+        const frames = [];
+        let start = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (this.afterCr) {
+                this.afterCr = false;
+                if (char === "\n") {
+                    start = index + 1;
+                    continue;
+                }
+            }
+            if (char !== "\r" && char !== "\n")
+                continue;
+            this.line += text.slice(start, index);
+            this.acceptLine(frames);
+            this.line = "";
+            this.afterCr = char === "\r";
+            start = index + 1;
+        }
+        this.line += text.slice(start);
+        return frames;
+    }
+    acceptLine(frames) {
+        if (!this.line) {
+            if (this.data.length)
+                frames.push(this.data.join("\n"));
+            this.data = [];
+            return;
+        }
+        const colon = this.line.indexOf(":");
+        const field = colon < 0 ? this.line : this.line.slice(0, colon);
+        if (field !== "data")
+            return;
+        const value = colon < 0 ? "" : this.line.slice(colon + 1);
+        this.data.push(value.startsWith(" ") ? value.slice(1) : value);
+    }
+}
+export async function* readOpenAIDataFrames(body) {
+    const reader = body.getReader();
+    const decoder = new OpenAISseDataDecoder();
+    let reachedEof = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                reachedEof = true;
+                return;
+            }
+            yield* decoder.accept(value);
+        }
+    }
+    finally {
+        // A tee branch cannot await cancellation before the other readers finish.
+        if (!reachedEof)
+            void reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

package/dist/src/model-gateway/providers/openai/stream-normalizer.d.ts

@@ -1,25 +1,10 @@
 import type { ModelTokenUsage } from "../../types.js";
 import type { ModelProviderEventSink } from "../contracts.js";
-export type OpenAIMessageOutputNormalizationDiagnostic = Readonly<{
-    outcome: "additional_message_outputs_ignored";
-    outputCount: number;
-    selectedOutput: Readonly<{
-        itemId: string | null;
-        outputIndex: number | null;
-        arrivalOrder: number;
-        textByteCount: number;
-    }>;
-    ignoredOutputCount: number;
-    sampledIgnoredOutputs: readonly Readonly<{
-        itemId: string | null;
-        outputIndex: number | null;
-        arrivalOrder: number;
-        textByteCount: number;
-    }>[];
-    omittedIgnoredOutputCount: number;
-}>;
+import { type OpenAIMessageOutputNormalizationDiagnostic } from "./structured-message-output.js";
+export type { OpenAIMessageOutputNormalizationDiagnostic } from "./structured-message-output.js";
 export type OpenAIResponsesStreamOptions = Readonly<{
     structuredOutput?: boolean;
+    functionOutputName?: string;
     onMessageOutputDiagnostic?: (diagnostic: OpenAIMessageOutputNormalizationDiagnostic) => void;
 }>;
 export type NormalizedOpenAIStreamEvent = {
@@ -36,16 +21,19 @@ export type NormalizedOpenAIStreamEvent = {
 };
 export declare class OpenAIResponsesStreamNormalizer {
     private readonly options;
-    private readonly outputs;
-    private primaryOutputKey;
+    private readonly structuredOutput;
     private terminal;
     constructor(options: OpenAIResponsesStreamOptions);
+    get hasTerminated(): boolean;
     consume(data: unknown): NormalizedOpenAIStreamEvent[];
     finish(): NormalizedOpenAIStreamEvent[];
     private consumeTextDelta;
     private consumeIncompleteResponse;
-    private getMessageOutput;
+    private consumeMessageItem;
+    end(): NormalizedOpenAIStreamEvent[];
+    private finishStructuredOutput;
+    private fail;
+    private finishFunctionOutput;
     private complete;
-    private emitAdditionalOutputDiagnostic;
 }
 export declare function writeNormalizedOpenAIEvents(events: readonly NormalizedOpenAIStreamEvent[], sink: ModelProviderEventSink): void;

package/dist/src/model-gateway/providers/openai/stream-normalizer.js

@@ -1,33 +1,10 @@
+import { readOpenAIFunctionResult } from "./function-result.js";
 import { buildModelTokenUsage } from "../../protocol/usage.js";
-const OPENAI_IGNORED_MESSAGE_OUTPUT_DIAGNOSTIC_LIMIT = 8;
+import { OpenAIStructuredMessageOutput, } from "./structured-message-output.js";
 function readRecord(value) {
     const isRecord = value !== null && typeof value === "object" && !Array.isArray(value);
     return isRecord ? value : {};
 }
-function resolveMessageOutputKey(params) {
-    if (params.itemId !== null) {
-        return `item:${params.itemId}`;
-    }
-    if (params.outputIndex !== null) {
-        return `output:${params.outputIndex}`;
-    }
-    return "unidentified-message-output";
-}
-function readOpenAIMessageOutputIdentity(event) {
-    const itemId = typeof event.item_id === "string" && event.item_id.length > 0
-        ? event.item_id
-        : null;
-    const outputIndex = typeof event.output_index === "number" &&
-        Number.isInteger(event.output_index) &&
-        event.output_index >= 0
-        ? event.output_index
-        : null;
-    return {
-        key: resolveMessageOutputKey({ itemId, outputIndex }),
-        itemId,
-        outputIndex,
-    };
-}
 function readOpenAIUsage(data) {
     const event = readRecord(data);
     const response = readRecord(event.response);
@@ -58,24 +35,42 @@ function readOpenAIIncompleteReason(data) {
         ? reason.trim()
         : "unknown_reason";
 }
+function isMessageItemEvent(event) {
+    return event.type === "response.output_item.added" || event.type === "response.output_item.done";
+}
+function contentEvents(texts) {
+    return texts.map((text) => ({ type: "content", text }));
+}
+function isStreamError(event) {
+    return event.type === "error";
+}
 export class OpenAIResponsesStreamNormalizer {
     options;
-    outputs = new Map();
-    primaryOutputKey;
+    structuredOutput = new OpenAIStructuredMessageOutput();
     terminal = false;
     constructor(options) {
         this.options = options;
     }
+    get hasTerminated() {
+        return this.terminal;
+    }
     consume(data) {
         if (this.terminal) {
             return [];
         }
         const event = readRecord(data);
+        const isFailedResponse = event.type === "response.failed";
+        if (isFailedResponse) {
+            return this.fail(readOpenAIError(event.response));
+        }
         if (event.type === "response.output_text.delta") {
             return this.consumeTextDelta(event);
         }
+        if (isMessageItemEvent(event)) {
+            return this.consumeMessageItem(event);
+        }
         if (event.type === "response.completed") {
-            return this.complete(readOpenAIUsage(data));
+            return this.complete(readOpenAIUsage(data), undefined, event.response);
         }
         if (event.type === "response.incomplete") {
             return this.consumeIncompleteResponse(data);
@@ -87,9 +82,14 @@ export class OpenAIResponsesStreamNormalizer {
         return [];
     }
     finish() {
+        const events = this.end();
+        if (this.terminal)
+            return events;
         return this.complete(undefined);
     }
     consumeTextDelta(event) {
+        if (this.options.functionOutputName)
+            return [];
         const delta = typeof event.delta === "string" ? event.delta : "";
         if (!delta) {
             return [];
@@ -97,41 +97,69 @@ export class OpenAIResponsesStreamNormalizer {
         if (!this.options.structuredOutput) {
             return [{ type: "content", text: delta }];
         }
-        const output = this.getMessageOutput(event);
-        output.textByteCount += Buffer.byteLength(delta, "utf8");
-        return output.key === this.primaryOutputKey
-            ? [{ type: "content", text: delta }]
-            : [];
+        return contentEvents(this.structuredOutput.consumeDelta(event, delta));
     }
     consumeIncompleteResponse(data) {
         const reason = readOpenAIIncompleteReason(data);
-        if (reason === "max_output_tokens") {
-            return this.complete(readOpenAIUsage(data), reason);
+        if (!this.options.functionOutputName && reason === "max_output_tokens") {
+            return this.complete(readOpenAIUsage(data), reason, readRecord(data).response);
         }
         this.terminal = true;
         return [{ type: "error", error: `openai response incomplete: ${reason}` }];
     }
-    getMessageOutput(event) {
-        const identity = readOpenAIMessageOutputIdentity(event);
-        let output = this.outputs.get(identity.key);
-        if (!output) {
-            output = {
-                ...identity,
-                arrivalOrder: this.outputs.size + 1,
-                textByteCount: 0,
-            };
-            this.outputs.set(identity.key, output);
-            this.primaryOutputKey ??= identity.key;
-        }
-        return output;
+    consumeMessageItem(event) {
+        if (this.options.functionOutputName)
+            return [];
+        if (!this.options.structuredOutput)
+            return [];
+        return contentEvents(this.structuredOutput.observeItem(event));
+    }
+    // Transport endings cannot authorize decisions or payloads. Ordinary text
+    // retains its legacy partial-output behavior.
+    end() {
+        if (this.terminal)
+            return [];
+        if (this.options.functionOutputName)
+            return this.fail("openai function response not completed");
+        const requiresCompletedMessage = this.options.structuredOutput === true;
+        if (requiresCompletedMessage)
+            return this.fail("openai response not completed");
+        return [];
+    }
+    finishStructuredOutput(response) {
+        if (!this.options.structuredOutput)
+            return [];
+        const pending = this.structuredOutput.observeResponse(response);
+        const result = this.structuredOutput.finish();
+        if (result.error)
+            return [{ type: "error", error: result.error }];
+        const diagnostic = this.structuredOutput.diagnostic();
+        if (diagnostic)
+            this.options.onMessageOutputDiagnostic?.(diagnostic);
+        return contentEvents([...pending, ...result.text]);
     }
-    complete(usage, doneReason) {
+    fail(error) {
+        this.terminal = true;
+        return [{ type: "error", error }];
+    }
+    finishFunctionOutput(response, name) {
+        const result = readOpenAIFunctionResult(response, name);
+        if ("error" in result)
+            return [{ type: "error", error: result.error }];
+        return [{ type: "content", text: result.text }];
+    }
+    complete(usage, doneReason, response) {
         if (this.terminal) {
             return [];
         }
-        this.emitAdditionalOutputDiagnostic();
+        const pending = this.options.functionOutputName
+            ? this.finishFunctionOutput(response, this.options.functionOutputName)
+            : this.finishStructuredOutput(response);
         this.terminal = true;
+        if (pending.some(isStreamError))
+            return pending;
         return [
+            ...pending,
             {
                 type: "done",
                 done: true,
@@ -140,35 +168,6 @@ export class OpenAIResponsesStreamNormalizer {
             },
         ];
     }
-    emitAdditionalOutputDiagnostic() {
-        const hasAdditionalStructuredOutputs = this.options.structuredOutput && this.outputs.size > 1;
-        if (!hasAdditionalStructuredOutputs) {
-            return;
-        }
-        const outputs = [...this.outputs.values()];
-        const selectedOutput = outputs[0];
-        const ignoredOutputs = outputs.slice(1);
-        this.options.onMessageOutputDiagnostic?.({
-            outcome: "additional_message_outputs_ignored",
-            outputCount: outputs.length,
-            selectedOutput: {
-                itemId: selectedOutput.itemId?.slice(0, 160) ?? null,
-                outputIndex: selectedOutput.outputIndex,
-                arrivalOrder: selectedOutput.arrivalOrder,
-                textByteCount: selectedOutput.textByteCount,
-            },
-            ignoredOutputCount: ignoredOutputs.length,
-            sampledIgnoredOutputs: ignoredOutputs
-                .slice(0, OPENAI_IGNORED_MESSAGE_OUTPUT_DIAGNOSTIC_LIMIT)
-                .map(({ itemId, outputIndex, arrivalOrder, textByteCount }) => ({
-                itemId: itemId?.slice(0, 160) ?? null,
-                outputIndex,
-                arrivalOrder,
-                textByteCount,
-            })),
-            omittedIgnoredOutputCount: Math.max(0, ignoredOutputs.length - OPENAI_IGNORED_MESSAGE_OUTPUT_DIAGNOSTIC_LIMIT),
-        });
-    }
 }
 export function writeNormalizedOpenAIEvents(events, sink) {
     for (const event of events) {

package/dist/src/model-gateway/providers/openai/stream.js

@@ -1,47 +1,11 @@
+import { readOpenAIDataFrames } from "./sse-data.js";
 import { OpenAIResponsesStreamNormalizer, writeNormalizedOpenAIEvents, } from "./stream-normalizer.js";
-function parseSseEvents(buffer) {
-    const events = [];
-    let remaining = buffer;
-    let boundaryIndex;
-    while ((boundaryIndex = remaining.indexOf("\n\n")) !== -1) {
-        events.push(remaining.slice(0, boundaryIndex));
-        remaining = remaining.slice(boundaryIndex + 2);
-    }
-    return { events, rest: remaining };
-}
-function readSseData(eventBlock) {
-    return eventBlock
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice("data:".length).trim())
-        .filter(Boolean);
-}
-async function* readOpenAIDataLines(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
-        const parsed = parseSseEvents(buffer);
-        buffer = parsed.rest;
-        for (const eventBlock of parsed.events) {
-            for (const dataLine of readSseData(eventBlock)) {
-                yield dataLine;
-            }
-        }
-        if (done) {
-            break;
-        }
-    }
-}
 export async function forwardOpenAIResponsesStream(body, sink, options = {}) {
     const normalizer = new OpenAIResponsesStreamNormalizer(options);
-    for await (const dataLine of readOpenAIDataLines(body)) {
+    for await (const dataLine of readOpenAIDataFrames(body)) {
         if (dataLine === "[DONE]") {
             writeNormalizedOpenAIEvents(normalizer.finish(), sink);
-            continue;
+            break;
         }
         try {
             const event = JSON.parse(dataLine);
@@ -50,7 +14,10 @@ export async function forwardOpenAIResponsesStream(body, sink, options = {}) {
         catch {
             // Keep gateway behavior: ignore malformed upstream stream chunks.
         }
+        if (normalizer.hasTerminated)
+            break;
     }
+    writeNormalizedOpenAIEvents(normalizer.end(), sink);
 }
 function applyCollectedEvent(collected, event) {
     switch (event.type) {
@@ -68,12 +35,12 @@ function applyCollectedEvent(collected, event) {
 export async function collectOpenAIResponsesStream(body, options = {}) {
     const normalizer = new OpenAIResponsesStreamNormalizer(options);
     const collected = { text: "" };
-    for await (const dataLine of readOpenAIDataLines(body)) {
+    for await (const dataLine of readOpenAIDataFrames(body)) {
         if (dataLine === "[DONE]") {
             for (const event of normalizer.finish()) {
                 applyCollectedEvent(collected, event);
             }
-            continue;
+            break;
         }
         let event;
         try {
@@ -86,6 +53,11 @@ export async function collectOpenAIResponsesStream(body, options = {}) {
         for (const normalized of normalizer.consume(event)) {
             applyCollectedEvent(collected, normalized);
         }
+        if (normalizer.hasTerminated)
+            break;
+    }
+    for (const event of normalizer.end()) {
+        applyCollectedEvent(collected, event);
     }
     return {
         text: collected.text,

package/dist/src/model-gateway/providers/openai/structured-message-output.d.ts

@@ -0,0 +1,42 @@
+type MessagePhase = "commentary" | "final_answer";
+type OutputDiagnostic = Readonly<{
+    itemId: string | null;
+    outputIndex: number | null;
+    arrivalOrder: number;
+    textByteCount: number;
+    phase?: MessagePhase;
+}>;
+export type OpenAIMessageOutputNormalizationDiagnostic = Readonly<{
+    outcome: "additional_message_outputs_ignored";
+    outputCount: number;
+    selectedOutput: OutputDiagnostic;
+    ignoredOutputCount: number;
+    sampledIgnoredOutputs: readonly OutputDiagnostic[];
+    omittedIgnoredOutputCount: number;
+}>;
+/** One invocation's structured result; never infer its phase from generated text. */
+export declare class OpenAIStructuredMessageOutput {
+    private readonly outputs;
+    private readonly byItemId;
+    private readonly byOutputIndex;
+    private unidentifiedOutput;
+    private firstTextOutput;
+    private selectedOutput;
+    private hasExplicitPhase;
+    private nextOutputOrder;
+    private nextChunkSequence;
+    observeItem(event: Record<string, unknown>): string[];
+    observeResponse(value: unknown): string[];
+    consumeDelta(event: Record<string, unknown>, text: string): string[];
+    finish(): {
+        text: string[];
+        error?: string;
+    };
+    diagnostic(): OpenAIMessageOutputNormalizationDiagnostic | undefined;
+    private selectFinalOutput;
+    private takeSelectedText;
+    private mergeOutputs;
+    private reconcileOutputs;
+    private resolveOutput;
+}
+export {};