@uncensoredcode/openbridge 0.1.0

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

@@ -0,0 +1,194 @@
+import type { CompiledProviderMessage } from "@uncensoredcode/openbridge/runtime";
+import { z } from "zod";
+import type { ProviderRecord } from "../stores/provider-store.ts";
+declare const requestTemplateSchema: z.ZodObject<{
+    method: z.ZodDefault<z.ZodString>;
+    url: z.ZodString;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    signing: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"z-ai-v1">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const sessionPolicySchema: z.ZodObject<{
+    requireCookie: z.ZodDefault<z.ZodBoolean>;
+    requireBearerToken: z.ZodDefault<z.ZodBoolean>;
+    requireUserAgent: z.ZodDefault<z.ZodBoolean>;
+    includeExtraHeaders: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const promptPolicySchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        auto_join: "auto_join";
+        flatten: "flatten";
+        latest_user: "latest_user";
+    }>>;
+}, z.core.$strict>;
+declare const responseMappingSchema: z.ZodObject<{
+    contentPaths: z.ZodArray<z.ZodString>;
+    responseIdPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    conversationIdPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    eventFilters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strip>>>;
+    fallbackResponseId: z.ZodOptional<z.ZodEnum<{
+        assistantMessageId: "assistantMessageId";
+        userMessageId: "userMessageId";
+    }>>;
+    trimLeadingAssistantBlock: z.ZodDefault<z.ZodBoolean>;
+    allowVisibleTextFinal: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const bindingPolicySchema: z.ZodObject<{
+    firstTurn: z.ZodDefault<z.ZodEnum<{
+        seed: "seed";
+        empty: "empty";
+    }>>;
+}, z.core.$strict>;
+declare const bootstrapConfigSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        method: z.ZodDefault<z.ZodString>;
+        url: z.ZodString;
+        headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        signing: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"z-ai-v1">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    conversationIdPath: z.ZodString;
+    parentIdPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const preflightConfigSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        method: z.ZodDefault<z.ZodString>;
+        url: z.ZodString;
+        headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        signing: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"z-ai-v1">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    headerBindings: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    proofOfWork: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"sha3-wasm-salt-expiry">;
+        headerName: z.ZodString;
+        wasmUrl: z.ZodString;
+        algorithmPath: z.ZodString;
+        challengePath: z.ZodString;
+        saltPath: z.ZodString;
+        signaturePath: z.ZodString;
+        difficultyPath: z.ZodString;
+        expireAtPath: z.ZodString;
+        targetPathPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const seedBindingSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const transportFamilySchema: z.ZodEnum<{
+    "http-sse": "http-sse";
+    "http-json": "http-json";
+    "http-connect": "http-connect";
+}>;
+type ProviderTransportFamily = z.infer<typeof transportFamilySchema>;
+type ProviderPromptMode = z.infer<typeof promptPolicySchema>["mode"];
+type ProviderTransportProfile = {
+    family: ProviderTransportFamily;
+    models: string[];
+    prompt: z.infer<typeof promptPolicySchema>;
+    binding: z.infer<typeof bindingPolicySchema>;
+    session: z.infer<typeof sessionPolicySchema>;
+    request: z.infer<typeof requestTemplateSchema>;
+    response: z.infer<typeof responseMappingSchema>;
+    seedBinding?: z.infer<typeof seedBindingSchema>;
+    bootstrap?: z.infer<typeof bootstrapConfigSchema>;
+    preflight?: z.infer<typeof preflightConfigSchema>;
+};
+declare function resolveProviderTransportProfile(provider: ProviderRecord | null): {
+    prompt: {
+        mode: "auto_join" | "flatten" | "latest_user";
+    };
+    binding: {
+        firstTurn: "seed" | "empty";
+    };
+    session: {
+        requireCookie: boolean;
+        requireBearerToken: boolean;
+        requireUserAgent: boolean;
+        includeExtraHeaders: boolean;
+    };
+    request: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body?: unknown;
+        signing?: {
+            kind: "z-ai-v1";
+        } | undefined;
+    };
+    response: {
+        contentPaths: string[];
+        responseIdPaths: string[];
+        conversationIdPaths: string[];
+        eventFilters: {
+            path: string;
+            equals: string | number | boolean;
+        }[];
+        trimLeadingAssistantBlock: boolean;
+        allowVisibleTextFinal: boolean;
+        fallbackResponseId?: "assistantMessageId" | "userMessageId" | undefined;
+    };
+    seedBinding?: {
+        conversationId: string;
+        parentId?: string | undefined;
+    } | undefined;
+    bootstrap?: {
+        request: {
+            method: string;
+            url: string;
+            headers: Record<string, string>;
+            body?: unknown;
+            signing?: {
+                kind: "z-ai-v1";
+            } | undefined;
+        };
+        conversationIdPath: string;
+        parentIdPath?: string | undefined;
+    } | undefined;
+    preflight?: {
+        request: {
+            method: string;
+            url: string;
+            headers: Record<string, string>;
+            body?: unknown;
+            signing?: {
+                kind: "z-ai-v1";
+            } | undefined;
+        };
+        headerBindings: Record<string, string>;
+        proofOfWork?: {
+            kind: "sha3-wasm-salt-expiry";
+            headerName: string;
+            wasmUrl: string;
+            algorithmPath: string;
+            challengePath: string;
+            saltPath: string;
+            signaturePath: string;
+            difficultyPath: string;
+            expireAtPath: string;
+            targetPathPath?: string | undefined;
+        } | undefined;
+    } | undefined;
+    family: "http-sse" | "http-json" | "http-connect";
+    models: string[];
+} | null;
+declare function readConfiguredModelIds(config: Record<string, unknown>): string[];
+declare function defaultModelForProviderRecord(provider: ProviderRecord | null): string;
+declare function selectProviderPrompt(messages: CompiledProviderMessage[], mode: ProviderPromptMode): string;
+export declare const providerTransportProfileModule: {
+    resolveProviderTransportProfile: typeof resolveProviderTransportProfile;
+    readConfiguredModelIds: typeof readConfiguredModelIds;
+    defaultModelForProviderRecord: typeof defaultModelForProviderRecord;
+    selectProviderPrompt: typeof selectProviderPrompt;
+};
+export type { ProviderPromptMode, ProviderTransportFamily, ProviderTransportProfile };

