@onereach/step-create-chat-completion 0.0.7-rc.58 → 0.0.7-rc.60

package/dist/index.d.mts

@@ -0,0 +1,726 @@
+import { ACTION, CONFIG, IActionEvent, IEvent, IStepId, IThread, IThreadId, LOCAL, RESULT, STATE } from "@onereach/flow-sdk/types/index.js";
+import * as z from "zod/mini";
+import { Step } from "@onereach/flow-sdk/step.js";
+import { ChatCompletion, ChatCompletionChunk, ChatCompletionMessageFunctionToolCall, ChatCompletionMessageParam, ChatCompletionToolMessageParam } from "openai/resources";
+import { ChatCompletionMessageFunctionToolCall as ChatCompletionMessageFunctionToolCall$1, ChatCompletionMessageParam as ChatCompletionMessageParam$1, ChatCompletionToolMessageParam as ChatCompletionToolMessageParam$1 } from "openai/resources.js";
+import { ChatCompletion as ChatCompletion$1, ChatCompletionChunk as ChatCompletionChunk$1, ChatCompletionToolMessageParam as ChatCompletionToolMessageParam$2 } from "openai/resources.mjs";
+
+//#region src/schemas/data-in.d.ts
+declare const dataInSchema: z.ZodMiniObject<{
+  provider: z.ZodMiniString<string>;
+  model: z.ZodMiniString<string>;
+  accountKey: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniString<string>]>, z.ZodMiniTransform<string | undefined, string | undefined>>>;
+  typeOfStep: z.ZodMiniEnum<{
+    chat: "chat";
+    completion: "completion";
+  }>;
+  systemMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  userMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  switchAssistantsMessage: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+  assistantsFirstMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  temperature: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  topP: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  maxTokens: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  presencePenalty: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  frequencyPenalty: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  n: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  stop: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+    token: z.ZodMiniString<string>;
+  }, z.core.$strip>>>;
+  reasoningEffort: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniEnum<{
+    none: "none";
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+  }>]>, z.ZodMiniTransform<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined, "" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined>>>;
+  streamResponse: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+  streamSettings: z.ZodMiniOptional<z.ZodMiniObject<{
+    maxBufferLength: z.ZodMiniNumber<unknown>;
+    debounceDuration: z.ZodMiniNumber<unknown>;
+  }, z.core.$strip>>;
+  customHistory: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+  historyLength: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>>;
+  historyMode: z.ZodMiniOptional<z.ZodMiniEnum<{
+    mergefield: "mergefield";
+    codeHistory: "codeHistory";
+  }>>;
+  historyMergefield: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"system">;
+    content: z.ZodMiniString<string>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"user">;
+    content: z.ZodMiniString<string>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"assistant">;
+    content: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    tool_calls: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+      id: z.ZodMiniString<string>;
+      type: z.ZodMiniLiteral<"function">;
+      function: z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        arguments: z.ZodMiniString<string>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"tool">;
+    content: z.ZodMiniString<string>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tool_call_id: z.ZodMiniString<string>;
+  }, z.core.$strip>], "role">>>;
+  historyCode: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"system">;
+    content: z.ZodMiniString<string>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"user">;
+    content: z.ZodMiniString<string>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"assistant">;
+    content: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    tool_calls: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+      id: z.ZodMiniString<string>;
+      type: z.ZodMiniLiteral<"function">;
+      function: z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        arguments: z.ZodMiniString<string>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    role: z.ZodMiniLiteral<"tool">;
+    content: z.ZodMiniString<string>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tool_call_id: z.ZodMiniString<string>;
+  }, z.core.$strip>], "role">>>;
+  functionsList: z.ZodMiniArray<z.ZodMiniObject<{
+    name: z.ZodMiniString<string>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    parameters: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniObject<{
+      type: z.ZodMiniLiteral<"object">;
+      properties: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        type: z.ZodMiniEnum<{
+          string: "string";
+          number: "number";
+          boolean: "boolean";
+          object: "object";
+          array: "array";
+        }>;
+        description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        items: z.ZodMiniOptional<z.ZodMiniObject<{
+          type: z.ZodMiniEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+          }>;
+          description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodMiniTransform<{
+      type: "object";
+      properties: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        description?: string | undefined;
+        items?: {
+          type: "string" | "number" | "boolean" | "object";
+          description?: string | undefined;
+        } | undefined;
+      }>;
+    } & {
+      additionalProperties: false;
+      required: string[];
+    }, {
+      type: "object";
+      properties: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        description?: string | undefined;
+        items?: {
+          type: "string" | "number" | "boolean" | "object";
+          description?: string | undefined;
+        } | undefined;
+      }>;
+    } & {
+      additionalProperties: false;
+      required: string[];
+    }>>>;
+    strict: z.ZodMiniBoolean<boolean>;
+  }, z.core.$strip>>;
+  useState: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+  stateSettings: z.ZodMiniOptional<z.ZodMiniObject<{
+    stateFunction: z.ZodMiniFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  }, z.core.$strip>>;
+  processError: z.ZodMiniBoolean<boolean>;
+  processTimeout: z.ZodMiniBoolean<boolean>;
+  timeoutDuration: z.ZodMiniString<string>;
+}, z.core.$strip>;
+type DataIn = z.infer<typeof dataInSchema>;
+//#endregion
+//#region src/threads/base/types.d.ts
+interface BaseConfig extends CONFIG {
+  dataIn: DataIn;
+}
+//#endregion
+//#region src/threads/base/base.d.ts
+declare class BaseStep<T extends BaseConfig> extends Step<T> {
+  resolveDataIn(): Promise<{
+    provider: string;
+    model: string;
+    typeOfStep: "chat" | "completion";
+    switchAssistantsMessage: boolean;
+    streamResponse: boolean;
+    customHistory: boolean;
+    functionsList: {
+      name: string;
+      strict: boolean;
+      description?: string | undefined;
+      parameters?: ({
+        type: "object";
+        properties: Record<string, {
+          type: "string" | "number" | "boolean" | "object" | "array";
+          description?: string | undefined;
+          items?: {
+            type: "string" | "number" | "boolean" | "object";
+            description?: string | undefined;
+          } | undefined;
+        }>;
+      } & {
+        additionalProperties: false;
+        required: string[];
+      }) | undefined;
+    }[];
+    processError: boolean;
+    processTimeout: boolean;
+    timeoutDuration: string;
+    accountKey?: string | undefined;
+    systemMessage?: string | undefined;
+    userMessage?: string | undefined;
+    assistantsFirstMessage?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    maxTokens?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    n?: number | undefined;
+    stop?: {
+      token: string;
+    }[] | undefined;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+    streamSettings?: {
+      maxBufferLength: number;
+      debounceDuration: number;
+    } | undefined;
+    historyLength?: number | undefined;
+    historyMode?: "mergefield" | "codeHistory" | undefined;
+    historyMergefield?: ({
+      role: "system";
+      content: string;
+    } | {
+      role: "user";
+      content: string;
+      name?: string | undefined;
+    } | {
+      role: "assistant";
+      content: string | null;
+      tool_calls?: {
+        id: string;
+        type: "function";
+        function: {
+          name: string;
+          arguments: string;
+        };
+      }[] | undefined;
+    } | {
+      role: "tool";
+      content: string;
+      tool_call_id: string;
+      name?: string | undefined;
+    })[] | undefined;
+    historyCode?: ({
+      role: "system";
+      content: string;
+    } | {
+      role: "user";
+      content: string;
+      name?: string | undefined;
+    } | {
+      role: "assistant";
+      content: string | null;
+      tool_calls?: {
+        id: string;
+        type: "function";
+        function: {
+          name: string;
+          arguments: string;
+        };
+      }[] | undefined;
+    } | {
+      role: "tool";
+      content: string;
+      tool_call_id: string;
+      name?: string | undefined;
+    })[] | undefined;
+    useState?: boolean | undefined;
+    stateSettings?: {
+      stateFunction: import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
+    } | undefined;
+  }>;
+}
+//#endregion
+//#region src/utils/thread-utilities.d.ts
+type ManagedThreadLocal = {
+  active: boolean;
+  parent: IThreadId;
+};
+//#endregion
+//#region src/threads/base/child-types.d.ts
+type BaseChildResultCancel = {
+  status: 'cancel';
+};
+type BaseChildResult = BaseChildResultCancel | Error;
+type BaseChildLocal = ManagedThreadLocal;
+interface BaseChildConfig<TResult extends RESULT<CONFIG> = BaseChildResult, TLocal extends LOCAL<CONFIG> = BaseChildLocal> extends BaseConfig {
+  result: TResult;
+  local: TLocal;
+}
+//#endregion
+//#region src/threads/cancel/constants.d.ts
+declare const cancelContextClassId = "cncl_ctrl";
+declare const parentEvents: {
+  readonly cancel: "st_cancel";
+};
+declare const cancelContentEvents: {
+  readonly cancel: "cnl_cancel";
+};
+//#endregion
+//#region src/threads/cancel/types.d.ts
+type ParentEventName = typeof parentEvents;
+type CancelContentEventName = typeof cancelContentEvents;
+type CancelContextEvents = IEvent<unknown, CancelContentEventName['cancel']>;
+type CancelContextState = {
+  class: typeof cancelContextClassId;
+};
+interface CancelContextConfig extends BaseChildConfig {
+  state: CancelContextState;
+  events: CancelContextEvents;
+}
+//#endregion
+//#region src/threads/main/types.d.ts
+type ChatCompletionOut = ChatCompletion;
+type ChatCompletionState = {
+  cancelled: boolean;
+  contentReady: boolean;
+  chatCompletion?: ChatCompletion;
+  toolsResults: ChatCompletionToolMessageParam[];
+};
+type ChatCompletionCancelEvent = IEvent<unknown, ParentEventName['cancel']>;
+type ChatCompletionEvent = ChatCompletionCancelEvent;
+interface ChatCompletionConfig extends BaseConfig {
+  dataOut: ChatCompletionOut;
+  state: ChatCompletionState;
+  events: ChatCompletionEvent;
+}
+//#endregion
+//#region src/threads/cancel/cancel-context.d.ts
+declare class CancelContext extends BaseStep<CancelContextConfig> {
+  static readonly class = "cncl_ctrl";
+  static start(thread: IThread<ChatCompletionConfig>): Promise<void>;
+  static stop(thread: IThread<ChatCompletionConfig>): Promise<void>;
+  static getThreadId(stepId: IStepId): IThreadId;
+  runStep(): void;
+  initialize(): void;
+  onCancel(): void;
+}
+//#endregion
+//#region src/threads/request/constants.d.ts
+declare const requestContextClassId = "rqst_ctx";
+//#endregion
+//#region src/threads/request/types.d.ts
+type RequestContextState = {
+  class: typeof requestContextClassId;
+};
+type RequestContextResultOk = {
+  status: 'ok';
+};
+type RequestContextResult = RequestContextResultOk | RESULT<BaseChildConfig>;
+interface RequestContextConfig extends BaseChildConfig<RequestContextResult> {
+  state: RequestContextState;
+  result: RequestContextResult;
+}
+//#endregion
+//#region src/threads/tools/context/constants.d.ts
+declare const toolsContextClassId = "tl_ctrl";
+declare const toolContextEvents: {
+  readonly callTool: "tl_run_call";
+  readonly lastToolCallReceived: "tl_rsp_end";
+};
+//#endregion
+//#region src/threads/tools/context/types.d.ts
+type ToolContextEventName = typeof toolContextEvents;
+type ToolCallTask = {
+  status: 'pending' | 'completed' | 'failed';
+  call: ChatCompletionMessageFunctionToolCall; /** result of the tool call, if completed */
+  result?: unknown;
+};
+type TasksMap = Record<ChatCompletionMessageFunctionToolCall['id'], ToolCallTask>;
+type ToolsContextResultOk = {
+  status: 'ok';
+  messages: ChatCompletionToolMessageParam[];
+};
+type ToolsContextResult = ToolsContextResultOk | RESULT<BaseChildConfig>;
+type CallToolParameters = {
+  toolCall: ChatCompletionMessageFunctionToolCall;
+};
+type ToolsContextEventCallTool = IEvent<CallToolParameters, ToolContextEventName['callTool']>;
+type ToolsContextEventLastToolReceived = IEvent<unknown, ToolContextEventName['lastToolCallReceived']>;
+type ToolsContextEvent = ToolsContextEventCallTool | ToolsContextEventLastToolReceived;
+type ToolsContextState = {
+  class: typeof toolsContextClassId; /** tool calls from LLM response */
+  tasks: TasksMap; /** flag to indicate if there are more tasks to process */
+  expectMoreTasks: boolean;
+};
+interface ToolsContextConfig extends BaseChildConfig<ToolsContextResult> {
+  state: ToolsContextState;
+  events: ToolsContextEvent;
+}
+//#endregion
+//#region src/threads/content/constants.d.ts
+declare const contentContextEvents: {
+  readonly handleContent: "hnd_cnt";
+};
+//#endregion
+//#region src/threads/content/types.d.ts
+type ContentContentEventName = typeof contentContextEvents;
+type ContentContextHandleContentEvent = IEvent<{
+  content: ChatCompletionChunk$1 | ChatCompletion$1;
+}, ContentContentEventName['handleContent']>;
+type ContentContextEvent = ContentContextHandleContentEvent;
+type ContentContextState = {
+  requestComplete: boolean;
+  chatCompletion?: ChatCompletion$1;
+  /**
+   * Are tool calls ready?
+   * - `undefined` - no tools to wait for
+   * - `false` - tools are processing
+   * - `true` - tools finished processing
+   */
+  toolsReady?: boolean;
+  toolsResults?: ChatCompletionToolMessageParam$2[];
+};
+type ContentContextOkResult = {
+  status: 'ok';
+  chatCompletion: ChatCompletion$1;
+  toolsResults: ChatCompletionToolMessageParam$2[];
+};
+type ContentContextResult = ContentContextOkResult | RESULT<BaseChildConfig>;
+interface ContentContextConfig extends BaseChildConfig<ContentContextResult> {
+  state: ContentContextState;
+  result: ContentContextResult;
+  events: ContentContextEvent;
+}
+//#endregion
+//#region src/threads/content/abstract-content-context.d.ts
+declare abstract class AbstractContentContext<T extends ContentContextConfig> extends BaseStep<T> {
+  static get class(): string;
+  static getInitialState<T extends ContentContextConfig>(): STATE<T>;
+  runStep(): void | Promise<void>;
+  initialize(): void;
+  abstract onHandleContent(event: ContentContextHandleContentEvent): void | Promise<void>;
+  protected abstract onAllContentReceived(): void | Promise<void>;
+  protected abstract tryToComplete(): void | Promise<void>;
+  onRequestContextEnd(event: IActionEvent<RequestContextConfig, ACTION.end>): Promise<void>;
+  onToolsContextEnd(event: IActionEvent<ToolsContextConfig, ACTION.end>): Promise<void>;
+  protected callFunction(toolCall: ChatCompletionMessageFunctionToolCall$1): Promise<void>;
+  protected handleMultipleChoices(): void;
+  protected initToolsContextThread(): Promise<void>;
+  protected cancel(): void;
+  protected complete(): void;
+}
+//#endregion
+//#region src/threads/content/simple/constants.d.ts
+declare const simpleContentContextClassId = "cnt_cxt_smp";
+//#endregion
+//#region src/threads/content/simple/types.d.ts
+type SimpleContentContextHandleContentEvent = IEvent<{
+  content: ChatCompletion;
+}, ContentContentEventName['handleContent']>;
+type SimpleContentContextEvent = SimpleContentContextHandleContentEvent;
+type SimpleContentContextState = ContentContextState & {
+  class: typeof simpleContentContextClassId;
+};
+interface SimpleContentContextConfig extends ContentContextConfig {
+  events: SimpleContentContextEvent;
+  state: SimpleContentContextState;
+}
+//#endregion
+//#region src/threads/content/simple/simple-content-context.d.ts
+declare class SimpleContentContext extends AbstractContentContext<SimpleContentContextConfig> {
+  static readonly class = "cnt_cxt_smp";
+  static getInitialState(): STATE<SimpleContentContextConfig>;
+  onHandleContent(event: SimpleContentContextHandleContentEvent): Promise<void>;
+  onAllContentReceived(): void;
+  protected tryToComplete(): void;
+}
+//#endregion
+//#region src/threads/content/stream/worker/constants.d.ts
+declare const streamContentContextWorkerClassId = "str_wrk";
+//#endregion
+//#region src/threads/content/stream/worker/types.d.ts
+type ContentChunk = {
+  content: string;
+  index: number;
+  ts: number;
+};
+type StreamContentContextWorkerOut = {
+  chunk: ContentChunk;
+};
+type StreamContentContextWorkerState = {
+  class: typeof streamContentContextWorkerClassId;
+  event: ContentChunk;
+};
+type StreamContentContextWorkerResult = undefined | RESULT<BaseChildConfig>;
+interface StreamContentContextWorkerConfig extends BaseChildConfig<StreamContentContextWorkerResult> {
+  dataOut: StreamContentContextWorkerOut;
+  state: StreamContentContextWorkerState;
+}
+//#endregion
+//#region src/threads/content/stream/context/constants.d.ts
+declare const streamContentContextClassId = "cnt_cxt_str";
+//#endregion
+//#region src/threads/content/stream/context/types.d.ts
+type StreamContentContextHandleContentEvent = IEvent<{
+  content: ChatCompletionChunk;
+}, ContentContentEventName['handleContent']>;
+type StreamContentContextEvent = StreamContentContextHandleContentEvent;
+type ContentChunkEvent = {
+  content: string;
+  index: number;
+  ts: number;
+};
+type ContentEndEvent = {
+  lastChunkReceived: true;
+};
+type ContentEvent = ContentChunkEvent | ContentEndEvent;
+type StreamContentContextState = ContentContextState & {
+  class: typeof streamContentContextClassId; /** aggregated result of the LLM response */
+  partialChatCompletion: Partial<ChatCompletion>; /** queue of response chunks */
+  events: ContentEvent[]; /** last index for a chunk to be processed by worker */
+  index: number; /** marker for end of response stream */
+  lastChunkReceived: boolean; /** When `true` means worker finished the processing the queue */
+  workerComplete: boolean;
+};
+interface StreamContentContextConfig extends ContentContextConfig {
+  events: StreamContentContextEvent;
+  state: StreamContentContextState;
+}
+//#endregion
+//#region src/threads/content/stream/context/stream-content-context.d.ts
+declare class StreamContentContext extends AbstractContentContext<StreamContentContextConfig> {
+  static readonly class = "cnt_cxt_str";
+  static getInitialState(): STATE<StreamContentContextConfig>;
+  private onToolCall;
+  /**
+   * Tries to flush the queue of response chunks to the controller thread.
+   * If the first event in the queue is not full, it waits for a debounce duration before flushing.
+   * If the first event is full, it flushes it immediately.
+   */
+  private scheduleNextContentEvent;
+  /**
+   * Compacts the content into the controller thread's events queue.
+   * If the content is too long, it splits it into multiple events.
+   * If the last event is not full, it extends it with the new content.
+   */
+  private addContentToQueue;
+  /**
+   * Processes the next event in the controller thread's queue.
+   * If the worker thread is busy, it skips processing.
+   * If the event is the termination marker, it notifies the end of the controller thread.
+   * If the event is ready for processing, it starts the worker thread to handle it.
+   */
+  private tryRunWorker;
+  private isEventReady;
+  private getEventToProcess;
+  protected tryToComplete(): void;
+  /**
+   * Handles the notification that all response chunks were received from the OpenAI API.
+   */
+  protected onAllContentReceived(): void;
+  protected get maxChunkContentLength(): number;
+  protected get debounceDuration(): number;
+  runStep(): Promise<void>;
+  /**
+   * Handler of the worker thread end event.
+   */
+  onWorkerThreadEnd(event: IActionEvent<StreamContentContextWorkerConfig, ACTION.end>): void;
+  /**
+   * Handles a single chunk of the streaming response from the OpenAI API.
+   */
+  onHandleContent(event: StreamContentContextHandleContentEvent): void;
+}
+//#endregion
+//#region src/threads/content/stream/worker/stream-content-context-worker.d.ts
+declare class StreamContentContextWorker extends BaseStep<StreamContentContextWorkerConfig> {
+  static readonly class = "str_wrk";
+  static start(thread: IThread<StreamContentContextConfig>, event: ContentChunk): Promise<void>;
+  static isBusy(thread: IThread<StreamContentContextConfig>): boolean;
+  static getThreadId(stepId: IStepId): IThreadId;
+  runStep(): void;
+}
+//#endregion
+//#region src/threads/history/types.d.ts
+declare const historyContextClassId = "hst_ctrl";
+declare const historyContextEvents: {
+  readonly appendToHistory: "hst_append";
+  readonly prepareHistory: "hst_prepare";
+  readonly adjustOnCancel: "hst_cncl";
+};
+type HistoryContextEventName = typeof historyContextEvents;
+type HistoryContextAppendParameters = {
+  message: ChatCompletionMessageParam | ChatCompletionMessageParam[];
+};
+type HistoryContextEventAppendToHistory = IEvent<HistoryContextAppendParameters, HistoryContextEventName['appendToHistory']>;
+type HistoryContextEventPrepareHistory = IEvent<unknown, HistoryContextEventName['prepareHistory']>;
+type HistoryContextEventAdjustOnCancel = IEvent<unknown, HistoryContextEventName['adjustOnCancel']>;
+type HistoryContextEvent = HistoryContextEventAppendToHistory | HistoryContextEventPrepareHistory | HistoryContextEventAdjustOnCancel;
+type HistoryContextState = {
+  class: typeof historyContextClassId; /** messages to send to OpenAI API */
+  messages: ChatCompletionMessageParam[];
+};
+interface HistoryContextConfig extends BaseConfig {
+  state: HistoryContextState;
+  events: HistoryContextEvent;
+}
+//#endregion
+//#region src/threads/history/history-context.d.ts
+declare class HistoryContext extends BaseStep<HistoryContextConfig> {
+  static readonly class = "hst_ctrl";
+  static start(thread: IThread<ChatCompletionConfig>): Promise<void>;
+  static prepareHistory<T extends ChatCompletionConfig>(thread: IThread<T>): Promise<void>;
+  static appendToHistory<T extends ChatCompletionConfig>(thread: IThread<T>, message: ChatCompletionMessageParam$1 | ChatCompletionMessageParam$1[]): Promise<void>;
+  static adjustOnCancel<T extends ChatCompletionConfig>(thread: IThread<T>): Promise<void>;
+  static getHistory<T extends CONFIG>(thread: IThread<T>): ChatCompletionMessageParam$1[];
+  static getThreadId(stepId: IStepId): IThreadId;
+  runStep(): void;
+  initialize(): void;
+  onAdjustOnCancel(): void;
+  onPrepareHistory(): void;
+  onAppendToHistory(event: HistoryContextEventAppendToHistory): void;
+}
+//#endregion
+//#region src/threads/request/request-context.d.ts
+declare class RequestContext extends BaseStep<RequestContextConfig> {
+  static readonly class = "rqst_ctx";
+  static start<T extends ContentContextConfig>(thread: IThread<T>): Promise<RequestContextResult>;
+  static getThreadId(stepId: IStepId): IThreadId;
+  private cancel;
+  private complete;
+  private getHistory;
+  private get openAiService();
+  private get responseHandler();
+  runStep(): Promise<void>;
+}
+//#endregion
+//#region src/threads/tools/worker/constants.d.ts
+declare const toolsContextWorkerClassId = "tl_wrk";
+//#endregion
+//#region src/threads/tools/worker/types.d.ts
+type ToolsContextParsedArguments = Record<string, unknown>;
+type ToolsContextWorkerMergeField = {
+  function: {
+    name: string;
+    arguments: ToolsContextParsedArguments;
+  };
+};
+type ToolsContextWorkerOut = ToolsContextWorkerMergeField;
+type ToolsContextWorkerState = {
+  class: typeof toolsContextWorkerClassId;
+};
+type ToolsContextWorkerLocal = LOCAL<BaseChildConfig> & {
+  toolCall: ChatCompletionMessageFunctionToolCall;
+  parsedArguments: ToolsContextParsedArguments;
+};
+type ThreadWorkerResultOk = {
+  status: 'ok'; /** id of the tool call that was processed */
+  toolCallId: string; /** result of the tool call */
+  data: unknown;
+};
+type ThreadWorkerResult = ThreadWorkerResultOk | RESULT<BaseChildConfig>;
+interface ToolsContextWorkerConfig extends BaseChildConfig<ThreadWorkerResult, ToolsContextWorkerLocal> {
+  dataOut: ToolsContextWorkerOut;
+  state: ToolsContextWorkerState;
+}
+//#endregion
+//#region src/threads/tools/context/tools-context.d.ts
+declare class ToolsContext extends BaseStep<ToolsContextConfig> {
+  static readonly class = "tl_ctrl";
+  static start<T extends ContentContextConfig>(thread: IThread<T>): Promise<void>;
+  static callTool<T extends ContentContextConfig>(thread: IThread<T>, toolCall: ChatCompletionMessageFunctionToolCall$1): Promise<void>;
+  /**
+   * Notify tools context thread that no more tool calls are expected
+   */
+  static lastToolCallReceived<T extends ContentContextConfig>(thread: IThread<T>): Promise<void>;
+  static getThreadId(stepId: IStepId): IThreadId;
+  runStep(): void;
+  initialize(): void;
+  onCallTool(event: ToolsContextEventCallTool): void;
+  onLastToolCallReceived(): void;
+  onWorkerThreadEnd(event: IActionEvent<ToolsContextWorkerConfig, ACTION.end>): void;
+  /**
+   * Starts the tool worker thread to process the tool call.
+   */
+  protected startToolWorkerThread(toolCall: ChatCompletionMessageFunctionToolCall$1): void;
+  protected setToolCallResult(toolCallId: string, result: unknown): void;
+  protected tryEndToolsContextThread(): void;
+  protected get messages(): ChatCompletionToolMessageParam$1[];
+}
+//#endregion
+//#region src/threads/tools/worker/tools-context-worker.d.ts
+declare class ToolsContextWorker extends BaseStep<ToolsContextWorkerConfig> {
+  static readonly class = "tl_wrk";
+  static start(thread: IThread<ToolsContextConfig>, toolCall: ChatCompletionMessageFunctionToolCall$1): Promise<void>;
+  static getThreadId(toolCall: ChatCompletionMessageFunctionToolCall$1): IThreadId;
+  /**
+   * Initializes the tool worker thread to handle processing of repackaged content chunks.
+   */
+  runStep(): void;
+  protected getExitName(): string;
+}
+//#endregion
+//#region src/threads/main/step.d.ts
+declare class CreateChatCompletionStep extends BaseStep<ChatCompletionConfig> {
+  private tryToExitStep;
+  /**
+   * Reset the step so it can handle new request
+   *
+   * - Reset state of initial thread (e.g. main) to original state;
+   * - End CancelContext thread;
+   * - End ContentController (with child thread);
+   *
+   * @throws if there any issues with stopping threads
+   */
+  private resetStep;
+  private resetState;
+  private validateMergeFieldType;
+  private get contentContext();
+  runStep(): void;
+  initialize(): Promise<void>;
+  onContentContextEnd(event: IActionEvent<ContentContextConfig, ACTION.end>): Promise<void>;
+  onHistoryContextEnd(event: IActionEvent<HistoryContextConfig, ACTION.end>): Promise<void>;
+  onCancel(): Promise<void>;
+}
+//#endregion
+//#region src/index.d.ts
+declare const states: {
+  hst_ctrl: typeof HistoryContext;
+  rqst_ctx: typeof RequestContext;
+  tl_ctrl: typeof ToolsContext;
+  tl_wrk: typeof ToolsContextWorker;
+  cnt_cxt_smp: typeof SimpleContentContext;
+  cnt_cxt_str: typeof StreamContentContext;
+  str_wrk: typeof StreamContentContextWorker;
+  cncl_ctrl: typeof CancelContext;
+};
+//#endregion
+export { type CallToolParameters, type CancelContentEventName, type CancelContextConfig, type CancelContextEvents, type CancelContextState, type ChatCompletionCancelEvent, type ChatCompletionConfig, type ChatCompletionEvent, type ChatCompletionOut, type ChatCompletionState, type ContentChunk, type ContentChunkEvent, type ContentContentEventName, type ContentContextConfig, type ContentContextEvent, type ContentContextHandleContentEvent, type ContentContextOkResult, type ContentContextResult, type ContentContextState, type ContentEndEvent, type ContentEvent, type HistoryContextAppendParameters, type HistoryContextConfig, type HistoryContextEvent, type HistoryContextEventAdjustOnCancel, type HistoryContextEventAppendToHistory, type HistoryContextEventName, type HistoryContextEventPrepareHistory, type HistoryContextState, type ParentEventName, type RequestContextConfig, type RequestContextResult, type RequestContextResultOk, type RequestContextState, type SimpleContentContextConfig, type SimpleContentContextEvent, type SimpleContentContextHandleContentEvent, type SimpleContentContextState, type StreamContentContextConfig, type StreamContentContextEvent, type StreamContentContextHandleContentEvent, type StreamContentContextState, type StreamContentContextWorkerConfig, type StreamContentContextWorkerOut, type StreamContentContextWorkerResult, type StreamContentContextWorkerState, type TasksMap, type ThreadWorkerResult, type ThreadWorkerResultOk, type ToolCallTask, type ToolContextEventName, type ToolsContextConfig, type ToolsContextEvent, type ToolsContextEventCallTool, type ToolsContextEventLastToolReceived, type ToolsContextParsedArguments, type ToolsContextResult, type ToolsContextResultOk, type ToolsContextState, type ToolsContextWorkerConfig, type ToolsContextWorkerLocal, type ToolsContextWorkerMergeField, type ToolsContextWorkerOut, type ToolsContextWorkerState, type historyContextClassId, type historyContextEvents, states, CreateChatCompletionStep as step };
+//# sourceMappingURL=index.d.mts.map