@bodhiapp/bodhi-js 0.0.1

package/README.md

@@ -0,0 +1,26 @@
+# @bodhiapp/bodhi-js
+
+Web SDK for Bodhi Browser - `window.bodhiext` communication.
+
+## Installation
+
+```bash
+npm install @bodhiapp/bodhi-js
+```
+
+## Usage
+
+```typescript
+import { WebUIClient } from '@bodhiapp/bodhi-js';
+
+const client = new WebUIClient('your-client-id');
+await client.init();
+```
+
+## Documentation
+
+See [bodhi-browser/bodhi-js-sdk](https://github.com/BodhiSearch/bodhi-browser/tree/main/bodhi-js-sdk) for complete documentation.
+
+## License
+
+MIT

package/dist/bodhi-browser-ext/src/types/bodhiext.d.ts

@@ -0,0 +1,202 @@
+import { OpenAiApiError, PingResponse, CreateChatCompletionRequest, CreateChatCompletionResponse, CreateChatCompletionStreamResponse } from '@bodhiapp/ts-client';
+
+/**
+ * HTTP response wrapper - body can be success type OR error type
+ * Use isApiErrorResponse() to narrow the type based on status
+ */
+export interface ApiResponse<T = unknown> {
+    body: T | OpenAiApiError;
+    status: number;
+    headers: Record<string, string>;
+}
+/**
+ * Stream chunk returned by sendStreamRequest
+ *
+ * This is the chunk structure yielded by the ReadableStream from sendStreamRequest.
+ * Different from StreamChunkMessage which is the internal message wrapper.
+ */
+export interface StreamChunk {
+    body: unknown;
+    headers?: Record<string, string>;
+    status?: number;
+    done?: boolean;
+}
+/**
+ * Server state information returned by /bodhi/v1/info endpoint
+ */
+export interface ServerStateInfo {
+    /** Current application status */
+    status: 'setup' | 'ready' | 'resource-admin' | 'error' | 'unreachable';
+    /** Application version */
+    version?: string;
+    /** Server URL (added by extension) */
+    url?: string;
+    /** Error details if status is 'error' or 'unreachable' */
+    error?: {
+        message: string;
+        type?: string;
+        code?: string;
+        param?: string;
+    };
+}
+/**
+ * API error thrown when server returns HTTP 4xx/5xx
+ * Used for streaming responses (non-streaming returns ApiResponse)
+ */
+export interface ApiError extends Error {
+    response: {
+        status: number;
+        body: OpenAiApiError;
+        headers?: Record<string, string>;
+    };
+}
+/**
+ * Operation error thrown when HTTP request couldn't complete
+ * (network unreachable, timeout, extension error)
+ */
+export interface OperationError extends Error {
+    error: {
+        message: string;
+        type: string;
+    };
+}
+/**
+ * Union of all extension-thrown errors
+ */
+export type ExtensionError = ApiError | OperationError;
+/**
+ * Type guard: API error (has response field)
+ */
+export declare function isApiError(err: unknown): err is ApiError;
+/**
+ * Type guard: Operation error (has error field, no response)
+ */
+export declare function isOperationError(err: unknown): err is OperationError;
+/**
+ * Chat API uses types from @bodhiapp/ts-client.
+ * Consumers should import these types directly from @bodhiapp/ts-client:
+ * - ChatCompletionRequestMessage
+ * - ChatCompletionResponseMessage
+ * - CreateChatCompletionRequest
+ * - CreateChatCompletionResponse
+ * - CreateChatCompletionStreamResponse
+ * - ChatChoice
+ * - ChatChoiceStream
+ * - ChatCompletionStreamResponseDelta
+ */
+/**
+ * Chat completions API interface
+ */
+export interface ChatCompletionsApi {
+    /**
+     * Create a chat completion
+     *
+     * Non-streaming: Returns ApiResponse - caller checks status for success/error
+     * Streaming: Yields chunks via AsyncIterable - throws ApiError or OperationError on error
+     *
+     * @param params - Chat completion parameters
+     * @returns Non-streaming: Promise<ApiResponse<CreateChatCompletionResponse>>, Streaming: AsyncIterable<CreateChatCompletionStreamResponse>
+     */
+    create(params: CreateChatCompletionRequest & {
+        stream?: false;
+    }): Promise<ApiResponse<CreateChatCompletionResponse>>;
+    create(params: CreateChatCompletionRequest & {
+        stream: true;
+    }): AsyncIterable<CreateChatCompletionStreamResponse>;
+    create(params: CreateChatCompletionRequest): Promise<ApiResponse<CreateChatCompletionResponse>> | AsyncIterable<CreateChatCompletionStreamResponse>;
+}
+/**
+ * Chat API namespace
+ */
+export interface ChatApi {
+    completions: ChatCompletionsApi;
+}
+/**
+ * Public window.bodhiext interface
+ *
+ * This interface defines all methods available to web pages through window.bodhiext.
+ * The extension creates this interface in inject.ts and attaches it to the window object.
+ */
+export interface BodhiExtPublicApi {
+    /**
+     * Send a generic API request through the extension to the backend server.
+     *
+     * @template TReq - Request body type (inferred from body parameter)
+     * @template TRes - Response body type (must be specified explicitly)
+     * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
+     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
+     * @param body - Optional request body (will be JSON stringified)
+     * @param headers - Optional additional headers
+     * @returns Promise resolving to ApiResponse with body, headers, and status
+     */
+    sendApiRequest<TReq = unknown, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>): Promise<ApiResponse<TRes>>;
+    /**
+     * Send a streaming API request through the extension.
+     *
+     * Used for SSE (Server-Sent Events) endpoints like streaming chat completions.
+     * Returns a ReadableStream that yields StreamChunk objects.
+     *
+     * @template TReq - Request body type (inferred from body parameter)
+     * @param method - HTTP method (typically POST for streaming)
+     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
+     * @param body - Optional request body
+     * @param headers - Optional additional headers
+     * @returns ReadableStream yielding StreamChunk objects
+     */
+    sendStreamRequest<TReq = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>): ReadableStream<StreamChunk>;
+    /**
+     * Send a generic extension request.
+     *
+     * Used for extension-specific operations like test_connection, get_extension_id, etc.
+     * This is a low-level API for extension capabilities.
+     *
+     * @param action - Extension action name (e.g., 'test_connection')
+     * @param params - Optional action parameters
+     * @returns Promise resolving to action-specific response
+     */
+    sendExtRequest(action: string, params?: any): Promise<any>;
+    /**
+     * Simple health check to verify extension connectivity.
+     *
+     * Returns ApiResponse - caller should check status to determine success/error.
+     * On success (2xx), body is PingResponse. On error (4xx/5xx), body is OpenAiApiError.
+     *
+     * @returns Promise resolving to ApiResponse<PingResponse>
+     */
+    ping(): Promise<ApiResponse<PingResponse>>;
+    /**
+     * Get server state information from /bodhi/v1/info endpoint.
+     *
+     * Returns the current status of the backend server including
+     * whether it's in setup mode, ready, or has errors.
+     *
+     * @returns Promise resolving to ServerStateInfo
+     */
+    serverState(): Promise<ServerStateInfo>;
+    /**
+     * OpenAI-compatible chat API.
+     *
+     * Provides chat completion functionality compatible with OpenAI's API structure.
+     */
+    chat: ChatApi;
+    /**
+     * Get the extension ID.
+     *
+     * The extension ID is fetched asynchronously during initialization.
+     * This method returns a promise that resolves to the extension ID once available.
+     *
+     * @returns Promise resolving to the extension ID string
+     */
+    getExtensionId(): Promise<string>;
+}
+/**
+ * Window augmentation for TypeScript
+ *
+ * Declares the optional bodhiext property on the Window interface.
+ * This allows TypeScript code to access window.bodhiext with proper typing.
+ */
+declare global {
+    interface Window {
+        bodhiext?: BodhiExtPublicApi;
+    }
+}