package/packages/server/dist/bridge/providers/provider-transport-profile.js

@@ -0,0 +1,198 @@
+import { z } from "zod";
+const nonEmptyString = (field) => z.string().trim().min(1, `${field} is required.`);
+const stringMapSchema = z.record(z.string(), z.string()).default({});
+const requestSigningSchema = z
+    .object({
+    kind: z.literal("z-ai-v1")
+})
+    .strict();
+const requestTemplateSchema = z
+    .object({
+    method: nonEmptyString("method").default("POST"),
+    url: nonEmptyString("url"),
+    headers: stringMapSchema,
+    body: z.unknown().optional(),
+    signing: requestSigningSchema.optional()
+})
+    .strict();
+const sessionPolicySchema = z
+    .object({
+    requireCookie: z.boolean().default(false),
+    requireBearerToken: z.boolean().default(false),
+    requireUserAgent: z.boolean().default(false),
+    includeExtraHeaders: z.boolean().default(true)
+})
+    .strict();
+const promptPolicySchema = z
+    .object({
+    mode: z.enum(["auto_join", "flatten", "latest_user"]).default("auto_join")
+})
+    .strict();
+const responseMappingSchema = z
+    .object({
+    contentPaths: z
+        .array(nonEmptyString("content path"))
+        .min(1, "At least one content path is required."),
+    responseIdPaths: z.array(nonEmptyString("response id path")).default([]),
+    conversationIdPaths: z.array(nonEmptyString("conversation id path")).default([]),
+    eventFilters: z
+        .array(z.object({
+        path: nonEmptyString("event filter path"),
+        equals: z.union([z.string(), z.number(), z.boolean()])
+    }))
+        .default([]),
+    fallbackResponseId: z.enum(["assistantMessageId", "userMessageId"]).optional(),
+    trimLeadingAssistantBlock: z.boolean().default(false),
+    allowVisibleTextFinal: z.boolean().default(false)
+})
+    .strict();
+const bindingPolicySchema = z
+    .object({
+    firstTurn: z.enum(["seed", "empty"]).default("seed")
+})
+    .strict();
+const bootstrapConfigSchema = z
+    .object({
+    request: requestTemplateSchema,
+    conversationIdPath: nonEmptyString("conversationIdPath"),
+    parentIdPath: nonEmptyString("parentIdPath").optional()
+})
+    .strict();
+const proofOfWorkConfigSchema = z
+    .object({
+    kind: z.literal("sha3-wasm-salt-expiry"),
+    headerName: nonEmptyString("headerName"),
+    wasmUrl: z.string().url(),
+    algorithmPath: nonEmptyString("algorithmPath"),
+    challengePath: nonEmptyString("challengePath"),
+    saltPath: nonEmptyString("saltPath"),
+    signaturePath: nonEmptyString("signaturePath"),
+    difficultyPath: nonEmptyString("difficultyPath"),
+    expireAtPath: nonEmptyString("expireAtPath"),
+    targetPathPath: nonEmptyString("targetPathPath").optional()
+})
+    .strict();
+const preflightConfigSchema = z
+    .object({
+    request: requestTemplateSchema,
+    headerBindings: stringMapSchema.default({}),
+    proofOfWork: proofOfWorkConfigSchema.optional()
+})
+    .strict();
+const seedBindingSchema = z
+    .object({
+    conversationId: nonEmptyString("conversationId"),
+    parentId: nonEmptyString("parentId").optional()
+})
+    .strict();
+const transportConfigSchema = z
+    .object({
+    prompt: promptPolicySchema.default({
+        mode: "auto_join"
+    }),
+    binding: bindingPolicySchema.default({
+        firstTurn: "seed"
+    }),
+    session: sessionPolicySchema.default({
+        requireCookie: false,
+        requireBearerToken: false,
+        requireUserAgent: false,
+        includeExtraHeaders: true
+    }),
+    request: requestTemplateSchema,
+    response: responseMappingSchema,
+    seedBinding: seedBindingSchema.optional(),
+    bootstrap: bootstrapConfigSchema.optional(),
+    preflight: preflightConfigSchema.optional()
+})
+    .strict();
+const transportFamilySchema = z.enum(["http-sse", "http-json", "http-connect"]);
+function resolveProviderTransportProfile(provider) {
+    if (!provider) {
+        return null;
+    }
+    const family = transportFamilySchema.safeParse(provider.kind);
+    if (!family.success) {
+        return null;
+    }
+    const transportConfig = transportConfigSchema.safeParse(provider.config.transport ?? {});
+    if (!transportConfig.success) {
+        return null;
+    }
+    return {
+        family: family.data,
+        models: readConfiguredModelIds(provider.config),
+        ...transportConfig.data
+    };
+}
+function readConfiguredModelIds(config) {
+    const configuredModels = config.models;
+    if (!Array.isArray(configuredModels)) {
+        return [];
+    }
+    return [
+        ...new Set(configuredModels
+            .filter((value) => typeof value === "string")
+            .map((value) => value.trim()))
+    ]
+        .filter(Boolean)
+        .sort((left, right) => left.localeCompare(right));
+}
+function defaultModelForProviderRecord(provider) {
+    const models = provider ? readConfiguredModelIds(provider.config) : [];
+    return models[0] ?? null;
+}
+function selectProviderPrompt(messages, mode) {
+    if (messages.length === 0) {
+        return "";
+    }
+    if (isBridgeToolAwarePrompt(messages)) {
+        return messages
+            .map((message) => message.content.trim())
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    if (mode === "latest_user") {
+        return selectLatestUserPrompt(messages);
+    }
+    if (messages.length === 1) {
+        return messages[0].content.trim();
+    }
+    if (mode === "flatten") {
+        return flattenMessages(messages);
+    }
+    return flattenMessages(messages);
+}
+function selectLatestUserPrompt(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role === "user") {
+            return message.content.trim();
+        }
+    }
+    return messages[messages.length - 1].content.trim();
+}
+function isBridgeToolAwarePrompt(messages) {
+    const systemContent = messages
+        .filter((message) => message.role === "system")
+        .map((message) => message.content)
+        .join("\n\n");
+    const userContent = messages
+        .filter((message) => message.role === "user")
+        .map((message) => message.content)
+        .join("\n\n");
+    return (/OpenAI-compatible tool-calling adapter/i.test(systemContent) &&
+        /(Conversation transcript:|Current turn:|Prior turns are already present upstream\.)/i.test(userContent));
+}
+function flattenMessages(messages) {
+    return messages
+        .map((message) => `${message.role.toUpperCase()}:\n${message.content.trim()}`)
+        .join("\n\n")
+        .trim();
+}
+export const providerTransportProfileModule = {
+    resolveProviderTransportProfile,
+    readConfiguredModelIds,
+    defaultModelForProviderRecord,
+    selectProviderPrompt
+};

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

