@mtharrison/loupe 1.1.1 → 1.2.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { type ChatModelLike, type LocalLLMTracer, type TraceConfig, type TraceContext, type TraceRequest } from './types';
-export type { ChatModelLike, HierarchyNode, HierarchyResponse, LocalLLMTracer, NormalizedTraceContext, TraceConfig, TraceContext, TraceEvent, TraceFilters, TraceHierarchy, TraceListResponse, TraceMode, TraceRecord, TraceRequest, TraceServer, TraceStatus, TraceSummary, TraceTags, UIReloadEvent, } from './types';
+import { type ChatModelLike, type LocalLLMTracer, type OpenAIChatCompletionCreateParamsLike, type OpenAIClientLike, type TraceConfig, type TraceContext, type TraceRequest } from './types';
+export type { ChatModelLike, HierarchyNode, HierarchyResponse, LocalLLMTracer, NormalizedTraceContext, OpenAIChatCompletionCreateParamsLike, OpenAIChatCompletionStreamLike, OpenAIClientLike, TraceConfig, TraceContext, TraceEvent, TraceFilters, TraceHierarchy, TraceListResponse, TraceMode, TraceRecord, TraceRequest, TraceServer, TraceStatus, TraceSummary, TraceTags, UIReloadEvent, } from './types';
 export declare function isTraceEnabled(): boolean;
 export declare function getLocalLLMTracer(config?: TraceConfig): LocalLLMTracer;
 export declare function startTraceServer(config?: TraceConfig): Promise<{
@@ -15,3 +15,4 @@ export declare function recordStreamFinish(traceId: string, chunk: unknown, conf
 export declare function recordError(traceId: string, error: unknown, config?: TraceConfig): void;
 export declare function __resetLocalLLMTracerForTests(): void;
 export declare function wrapChatModel<TModel extends ChatModelLike<TInput, TOptions, TValue, TChunk>, TInput = any, TOptions = any, TValue = any, TChunk = any>(model: TModel, getContext: () => TraceContext, config?: TraceConfig): TModel;
+export declare function wrapOpenAIClient<TClient extends OpenAIClientLike<TParams, TOptions, TResponse, TChunk>, TParams extends OpenAIChatCompletionCreateParamsLike = OpenAIChatCompletionCreateParamsLike, TOptions = Record<string, any>, TResponse = any, TChunk = any>(client: TClient, getContext: () => TraceContext, config?: TraceConfig): TClient;

package/dist/index.js

@@ -11,11 +11,13 @@ exports.recordStreamFinish = recordStreamFinish;
 exports.recordError = recordError;
 exports.__resetLocalLLMTracerForTests = __resetLocalLLMTracerForTests;
 exports.wrapChatModel = wrapChatModel;
+exports.wrapOpenAIClient = wrapOpenAIClient;
 const server_1 = require("./server");
 const store_1 = require("./store");
 const ui_build_1 = require("./ui-build");
 const utils_1 = require("./utils");
 let singleton = null;
+const DEFAULT_TRACE_PORT = 4319;
 function isTraceEnabled() {
     return (0, utils_1.envFlag)('LLM_TRACE_ENABLED');
 }
@@ -105,9 +107,66 @@ function wrapChatModel(model, getContext, config) {
         },
     };
 }