package/dist/bodhi-browser-ext/src/types/common.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared constants for Bodhi Browser Extension
+ *
+ * Constants used by both inject.ts and background/content.ts scripts,
+ * or common to the entire extension.
+ */
+export declare const CONTENT_TYPE_JSON = "application/json";
+export declare const CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+export declare const CONTENT_TYPE_HEADER = "Content-Type";
+export declare const HTTP_METHOD_GET = "GET";
+export declare const HTTP_METHOD_POST = "POST";
+export declare const ENDPOINT_PING = "/ping";
+export declare const ENDPOINT_CHAT_COMPLETIONS = "/v1/chat/completions";
+export declare const DEFAULT_API_BASE_URL = "http://localhost:1135";
+export declare const DEFAULT_API_TIMEOUT = 10000;
+export declare const DEFAULT_STREAM_TIMEOUT = 60000;
+export declare const STORAGE_KEY_BACKEND_URL = "backendUrl";
+export declare const SSE_DONE_MARKER = "[DONE]";
+export declare const SSE_DATA_PREFIX = "data: ";
+export declare const SSE_CHUNK_DELIMITER = "\n\n";
+export declare const EXT_ACTIONS: {
+    readonly GET_EXTENSION_ID: "get_extension_id";
+    readonly TEST_CONNECTION: "test_connection";
+};
+export declare const ERROR_TYPES: {
+    readonly NETWORK_ERROR: "network_error";
+    readonly EXTENSION_ERROR: "extension_error";
+    readonly TIMEOUT_ERROR: "timeout_error";
+};
+export type ConnectionErrorType = (typeof ERROR_TYPES)[keyof typeof ERROR_TYPES];
+export declare const DOCUMENT_STATE_COMPLETE = "complete";
+export declare const EVENT_INITIALIZED = "bodhiext:initialized";
+export declare const BODHI_STREAM_PORT = "BODHI_STREAM_PORT";
+export declare const ORIGIN_WILDCARD = "*";
+export declare const ERROR_MISSING_REQUEST_ID = "Invalid message format: missing requestId or request";
+export declare const ERROR_CONNECTION_CLOSED = "Connection closed unexpectedly";

