@superinterface/react 5.1.2 → 5.2.0-beta.0

package/types/node_modules/openai/internal/utils/path.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export declare function encodeURIPath(str: string): string;
+export declare const createPathTagFunction: (pathEncoder?: typeof encodeURIPath) => (statics: readonly string[], ...params: readonly unknown[]) => string;
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export declare const path: (statics: readonly string[], ...params: readonly unknown[]) => string;
+//# sourceMappingURL=path.d.mts.map

package/types/node_modules/openai/internal/utils/path.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export declare function encodeURIPath(str: string): string;
+export declare const createPathTagFunction: (pathEncoder?: typeof encodeURIPath) => (statics: readonly string[], ...params: readonly unknown[]) => string;
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export declare const path: (statics: readonly string[], ...params: readonly unknown[]) => string;
+//# sourceMappingURL=path.d.ts.map

package/types/node_modules/openai/internal/utils/sleep.d.mts

@@ -0,0 +1,2 @@
+export declare const sleep: (ms: number) => Promise<void>;
+//# sourceMappingURL=sleep.d.mts.map

package/types/node_modules/openai/internal/utils/sleep.d.ts

@@ -0,0 +1,2 @@
+export declare const sleep: (ms: number) => Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/types/node_modules/openai/internal/utils/uuid.d.mts

@@ -0,0 +1,5 @@
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export declare let uuid4: () => any;
+//# sourceMappingURL=uuid.d.mts.map

package/types/node_modules/openai/internal/utils/uuid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export declare let uuid4: () => any;
+//# sourceMappingURL=uuid.d.ts.map

package/types/node_modules/openai/internal/utils/values.d.mts

@@ -0,0 +1,18 @@
+export declare const isAbsoluteURL: (url: string) => boolean;
+export declare let isArray: (val: unknown) => val is unknown[];
+export declare let isReadonlyArray: (val: unknown) => val is readonly unknown[];
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export declare function maybeObj(x: unknown): object;
+export declare function isEmptyObj(obj: Object | null | undefined): boolean;
+export declare function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T;
+export declare function isObj(obj: unknown): obj is Record<string, unknown>;
+export declare const ensurePresent: <T>(value: T | null | undefined) => T;
+export declare const validatePositiveInteger: (name: string, n: unknown) => number;
+export declare const coerceInteger: (value: unknown) => number;
+export declare const coerceFloat: (value: unknown) => number;
+export declare const coerceBoolean: (value: unknown) => boolean;
+export declare const maybeCoerceInteger: (value: unknown) => number | undefined;
+export declare const maybeCoerceFloat: (value: unknown) => number | undefined;
+export declare const maybeCoerceBoolean: (value: unknown) => boolean | undefined;
+export declare const safeJSON: (text: string) => any;
+//# sourceMappingURL=values.d.mts.map

package/types/node_modules/openai/internal/utils/values.d.ts

@@ -0,0 +1,18 @@
+export declare const isAbsoluteURL: (url: string) => boolean;
+export declare let isArray: (val: unknown) => val is unknown[];
+export declare let isReadonlyArray: (val: unknown) => val is readonly unknown[];
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export declare function maybeObj(x: unknown): object;
+export declare function isEmptyObj(obj: Object | null | undefined): boolean;
+export declare function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T;
+export declare function isObj(obj: unknown): obj is Record<string, unknown>;
+export declare const ensurePresent: <T>(value: T | null | undefined) => T;
+export declare const validatePositiveInteger: (name: string, n: unknown) => number;
+export declare const coerceInteger: (value: unknown) => number;
+export declare const coerceFloat: (value: unknown) => number;
+export declare const coerceBoolean: (value: unknown) => boolean;
+export declare const maybeCoerceInteger: (value: unknown) => number | undefined;
+export declare const maybeCoerceFloat: (value: unknown) => number | undefined;
+export declare const maybeCoerceBoolean: (value: unknown) => boolean | undefined;
+export declare const safeJSON: (text: string) => any;
+//# sourceMappingURL=values.d.ts.map

package/types/node_modules/openai/internal/utils.d.mts

