@uncensoredcode/openbridge 0.1.0

package/packages/server/dist/bridge/providers/provider-session-resolver.d.ts

@@ -0,0 +1,17 @@
+import type { BridgeProviderSession } from "../state/file-bridge-state-store.ts";
+import type { FileBridgeStateStore } from "../state/file-bridge-state-store.ts";
+import type { SessionPackageStore } from "../stores/session-package-store.ts";
+type BridgeProviderSessionResolver = {
+    rootDir: string;
+    loadProviderSession(input: {
+        providerId: string;
+    }): Promise<BridgeProviderSession | null>;
+};
+declare function createBridgeProviderSessionResolver(input: {
+    sessionPackageStore?: SessionPackageStore;
+    stateStore: FileBridgeStateStore;
+}): BridgeProviderSessionResolver;
+export declare const providerSessionResolverModule: {
+    createBridgeProviderSessionResolver: typeof createBridgeProviderSessionResolver;
+};
+export type { BridgeProviderSessionResolver };

package/packages/server/dist/bridge/providers/provider-session-resolver.js

@@ -0,0 +1,95 @@
+const DEFAULT_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome Safari/537.36";
+function createBridgeProviderSessionResolver(input) {
+    return {
+        rootDir: input.stateStore.rootDir,
+        async loadProviderSession({ providerId }) {
+            const uploaded = input.sessionPackageStore?.get(providerId);
+            const normalizedUploaded = uploaded
+                ? normalizeUploadedSessionPackage(providerId, uploaded)
+                : null;
+            if (normalizedUploaded) {
+                return normalizedUploaded;
+            }
+            const legacyProviderSession = await input.stateStore.loadProviderSession(providerId);
+            if (legacyProviderSession) {
+                return legacyProviderSession;
+            }
+            return null;
+        }
+    };
+}
+function normalizeUploadedSessionPackage(providerId, stored) {
+    const cookie = serializeCookies(stored.cookies);
+    const userAgent = readHeaderValue(stored.headers, "user-agent") || DEFAULT_USER_AGENT;
+    const authorization = readHeaderValue(stored.headers, "authorization");
+    const bearerToken = extractBearerToken(authorization);
+    const extraHeaders = extractExtraHeaders(stored.headers);
+    if (!cookie && !bearerToken && Object.keys(extraHeaders).length === 0) {
+        return null;
+    }
+    return {
+        providerId,
+        cookie,
+        userAgent,
+        bearerToken,
+        extraHeaders,
+        updatedAt: stored.capturedAt
+    };
+}
+function serializeCookies(cookies) {
+    const parts = [];
+    for (const cookie of cookies) {
+        if (typeof cookie !== "object" || cookie === null) {
+            continue;
+        }
+        const name = "name" in cookie && typeof cookie.name === "string" ? cookie.name.trim() : "";
+        const value = "value" in cookie && typeof cookie.value === "string" ? cookie.value : "";
+        if (!name) {
+            continue;
+        }
+        parts.push(`${name}=${value}`);
+    }
+    return parts.join("; ");
+}
+function readHeaderValue(headers, headerName) {
+    const target = headerName.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== target || typeof value !== "string") {
+            continue;
+        }
+        const trimmed = value.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return "";
+}
+function extractBearerToken(value) {
+    if (!value || !/^Bearer\s+/i.test(value)) {
+        return "";
+    }
+    return value.replace(/^Bearer\s+/i, "").trim();
+}
+function extractExtraHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const normalizedKey = key.toLowerCase();
+        if (normalizedKey === "authorization" ||
+            normalizedKey === "user-agent" ||
+            normalizedKey === "cookie") {
+            continue;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            continue;
+        }
+        result[key] = trimmed;
+    }
+    return result;
+}
+export const providerSessionResolverModule = {
+    createBridgeProviderSessionResolver
+};

package/packages/server/dist/bridge/providers/provider-streams.d.ts

@@ -0,0 +1,80 @@
+type CollectedProviderCompletion = {
+    content: string;
+    responseId: string;
+    conversationId: string;
+    eventCount: number;
+    fragmentCount: number;
+};
+type ProviderStreamFragment = {
+    content: string;
+    responseId: string;
+    conversationId: string;
+    eventCountDelta: number;
+    fragmentCountDelta: number;
+};
+type ProviderStreamEventParser = (parts: string[], rawLine: string, currentResponseId: string, currentConversationId: string) => {
+    responseId: string;
+    conversationId: string;
+    eventCountDelta: number;
+    fragmentCountDelta: number;
+};
+declare function collectSseCompletion(stream: ReadableStream<Uint8Array> | null, pushEvent: ProviderStreamEventParser, finalizeContent?: (content: string) => string): Promise<{
+    content: string;
+    responseId: string;
+    conversationId: string;
+    eventCount: number;
+    fragmentCount: number;
+}>;
+declare function streamSseFragments(stream: ReadableStream<Uint8Array> | null, pushEvent: ProviderStreamEventParser, onComplete?: (completion: CollectedProviderCompletion) => void): AsyncGenerator<ProviderStreamFragment, void, unknown>;
+declare function streamVisibleProviderCompletion(stream: ReadableStream<Uint8Array> | null, pushEvent: ProviderStreamEventParser, onComplete?: (completion: CollectedProviderCompletion) => void): AsyncGenerator<string, void, unknown>;
+declare function createSseJsonEventParser(input: {
+    contentPaths: string[];
+    responseIdPaths?: string[];
+    conversationIdPaths?: string[];
+    eventFilters?: Array<{
+        path: string;
+        equals: string | number | boolean;
+    }>;
+}): (parts: string[], rawLine: string, currentResponseId: string, currentConversationId: string) => {
+    responseId: string;
+    conversationId: string;
+    eventCountDelta: number;
+    fragmentCountDelta: number;
+};
+declare function collectConnectJsonCompletion(stream: ReadableStream<Uint8Array> | null, input: {
+    contentPaths: string[];
+    responseIdPaths?: string[];
+    conversationIdPaths?: string[];
+    eventFilters?: Array<{
+        path: string;
+        equals: string | number | boolean;
+    }>;
+}, finalizeContent?: (content: string) => string): Promise<{
+    content: string;
+    responseId: string;
+    conversationId: string;
+    eventCount: number;
+    fragmentCount: number;
+}>;
+declare function streamConnectJsonFragments(stream: ReadableStream<Uint8Array> | null, input: {
+    contentPaths: string[];
+    responseIdPaths?: string[];
+    conversationIdPaths?: string[];
+    eventFilters?: Array<{
+        path: string;
+        equals: string | number | boolean;
+    }>;
+}, onComplete?: (completion: CollectedProviderCompletion) => void): AsyncGenerator<ProviderStreamFragment, void, unknown>;
+declare function extractIncrementalPacketMessage(content: string): string;
+declare function normalizeLeadingAssistantBlock(content: string): string;
+export declare const providerStreamsModule: {
+    collectSseCompletion: typeof collectSseCompletion;
+    streamSseFragments: typeof streamSseFragments;
+    streamVisibleProviderCompletion: typeof streamVisibleProviderCompletion;
+    createSseJsonEventParser: typeof createSseJsonEventParser;
+    collectConnectJsonCompletion: typeof collectConnectJsonCompletion;
+    streamConnectJsonFragments: typeof streamConnectJsonFragments;
+    extractIncrementalPacketMessage: typeof extractIncrementalPacketMessage;
+    normalizeLeadingAssistantBlock: typeof normalizeLeadingAssistantBlock;
+};
+export type { CollectedProviderCompletion, ProviderStreamEventParser, ProviderStreamFragment };