package/dist/bodhi-browser-ext/src/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { ApiResponse, StreamChunk, ServerStateInfo, ApiError, OperationError, ExtensionError, ChatCompletionsApi, ChatApi, BodhiExtPublicApi } from './bodhiext';
+export { isApiError, isOperationError } from './bodhiext';
+export type { ApiRequest, ApiRequestMessage, OperationErrorResponse, ApiResponseSuccessMessage, OperationErrorResponseMessage, ApiResponseMessage, ErrorMessage, StreamChunkMessage, StreamApiErrorMessage, StreamErrorMessage, StreamMessage, StreamController, SSEChunk, ExtRequest, ExtRequestMessage, ExtError, ExtErrorResponse, ExtResponse, ExtResponseMessage, GetExtensionIdRequest, GetExtensionIdResponse, TestConnectionRequest, TestConnectionResponse, } from './protocol';
+export { MESSAGE_TYPES, isOperationErrorResponse, isApiErrorResponse, isApiSuccessResponse, isStreamChunk, isStreamApiError, isStreamError, isExtError, isOpenAiApiErrorBody, isOperationErrorStructure, } from './protocol';
+export { CONTENT_TYPE_JSON, CONTENT_TYPE_EVENT_STREAM, CONTENT_TYPE_HEADER, HTTP_METHOD_GET, HTTP_METHOD_POST, ENDPOINT_PING, ENDPOINT_CHAT_COMPLETIONS, DEFAULT_API_BASE_URL, DEFAULT_API_TIMEOUT, DEFAULT_STREAM_TIMEOUT, STORAGE_KEY_BACKEND_URL, SSE_DONE_MARKER, SSE_DATA_PREFIX, SSE_CHUNK_DELIMITER, EXT_ACTIONS, ERROR_TYPES, DOCUMENT_STATE_COMPLETE, EVENT_INITIALIZED, BODHI_STREAM_PORT, ORIGIN_WILDCARD, ERROR_MISSING_REQUEST_ID, ERROR_CONNECTION_CLOSED, } from './common';
+export type { ConnectionErrorType } from './common';

package/dist/bodhi-browser-ext/src/types/protocol.d.ts

