@uncensoredcode/openbridge 0.1.0

package/packages/server/dist/bridge/providers/provider-streams.js

@@ -0,0 +1,844 @@
+import { bridgeRuntime } from "@uncensoredcode/openbridge/runtime";
+import { outputModule } from "../../shared/output.js";
+const { extractPacketMessage, ProviderFailure } = bridgeRuntime;
+const { sanitizeBridgeApiOutput } = outputModule;
+async function collectSseCompletion(stream, pushEvent, finalizeContent) {
+    const completion = await collectProviderCompletion(stream, pushEvent);
+    return {
+        ...completion,
+        content: finalizeContent ? finalizeContent(completion.content) : completion.content
+    };
+}
+async function* streamSseFragments(stream, pushEvent, onComplete) {
+    yield* streamProviderFragments(stream, pushEvent, onComplete);
+}
+async function* streamVisibleProviderCompletion(stream, pushEvent, onComplete) {
+    const rawFragments = [];
+    let emittedContent = "";
+    for await (const fragment of streamProviderFragments(stream, pushEvent, onComplete)) {
+        rawFragments.push(fragment.content);
+        const visibleContent = extractIncrementalPacketMessage(rawFragments.join(""));
+        if (visibleContent.startsWith(emittedContent) &&
+            visibleContent.length > emittedContent.length) {
+            const delta = visibleContent.slice(emittedContent.length);
+            emittedContent = visibleContent;
+            yield delta;
+        }
+    }
+    const finalContent = sanitizeBridgeApiOutput(rawFragments.join("")).content;
+    if (finalContent.startsWith(emittedContent) && finalContent.length > emittedContent.length) {
+        yield finalContent.slice(emittedContent.length);
+    }
+    else if (!emittedContent && finalContent) {
+        yield finalContent;
+    }
+}
+function createSseJsonEventParser(input) {
+    const contentPaths = input.contentPaths.map((path) => splitPath(path));
+    const responseIdPaths = (input.responseIdPaths ?? []).map((path) => splitPath(path));
+    const conversationIdPaths = (input.conversationIdPaths ?? []).map((path) => splitPath(path));
+    const eventFilters = (input.eventFilters ?? []).map((filter) => ({
+        path: splitPath(filter.path),
+        equals: filter.equals
+    }));
+    const patchState = createPatchContentState();
+    return (parts, rawLine, currentResponseId, currentConversationId) => {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("event:")) {
+            return {
+                responseId: currentResponseId,
+                conversationId: currentConversationId,
+                eventCountDelta: 0,
+                fragmentCountDelta: 0
+            };
+        }
+        const normalized = line.startsWith("data:") ? line.slice("data:".length).trim() : line;
+        if (!normalized || normalized === "[DONE]") {
+            return {
+                responseId: currentResponseId,
+                conversationId: currentConversationId,
+                eventCountDelta: 0,
+                fragmentCountDelta: 0
+            };
+        }
+        try {
+            const payload = JSON.parse(normalized);
+            const responseId = extractConfiguredString(payload, responseIdPaths) || currentResponseId;
+            const conversationId = extractConfiguredString(payload, conversationIdPaths) || currentConversationId;
+            if (!matchesEventFilters(payload, eventFilters)) {
+                return {
+                    responseId,
+                    conversationId,
+                    eventCountDelta: 0,
+                    fragmentCountDelta: 0
+                };
+            }
+            const fragments = extractConfiguredFragments(payload, contentPaths);
+            const patchedFragments = fragments.length === 0 ? extractPatchedContentFragments(payload, patchState) : [];
+            if (patchedFragments.length > 0) {
+                fragments.push(...patchedFragments);
+            }
+            parts.push(...fragments);
+            return {
+                responseId,
+                conversationId,
+                eventCountDelta: 1,
+                fragmentCountDelta: fragments.length
+            };
+        }
+        catch {
+            return {
+                responseId: currentResponseId,
+                conversationId: currentConversationId,
+                eventCountDelta: 0,
+                fragmentCountDelta: 0
+            };
+        }
+    };
+}
+async function collectConnectJsonCompletion(stream, input, finalizeContent) {
+    const completion = await collectConnectProviderCompletion(stream, input);
+    return {
+        ...completion,
+        content: finalizeContent ? finalizeContent(completion.content) : completion.content
+    };
+}
+async function* streamConnectJsonFragments(stream, input, onComplete) {
+    yield* streamConnectProviderFragments(stream, input, onComplete);
+}
+function extractIncrementalPacketMessage(content) {
+    const finalStart = content.search(/<final>/i);
+    if (finalStart >= 0) {
+        const finalContent = content.slice(finalStart + "<final>".length);
+        const finalEnd = finalContent.search(/<\/final>/i);
+        return finalEnd >= 0 ? finalContent.slice(0, finalEnd) : finalContent;
+    }
+    const packetStart = content.search(/<(?:zc_packet|packet)\b/i);
+    if (packetStart < 0) {
+        return "";
+    }
+    const packetContent = content.slice(packetStart);
+    const messageStartMatch = packetContent.match(/<message>/i);
+    if (!messageStartMatch) {
+        return "";
+    }
+    const messageStartIndex = (messageStartMatch.index ?? 0) + messageStartMatch[0].length;
+    const messageBody = packetContent.slice(messageStartIndex);
+    if (/^<!\[CDATA\[/i.test(messageBody)) {
+        const cdataBody = messageBody.slice("<![CDATA[".length);
+        const cdataEnd = cdataBody.indexOf("]]>");
+        return cdataEnd >= 0 ? (extractPacketMessage(packetContent) ?? "") : cdataBody;
+    }
+    const messageEnd = messageBody.search(/<\/message>/i);
+    if (messageEnd >= 0) {
+        const messageContent = messageBody.slice(0, messageEnd);
+        return /</.test(messageContent) ? "" : messageContent;
+    }
+    return /</.test(messageBody) ? "" : messageBody;
+}
+function normalizeLeadingAssistantBlock(content) {
+    const trimmed = content.trim();
+    return (extractLeadingSimpleAssistantBlock(trimmed, "final") ??
+        extractLeadingSimpleAssistantBlock(trimmed, "tool") ??
+        extractLatestSimpleAssistantBlock(trimmed) ??
+        trimmed);
+}
+async function collectProviderCompletion(stream, pushEvent) {
+    if (!stream) {
+        return {
+            content: "",
+            responseId: "",
+            conversationId: "",
+            eventCount: 0,
+            fragmentCount: 0
+        };
+    }
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const parts = [];
+    let responseId = "";
+    let conversationId = "";
+    let eventCount = 0;
+    let fragmentCount = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const rawLine of lines) {
+            const result = pushEvent(parts, rawLine, responseId, conversationId);
+            responseId = result.responseId;
+            conversationId = result.conversationId;
+            eventCount += result.eventCountDelta;
+            fragmentCount += result.fragmentCountDelta;
+        }
+    }
+    const finalResult = pushEvent(parts, buffer, responseId, conversationId);
+    return {
+        content: parts.join("").trim(),
+        responseId: finalResult.responseId,
+        conversationId: finalResult.conversationId,
+        eventCount: eventCount + finalResult.eventCountDelta,
+        fragmentCount: fragmentCount + finalResult.fragmentCountDelta
+    };
+}
+async function* streamProviderFragments(stream, pushEvent, onComplete) {
+    const rawFragments = [];
+    let responseId = "";
+    let conversationId = "";
+    let eventCount = 0;
+    let fragmentCount = 0;
+    for await (const fragment of iterateProviderFragments(stream, pushEvent)) {
+        rawFragments.push(fragment.content);
+        responseId = fragment.responseId;
+        conversationId = fragment.conversationId;
+        eventCount += fragment.eventCountDelta;
+        fragmentCount += fragment.fragmentCountDelta;
+        yield fragment;
+    }
+    onComplete?.({
+        content: rawFragments.join("").trim(),
+        responseId,
+        conversationId,
+        eventCount,
+        fragmentCount
+    });
+}
+async function* iterateProviderFragments(stream, pushEvent) {
+    if (!stream) {
+        return;
+    }
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let responseId = "";
+    let conversationId = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const rawLine of lines) {
+            const parts = [];
+            const result = pushEvent(parts, rawLine, responseId, conversationId);
+            responseId = result.responseId;
+            conversationId = result.conversationId;
+            for (const fragment of parts) {
+                if (fragment) {
+                    yield {
+                        content: fragment,
+                        responseId,
+                        conversationId,
+                        eventCountDelta: result.eventCountDelta,
+                        fragmentCountDelta: result.fragmentCountDelta
+                    };
+                }
+            }
+        }
+    }
+    const parts = [];
+    const result = pushEvent(parts, buffer, responseId, conversationId);
+    responseId = result.responseId;
+    conversationId = result.conversationId;
+    for (const fragment of parts) {
+        if (fragment) {
+            yield {
+                content: fragment,
+                responseId,
+                conversationId,
+                eventCountDelta: result.eventCountDelta,
+                fragmentCountDelta: result.fragmentCountDelta
+            };
+        }
+    }
+}
+async function collectConnectProviderCompletion(stream, input) {
+    const fragments = [];
+    let responseId = "";
+    let conversationId = "";
+    let eventCount = 0;
+    let fragmentCount = 0;
+    for await (const fragment of iterateConnectProviderFragments(stream, input)) {
+        fragments.push(fragment.content);
+        responseId = fragment.responseId;
+        conversationId = fragment.conversationId;
+        eventCount += fragment.eventCountDelta;
+        fragmentCount += fragment.fragmentCountDelta;
+    }
+    return {
+        content: fragments.join("").trim(),
+        responseId,
+        conversationId,
+        eventCount,
+        fragmentCount
+    };
+}
+async function* streamConnectProviderFragments(stream, input, onComplete) {
+    const rawFragments = [];
+    let responseId = "";
+    let conversationId = "";
+    let eventCount = 0;
+    let fragmentCount = 0;
+    for await (const fragment of iterateConnectProviderFragments(stream, input)) {
+        rawFragments.push(fragment.content);
+        responseId = fragment.responseId;
+        conversationId = fragment.conversationId;
+        eventCount += fragment.eventCountDelta;
+        fragmentCount += fragment.fragmentCountDelta;
+        yield fragment;
+    }
+    onComplete?.({
+        content: rawFragments.join("").trim(),
+        responseId,
+        conversationId,
+        eventCount,
+        fragmentCount
+    });
+}
+async function* iterateConnectProviderFragments(stream, input) {
+    if (!stream) {
+        return;
+    }
+    const reader = stream.getReader();
+    let buffer = new Uint8Array(0);
+    const contentPaths = input.contentPaths.map((path) => splitPath(path));
+    const responseIdPaths = (input.responseIdPaths ?? []).map((path) => splitPath(path));
+    const conversationIdPaths = (input.conversationIdPaths ?? []).map((path) => splitPath(path));
+    const eventFilters = (input.eventFilters ?? []).map((filter) => ({
+        path: splitPath(filter.path),
+        equals: filter.equals
+    }));
+    let responseId = "";
+    let conversationId = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer = concatUint8Arrays(buffer, value);
+        while (buffer.length >= 5) {
+            const messageLength = readConnectEnvelopeLength(buffer);
+            const totalLength = 5 + messageLength;
+            if (buffer.length < totalLength) {
+                break;
+            }
+            const envelope = buffer.slice(0, totalLength);
+            buffer = buffer.slice(totalLength);
+            const fragment = parseConnectEnvelope(envelope, contentPaths, responseIdPaths, conversationIdPaths, eventFilters, responseId, conversationId);
+            if (!fragment) {
+                continue;
+            }
+            responseId = fragment.responseId;
+            conversationId = fragment.conversationId;
+            yield fragment;
+        }
+    }
+    if (buffer.length > 0) {
+        throw new ProviderFailure({
+            kind: "permanent",
+            code: "request_invalid",
+            message: "Provider returned a truncated Connect stream.",
+            displayMessage: "Provider response format is invalid.",
+            retryable: false,
+            sessionResetEligible: false
+        });
+    }
+}
+function extractLeadingSimpleAssistantBlock(content, tag) {
+    const openTag = `<${tag}>`;
+    const closeTag = `</${tag}>`;
+    if (!content.startsWith(openTag)) {
+        return null;
+    }
+    const closeIndex = content.indexOf(closeTag);
+    if (closeIndex < 0) {
+        return null;
+    }
+    const inner = content.slice(openTag.length, closeIndex);
+    if (containsNestedAssistantBlockMarker(inner)) {
+        return null;
+    }
+    const block = content.slice(0, closeIndex + closeTag.length);
+    const trailing = content.slice(closeIndex + closeTag.length).trim();
+    if (!trailing) {
+        return block;
+    }
+    return trailing.includes("<") ? null : block;
+}
+function containsNestedAssistantBlockMarker(content) {
+    return /<(?:final|tool)>/i.test(content) || /(?:^|[^<])(?:final|tool)>/i.test(content);
+}
+function extractLatestSimpleAssistantBlock(content) {
+    const finalBlock = extractLastSimpleAssistantBlock(content, "final");
+    const toolBlock = extractLastSimpleAssistantBlock(content, "tool");
+    if (!finalBlock) {
+        return toolBlock?.block ?? null;
+    }
+    if (!toolBlock) {
+        return finalBlock.block;
+    }
+    return finalBlock.index >= toolBlock.index ? finalBlock.block : toolBlock.block;
+}
+function extractLastSimpleAssistantBlock(content, tag) {
+    const closeTag = `</${tag}>`;
+    const closeIndex = content.lastIndexOf(closeTag);
+    if (closeIndex < 0) {
+        return null;
+    }
+    const marker = new RegExp(`(?:<)?${tag}>`, "gi");
+    let latestMatch = null;
+    for (const match of content.matchAll(marker)) {
+        const index = match.index ?? -1;
+        if (index < 0 || index >= closeIndex) {
+            continue;
+        }
+        latestMatch = {
+            index,
+            markerLength: match[0].length
+        };
+    }
+    if (!latestMatch) {
+        return null;
+    }
+    return {
+        index: latestMatch.index,
+        block: `<${tag}>${content.slice(latestMatch.index + latestMatch.markerLength, closeIndex)}${closeTag}`
+    };
+}
+function splitPath(path) {
+    return path
+        .split(".")
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function extractConfiguredString(payload, paths) {
+    for (const path of paths) {
+        for (const value of extractPathValues(payload, path)) {
+            const normalized = normalizeProviderResponseId(value);
+            if (normalized) {
+                return normalized;
+            }
+        }
+    }
+    return "";
+}
+function extractConfiguredFragments(payload, paths) {
+    const fragments = [];
+    const filteredPaths = filterNonAssistantMessageContentPaths(payload, paths);
+    for (const path of filteredPaths) {
+        for (const value of extractPathValues(payload, path)) {
+            if (typeof value === "string" && value) {
+                const normalized = normalizeProviderContentFragment(value);
+                if (normalized) {
+                    fragments.push(normalized);
+                }
+            }
+        }
+    }
+    return fragments;
+}
+function createPatchContentState() {
+    return {
+        fragmentTypes: new Map(),
+        pendingContent: new Map(),
+        currentPath: "",
+        currentOp: "SET",
+        collectionLastIndex: new Map()
+    };
+}
+function extractPatchedContentFragments(payload, state) {
+    const fragments = [];
+    for (const operation of flattenPatchOperations(payload, state)) {
+        collectPatchContentFromStructuredValue(operation.value, state, fragments);
+        const fragmentPath = parseResponseFragmentPath(operation.path, state);
+        if (!fragmentPath) {
+            continue;
+        }
+        if (fragmentPath.kind === "collection") {
+            collectFragmentArray(fragmentPath.basePath, operation.value, state, fragments, operation.op);
+            continue;
+        }
+        if (fragmentPath.kind === "fragment") {
+            collectFragmentRecord(fragmentPath.basePath, operation.value, state, fragments);
+            continue;
+        }
+        if (fragmentPath.kind === "field" &&
+            fragmentPath.field === "type" &&
+            typeof operation.value === "string") {
+            setFragmentType(fragmentPath.basePath, operation.value, state, fragments);
+            continue;
+        }
+        if (fragmentPath.kind === "field" &&
+            fragmentPath.field === "content" &&
+            typeof operation.value === "string") {
+            pushFragmentContent(fragmentPath.basePath, operation.value, state, fragments);
+        }
+    }
+    return fragments;
+}
+function flattenPatchOperations(payload, state) {
+    const parserState = {
+        path: state.currentPath,
+        op: state.currentOp
+    };
+    const operations = flattenPatchOperation({
+        p: typeof payload.p === "string" ? payload.p : "",
+        o: typeof payload.o === "string" ? payload.o : "",
+        v: "v" in payload ? payload.v : payload
+    }, parserState);
+    state.currentPath = parserState.path;
+    state.currentOp = parserState.op;
+    return operations;
+}
+function flattenPatchOperation(input, parserState) {
+    const operation = input.o.trim().toUpperCase() || parserState.op || "SET";
+    const path = input.p.trim() || parserState.path || "";
+    parserState.op = operation;
+    parserState.path = path;
+    if (operation !== "BATCH") {
+        return [
+            {
+                path,
+                op: operation,
+                value: input.v
+            }
+        ];
+    }
+    if (!Array.isArray(input.v)) {
+        return [];
+    }
+    const batchState = {
+        path: "",
+        op: "SET"
+    };
+    return input.v.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return [];
+        }
+        const record = entry;
+        return flattenPatchOperation({
+            p: typeof record.p === "string" ? record.p : "",
+            o: typeof record.o === "string" ? record.o : "",
+            v: "v" in record ? record.v : record
+        }, batchState).map((nestedOperation) => ({
+            ...nestedOperation,
+            path: joinPatchPaths(path, nestedOperation.path)
+        }));
+    });
+}
+function joinPatchPaths(basePath, nextPath) {
+    if (!basePath) {
+        return nextPath;
+    }
+    if (!nextPath) {
+        return basePath;
+    }
+    const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+    const normalizedNext = nextPath.startsWith("/") ? nextPath.slice(1) : nextPath;
+    return `${normalizedBase}/${normalizedNext}`;
+}
+function collectPatchContentFromStructuredValue(value, state, fragments) {
+    for (const [path, basePath] of [
+        ["response.fragments", "/response/fragments"],
+        ["v.response.fragments", "/response/fragments"],
+        ["fragments", "/response/fragments"]
+    ]) {
+        const fragmentArrays = extractPathValues(value, splitPath(path));
+        for (const fragmentArray of fragmentArrays) {
+            collectFragmentArray(basePath, fragmentArray, state, fragments, "SET");
+        }
+    }
+}
+function collectFragmentArray(basePath, value, state, fragments, operation) {
+    if (!Array.isArray(value)) {
+        return;
+    }
+    const startIndex = operation === "APPEND" ? (state.collectionLastIndex.get(basePath) ?? -1) + 1 : 0;
+    value.forEach((entry, index) => {
+        collectFragmentRecord(`${basePath}/${startIndex + index}`, entry, state, fragments);
+    });
+    state.collectionLastIndex.set(basePath, startIndex + value.length - 1);
+}
+function collectFragmentRecord(basePath, value, state, fragments) {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    const record = value;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type) {
+        setFragmentType(basePath, type, state, fragments);
+    }
+    if (typeof record.content === "string") {
+        pushFragmentContent(basePath, record.content, state, fragments);
+    }
+}
+function setFragmentType(basePath, type, state, fragments) {
+    const normalizedType = type.trim().toUpperCase();
+    if (!normalizedType) {
+        return;
+    }
+    state.fragmentTypes.set(basePath, normalizedType);
+    const pending = state.pendingContent.get(basePath) ?? [];
+    state.pendingContent.delete(basePath);
+    if (!isVisibleResponseFragmentType(normalizedType)) {
+        return;
+    }
+    for (const content of pending) {
+        if (content) {
+            fragments.push(content);
+        }
+    }
+}
+function pushFragmentContent(basePath, content, state, fragments) {
+    if (!content) {
+        return;
+    }
+    const type = state.fragmentTypes.get(basePath);
+    if (!type) {
+        fragments.push(content);
+        return;
+    }
+    if (isVisibleResponseFragmentType(type)) {
+        fragments.push(content);
+    }
+}
+function isVisibleResponseFragmentType(type) {
+    return type === "RESPONSE" || type === "TEMPLATE_RESPONSE";
+}
+function parseResponseFragmentPath(path, state) {
+    const segments = path
+        .split("/")
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return null;
+    }
+    const normalized = segments.map((segment) => segment.toLowerCase());
+    const rootOffset = normalized[0] === "response" ? 1 : 0;
+    if (normalized[rootOffset] !== "fragments") {
+        return null;
+    }
+    const basePathRoot = "/response/fragments";
+    if (normalized.length === rootOffset + 1) {
+        return {
+            kind: "collection",
+            basePath: basePathRoot
+        };
+    }
+    const fragmentIndexToken = normalized[rootOffset + 1] ?? "";
+    const fragmentIndex = fragmentIndexToken === "-1"
+        ? (state.collectionLastIndex.get(basePathRoot) ?? -1)
+        : Number.parseInt(fragmentIndexToken, 10);
+    if (!Number.isInteger(fragmentIndex)) {
+        return null;
+    }
+    const basePath = `${basePathRoot}/${fragmentIndex}`;
+    if (normalized.length === rootOffset + 2) {
+        return {
+            kind: "fragment",
+            basePath
+        };
+    }
+    return {
+        kind: "field",
+        basePath,
+        field: normalized[rootOffset + 2] ?? ""
+    };
+}
+function filterNonAssistantMessageContentPaths(payload, paths) {
+    const message = readProviderMessageRecord(payload);
+    if (!message || typeof message !== "object") {
+        return paths;
+    }
+    const role = readProviderMessageRole(message);
+    if (!role || role === "assistant") {
+        return paths;
+    }
+    return paths.filter((path) => path[0] !== "message");
+}
+function readProviderMessageRecord(payload) {
+    const direct = payload.message;
+    if (direct && typeof direct === "object") {
+        return direct;
+    }
+    const nestedValue = payload.v;
+    if (!nestedValue || typeof nestedValue !== "object") {
+        return null;
+    }
+    const nestedMessage = nestedValue.message;
+    return nestedMessage && typeof nestedMessage === "object"
+        ? nestedMessage
+        : null;
+}
+function readProviderMessageRole(message) {
+    const directRole = typeof message.role === "string" ? message.role.trim().toLowerCase() : "";
+    if (directRole) {
+        return directRole;
+    }
+    const author = message.author;
+    if (!author || typeof author !== "object") {
+        return "";
+    }
+    return typeof author.role === "string"
+        ? String(author.role)
+            .trim()
+            .toLowerCase()
+        : "";
+}
+function normalizeProviderContentFragment(value) {
+    if (isHiddenInlineReferenceToken(value)) {
+        return "";
+    }
+    return value;
+}
+function isHiddenInlineReferenceToken(value) {
+    return /^\uE200[A-Za-z0-9_-]+\uE202[\s\S]*\uE201$/u.test(value.trim());
+}
+function extractPathValues(value, segments) {
+    if (segments.length === 0) {
+        return [value];
+    }
+    if (value === null || value === undefined) {
+        return [];
+    }
+    const [segment, ...rest] = segments;
+    if (segment === "*") {
+        if (Array.isArray(value)) {
+            return value.flatMap((entry) => extractPathValues(entry, rest));
+        }
+        if (typeof value === "object") {
+            return Object.values(value).flatMap((entry) => extractPathValues(entry, rest));
+        }
+        return [];
+    }
+    if (Array.isArray(value)) {
+        const index = Number.parseInt(segment, 10);
+        if (!Number.isInteger(index)) {
+            return [];
+        }
+        return extractPathValues(value[index], rest);
+    }
+    if (typeof value === "object") {
+        return extractPathValues(value[segment], rest);
+    }
+    return [];
+}
+function normalizeProviderResponseId(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    return "";
+}
+function parseConnectEnvelope(envelope, contentPaths, responseIdPaths, conversationIdPaths, eventFilters, currentResponseId, currentConversationId) {
+    const flags = envelope[0] ?? 0;
+    if ((flags & 0x01) !== 0) {
+        throw new ProviderFailure({
+            kind: "permanent",
+            code: "request_invalid",
+            message: "Provider returned a compressed Connect message, which is not supported yet.",
+            displayMessage: "Provider response format is unsupported.",
+            retryable: false,
+            sessionResetEligible: false
+        });
+    }
+    const payloadBytes = envelope.slice(5);
+    const payloadText = new TextDecoder().decode(payloadBytes).trim();
+    if (!payloadText) {
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(payloadText);
+    }
+    catch {
+        return null;
+    }
+    if ((flags & 0x02) !== 0) {
+        const error = readConnectEndStreamError(payload);
+        if (error) {
+            throw new ProviderFailure({
+                kind: error.retryable ? "transient" : "permanent",
+                code: error.retryable ? "transport_error" : "request_invalid",
+                message: `Provider Connect stream ended with error code "${error.code}"${error.message ? `: ${error.message}` : "."}`,
+                displayMessage: error.message || "Provider request failed.",
+                retryable: error.retryable,
+                sessionResetEligible: false,
+                details: {
+                    upstreamCode: error.code
+                }
+            });
+        }
+        return null;
+    }
+    const nextResponseId = extractConfiguredString(payload, responseIdPaths) || currentResponseId;
+    const nextConversationId = extractConfiguredString(payload, conversationIdPaths) || currentConversationId;
+    if (!matchesEventFilters(payload, eventFilters)) {
+        return {
+            content: "",
+            responseId: nextResponseId,
+            conversationId: nextConversationId,
+            eventCountDelta: 0,
+            fragmentCountDelta: 0
+        };
+    }
+    const fragments = extractConfiguredFragments(payload, contentPaths);
+    return {
+        content: fragments.join(""),
+        responseId: nextResponseId,
+        conversationId: nextConversationId,
+        eventCountDelta: fragments.length > 0 ? 1 : 0,
+        fragmentCountDelta: fragments.length
+    };
+}
+function matchesEventFilters(payload, filters) {
+    if (filters.length === 0) {
+        return true;
+    }
+    return filters.every((filter) => extractPathValues(payload, filter.path).some((value) => value === filter.equals));
+}
+function readConnectEnvelopeLength(buffer) {
+    return (((buffer[1] ?? 0) << 24) | ((buffer[2] ?? 0) << 16) | ((buffer[3] ?? 0) << 8) | (buffer[4] ?? 0));
+}
+function concatUint8Arrays(left, right) {
+    const combined = new Uint8Array(left.length + right.length);
+    combined.set(left, 0);
+    combined.set(right, left.length);
+    return combined;
+}
+function readConnectEndStreamError(payload) {
+    const error = payload.error;
+    if (typeof error !== "object" || error === null) {
+        return null;
+    }
+    const record = error;
+    const code = typeof record.code === "string" ? record.code.trim() : "";
+    if (!code) {
+        return null;
+    }
+    const message = typeof record.message === "string" ? record.message.trim() : "";
+    return {
+        code,
+        message,
+        retryable: /^(aborted|deadline_exceeded|resource_exhausted|unavailable)$/i.test(code)
+    };
+}
+export const providerStreamsModule = {
+    collectSseCompletion,
+    streamSseFragments,
+    streamVisibleProviderCompletion,
+    createSseJsonEventParser,
+    collectConnectJsonCompletion,
+    streamConnectJsonFragments,
+    extractIncrementalPacketMessage,
+    normalizeLeadingAssistantBlock
+};