@@ -0,0 +1,7 @@
+export * from "./utils/values.mjs";
+export * from "./utils/base64.mjs";
+export * from "./utils/env.mjs";
+export * from "./utils/log.mjs";
+export * from "./utils/uuid.mjs";
+export * from "./utils/sleep.mjs";
+//# sourceMappingURL=utils.d.mts.map

package/types/node_modules/openai/internal/utils.d.ts

@@ -0,0 +1,7 @@
+export * from "./utils/values.js";
+export * from "./utils/base64.js";
+export * from "./utils/env.js";
+export * from "./utils/log.js";
+export * from "./utils/uuid.js";
+export * from "./utils/sleep.js";
+//# sourceMappingURL=utils.d.ts.map

package/types/node_modules/openai/lib/AbstractChatCompletionRunner.d.mts

@@ -0,0 +1,59 @@
+import type OpenAI from "../index.mjs";
+import type { RequestOptions } from "../internal/request-options.mjs";
+import type { ChatCompletion, ChatCompletionCreateParams, ChatCompletionMessage, ChatCompletionMessageFunctionToolCall, ChatCompletionMessageParam, ParsedChatCompletion } from "../resources/chat/completions.mjs";
+import type { CompletionUsage } from "../resources/completions.mjs";
+import type { ChatCompletionToolRunnerParams } from "./ChatCompletionRunner.mjs";
+import type { ChatCompletionStreamingToolRunnerParams } from "./ChatCompletionStreamingRunner.mjs";
+import { BaseEvents, EventStream } from "./EventStream.mjs";
+import { type BaseFunctionsArgs } from "./RunnableFunction.mjs";
+export interface RunnerOptions extends RequestOptions {
+    /** How many requests to make before canceling. Default 10. */
+    maxChatCompletions?: number;
+}
+export declare class AbstractChatCompletionRunner<EventTypes extends AbstractChatCompletionRunnerEvents, ParsedT> extends EventStream<EventTypes> {
+    #private;
+    protected _chatCompletions: ParsedChatCompletion<ParsedT>[];
+    messages: ChatCompletionMessageParam[];
+    protected _addChatCompletion(this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>, chatCompletion: ParsedChatCompletion<ParsedT>): ParsedChatCompletion<ParsedT>;
+    protected _addMessage(this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>, message: ChatCompletionMessageParam, emit?: boolean): void;
+    /**
+     * @returns a promise that resolves with the final ChatCompletion, or rejects
+     * if an error occurred or the stream ended prematurely without producing a ChatCompletion.
+     */
+    finalChatCompletion(): Promise<ParsedChatCompletion<ParsedT>>;
+    /**
+     * @returns a promise that resolves with the content of the final ChatCompletionMessage, or rejects
+     * if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
+     */
+    finalContent(): Promise<string | null>;
+    /**
+     * @returns a promise that resolves with the the final assistant ChatCompletionMessage response,
+     * or rejects if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
+     */
+    finalMessage(): Promise<ChatCompletionMessage>;
+    /**
+     * @returns a promise that resolves with the content of the final FunctionCall, or rejects
+     * if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
+     */
+    finalFunctionToolCall(): Promise<ChatCompletionMessageFunctionToolCall.Function | undefined>;
+    finalFunctionToolCallResult(): Promise<string | undefined>;
+    totalUsage(): Promise<CompletionUsage>;
+    allChatCompletions(): ChatCompletion[];
+    protected _emitFinal(this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>): void;
+    protected _createChatCompletion(client: OpenAI, params: ChatCompletionCreateParams, options?: RequestOptions): Promise<ParsedChatCompletion<ParsedT>>;
+    protected _runChatCompletion(client: OpenAI, params: ChatCompletionCreateParams, options?: RequestOptions): Promise<ChatCompletion>;
+    protected _runTools<FunctionsArgs extends BaseFunctionsArgs>(client: OpenAI, params: ChatCompletionToolRunnerParams<FunctionsArgs> | ChatCompletionStreamingToolRunnerParams<FunctionsArgs>, options?: RunnerOptions): Promise<void>;
+}
+export interface AbstractChatCompletionRunnerEvents extends BaseEvents {
+    functionToolCall: (functionCall: ChatCompletionMessageFunctionToolCall.Function) => void;
+    message: (message: ChatCompletionMessageParam) => void;
+    chatCompletion: (completion: ChatCompletion) => void;
+    finalContent: (contentSnapshot: string) => void;
+    finalMessage: (message: ChatCompletionMessageParam) => void;
+    finalChatCompletion: (completion: ChatCompletion) => void;
+    finalFunctionToolCall: (functionCall: ChatCompletionMessageFunctionToolCall.Function) => void;
+    functionToolCallResult: (content: string) => void;
+    finalFunctionToolCallResult: (content: string) => void;
+    totalUsage: (usage: CompletionUsage) => void;
+}
+//# sourceMappingURL=AbstractChatCompletionRunner.d.mts.map

