glirastes 0.3.0 → 0.3.2

package/dist/cjs/openapi/index.d.ts

@@ -0,0 +1,78 @@
+import type { EndpointMethod, OpenApiAiExtension } from '../types.js';
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+interface OpenApiReference {
+    $ref: string;
+}
+interface OpenApiSchema {
+    type?: string;
+    format?: string;
+    enum?: unknown[];
+    items?: OpenApiSchema | OpenApiReference;
+    properties?: Record<string, OpenApiSchema | OpenApiReference>;
+    required?: string[];
+    additionalProperties?: boolean | OpenApiSchema | OpenApiReference;
+}
+interface OpenApiMediaType {
+    schema?: OpenApiSchema | OpenApiReference;
+}
+interface OpenApiRequestBody {
+    required?: boolean;
+    content?: Record<string, OpenApiMediaType>;
+}
+interface OpenApiParameter {
+    name: string;
+    in: ParameterLocation;
+    required?: boolean;
+    schema?: OpenApiSchema | OpenApiReference;
+}
+interface OpenApiOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    parameters?: Array<OpenApiParameter | OpenApiReference>;
+    requestBody?: OpenApiRequestBody | OpenApiReference;
+    'x-ai'?: OpenApiAiExtension;
+}
+interface OpenApiPathItem {
+    parameters?: Array<OpenApiParameter | OpenApiReference>;
+    get?: OpenApiOperation;
+    post?: OpenApiOperation;
+    patch?: OpenApiOperation;
+    put?: OpenApiOperation;
+    delete?: OpenApiOperation;
+}
+interface OpenApiComponents {
+    schemas?: Record<string, OpenApiSchema>;
+    parameters?: Record<string, OpenApiParameter>;
+    requestBodies?: Record<string, OpenApiRequestBody>;
+}
+interface OpenApiDocument {
+    paths?: Record<string, OpenApiPathItem>;
+    components?: OpenApiComponents;
+}
+interface ValidationResult {
+    enabledTools: number;
+    errors: string[];
+    warnings: string[];
+}
+export interface GeneratedToolSpec {
+    id: string;
+    toolName: string;
+    description: string;
+    method: EndpointMethod;
+    path: string;
+    needsApproval: boolean;
+    inputSchemaCode: string;
+    uiActionOnSuccess?: Record<string, unknown> | Record<string, unknown>[];
+}
+export declare function validateOpenApiDocument(document: OpenApiDocument): ValidationResult;
+export declare function extractGeneratedToolSpecs(document: OpenApiDocument): GeneratedToolSpec[];
+export declare function renderTypeScriptFromSpecs(specs: GeneratedToolSpec[]): string;
+export declare function validateOpenApiFile(options: {
+    inputPath: string;
+}): Promise<ValidationResult>;
+export declare function generateFromOpenApiFile(options: {
+    inputPath: string;
+    outputPath: string;
+}): Promise<ValidationResult>;
+export {};