@@ -0,0 +1,223 @@
+import { OpenAiApiError, ErrorBody } from '@bodhiapp/ts-client';
+import { ApiResponse, ServerStateInfo } from './bodhiext';
+
+/**
+ * Validate OpenAI API error body structure
+ * { error: { message: string, type: string } }
+ */
+export declare function isOpenAiApiErrorBody(body: unknown): body is OpenAiApiError;
+/**
+ * Validate OperationErrorResponse structure
+ * { message: string, type: string }
+ */
+export declare function isOperationErrorStructure(obj: unknown): obj is OperationErrorResponse;
+export declare const MESSAGE_TYPES: {
+    readonly API_REQUEST: "BODHI_API_REQUEST";
+    readonly API_RESPONSE: "BODHI_API_RESPONSE";
+    readonly STREAM_REQUEST: "BODHI_STREAM_REQUEST";
+    readonly STREAM_CHUNK: "BODHI_STREAM_CHUNK";
+    readonly STREAM_ERROR: "BODHI_STREAM_ERROR";
+    readonly STREAM_API_ERROR: "BODHI_STREAM_API_ERROR";
+    readonly ERROR: "BODHI_ERROR";
+    readonly EXT_REQUEST: "BODHI_EXT_REQUEST";
+    readonly EXT_RESPONSE: "BODHI_EXT_RESPONSE";
+};
+export interface ApiRequest<T = unknown> {
+    method: string;
+    endpoint: string;
+    body?: T;
+    headers?: Record<string, string>;
+}
+export interface ApiRequestMessage<TReq = unknown> {
+    type: string;
+    requestId: string;
+    request: ApiRequest<TReq>;
+}
+/**
+ * Operation-level error response (network unreachable, timeout, extension error)
+ * NOT an API error (those come through ApiResponse with OpenAiApiError body)
+ * This is a response type, not a thrown error
+ */
+export interface OperationErrorResponse {
+    message: string;
+    type: string;
+}
+/**
+ * Success API response message (HTTP request completed, regardless of status code)
+ */
+export interface ApiResponseSuccessMessage<T = unknown> {
+    type: string;
+    requestId: string;
+    response: ApiResponse<T>;
+}
+/**
+ * Operation error response message - HTTP request couldn't complete
+ */
+export interface OperationErrorResponseMessage {
+    type: string;
+    requestId: string;
+    error: OperationErrorResponse;
+}
+/**
+ * API response message - discriminated union
+ */
+export type ApiResponseMessage<T = unknown> = ApiResponseSuccessMessage<T> | OperationErrorResponseMessage;
+/**
+ * Type guard for operation error response
+ */
+export declare function isOperationErrorResponse(msg: ApiResponseMessage): msg is OperationErrorResponseMessage;
+/**
+ * Type guard to check if response is an API error (4xx/5xx)
+ * Narrows body type to OpenAiApiError
+ */
+export declare function isApiErrorResponse<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    body: OpenAiApiError;
+    status: number;
+};
+/**
+ * Type guard to check if response is successful (2xx)
+ * Narrows body type to T
+ */
+export declare function isApiSuccessResponse<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    body: T;
+    status: number;
+};
+export interface ErrorMessage {
+    type: string;
+    requestId: string;
+    response: {
+        body: ErrorBody;
+        status: number;
+        headers: Record<string, string>;
+    };
+}
+/**
+ * Stream chunk message - successful SSE chunk received
+ * Uses ApiResponse<T> wrapper for consistency with non-streaming pattern
+ */
+export interface StreamChunkMessage<T = unknown> {
+    type: typeof MESSAGE_TYPES.STREAM_CHUNK;
+    requestId: string;
+    response: ApiResponse<T>;
+}
+/**
+ * Stream API error message - server returned error response (not SSE)
+ * E.g., 400/401/500 JSON error instead of SSE stream
+ */
+export interface StreamApiErrorMessage {
+    type: typeof MESSAGE_TYPES.STREAM_API_ERROR;
+    requestId: string;
+    response: ApiResponse<OpenAiApiError>;
+}
+/**
+ * Stream error message - network/extension level error
+ * E.g., connection refused, timeout, extension error
+ */
+export interface StreamErrorMessage {
+    type: typeof MESSAGE_TYPES.STREAM_ERROR;
+    requestId: string;
+    error: OperationErrorResponse;
+}
+/**
+ * Union type for all streaming messages
+ */
+export type StreamMessage<T = unknown> = StreamChunkMessage<T> | StreamApiErrorMessage | StreamErrorMessage;
+/**
+ * Type guard for stream chunk message
+ */
+export declare function isStreamChunk<T>(msg: StreamMessage<T>): msg is StreamChunkMessage<T>;
+/**
+ * Type guard for stream API error
+ */
+export declare function isStreamApiError(msg: StreamMessage): msg is StreamApiErrorMessage;
+/**
+ * Type guard for stream error
+ */
+export declare function isStreamError(msg: StreamMessage): msg is StreamErrorMessage;
+/**
+ * Interface for stream controller to handle SSE responses
+ */
+export interface StreamController {
+    enqueue: (chunk: any) => void;
+    error: (err: Error) => void;
+    complete: () => void;
+}
+/**
+ * Interface for SSE data chunk
+ */
+export interface SSEChunk {
+    done?: boolean;
+    [key: string]: any;
+}
+/**
+ * Generic extension request interface
+ */
+export interface ExtRequest {
+    action: string;
+    params?: any;
+}
+/**
+ * Generic extension request message
+ */
+export interface ExtRequestMessage {
+    type: 'BODHI_EXT_REQUEST';
+    requestId: string;
+    request: ExtRequest;
+}
+/**
+ * Extension-level error structure
+ */
+export interface ExtError {
+    message: string;
+    type?: string;
+}
+/**
+ * Error response for extension operations
+ */
+export interface ExtErrorResponse {
+    error: ExtError;
+}
+/**
+ * Union type for extension response (flattened - no wrapper for success)
+ * Success: T (the actual response data)
+ * Error: { error: ExtError }
+ */
+export type ExtResponse<T = unknown> = T | ExtErrorResponse;
+/**
+ * Type guard to check if extension response is an error
+ */
+export declare function isExtError<T>(res: ExtResponse<T>): res is ExtErrorResponse;
+/**
+ * Generic extension response message
+ */
+export interface ExtResponseMessage<T = unknown> {
+    type: 'BODHI_EXT_RESPONSE';
+    requestId: string;
+    response: ExtResponse<T>;
+}
+/**
+ * Get Extension ID request (no params needed)
+ */
+export interface GetExtensionIdRequest extends ExtRequest {
+    action: 'get_extension_id';
+    params?: undefined;
+}
+/**
+ * Get Extension ID response body
+ */
+export interface GetExtensionIdResponse {
+    extension_id: string;
+}
+/**
+ * Test Connection request
+ */
+export interface TestConnectionRequest extends ExtRequest {
+    action: 'test_connection';
+    params: {
+        url: string;
+    };
+}
+/**
+ * Test Connection response body (reuses ServerStateInfo)
+ */
+export type TestConnectionResponse = ServerStateInfo;