package/types/node_modules/openai/lib/AbstractChatCompletionRunner.d.ts

@@ -0,0 +1,59 @@
+import type OpenAI from "../index.js";
+import type { RequestOptions } from "../internal/request-options.js";
+import type { ChatCompletion, ChatCompletionCreateParams, ChatCompletionMessage, ChatCompletionMessageFunctionToolCall, ChatCompletionMessageParam, ParsedChatCompletion } from "../resources/chat/completions.js";
+import type { CompletionUsage } from "../resources/completions.js";
+import type { ChatCompletionToolRunnerParams } from "./ChatCompletionRunner.js";
+import type { ChatCompletionStreamingToolRunnerParams } from "./ChatCompletionStreamingRunner.js";
+import { BaseEvents, EventStream } from "./EventStream.js";
+import { type BaseFunctionsArgs } from "./RunnableFunction.js";
+export interface RunnerOptions extends RequestOptions {
+    /** How many requests to make before canceling. Default 10. */
+    maxChatCompletions?: number;
+}
+export declare class AbstractChatCompletionRunner<EventTypes extends AbstractChatCompletionRunnerEvents, ParsedT> extends EventStream<EventTypes> {
+    #private;
+    protected _chatCompletions: ParsedChatCompletion<ParsedT>[];
+    messages: ChatCompletionMessageParam[];
+    protected _addChatCompletion(this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>, chatCompletion: ParsedChatCompletion<ParsedT>): ParsedChatCompletion<ParsedT>;
+    protected _addMessage(this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>, message: ChatCompletionMessageParam, emit?: boolean): void;
+    /**
+     * @returns a promise that resolves with the final ChatCompletion, or rejects
+     * if an error occurred or the stream ended prematurely without producing a ChatCompletion.
+     */
+    finalChatCompletion(): Promise<ParsedChatCompletion<ParsedT>>;
+    /**
+     * @returns a promise that resolves with the content of the final ChatCompletionMessage, or rejects
+     * if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
+     */
+    finalContent(): Promise<string | null>;
+    /**
+     * @returns a promise that resolves with the the final assistant ChatCompletionMessage response,
+     * or rejects if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
+     */
+    finalMessage(): Promise<ChatCompletionMessage>;
+    /**
+     * @returns a promise that resolves with the content of the final FunctionCall, or rejects
+     * if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
+     */
+    finalFunctionToolCall(): Promise<ChatCompletionMessageFunctionToolCall.Function | undefined>;
+    finalFunctionToolCallResult(): Promise<string | undefined>;
+    totalUsage(): Promise<CompletionUsage>;
+    allChatCompletions(): ChatCompletion[];
+    protected _emitFinal(this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>): void;
+    protected _createChatCompletion(client: OpenAI, params: ChatCompletionCreateParams, options?: RequestOptions): Promise<ParsedChatCompletion<ParsedT>>;
+    protected _runChatCompletion(client: OpenAI, params: ChatCompletionCreateParams, options?: RequestOptions): Promise<ChatCompletion>;
+    protected _runTools<FunctionsArgs extends BaseFunctionsArgs>(client: OpenAI, params: ChatCompletionToolRunnerParams<FunctionsArgs> | ChatCompletionStreamingToolRunnerParams<FunctionsArgs>, options?: RunnerOptions): Promise<void>;
+}
+export interface AbstractChatCompletionRunnerEvents extends BaseEvents {
+    functionToolCall: (functionCall: ChatCompletionMessageFunctionToolCall.Function) => void;
+    message: (message: ChatCompletionMessageParam) => void;
+    chatCompletion: (completion: ChatCompletion) => void;
+    finalContent: (contentSnapshot: string) => void;
+    finalMessage: (message: ChatCompletionMessageParam) => void;
+    finalChatCompletion: (completion: ChatCompletion) => void;
+    finalFunctionToolCall: (functionCall: ChatCompletionMessageFunctionToolCall.Function) => void;
+    functionToolCallResult: (content: string) => void;
+    finalFunctionToolCallResult: (content: string) => void;
+    totalUsage: (usage: CompletionUsage) => void;
+}
+//# sourceMappingURL=AbstractChatCompletionRunner.d.ts.map