package/dist/cjs/openapi/index.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOpenApiDocument = validateOpenApiDocument;
+exports.extractGeneratedToolSpecs = extractGeneratedToolSpecs;
+exports.renderTypeScriptFromSpecs = renderTypeScriptFromSpecs;
+exports.validateOpenApiFile = validateOpenApiFile;
+exports.generateFromOpenApiFile = generateFromOpenApiFile;
+const promises_1 = require("node:fs/promises");
+const SUPPORTED_METHODS = ['get', 'post', 'patch', 'put', 'delete'];
+const MUTATING_METHODS = new Set(['post', 'patch', 'put', 'delete']);
+function isRef(value) {
+    return typeof value === 'object' && value !== null && '$ref' in value;
+}
+function toMethod(value) {
+    return value.toUpperCase();
+}
+function normalizePath(path) {
+    return path.replace(/\{([^}]+)\}/g, ':$1');
+}
+function normalizeToolName(value) {
+    return value.trim();
+}
+function escapeString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+function renderObject(value, indent = 2) {
+    return JSON.stringify(value, null, indent);
+}
+function renderObjectKey(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeString(key)}'`;
+}
+function readRef(document, ref) {
+    if (!ref.startsWith('#/')) {
+        throw new Error(`Only local refs are supported in this prototype: ${ref}`);
+    }
+    const segments = ref.slice(2).split('/');
+    let current = document;
+    for (const rawSegment of segments) {
+        const segment = rawSegment.replace(/~1/g, '/').replace(/~0/g, '~');
+        if (typeof current !== 'object' || current === null || !(segment in current)) {
+            throw new Error(`Cannot resolve ref: ${ref}`);
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function resolveSchema(document, schema, seenRefs = new Set()) {
+    if (!schema)
+        return undefined;
+    if (!isRef(schema))
+        return schema;
+    const ref = schema.$ref;
+    if (seenRefs.has(ref)) {
+        return { type: 'object' };
+    }
+    seenRefs.add(ref);
+    const resolved = readRef(document, ref);
+    if (typeof resolved !== 'object' || resolved === null) {
+        throw new Error(`Ref does not point to an object schema: ${ref}`);
+    }
+    return resolveSchema(document, resolved, seenRefs);
+}
+function resolveParameter(document, parameter) {
+    if (!isRef(parameter))
+        return parameter;
+    const resolved = readRef(document, parameter.$ref);
+    if (!resolved || typeof resolved !== 'object') {
+        throw new Error(`Invalid parameter ref: ${parameter.$ref}`);
+    }
+    return resolved;
+}
+function resolveRequestBody(document, requestBody) {
+    if (!requestBody)
+        return undefined;
+    if (!isRef(requestBody))
+        return requestBody;
+    const resolved = readRef(document, requestBody.$ref);
+    if (!resolved || typeof resolved !== 'object') {
+        throw new Error(`Invalid requestBody ref: ${requestBody.$ref}`);
+    }
+    return resolved;
+}
+function collectOperations(document) {
+    const operations = [];
+    for (const [path, pathItem] of Object.entries(document.paths ?? {})) {
+        for (const method of SUPPORTED_METHODS) {
+            const operation = pathItem[method];
+            if (!operation)
+                continue;
+            operations.push({ path, method, operation, pathItem });
+        }
+    }
+    return operations;
+}
+function getMergedParameters(document, context) {
+    const merged = new Map();
+    const pathLevel = context.pathItem.parameters ?? [];
+    const operationLevel = context.operation.parameters ?? [];
+    for (const param of pathLevel) {
+        const resolved = resolveParameter(document, param);
+        merged.set(`${resolved.in}:${resolved.name}`, resolved);
+    }
+    for (const param of operationLevel) {
+        const resolved = resolveParameter(document, param);
+        merged.set(`${resolved.in}:${resolved.name}`, resolved);
+    }
+    return Array.from(merged.values());
+}
+function listPathParams(path) {
+    return Array.from(path.matchAll(/\{([^}]+)\}/g), (match) => match[1]);
+}
+function isNonEmptyStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === 'string' && item.trim());
+}
+function schemaToZodCode(document, schema) {
+    const resolved = resolveSchema(document, schema);
+    if (!resolved)
+        return 'z.unknown()';
+    if (Array.isArray(resolved.enum) && resolved.enum.length > 0) {
+        if (resolved.enum.every((item) => typeof item === 'string')) {
+            return `z.enum(${renderObject(resolved.enum)})`;
+        }
+        const literals = resolved.enum
+            .filter((item) => ['string', 'number', 'boolean'].includes(typeof item))
+            .map((item) => `z.literal(${JSON.stringify(item)})`);
+        if (literals.length > 0) {
+            return `z.union([${literals.join(', ')}])`;
+        }
+    }
+    if (resolved.type === 'string') {
+        if (resolved.format === 'uuid')
+            return 'z.string().uuid()';
+        return 'z.string()';
+    }
+    if (resolved.type === 'integer' || resolved.type === 'number') {
+        return 'z.number()';
+    }
+    if (resolved.type === 'boolean') {
+        return 'z.boolean()';
+    }
+    if (resolved.type === 'array') {
+        return `z.array(${schemaToZodCode(document, resolved.items)})`;
+    }
+    if (resolved.type === 'object' || resolved.properties || resolved.additionalProperties) {
+        const properties = resolved.properties ?? {};
+        const required = new Set(resolved.required ?? []);
+        const entries = Object.entries(properties).map(([name, childSchema]) => {
+            const base = schemaToZodCode(document, childSchema);
+            const code = required.has(name) ? base : `${base}.optional()`;
+            return `${renderObjectKey(name)}: ${code}`;
+        });
+        const objectCode = `z.object({${entries.length > 0 ? `\n      ${entries.join(',\n      ')}\n    ` : ''}})`;
+        if (resolved.additionalProperties) {
+            return `${objectCode}.passthrough()`;
+        }
+        return objectCode;
+    }
+    return 'z.unknown()';
+}
+function addOrMergeField(fields, candidate) {
+    const existing = fields.get(candidate.name);
+    if (!existing) {
+        fields.set(candidate.name, candidate);
+        return;
+    }
+    const mergedRequired = existing.required || candidate.required;
+    const mergedCode = existing.zodCode === candidate.zodCode ? existing.zodCode : 'z.unknown()';
+    fields.set(candidate.name, {
+        ...existing,
+        required: mergedRequired,
+        zodCode: mergedCode,
+    });
+}
+function createInputSchemaCode(document, context) {
+    const fields = new Map();
+    const mergedParameters = getMergedParameters(document, context);
+    for (const parameter of mergedParameters) {
+        const required = parameter.in === 'path' ? true : Boolean(parameter.required);
+        addOrMergeField(fields, {
+            name: parameter.name,
+            zodCode: schemaToZodCode(document, parameter.schema),
+            required,
+            source: parameter.in,
+        });
+    }
+    const requestBody = resolveRequestBody(document, context.operation.requestBody);
+    const jsonSchema = requestBody?.content?.['application/json']?.schema;
+    const resolvedBodySchema = resolveSchema(document, jsonSchema);
+    if (resolvedBodySchema) {
+        if (resolvedBodySchema.type === 'object' || resolvedBodySchema.properties) {
+            const required = new Set(resolvedBodySchema.required ?? []);
+            for (const [name, child] of Object.entries(resolvedBodySchema.properties ?? {})) {
+                addOrMergeField(fields, {
+                    name,
+                    zodCode: schemaToZodCode(document, child),
+                    required: required.has(name),
+                    source: 'body',
+                });
+            }
+        }
+        else {
+            addOrMergeField(fields, {
+                name: 'body',
+                zodCode: schemaToZodCode(document, resolvedBodySchema),
+                required: Boolean(requestBody?.required),
+                source: 'body',
+            });
+        }
+    }
+    const sorted = Array.from(fields.values()).sort((a, b) => a.name.localeCompare(b.name));
+    if (sorted.length === 0) {
+        return 'z.object({}).passthrough()';
+    }
+    const entries = sorted.map((field) => {
+        const code = field.required ? field.zodCode : `${field.zodCode}.optional()`;
+        return `${renderObjectKey(field.name)}: ${code}`;
+    });
+    return `z.object({\n      ${entries.join(',\n      ')}\n    })`;
+}
+function formatValidationMessage(kind, message) {
+    const marker = kind === 'error' ? 'ERROR' : 'WARN';
+    return `[${marker}] ${message}`;
+}
+function validateOpenApiDocument(document) {
+    const errors = [];
+    const warnings = [];
+    const operationIds = new Map();
+    const toolNames = new Map();
+    let enabledTools = 0;
+    for (const context of collectOperations(document)) {
+        const pointer = `${context.method.toUpperCase()} ${context.path}`;
+        const operationId = context.operation.operationId;
+        if (operationId) {
+            const seenAt = operationIds.get(operationId);
+            if (seenAt) {
+                errors.push(formatValidationMessage('error', `Duplicate operationId "${operationId}" at ${pointer}. First seen at ${seenAt}.`));
+            }
+            else {
+                operationIds.set(operationId, pointer);
+            }
+        }
+        const ai = context.operation['x-ai'];
+        if (!ai?.enabled)
+            continue;
+        enabledTools += 1;
+        if (!operationId) {
+            errors.push(formatValidationMessage('error', `Missing operationId for enabled tool at ${pointer}.`));
+        }
+        const toolName = ai.toolName ? normalizeToolName(ai.toolName) : '';
+        if (!toolName) {
+            errors.push(formatValidationMessage('error', `Missing x-ai.toolName for ${pointer}.`));
+        }
+        else {
+            const seenAt = toolNames.get(toolName);
+            if (seenAt) {
+                errors.push(formatValidationMessage('error', `Duplicate x-ai.toolName "${toolName}" at ${pointer}. First seen at ${seenAt}.`));
+            }
+            else {
+                toolNames.set(toolName, pointer);
+            }
+            if (!/^[a-z0-9_]+$/.test(toolName)) {
+                warnings.push(formatValidationMessage('warning', `Tool name "${toolName}" at ${pointer} should match ^[a-z0-9_]+$ for model/tooling consistency.`));
+            }
+        }
+        if (MUTATING_METHODS.has(context.method) && ai.needsApproval === false) {
+            errors.push(formatValidationMessage('error', `Mutating endpoint ${pointer} cannot set x-ai.needsApproval to false.`));
+        }
+        const params = getMergedParameters(document, context);
+        const pathParams = new Set(params.filter((param) => param.in === 'path').map((param) => param.name));
+        for (const pathParam of listPathParams(context.path)) {
+            if (!pathParams.has(pathParam)) {
+                errors.push(formatValidationMessage('error', `Path parameter "${pathParam}" in ${pointer} is missing from OpenAPI parameters.`));
+            }
+        }
+        if (!ai.description && !context.operation.summary && !context.operation.description) {
+            warnings.push(formatValidationMessage('warning', `No description found for enabled tool at ${pointer}. Add x-ai.description or summary.`));
+        }
+    }
+    return {
+        enabledTools,
+        errors,
+        warnings,
+    };
+}
+function extractGeneratedToolSpecs(document) {
+    const tools = [];
+    for (const context of collectOperations(document)) {
+        const ai = context.operation['x-ai'];
+        if (!ai?.enabled)
+            continue;
+        if (!context.operation.operationId) {
+            throw new Error(`Missing operationId for ${context.method.toUpperCase()} ${context.path}`);
+        }
+        const toolName = ai.toolName ? normalizeToolName(ai.toolName) : '';
+        if (!toolName) {
+            throw new Error(`Missing x-ai.toolName for ${context.operation.operationId}`);
+        }
+        const description = ai.description ??
+            context.operation.summary ??
+            context.operation.description ??
+            `${context.method.toUpperCase()} ${context.path}`;
+        tools.push({
+            id: context.operation.operationId,
+            toolName,
+            description,
+            method: toMethod(context.method),
+            path: normalizePath(context.path),
+            inputSchemaCode: createInputSchemaCode(document, context),
+            needsApproval: ai.needsApproval ?? MUTATING_METHODS.has(context.method),
+            uiActionOnSuccess: ai.uiActionOnSuccess,
+        });
+    }
+    tools.sort((a, b) => a.toolName.localeCompare(b.toolName));
+    return tools;
+}
+function renderTypeScriptFromSpecs(specs) {
+    const header = `/* eslint-disable */\n/**\n * AUTO-GENERATED FILE.\n * Generated from OpenAPI + x-ai metadata.\n */\n\n`;
+    if (specs.length === 0) {
+        return `${header}import { z } from 'zod';\nimport { defineEndpointTool } from 'glirastes';\n\nexport const generatedEndpointTools = [] as const;\n`;
+    }
+    const bodies = specs
+        .map((spec) => {
+        const uiActionLine = spec.uiActionOnSuccess
+            ? `\n    uiActionOnSuccess: ${renderObject(spec.uiActionOnSuccess, 4)},`
+            : '';
+        return `  defineEndpointTool({\n    id: '${escapeString(spec.id)}',\n    toolName: '${escapeString(spec.toolName)}',\n    description: '${escapeString(spec.description)}',\n    method: '${spec.method}',\n    path: '${escapeString(spec.path)}',\n    inputSchema: ${spec.inputSchemaCode},\n    needsApproval: ${spec.needsApproval},${uiActionLine}\n  })`;
+    })
+        .join(',\n\n');
+    return `${header}import { z } from 'zod';\nimport { defineEndpointTool } from 'glirastes';\n\nexport const generatedEndpointTools = [\n${bodies}\n] as const;\n`;
+}
+async function validateOpenApiFile(options) {
+    const raw = await (0, promises_1.readFile)(options.inputPath, 'utf8');
+    const document = JSON.parse(raw);
+    return validateOpenApiDocument(document);
+}
+async function generateFromOpenApiFile(options) {
+    const raw = await (0, promises_1.readFile)(options.inputPath, 'utf8');
+    const document = JSON.parse(raw);
+    const validation = validateOpenApiDocument(document);
+    if (validation.errors.length > 0) {
+        throw new Error(`OpenAPI validation failed:\n${validation.errors.join('\n')}`);
+    }
+    const specs = extractGeneratedToolSpecs(document);
+    const output = renderTypeScriptFromSpecs(specs);
+    await (0, promises_1.writeFile)(options.outputPath, output, 'utf8');
+    return validation;
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/react/audio-worklet-processor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AudioWorklet processor for real-time audio streaming
+ * Converts Float32 audio samples to Int16 format for Deepgram
+ *
+ * Note: This file is intentionally not unit tested as AudioWorkletProcessor
+ * runs in a separate audio rendering thread and is difficult to test in isolation.
+ * Integration testing happens in the useDeepgramTranscription hook.
+ */
+declare class AudioWorkletProcessor {
+    readonly port: MessagePort;
+    process(inputs: Float32Array[][], outputs: Float32Array[][], parameters: Record<string, Float32Array>): boolean;
+}
+declare function registerProcessor(name: string, processorCtor: typeof AudioWorkletProcessor): void;
+declare class AudioProcessor extends AudioWorkletProcessor {
+    process(inputs: Float32Array[][], outputs: Float32Array[][], parameters: Record<string, Float32Array>): boolean;
+}

package/dist/cjs/react/audio-worklet-processor.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * AudioWorklet processor for real-time audio streaming
+ * Converts Float32 audio samples to Int16 format for Deepgram
+ *
+ * Note: This file is intentionally not unit tested as AudioWorkletProcessor
+ * runs in a separate audio rendering thread and is difficult to test in isolation.
+ * Integration testing happens in the useDeepgramTranscription hook.
+ */
+class AudioProcessor extends AudioWorkletProcessor {
+    process(inputs, outputs, parameters) {
+        const input = inputs[0]?.[0];
+        if (!input || input.length === 0) {
+            return true;
+        }
+        // Convert Float32 (-1.0 to 1.0) to Int16 (-32768 to 32767)
+        const int16Data = new Int16Array(input.length);
+        for (let i = 0; i < input.length; i++) {
+            const sample = Math.max(-1, Math.min(1, input[i] ?? 0));
+            int16Data[i] = sample < 0 ? sample * 0x8000 : sample * 0x7fff;
+        }
+        // Send to main thread
+        this.port.postMessage(int16Data, [int16Data.buffer]);
+        return true; // Keep processor alive
+    }
+}
+registerProcessor('audio-processor', AudioProcessor);

package/dist/cjs/react/bridges/rest-session-bridge.d.ts

@@ -0,0 +1,113 @@
+import type { ChatMessage, SessionConfig, SessionSummary, WireChatMessage } from '../types.js';
+export type HeadersResolver = Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+export interface RestSessionBridgeOptions {
+    /**
+     * Base URL of the sessions collection. Must NOT end with a trailing
+     * slash. Examples: `/api/chat/sessions`, `https://api.example.com/chat/sessions`.
+     */
+    baseUrl: string;
+    /**
+     * Query-string parameters appended to the `list()` GET request. Use
+     * this to filter server-side — for example, hide archived sessions
+     * from a soft-delete backend:
+     *
+     * ```ts
+     * listQuery: () => ({ status: 'active' })
+     * ```
+     *
+     * The function is called on every `list()` invocation, so values
+     * that depend on runtime state (auth, filters) are re-evaluated.
+     */
+    listQuery?: () => Record<string, string>;
+    /**
+     * Static headers or a function that returns headers per request. Useful
+     * for injecting `Authorization`.
+     */
+    headers?: HeadersResolver;
+    /** `fetch` credentials mode. Default: `'same-origin'`. */
+    credentials?: RequestCredentials;
+    /**
+     * Inject a custom `fetch` — defaults to `globalThis.fetch`. Pass a
+     * preconfigured axios-like wrapper via `request` instead if you need
+     * interceptors.
+     */
+    fetchFn?: typeof fetch;
+    /**
+     * Full request override. If provided, this function is called for
+     * every request and the bridge will not touch `fetchFn`/`headers`.
+     * Useful when you already have an axios instance with interceptors.
+     *
+     * Must return the parsed JSON body (or `undefined` for 204s).
+     */
+    request?: (init: {
+        method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+        url: string;
+        body?: unknown;
+    }) => Promise<unknown>;
+    /**
+     * Body used for `create(opts)` POST requests. Default: `{ title }` when
+     * a title was supplied, otherwise `{}`. Override when your backend
+     * requires extra fields (e.g. `{ execution_types: ['chat'] }`).
+     */
+    createBody?: (opts: {
+        title?: string;
+    }) => unknown;
+    /**
+     * How to delete a session. Default: `{ method: 'DELETE' }`. Override
+     * when your backend uses soft deletes — e.g. archive via
+     * `{ method: 'PATCH', body: { status: 'archived' } }`.
+     */
+    removeRequest?: (id: string) => {
+        method: 'DELETE' | 'PATCH' | 'POST';
+        body?: unknown;
+    };
+    /**
+     * Path of the messages sub-collection, relative to a session. Default:
+     * `/messages`.
+     */
+    messagesPath?: string;
+    /**
+     * Map a backend session row onto `SessionSummary`. The default handles
+     * both `camelCase` and `snake_case` variants of the common fields
+     * (`id`, `title` / `name`, `createdAt` / `created_at`, etc.).
+     */
+    mapSession?: (row: unknown) => SessionSummary;
+    /**
+     * Map a backend message row onto the SDK's `ChatMessage` shape. The
+     * default reads `{ id, role, content, created_at }` (or `createdAt`),
+     * which covers most REST chat backends. Returning a `WireChatMessage`
+     * is also fine — the provider coerces it.
+     */
+    mapMessage?: (row: unknown) => ChatMessage | WireChatMessage | null;
+}
+/**
+ * Build a `SessionConfig` from a standard REST chat backend.
+ *
+ * The factory wires the five session hooks (`list`, `load`, `create`,
+ * `remove`, `rename`) to a conventional REST layout:
+ *
+ * | Hook     | Request                                    |
+ * |----------|--------------------------------------------|
+ * | `list`   | `GET    {baseUrl}`                         |
+ * | `load`   | `GET    {baseUrl}/{id}{messagesPath}`      |
+ * | `create` | `POST   {baseUrl}` with `createBody(opts)` |
+ * | `remove` | `DELETE {baseUrl}/{id}` (or PATCH via `removeRequest`) |
+ * | `rename` | `PATCH  {baseUrl}/{id}` with `{ title }`   |
+ *
+ * All field-name mapping is done through `mapSession` / `mapMessage`,
+ * which have defaults that tolerate both `snake_case` and `camelCase`.
+ * For anything exotic (different status codes, non-JSON bodies, etc.),
+ * pass `request` and take over the transport entirely.
+ *
+ * @example
+ * ```ts
+ * // Chaingrow — uses archive-instead-of-delete and a non-standard create body
+ * export const chainGrowSessions = createRestSessionBridge({
+ *   baseUrl: `${API_URL}/chat/sessions`,
+ *   headers: () => ({ Authorization: `Bearer ${authStore.getState().token}` }),
+ *   createBody: () => ({ execution_types: ['chat'] }),
+ *   removeRequest: () => ({ method: 'PATCH', body: { status: 'archived' } }),
+ * });
+ * ```
+ */
+export declare function createRestSessionBridge(options: RestSessionBridgeOptions): SessionConfig;