package/dist/bodhi-js-sdk/core/src/direct-client-base.d.ts

@@ -0,0 +1,129 @@
+import { CreateChatCompletionStreamResponse } from '@bodhiapp/ts-client';
+import { IDirectClient } from './interface';
+import { Logger } from './logger';
+import { OAuthEndpoints, RefreshTokenResponse } from './oauth';
+import { StorageKeys } from './storage';
+import { ApiResponseResult, AuthLoggedIn, AuthLoggedOut, AuthState, BackendServerState, ClientState, DirectState, InitParams, LogLevel, SerializedDirectState, StateChangeCallback } from './types';
+/**
+ * DirectClientBase - Abstract base class for DirectClient implementations
+ *
+ * Contains common HTTP fetch and streaming logic shared between
+ * DirectExtClient and DirectWebClient.
+ */
+export interface ConnectivityTestResult {
+    success: boolean;
+    serverInfo?: {
+        status: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        type: string;
+    };
+}
+/**
+ * Test connectivity to a local server
+ * @param serverUrl - The server URL to test
+ * @returns Promise with connectivity test result
+ */
+export declare function testServerConnectivity(serverUrl: string): Promise<ConnectivityTestResult>;
+/**
+ * Base configuration for DirectClient
+ */
+export interface DirectClientBaseConfig {
+    authClientId: string;
+    authServerUrl?: string;
+    userScope?: string;
+    storagePrefix: string;
+    logLevel?: LogLevel;
+}
+/**
+ * DirectClientBase - Abstract base implementing common HTTP/streaming logic
+ */
+export declare abstract class DirectClientBase implements IDirectClient {
+    protected logger: Logger;
+    protected serverUrl: string | null;
+    protected authClientId: string;
+    protected authServerUrl: string;
+    protected userScope: string;
+    protected authEndpoints: OAuthEndpoints;
+    protected storageKeys: StorageKeys;
+    protected state: DirectState;
+    private onStateChange;
+    private refreshPromise;
+    constructor(config: DirectClientBaseConfig, loggerPrefix: string, onStateChange?: StateChangeCallback);
+    /**
+     * Set client state and notify callback
+     */
+    protected setState(newState: DirectState): void;
+    /**
+     * Set auth state and notify callback
+     */
+    protected setAuthState(authState: AuthState): void;
+    /**
+     * Set or update the state change callback
+     */
+    setStateCallback(callback: StateChangeCallback): void;
+    init(params: InitParams): Promise<DirectState>;
+    getState(): ClientState;
+    isClientInitialized(): boolean;
+    isServerReady(): boolean;
+    /**
+     * Ensures client is initialized before operations
+     */
+    private ensureInitialized;
+    sendApiRequest<TReq = void, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>, authenticated?: boolean): Promise<ApiResponseResult<TRes>>;
+    pingApi(): Promise<ApiResponseResult<{
+        message: string;
+    }>>;
+    fetchModels(): Promise<ApiResponseResult<{
+        data: Array<{
+            id: string;
+            object: string;
+        }>;
+    }>>;
+    /**
+     * Get backend server state
+     * Calls /bodhi/v1/info and returns structured server state
+     */
+    getServerState(): Promise<BackendServerState>;
+    stream<TReq = unknown, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>, authenticated?: boolean): AsyncGenerator<TRes>;
+    streamChat(model: string, prompt: string, authenticated?: boolean): AsyncGenerator<CreateChatCompletionStreamResponse>;
+    /**
+     * Test connectivity to local server
+     */
+    testConnectivity(): Promise<ConnectivityTestResult>;
+    /**
+     * Serialize DirectClient state for persistence
+     */
+    serialize(): SerializedDirectState;
+    /**
+     * Debug dump of DirectClient internal state
+     */
+    debug(): Promise<Record<string, unknown>>;
+    abstract login(): Promise<AuthLoggedIn>;
+    abstract logout(): Promise<AuthLoggedOut>;
+    getAuthState(): Promise<AuthState>;
+    protected _getAccessTokenRaw(): Promise<string | null>;
+    /**
+     * Try to refresh access token using refresh token
+     * Race condition prevention: Returns existing promise if refresh already in progress
+     */
+    protected _tryRefreshToken(refreshToken: string): Promise<string | null>;
+    /**
+     * Perform the actual token refresh
+     */
+    private _doRefreshToken;
+    /**
+     * Store refreshed tokens
+     */
+    protected _storeRefreshedTokens(tokens: RefreshTokenResponse): Promise<void>;
+    protected requestResourceAccess(): Promise<string>;
+    protected exchangeCodeForTokens(code: string): Promise<void>;
+    protected revokeRefreshToken(): Promise<void>;
+    protected clearAuthStorage(): Promise<void>;
+    protected abstract _storageGet(key: string): Promise<string | null>;
+    protected abstract _storageSet(items: Record<string, string | number>): Promise<void>;
+    protected abstract _storageRemove(keys: string[]): Promise<void>;
+    protected abstract _getRedirectUri(): string;
+}

package/dist/bodhi-js-sdk/core/src/errors.d.ts

@@ -0,0 +1,23 @@
+import { ApiError, OperationError } from '../../../bodhi-browser-ext/src/types';
+import { OpenAiApiError } from '@bodhiapp/ts-client';
+
+/**
+ * Create API error (HTTP 4xx/5xx from server)
+ * Thrown for streaming responses when server returns error
+ *
+ * @param message - Error message
+ * @param status - HTTP status code
+ * @param body - Error body from server
+ * @param headers - Optional response headers
+ * @returns ApiError instance
+ */
+export declare const createApiError: (message: string, status: number, body: OpenAiApiError, headers?: Record<string, string>) => ApiError;
+/**
+ * Create operation error (network/extension level)
+ * Thrown when HTTP request couldn't complete
+ *
+ * @param message - Error message
+ * @param type - Error type (network_error, timeout_error, etc.)
+ * @returns OperationError instance
+ */
+export declare const createOperationError: (message: string, type: string) => OperationError;