package/types/node_modules/openai/lib/AssistantStream.d.mts

@@ -0,0 +1,60 @@
+import { Message, Text, ImageFile, TextDelta, MessageDelta } from "../resources/beta/threads/messages.mjs";
+import { RequestOptions } from "../internal/request-options.mjs";
+import { Run, RunCreateParamsBase, Runs, RunSubmitToolOutputsParamsBase } from "../resources/beta/threads/runs/runs.mjs";
+import { type ReadableStream } from "../internal/shim-types.mjs";
+import { AssistantStreamEvent } from "../resources/beta/assistants.mjs";
+import { RunStep, RunStepDelta, ToolCall, ToolCallDelta } from "../resources/beta/threads/runs/steps.mjs";
+import { ThreadCreateAndRunParamsBase, Threads } from "../resources/beta/threads/threads.mjs";
+import { BaseEvents, EventStream } from "./EventStream.mjs";
+export interface AssistantStreamEvents extends BaseEvents {
+    run: (run: Run) => void;
+    messageCreated: (message: Message) => void;
+    messageDelta: (message: MessageDelta, snapshot: Message) => void;
+    messageDone: (message: Message) => void;
+    runStepCreated: (runStep: RunStep) => void;
+    runStepDelta: (delta: RunStepDelta, snapshot: Runs.RunStep) => void;
+    runStepDone: (runStep: Runs.RunStep, snapshot: Runs.RunStep) => void;
+    toolCallCreated: (toolCall: ToolCall) => void;
+    toolCallDelta: (delta: ToolCallDelta, snapshot: ToolCall) => void;
+    toolCallDone: (toolCall: ToolCall) => void;
+    textCreated: (content: Text) => void;
+    textDelta: (delta: TextDelta, snapshot: Text) => void;
+    textDone: (content: Text, snapshot: Message) => void;
+    imageFileDone: (content: ImageFile, snapshot: Message) => void;
+    event: (event: AssistantStreamEvent) => void;
+}
+export type ThreadCreateAndRunParamsBaseStream = Omit<ThreadCreateAndRunParamsBase, 'stream'> & {
+    stream?: true;
+};
+export type RunCreateParamsBaseStream = Omit<RunCreateParamsBase, 'stream'> & {
+    stream?: true;
+};
+export type RunSubmitToolOutputsParamsStream = Omit<RunSubmitToolOutputsParamsBase, 'stream'> & {
+    stream?: true;
+};
+export declare class AssistantStream extends EventStream<AssistantStreamEvents> implements AsyncIterable<AssistantStreamEvent> {
+    #private;
+    [Symbol.asyncIterator](): AsyncIterator<AssistantStreamEvent>;
+    static fromReadableStream(stream: ReadableStream): AssistantStream;
+    protected _fromReadableStream(readableStream: ReadableStream, options?: RequestOptions): Promise<Run>;
+    toReadableStream(): ReadableStream;
+    static createToolAssistantStream(runId: string, runs: Runs, params: RunSubmitToolOutputsParamsStream, options: RequestOptions | undefined): AssistantStream;
+    protected _createToolAssistantStream(run: Runs, runId: string, params: RunSubmitToolOutputsParamsStream, options?: RequestOptions): Promise<Run>;
+    static createThreadAssistantStream(params: ThreadCreateAndRunParamsBaseStream, thread: Threads, options?: RequestOptions): AssistantStream;
+    static createAssistantStream(threadId: string, runs: Runs, params: RunCreateParamsBaseStream, options?: RequestOptions): AssistantStream;
+    currentEvent(): AssistantStreamEvent | undefined;
+    currentRun(): Run | undefined;
+    currentMessageSnapshot(): Message | undefined;
+    currentRunStepSnapshot(): Runs.RunStep | undefined;
+    finalRunSteps(): Promise<Runs.RunStep[]>;
+    finalMessages(): Promise<Message[]>;
+    finalRun(): Promise<Run>;
+    protected _createThreadAssistantStream(thread: Threads, params: ThreadCreateAndRunParamsBase, options?: RequestOptions): Promise<Run>;
+    protected _createAssistantStream(run: Runs, threadId: string, params: RunCreateParamsBase, options?: RequestOptions): Promise<Run>;
+    static accumulateDelta(acc: Record<string, any>, delta: Record<string, any>): Record<string, any>;
+    protected _addRun(run: Run): Run;
+    protected _threadAssistantStream(params: ThreadCreateAndRunParamsBase, thread: Threads, options?: RequestOptions): Promise<Run>;
+    protected _runAssistantStream(threadId: string, runs: Runs, params: RunCreateParamsBase, options?: RequestOptions): Promise<Run>;
+    protected _runToolAssistantStream(runId: string, runs: Runs, params: RunSubmitToolOutputsParamsStream, options?: RequestOptions): Promise<Run>;
+}
+//# sourceMappingURL=AssistantStream.d.mts.map