@@ -0,0 +1,30 @@
+import type { ProviderTransport, ProviderTransportRequest, ProviderTransportResponse } from "@uncensoredcode/openbridge/runtime";
+import type { FileBridgeStateStore } from "../state/file-bridge-state-store.ts";
+import type { ProviderRecord } from "../stores/provider-store.ts";
+import type { CollectedProviderTransportCompletion } from "./generic-provider-transport.ts";
+import type { BridgeProviderSessionResolver } from "./provider-session-resolver.ts";
+import type { ProviderStreamFragment } from "./provider-streams.ts";
+type StreamingProviderTransport = {
+    streamChat(request: ProviderTransportRequest): Promise<{
+        content: AsyncIterable<ProviderStreamFragment>;
+        upstreamBinding: Promise<Pick<NonNullable<ProviderTransportRequest["upstreamBinding"]>, "conversationId" | "parentId"> | null>;
+    }>;
+};
+declare class WebProviderTransport implements ProviderTransport {
+    #private;
+    constructor(input: {
+        providerSessionResolver: BridgeProviderSessionResolver;
+        loadProvider?: (providerId: string) => ProviderRecord | null;
+    });
+    completeChat(request: ProviderTransportRequest): Promise<ProviderTransportResponse>;
+    streamChat(request: ProviderTransportRequest): Promise<{
+        content: AsyncIterable<ProviderStreamFragment>;
+        upstreamBinding: Promise<Pick<NonNullable<ProviderTransportRequest["upstreamBinding"]>, "conversationId" | "parentId"> | null>;
+    }>;
+}
+declare function collectProviderTransportCompletion(stateStore: FileBridgeStateStore, request: ProviderTransportRequest): Promise<CollectedProviderTransportCompletion>;
+export declare const webProviderTransportModule: {
+    WebProviderTransport: typeof WebProviderTransport;
+    collectProviderTransportCompletion: typeof collectProviderTransportCompletion;
+};
+export type { StreamingProviderTransport, WebProviderTransport };