+function wrapOpenAIClient(client, getContext, config) {
+    if (!client || typeof client.chat?.completions?.create !== 'function') {
+        throw new TypeError('wrapOpenAIClient expects an OpenAI client with chat.completions.create().');
+    }
+    const wrappedCompletions = new Proxy(client.chat.completions, {
+        get(target, prop, receiver) {
+            if (prop === 'create') {
+                return async (params, options) => {
+                    const tracer = getLocalLLMTracer(config);
+                    if (!tracer.isEnabled()) {
+                        return target.create.call(target, params, options);
+                    }
+                    const context = withOpenAITraceContext(getContext ? getContext() : {}, params);
+                    if (params?.stream) {
+                        const traceId = tracer.recordStreamStart(context, { input: params, options: options });
+                        try {
+                            const stream = await target.create.call(target, params, options);
+                            return wrapOpenAIChatCompletionsStream(stream, tracer, traceId);
+                        }
+                        catch (error) {
+                            tracer.recordError(traceId, error);
+                            throw error;
+                        }
+                    }
+                    const traceId = tracer.recordInvokeStart(context, { input: params, options: options });
+                    try {
+                        const response = await target.create.call(target, params, options);
+                        tracer.recordInvokeFinish(traceId, normalizeOpenAIChatCompletionResponse(response));
+                        return response;
+                    }
+                    catch (error) {
+                        tracer.recordError(traceId, error);
+                        throw error;
+                    }
+                };
+            }
+            return bindMethod(target, Reflect.get(target, prop, receiver));
+        },
+    });
+    const wrappedChat = new Proxy(client.chat, {
+        get(target, prop, receiver) {
+            if (prop === 'completions') {
+                return wrappedCompletions;
+            }
+            return bindMethod(target, Reflect.get(target, prop, receiver));
+        },
+    });
+    return new Proxy(client, {
+        get(target, prop, receiver) {
+            if (prop === 'chat') {
+                return wrappedChat;
+            }
+            return bindMethod(target, Reflect.get(target, prop, receiver));
+        },
+    });
+}
 class LocalLLMTracerImpl {
     config;
     loggedUrl;
+    portWasExplicit;
     server;
     serverFailed;
     serverInfo;
@@ -121,6 +180,7 @@ class LocalLLMTracerImpl {
             port: 4319,
             uiHotReload: false,
         };
+        this.portWasExplicit = false;
         this.configure(config);
         this.store = new store_1.TraceStore({ maxTraces: this.config.maxTraces });
         this.server = null;
@@ -134,9 +194,11 @@ class LocalLLMTracerImpl {
         if (this.serverInfo && (config.host || config.port)) {
             return;
         }
+        const explicitPort = getConfiguredPort(config.port, process.env.LLM_TRACE_PORT, this.portWasExplicit ? this.config.port : undefined);
+        this.portWasExplicit = explicitPort !== undefined;
         this.config = {
             host: config.host || this.config.host || process.env.LLM_TRACE_HOST || '127.0.0.1',
-            port: Number(config.port || this.config.port || process.env.LLM_TRACE_PORT) || 4319,
+            port: explicitPort ?? DEFAULT_TRACE_PORT,
             maxTraces: Number(config.maxTraces || this.config.maxTraces || process.env.LLM_TRACE_MAX_TRACES) || 1000,
             uiHotReload: typeof config.uiHotReload === 'boolean'
                 ? config.uiHotReload
@@ -163,7 +225,10 @@ class LocalLLMTracerImpl {
         }
         this.serverStartPromise = (async () => {
             try {
-                this.server = (0, server_1.createTraceServer)(this.store, this.config);
+                this.server = (0, server_1.createTraceServer)(this.store, {
+                    ...this.config,
+                    allowPortFallback: !this.portWasExplicit,
+                });
                 this.serverInfo = await this.server.start();
                 if (this.serverInfo && !this.uiWatcher) {
                     this.uiWatcher = await (0, ui_build_1.maybeStartUIWatcher)(() => {
@@ -218,3 +283,266 @@ function normaliseRequest(request) {
         options: (0, utils_1.safeClone)(request?.options),
     };
 }
+function bindMethod(target, value) {
+    return typeof value === 'function' ? value.bind(target) : value;
+}
+function getConfiguredPort(configPort, envPort, currentExplicitPort) {
+    if (typeof configPort === 'number' && Number.isFinite(configPort)) {
+        return configPort;
+    }
+    if (envPort !== undefined) {
+        const parsed = Number(envPort);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return typeof currentExplicitPort === 'number' && Number.isFinite(currentExplicitPort) ? currentExplicitPort : undefined;
+}
+function withOpenAITraceContext(context, params) {
+    return {
+        ...(context || {}),
+        model: context?.model || (typeof params?.model === 'string' ? params.model : null),
+        provider: context?.provider || 'openai',
+    };
+}
+function wrapOpenAIChatCompletionsStream(stream, tracer, traceId) {
+    const state = {
+        content: '',
+        finished: false,
+        finishReasons: [],
+        began: false,
+        role: null,
+        toolCalls: new Map(),
+        usage: null,
+    };
+    const emitBegin = (role) => {
+        if (state.began) {
+            return;
+        }
+        state.began = true;
+        const nextRole = role || state.role || 'assistant';
+        state.role = nextRole;
+        tracer.recordStreamChunk(traceId, { type: 'begin', role: nextRole });
+    };
+    const emitFinish = () => {
+        if (state.finished) {
+            return;
+        }
+        emitBegin(state.role);
+        state.finished = true;
+        tracer.recordStreamFinish(traceId, {
+            type: 'finish',
+            finish_reasons: state.finishReasons,
+            message: {
+                role: state.role || 'assistant',
+                content: state.content || null,
+            },
+            tool_calls: serializeOpenAIToolCalls(state.toolCalls),
+            usage: (0, utils_1.safeClone)(state.usage),
+        });
+    };
+    const processChunk = (chunk) => {
+        const raw = (0, utils_1.safeClone)(chunk);
+        const chunkToolCalls = [];
+        const finishReasons = new Set();
+        const contentParts = [];
+        const choices = Array.isArray(chunk?.choices) ? chunk.choices : [];
+        let sawEvent = false;
+        for (const choice of choices) {
+            const delta = choice?.delta || {};
+            if (typeof delta?.role === 'string' && delta.role) {
+                state.role = delta.role;
+                sawEvent = true;
+            }
+            for (const part of extractOpenAITextParts(delta?.content)) {
+                state.content = `${state.content}${part}`;
+                contentParts.push(part);
+                sawEvent = true;
+            }
+            if (Array.isArray(delta?.tool_calls) && delta.tool_calls.length > 0) {
+                sawEvent = true;
+                for (const toolCall of delta.tool_calls) {
+                    mergeOpenAIToolCallDelta(state.toolCalls, toolCall);
+                    chunkToolCalls.push((0, utils_1.safeClone)(toolCall));
+                }
+            }
+            if (typeof choice?.finish_reason === 'string' && choice.finish_reason) {
+                finishReasons.add(choice.finish_reason);
+            }
+        }
+        const usage = normalizeOpenAIUsage(chunk?.usage);
+        if (usage) {
+            state.usage = usage;
+            sawEvent = true;
+        }
+        for (const finishReason of finishReasons) {
+            state.finishReasons.push(finishReason);
+        }
+        if (sawEvent) {
+            emitBegin(state.role);
+        }
+        if (contentParts.length > 0) {
+            tracer.recordStreamChunk(traceId, {
+                type: 'chunk',
+                content: contentParts.join(''),
+                finish_reasons: [...finishReasons],
+                raw,
+                tool_calls: chunkToolCalls,
+                usage,
+            });
+            return;
+        }
+        tracer.recordStreamChunk(traceId, {
+            type: 'event',
+            finish_reasons: [...finishReasons],
+            raw,
+            tool_calls: chunkToolCalls,
+            usage,
+        });
+    };
+    const createWrappedIterator = (iterator) => ({
+        async next(...args) {
+            try {
+                const result = await iterator.next(...args);
+                if (result.done) {
+                    emitFinish();
+                    return result;
+                }
+                processChunk(result.value);
+                return result;
+            }
+            catch (error) {
+                tracer.recordError(traceId, error);
+                throw error;
+            }
+        },
+        async return(value) {
+            try {
+                const result = typeof iterator.return === 'function'
+                    ? await iterator.return(value)
+                    : {
+                        done: true,
+                        value,
+                    };
+                emitFinish();
+                return result;
+            }
+            catch (error) {
+                tracer.recordError(traceId, error);
+                throw error;
+            }
+        },
+        async throw(error) {
+            tracer.recordError(traceId, error);
+            if (typeof iterator.throw === 'function') {
+                return iterator.throw(error);
+            }
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    });
+    return new Proxy(stream, {
+        get(target, prop, receiver) {
+            if (prop === Symbol.asyncIterator) {
+                return () => createWrappedIterator(target[Symbol.asyncIterator]());
+            }
+            return bindMethod(target, Reflect.get(target, prop, receiver));
+        },
+    });
+}
+function normalizeOpenAIChatCompletionResponse(response) {
+    const message = response?.choices?.[0]?.message;
+    return {
+        finish_reason: response?.choices?.[0]?.finish_reason || null,
+        id: response?.id || null,
+        message: normalizeOpenAIMessage(message),
+        model: response?.model || null,
+        object: response?.object || null,
+        raw: (0, utils_1.safeClone)(response),
+        tool_calls: Array.isArray(message?.tool_calls) ? (0, utils_1.safeClone)(message.tool_calls) : [],
+        usage: normalizeOpenAIUsage(response?.usage),
+    };
+}
+function normalizeOpenAIMessage(message) {
+    return {
+        ...(0, utils_1.safeClone)(message),
+        content: normalizeOpenAIMessageContent(message),
+        role: typeof message?.role === 'string' ? message.role : 'assistant',
+    };
+}
+function normalizeOpenAIMessageContent(message) {
+    const content = extractOpenAITextParts(message?.content);
+    if (content.length > 0) {
+        return content.join('');
+    }
+    if (typeof message?.refusal === 'string' && message.refusal) {
+        return message.refusal;
+    }
+    return message?.content ?? null;
+}
+function extractOpenAITextParts(content) {
+    if (typeof content === 'string' && content) {
+        return [content];
+    }
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const parts = [];
+    for (const item of content) {
+        if (typeof item === 'string' && item) {
+            parts.push(item);
+            continue;
+        }
+        if (typeof item?.text === 'string' && item.text) {
+            parts.push(item.text);
+            continue;
+        }
+        if (typeof item?.content === 'string' && item.content) {
+            parts.push(item.content);
+        }
+    }
+    return parts;
+}
+function normalizeOpenAIUsage(usage) {
+    if (!usage || typeof usage !== 'object') {
+        return null;
+    }
+    return {
+        raw: (0, utils_1.safeClone)(usage),
+        tokens: {
+            completion: typeof usage?.completion_tokens === 'number' ? usage.completion_tokens : null,
+            prompt: typeof usage?.prompt_tokens === 'number' ? usage.prompt_tokens : null,
+            total: typeof usage?.total_tokens === 'number' ? usage.total_tokens : null,
+        },
+    };
+}
+function mergeOpenAIToolCallDelta(target, delta) {
+    const index = Number.isInteger(delta?.index) ? delta.index : target.size;
+    const current = (0, utils_1.safeClone)(target.get(index) || { function: { arguments: '' } });
+    if (delta?.id) {
+        current.id = delta.id;
+    }
+    if (delta?.type) {
+        current.type = delta.type;
+    }
+    if (delta?.function?.name) {
+        current.function = {
+            ...(current.function || {}),
+            name: delta.function.name,
+        };
+    }
+    if (delta?.function?.arguments) {
+        current.function = {
+            ...(current.function || {}),
+            arguments: `${current.function?.arguments || ''}${delta.function.arguments}`,
+        };
+    }
+    target.set(index, current);
+}
+function serializeOpenAIToolCalls(toolCalls) {
+    return [...toolCalls.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([, value]) => (0, utils_1.safeClone)(value));
+}

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import { type TraceServer } from './types';
 import { TraceStore } from './store';
 export declare function createTraceServer(store: TraceStore, options?: {
+    allowPortFallback?: boolean;
     host?: string;
     port?: number;
 }): TraceServer;

package/dist/server.js

@@ -11,11 +11,12 @@ const node_url_1 = require("node:url");
 const ui_1 = require("./ui");
 function createTraceServer(store, options = {}) {
     const host = options.host || '127.0.0.1';
-    const port = Number(options.port) || 4319;
+    const requestedPort = toPortNumber(options.port, 4319);
+    let activePort = requestedPort;
     const clients = new Set();
     const server = node_http_1.default.createServer(async (req, res) => {
         try {
-            const url = new node_url_1.URL(req.url || '/', `http://${req.headers.host || `${host}:${port}`}`);
+            const url = new node_url_1.URL(req.url || '/', `http://${req.headers.host || `${host}:${activePort}`}`);
             if (req.method === 'GET' && url.pathname === '/') {
                 sendHtml(res, (0, ui_1.renderAppHtml)());
                 return;
@@ -62,18 +63,13 @@ function createTraceServer(store, options = {}) {
     });
     return {
         async start() {
-            await new Promise((resolve, reject) => {
-                server.once('error', reject);
-                server.listen(port, host, () => {
-                    server.removeListener('error', reject);
-                    resolve();
-                });
-            });
+            await listenWithFallback(server, host, requestedPort, options.allowPortFallback);
+            activePort = getBoundPort(server, requestedPort);
             server.unref();
             return {
                 host,
-                port,
-                url: `http://${host}:${port}`,
+                port: activePort,
+                url: `http://${host}:${activePort}`,
             };
         },
         broadcast,
@@ -92,6 +88,41 @@ function createTraceServer(store, options = {}) {
         }
     }
 }
+async function listenWithFallback(server, host, port, allowPortFallback = false) {
+    await new Promise((resolve, reject) => {
+        const tryListen = (nextPort, canFallback) => {
+            const onError = (error) => {
+                server.removeListener('listening', onListening);
+                if (canFallback && error?.code === 'EADDRINUSE') {
+                    tryListen(0, false);
+                    return;
+                }
+                reject(error);
+            };
+            const onListening = () => {
+                server.removeListener('error', onError);
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(nextPort, host);
+        };
+        tryListen(port, allowPortFallback);
+    });
+}
+function getBoundPort(server, fallbackPort) {
+    const address = server.address();
+    if (address && typeof address === 'object' && typeof address.port === 'number') {
+        return address.port;
+    }
+    return fallbackPort;
+}
+function toPortNumber(value, fallback) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    return fallback;
+}
 function parseFilters(url) {
     return {
         search: url.searchParams.get('search') || undefined,

package/dist/session-nav.d.ts

@@ -31,4 +31,14 @@ export type SessionNavItem = {
     shortSessionId: string;
     status: "error" | "ok" | "pending";
 };
+export type SessionTreeSelection = {
+    selectedNodeId: string | null;
+    selectedTraceId: string | null;
+};
 export declare function deriveSessionNavItems(sessionNodes: SessionNavHierarchyNode[], traceById: Map<string, SessionNavTraceSummary>): SessionNavItem[];
+export declare function sortSessionNodesForNav(sessionNodes: SessionNavHierarchyNode[], traceById: Map<string, SessionNavTraceSummary>): SessionNavHierarchyNode[];
+export declare function findSessionNodePath(nodes: SessionNavHierarchyNode[], id: string, trail?: SessionNavHierarchyNode[]): SessionNavHierarchyNode[];
+export declare function findSessionNodeById(nodes: SessionNavHierarchyNode[], id: string): SessionNavHierarchyNode | null;
+export declare function getNewestTraceIdForNode(node: SessionNavHierarchyNode | null | undefined): string | null;
+export declare function resolveSessionTreeSelection(sessionNodes: SessionNavHierarchyNode[], selectedNodeId: string | null, selectedTraceId: string | null): SessionTreeSelection;
+export declare function getDefaultExpandedSessionTreeNodeIds(sessionNodes: SessionNavHierarchyNode[], activeSessionId: string | null, selectedNodeId: string | null): Set<string>;

package/dist/session-nav.js

@@ -1,11 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deriveSessionNavItems = deriveSessionNavItems;
+exports.sortSessionNodesForNav = sortSessionNodesForNav;
+exports.findSessionNodePath = findSessionNodePath;
+exports.findSessionNodeById = findSessionNodeById;
+exports.getNewestTraceIdForNode = getNewestTraceIdForNode;
+exports.resolveSessionTreeSelection = resolveSessionTreeSelection;
+exports.getDefaultExpandedSessionTreeNodeIds = getDefaultExpandedSessionTreeNodeIds;
 function deriveSessionNavItems(sessionNodes, traceById) {
     return sessionNodes
         .map((node) => deriveSessionNavItem(node, traceById))
         .sort(compareSessionNavItems);
 }
+function sortSessionNodesForNav(sessionNodes, traceById) {
+    const itemById = new Map(sessionNodes.map((node) => [node.id, deriveSessionNavItem(node, traceById)]));
+    return sessionNodes
+        .slice()
+        .sort((left, right) => compareSessionNavItems(itemById.get(left.id), itemById.get(right.id)));
+}
+function findSessionNodePath(nodes, id, trail = []) {
+    for (const node of nodes) {
+        const nextTrail = [...trail, node];
+        if (node.id === id) {
+            return nextTrail;
+        }
+        const childTrail = findSessionNodePath(node.children, id, nextTrail);
+        if (childTrail.length) {
+            return childTrail;
+        }
+    }
+    return [];
+}
+function findSessionNodeById(nodes, id) {
+    return findSessionNodePath(nodes, id).at(-1) ?? null;
+}
+function getNewestTraceIdForNode(node) {
+    if (!node?.traceIds.length) {
+        return null;
+    }
+    if (typeof node.meta?.traceId === "string" && node.meta.traceId) {
+        return node.meta.traceId;
+    }
+    return node.traceIds[0] || null;
+}
+function resolveSessionTreeSelection(sessionNodes, selectedNodeId, selectedTraceId) {
+    const selectedNode = selectedNodeId
+        ? findSessionNodeById(sessionNodes, selectedNodeId)
+        : null;
+    const selectedTraceNode = selectedTraceId
+        ? findSessionNodeById(sessionNodes, `trace:${selectedTraceId}`)
+        : null;
+    const fallbackNode = selectedNode ?? selectedTraceNode ?? sessionNodes[0] ?? null;
+    if (!fallbackNode) {
+        return {
+            selectedNodeId: null,
+            selectedTraceId: null,
+        };
+    }
+    const nextSelectedNodeId = selectedNode?.id ?? fallbackNode.id;
+    const nextSelectedTraceId = selectedTraceId && fallbackNode.traceIds.includes(selectedTraceId)
+        ? selectedTraceId
+        : getNewestTraceIdForNode(fallbackNode);
+    return {
+        selectedNodeId: nextSelectedNodeId,
+        selectedTraceId: nextSelectedTraceId,
+    };
+}
+function getDefaultExpandedSessionTreeNodeIds(sessionNodes, activeSessionId, selectedNodeId) {
+    const expanded = new Set();
+    const activeSession = (activeSessionId
+        ? sessionNodes.find((node) => node.id === activeSessionId) ?? null
+        : null) ?? sessionNodes[0] ?? null;
+    if (!activeSession) {
+        return expanded;
+    }
+    if (activeSession.children.length) {
+        expanded.add(activeSession.id);
+    }
+    visitSessionTree(activeSession.children, (node) => {
+        if (node.children.length && node.type === "actor") {
+            expanded.add(node.id);
+        }
+    });
+    if (selectedNodeId) {
+        for (const node of findSessionNodePath([activeSession], selectedNodeId)) {
+            if (node.children.length) {
+                expanded.add(node.id);
+            }
+        }
+    }
+    return expanded;
+}
 function deriveSessionNavItem(node, traceById) {
     const traces = node.traceIds
         .map((traceId) => traceById.get(traceId))
@@ -130,3 +215,9 @@ function formatCompactTimestamp(value) {
         minute: "2-digit",
     });
 }
+function visitSessionTree(nodes, visitor) {
+    for (const node of nodes) {
+        visitor(node);
+        visitSessionTree(node.children, visitor);
+    }
+}

package/dist/types.d.ts

@@ -202,6 +202,24 @@ export interface ChatModelLike<TInput = any, TOptions = any, TValue = any, TChun
     invoke(input: TInput, options?: TOptions): Promise<TValue>;
     stream(input: TInput, options?: TOptions): AsyncGenerator<TChunk>;
 }
+export type OpenAIChatCompletionCreateParamsLike = Record<string, any> & {
+    messages?: Record<string, any>[];
+    model?: string | null;
+    stream?: boolean | null;
+};
+export interface OpenAIChatCompletionStreamLike<TChunk = any> extends AsyncIterable<TChunk> {
+    [Symbol.asyncIterator](): AsyncIterator<TChunk>;
+}
+export interface OpenAIChatCompletionsLike<TParams = OpenAIChatCompletionCreateParamsLike, TOptions = Record<string, any>, TResponse = any, TChunk = any> {
+    create(params: TParams, options?: TOptions): Promise<TResponse> | Promise<OpenAIChatCompletionStreamLike<TChunk>> | OpenAIChatCompletionStreamLike<TChunk>;
+}
+export interface OpenAIClientLike<TParams = OpenAIChatCompletionCreateParamsLike, TOptions = Record<string, any>, TResponse = any, TChunk = any> {
+    chat: {
+        completions: OpenAIChatCompletionsLike<TParams, TOptions, TResponse, TChunk>;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
 export type TraceServer = {
     broadcast(event: TraceEvent | UIReloadEvent): void;
     close(): void;