package/types/node_modules/openai/lib/AssistantStream.d.ts

@@ -0,0 +1,60 @@
+import { Message, Text, ImageFile, TextDelta, MessageDelta } from "../resources/beta/threads/messages.js";
+import { RequestOptions } from "../internal/request-options.js";
+import { Run, RunCreateParamsBase, Runs, RunSubmitToolOutputsParamsBase } from "../resources/beta/threads/runs/runs.js";
+import { type ReadableStream } from "../internal/shim-types.js";
+import { AssistantStreamEvent } from "../resources/beta/assistants.js";
+import { RunStep, RunStepDelta, ToolCall, ToolCallDelta } from "../resources/beta/threads/runs/steps.js";
+import { ThreadCreateAndRunParamsBase, Threads } from "../resources/beta/threads/threads.js";
+import { BaseEvents, EventStream } from "./EventStream.js";
+export interface AssistantStreamEvents extends BaseEvents {
+    run: (run: Run) => void;
+    messageCreated: (message: Message) => void;
+    messageDelta: (message: MessageDelta, snapshot: Message) => void;
+    messageDone: (message: Message) => void;
+    runStepCreated: (runStep: RunStep) => void;
+    runStepDelta: (delta: RunStepDelta, snapshot: Runs.RunStep) => void;
+    runStepDone: (runStep: Runs.RunStep, snapshot: Runs.RunStep) => void;
+    toolCallCreated: (toolCall: ToolCall) => void;
+    toolCallDelta: (delta: ToolCallDelta, snapshot: ToolCall) => void;
+    toolCallDone: (toolCall: ToolCall) => void;
+    textCreated: (content: Text) => void;
+    textDelta: (delta: TextDelta, snapshot: Text) => void;
+    textDone: (content: Text, snapshot: Message) => void;
+    imageFileDone: (content: ImageFile, snapshot: Message) => void;
+    event: (event: AssistantStreamEvent) => void;
+}
+export type ThreadCreateAndRunParamsBaseStream = Omit<ThreadCreateAndRunParamsBase, 'stream'> & {
+    stream?: true;
+};
+export type RunCreateParamsBaseStream = Omit<RunCreateParamsBase, 'stream'> & {
+    stream?: true;
+};
+export type RunSubmitToolOutputsParamsStream = Omit<RunSubmitToolOutputsParamsBase, 'stream'> & {
+    stream?: true;
+};
+export declare class AssistantStream extends EventStream<AssistantStreamEvents> implements AsyncIterable<AssistantStreamEvent> {
+    #private;
+    [Symbol.asyncIterator](): AsyncIterator<AssistantStreamEvent>;
+    static fromReadableStream(stream: ReadableStream): AssistantStream;
+    protected _fromReadableStream(readableStream: ReadableStream, options?: RequestOptions): Promise<Run>;
+    toReadableStream(): ReadableStream;
+    static createToolAssistantStream(runId: string, runs: Runs, params: RunSubmitToolOutputsParamsStream, options: RequestOptions | undefined): AssistantStream;
+    protected _createToolAssistantStream(run: Runs, runId: string, params: RunSubmitToolOutputsParamsStream, options?: RequestOptions): Promise<Run>;
+    static createThreadAssistantStream(params: ThreadCreateAndRunParamsBaseStream, thread: Threads, options?: RequestOptions): AssistantStream;
+    static createAssistantStream(threadId: string, runs: Runs, params: RunCreateParamsBaseStream, options?: RequestOptions): AssistantStream;
+    currentEvent(): AssistantStreamEvent | undefined;
+    currentRun(): Run | undefined;
+    currentMessageSnapshot(): Message | undefined;
+    currentRunStepSnapshot(): Runs.RunStep | undefined;
+    finalRunSteps(): Promise<Runs.RunStep[]>;
+    finalMessages(): Promise<Message[]>;
+    finalRun(): Promise<Run>;
+    protected _createThreadAssistantStream(thread: Threads, params: ThreadCreateAndRunParamsBase, options?: RequestOptions): Promise<Run>;
+    protected _createAssistantStream(run: Runs, threadId: string, params: RunCreateParamsBase, options?: RequestOptions): Promise<Run>;
+    static accumulateDelta(acc: Record<string, any>, delta: Record<string, any>): Record<string, any>;
+    protected _addRun(run: Run): Run;
+    protected _threadAssistantStream(params: ThreadCreateAndRunParamsBase, thread: Threads, options?: RequestOptions): Promise<Run>;
+    protected _runAssistantStream(threadId: string, runs: Runs, params: RunCreateParamsBase, options?: RequestOptions): Promise<Run>;
+    protected _runToolAssistantStream(runId: string, runs: Runs, params: RunSubmitToolOutputsParamsStream, options?: RequestOptions): Promise<Run>;
+}
+//# sourceMappingURL=AssistantStream.d.ts.map