package/packages/server/dist/bridge/providers/web-provider-transport.js

@@ -0,0 +1,151 @@
+import { bridgeRuntime } from "@uncensoredcode/openbridge/runtime";
+import { genericProviderTransportModule } from "./generic-provider-transport.js";
+import { providerTransportProfileModule } from "./provider-transport-profile.js";
+const { ProviderFailure } = bridgeRuntime;
+const { collectGenericProviderCompletion, openGenericProviderStream } = genericProviderTransportModule;
+const { resolveProviderTransportProfile } = providerTransportProfileModule;
+class WebProviderTransport {
+    #providerSessionResolver;
+    #loadProvider;
+    constructor(input) {
+        this.#providerSessionResolver = input.providerSessionResolver;
+        this.#loadProvider = input.loadProvider ?? (() => null);
+    }
+    async completeChat(request) {
+        const result = await collectProviderTransportCompletionWithResolver(this.#providerSessionResolver, request, this.#loadProvider);
+        logCollectedCompletionSummary(request.requestId, result);
+        if (!result.completion.content) {
+            throw createEmptyCompletionFailure(result.providerId, result.completion, Boolean(request.upstreamBinding));
+        }
+        return {
+            content: result.completion.content,
+            upstreamBinding: result.upstreamBinding ?? request.upstreamBinding
+        };
+    }
+    async streamChat(request) {
+        return await openProviderTransportStreamWithResolver(this.#providerSessionResolver, request, this.#loadProvider);
+    }
+}
+function logCollectedCompletionSummary(requestId, result) {
+    console.log(`[BridgeTransport][${requestId}] provider_completion_collected ${JSON.stringify({
+        providerId: result.providerId,
+        modelId: result.modelId,
+        responseId: result.completion.responseId || null,
+        eventCount: result.completion.eventCount,
+        fragmentCount: result.completion.fragmentCount,
+        contentLength: result.completion.content.length,
+        contentPreview: summarizeProviderContent(result.completion.content)
+    })}`);
+}
+async function collectProviderTransportCompletion(stateStore, request) {
+    return collectProviderTransportCompletionWithResolver({
+        rootDir: stateStore.rootDir,
+        loadProviderSession: ({ providerId }) => stateStore.loadProviderSession(providerId)
+    }, request, () => null);
+}
+async function collectProviderTransportCompletionWithResolver(providerSessionResolver, request, loadProvider) {
+    const provider = loadProvider(request.providerId);
+    const profile = resolveProviderTransportProfile(provider);
+    if (!profile) {
+        throw unsupportedProviderFailure(provider);
+    }
+    const session = await providerSessionResolver.loadProviderSession({
+        providerId: request.providerId
+    });
+    if (!session) {
+        throw missingSessionFailure(request.providerId, providerSessionResolver.rootDir);
+    }
+    logProviderSessionSummary(request.requestId, request.providerId, profile.family, session);
+    return collectGenericProviderCompletion({
+        stateRoot: providerSessionResolver.rootDir,
+        session,
+        request,
+        profile
+    });
+}
+async function openProviderTransportStreamWithResolver(providerSessionResolver, request, loadProvider) {
+    const provider = loadProvider(request.providerId);
+    const profile = resolveProviderTransportProfile(provider);
+    if (!profile) {
+        throw unsupportedProviderFailure(provider);
+    }
+    const session = await providerSessionResolver.loadProviderSession({
+        providerId: request.providerId
+    });
+    if (!session) {
+        throw missingSessionFailure(request.providerId, providerSessionResolver.rootDir);
+    }
+    logProviderSessionSummary(request.requestId, request.providerId, profile.family, session);
+    return openGenericProviderStream({
+        stateRoot: providerSessionResolver.rootDir,
+        session,
+        request,
+        profile
+    });
+}
+function logProviderSessionSummary(requestId, providerId, providerKind, session) {
+    const cookieCount = typeof session.cookie === "string" && session.cookie
+        ? session.cookie.split(/;\s*/).filter(Boolean).length
+        : 0;
+    const extraHeaderNames = session.extraHeaders ? Object.keys(session.extraHeaders).sort() : [];
+    console.log(`[BridgeTransport][${requestId}] provider_session_resolved ${JSON.stringify({
+        providerId,
+        providerKind,
+        hasCookie: Boolean(session.cookie),
+        cookieCount,
+        hasBearerToken: Boolean(session.bearerToken),
+        hasUserAgent: Boolean(session.userAgent),
+        extraHeaderNames,
+        updatedAt: session.updatedAt ?? null
+    })}`);
+}
+function unsupportedProviderFailure(provider) {
+    const providerId = provider?.id ?? "";
+    const providerKind = provider?.kind ?? "";
+    return new ProviderFailure({
+        kind: "permanent",
+        code: "request_invalid",
+        message: `Provider "${providerId}" does not define a supported transport family${providerKind ? ` ("${providerKind}")` : ""}.`,
+        displayMessage: "Provider transport configuration is invalid for this request.",
+        retryable: false,
+        sessionResetEligible: false,
+        details: {
+            providerId: providerId || null,
+            providerKind: providerKind || null,
+            hasTransportConfig: Boolean(provider?.config.transport)
+        }
+    });
+}
+function missingSessionFailure(providerId, rootDir) {
+    return new ProviderFailure({
+        kind: "permanent",
+        code: "authentication_failed",
+        message: `No uploaded or legacy provider session exists for provider "${providerId}" under ${rootDir}.`,
+        displayMessage: "Provider authentication/session state is missing or expired.",
+        retryable: false,
+        sessionResetEligible: false
+    });
+}
+function createEmptyCompletionFailure(providerId, completion, hasBinding) {
+    const noExtractableContent = completion.eventCount > 0 && completion.fragmentCount === 0;
+    return new ProviderFailure({
+        kind: "transient",
+        code: noExtractableContent ? "empty_extracted_response" : "empty_response",
+        message: `${providerId} returned ${noExtractableContent ? "no extractable assistant content" : "an empty response"}.`,
+        retryable: true,
+        sessionResetEligible: hasBinding,
+        emptyOutput: true,
+        details: {
+            streamEventCount: completion.eventCount,
+            fragmentCount: completion.fragmentCount
+        }
+    });
+}
+function summarizeProviderContent(value, maxLength = 320) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength)}...`;
+}
+export const webProviderTransportModule = {
+    WebProviderTransport,
+    collectProviderTransportCompletion
+};

package/packages/server/dist/bridge/state/file-bridge-state-store.d.ts

@@ -0,0 +1,36 @@
+import type { BridgeSessionTurn, SessionBindingStore, UpstreamConversationBinding } from "@uncensoredcode/openbridge/runtime";
+type BridgeProviderSession = {
+    providerId: string;
+    cookie: string;
+    userAgent: string;
+    bearerToken: string;
+    extraHeaders?: Record<string, string>;
+    updatedAt: string;
+};
+declare class FileBridgeStateStore implements SessionBindingStore {
+    readonly rootDir: string;
+    constructor(rootDir: string);
+    loadProviderSession(providerId: string): Promise<BridgeProviderSession | null>;
+    loadBinding(providerId: string, sessionId: string): Promise<UpstreamConversationBinding | null>;
+    saveBinding(providerId: string, sessionId: string, binding: UpstreamConversationBinding): Promise<void>;
+    clearBinding(providerId: string, sessionId: string): Promise<void>;
+    loadSessionHistory(sessionId: string): Promise<BridgeSessionTurn[]>;
+    appendSessionTurn(sessionId: string, turn: BridgeSessionTurn): Promise<void>;
+    loadChatCompletionSession(providerId: string, modelKey: string, lookupKey: string): Promise<string | null>;
+    loadSharedChatCompletionSession(lookupKey: string): Promise<string | null>;
+    saveChatCompletionSession(providerId: string, modelKey: string, lookupKey: string, sessionId: string): Promise<void>;
+    saveSharedChatCompletionSession(lookupKey: string, sessionId: string, metadata?: {
+        providerId?: string;
+        modelKey?: string;
+    }): Promise<void>;
+    private readStoredSessionHistory;
+    private getProviderSessionPath;
+    private getConversationPath;
+    private getSessionHistoryPath;
+    private getChatCompletionContinuationPath;
+    private getSharedChatCompletionContinuationPath;
+}
+export declare const fileBridgeStateStoreModule: {
+    FileBridgeStateStore: typeof FileBridgeStateStore;
+};
+export type { BridgeProviderSession, FileBridgeStateStore };