package/types/node_modules/openai/lib/ChatCompletionRunner.d.mts

@@ -0,0 +1,16 @@
+import { type ChatCompletionMessageParam, type ChatCompletionCreateParamsNonStreaming } from "../resources/chat/completions.mjs";
+import { type BaseFunctionsArgs, RunnableTools } from "./RunnableFunction.mjs";
+import { AbstractChatCompletionRunner, AbstractChatCompletionRunnerEvents, RunnerOptions } from "./AbstractChatCompletionRunner.mjs";
+import OpenAI from "../index.mjs";
+import { AutoParseableTool } from "../lib/parser.mjs";
+export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunnerEvents {
+    content: (content: string) => void;
+}
+export type ChatCompletionToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<ChatCompletionCreateParamsNonStreaming, 'tools'> & {
+    tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+};
+export declare class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletionRunner<ChatCompletionRunnerEvents, ParsedT> {
+    static runTools<ParsedT>(client: OpenAI, params: ChatCompletionToolRunnerParams<any[]>, options?: RunnerOptions): ChatCompletionRunner<ParsedT>;
+    _addMessage(this: ChatCompletionRunner<ParsedT>, message: ChatCompletionMessageParam, emit?: boolean): void;
+}
+//# sourceMappingURL=ChatCompletionRunner.d.mts.map

package/types/node_modules/openai/lib/ChatCompletionRunner.d.ts

@@ -0,0 +1,16 @@
+import { type ChatCompletionMessageParam, type ChatCompletionCreateParamsNonStreaming } from "../resources/chat/completions.js";
+import { type BaseFunctionsArgs, RunnableTools } from "./RunnableFunction.js";
+import { AbstractChatCompletionRunner, AbstractChatCompletionRunnerEvents, RunnerOptions } from "./AbstractChatCompletionRunner.js";
+import OpenAI from "../index.js";
+import { AutoParseableTool } from "../lib/parser.js";
+export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunnerEvents {
+    content: (content: string) => void;
+}
+export type ChatCompletionToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<ChatCompletionCreateParamsNonStreaming, 'tools'> & {
+    tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+};
+export declare class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletionRunner<ChatCompletionRunnerEvents, ParsedT> {
+    static runTools<ParsedT>(client: OpenAI, params: ChatCompletionToolRunnerParams<any[]>, options?: RunnerOptions): ChatCompletionRunner<ParsedT>;
+    _addMessage(this: ChatCompletionRunner<ParsedT>, message: ChatCompletionMessageParam, emit?: boolean): void;
+}
+//# sourceMappingURL=ChatCompletionRunner.d.ts.map

package/types/node_modules/openai/lib/ChatCompletionStream.d.mts

@@ -0,0 +1,208 @@
+import OpenAI from "../index.mjs";
+import { RequestOptions } from "../internal/request-options.mjs";
+import { type ReadableStream } from "../internal/shim-types.mjs";
+import { ParsedChatCompletion } from "../resources/chat/completions.mjs";
+import { ChatCompletionTokenLogprob, type ChatCompletion, type ChatCompletionChunk, type ChatCompletionCreateParams, type ChatCompletionCreateParamsBase, type ChatCompletionRole } from "../resources/chat/completions/completions.mjs";
+import { AbstractChatCompletionRunner, type AbstractChatCompletionRunnerEvents } from "./AbstractChatCompletionRunner.mjs";
+export interface ContentDeltaEvent {
+    delta: string;
+    snapshot: string;
+    parsed: unknown | null;
+}
+export interface ContentDoneEvent<ParsedT = null> {
+    content: string;
+    parsed: ParsedT | null;
+}
+export interface RefusalDeltaEvent {
+    delta: string;
+    snapshot: string;
+}
+export interface RefusalDoneEvent {
+    refusal: string;
+}
+export interface FunctionToolCallArgumentsDeltaEvent {
+    name: string;
+    index: number;
+    arguments: string;
+    parsed_arguments: unknown;
+    arguments_delta: string;
+}
+export interface FunctionToolCallArgumentsDoneEvent {
+    name: string;
+    index: number;
+    arguments: string;
+    parsed_arguments: unknown;
+}
+export interface LogProbsContentDeltaEvent {
+    content: Array<ChatCompletionTokenLogprob>;
+    snapshot: Array<ChatCompletionTokenLogprob>;
+}
+export interface LogProbsContentDoneEvent {
+    content: Array<ChatCompletionTokenLogprob>;
+}
+export interface LogProbsRefusalDeltaEvent {
+    refusal: Array<ChatCompletionTokenLogprob>;
+    snapshot: Array<ChatCompletionTokenLogprob>;
+}
+export interface LogProbsRefusalDoneEvent {
+    refusal: Array<ChatCompletionTokenLogprob>;
+}
+export interface ChatCompletionStreamEvents<ParsedT = null> extends AbstractChatCompletionRunnerEvents {
+    content: (contentDelta: string, contentSnapshot: string) => void;
+    chunk: (chunk: ChatCompletionChunk, snapshot: ChatCompletionSnapshot) => void;
+    'content.delta': (props: ContentDeltaEvent) => void;
+    'content.done': (props: ContentDoneEvent<ParsedT>) => void;
+    'refusal.delta': (props: RefusalDeltaEvent) => void;
+    'refusal.done': (props: RefusalDoneEvent) => void;
+    'tool_calls.function.arguments.delta': (props: FunctionToolCallArgumentsDeltaEvent) => void;
+    'tool_calls.function.arguments.done': (props: FunctionToolCallArgumentsDoneEvent) => void;
+    'logprobs.content.delta': (props: LogProbsContentDeltaEvent) => void;
+    'logprobs.content.done': (props: LogProbsContentDoneEvent) => void;
+    'logprobs.refusal.delta': (props: LogProbsRefusalDeltaEvent) => void;
+    'logprobs.refusal.done': (props: LogProbsRefusalDoneEvent) => void;
+}
+export type ChatCompletionStreamParams = Omit<ChatCompletionCreateParamsBase, 'stream'> & {
+    stream?: true;
+};
+export declare class ChatCompletionStream<ParsedT = null> extends AbstractChatCompletionRunner<ChatCompletionStreamEvents<ParsedT>, ParsedT> implements AsyncIterable<ChatCompletionChunk> {
+    #private;
+    constructor(params: ChatCompletionCreateParams | null);
+    get currentChatCompletionSnapshot(): ChatCompletionSnapshot | undefined;
+    /**
+     * Intended for use on the frontend, consuming a stream produced with
+     * `.toReadableStream()` on the backend.
+     *
+     * Note that messages sent to the model do not appear in `.on('message')`
+     * in this context.
+     */
+    static fromReadableStream(stream: ReadableStream): ChatCompletionStream<null>;
+    static createChatCompletion<ParsedT>(client: OpenAI, params: ChatCompletionStreamParams, options?: RequestOptions): ChatCompletionStream<ParsedT>;
+    protected _createChatCompletion(client: OpenAI, params: ChatCompletionCreateParams, options?: RequestOptions): Promise<ParsedChatCompletion<ParsedT>>;
+    protected _fromReadableStream(readableStream: ReadableStream, options?: RequestOptions): Promise<ChatCompletion>;
+    [Symbol.asyncIterator](this: ChatCompletionStream<ParsedT>): AsyncIterator<ChatCompletionChunk>;
+    toReadableStream(): ReadableStream;
+}
+/**
+ * Represents a streamed chunk of a chat completion response returned by model,
+ * based on the provided input.
+ */
+export interface ChatCompletionSnapshot {
+    /**
+     * A unique identifier for the chat completion.
+     */
+    id: string;
+    /**
+     * A list of chat completion choices. Can be more than one if `n` is greater
+     * than 1.
+     */
+    choices: Array<ChatCompletionSnapshot.Choice>;
+    /**
+     * The Unix timestamp (in seconds) of when the chat completion was created.
+     */
+    created: number;
+    /**
+     * The model to generate the completion.
+     */
+    model: string;
+    /**
+     * This fingerprint represents the backend configuration that the model runs with.
+     *
+     * Can be used in conjunction with the `seed` request parameter to understand when
+     * backend changes have been made that might impact determinism.
+     */
+    system_fingerprint?: string;
+}
+export declare namespace ChatCompletionSnapshot {
+    interface Choice {
+        /**
+         * A chat completion delta generated by streamed model responses.
+         */
+        message: Choice.Message;
+        /**
+         * The reason the model stopped generating tokens. This will be `stop` if the model
+         * hit a natural stop point or a provided stop sequence, `length` if the maximum
+         * number of tokens specified in the request was reached, `content_filter` if
+         * content was omitted due to a flag from our content filters, or `function_call`
+         * if the model called a function.
+         */
+        finish_reason: ChatCompletion.Choice['finish_reason'] | null;
+        /**
+         * Log probability information for the choice.
+         */
+        logprobs: ChatCompletion.Choice.Logprobs | null;
+        /**
+         * The index of the choice in the list of choices.
+         */
+        index: number;
+    }
+    namespace Choice {
+        /**
+         * A chat completion delta generated by streamed model responses.
+         */
+        interface Message {
+            /**
+             * The contents of the chunk message.
+             */
+            content?: string | null;
+            refusal?: string | null;
+            parsed?: unknown | null;
+            /**
+             * The name and arguments of a function that should be called, as generated by the
+             * model.
+             */
+            function_call?: Message.FunctionCall;
+            tool_calls?: Array<Message.ToolCall>;
+            /**
+             * The role of the author of this message.
+             */
+            role?: ChatCompletionRole;
+        }
+        namespace Message {
+            interface ToolCall {
+                /**
+                 * The ID of the tool call.
+                 */
+                id: string;
+                function: ToolCall.Function;
+                /**
+                 * The type of the tool.
+                 */
+                type: 'function';
+            }
+            namespace ToolCall {
+                interface Function {
+                    /**
+                     * The arguments to call the function with, as generated by the model in JSON
+                     * format. Note that the model does not always generate valid JSON, and may
+                     * hallucinate parameters not defined by your function schema. Validate the
+                     * arguments in your code before calling your function.
+                     */
+                    arguments: string;
+                    parsed_arguments?: unknown;
+                    /**
+                     * The name of the function to call.
+                     */
+                    name: string;
+                }
+            }
+            /**
+             * The name and arguments of a function that should be called, as generated by the
+             * model.
+             */
+            interface FunctionCall {
+                /**
+                 * The arguments to call the function with, as generated by the model in JSON
+                 * format. Note that the model does not always generate valid JSON, and may
+                 * hallucinate parameters not defined by your function schema. Validate the
+                 * arguments in your code before calling your function.
+                 */
+                arguments?: string;
+                /**
+                 * The name of the function to call.
+                 */
+                name?: string;
+            }
+        }
+    }
+}
+//# sourceMappingURL=ChatCompletionStream.d.mts.map