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

package/dist/index.d.mts

@@ -0,0 +1,709 @@
+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 * as _$zod_v4_core0 from "zod/v4/core";
+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/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/cancel-context-types.d.ts
+declare const cancelContextClassId = "cncl_ctrl";
+declare const parentEvents: {
+  readonly cancel: "st_cancel";
+};
+type ParentEventName = typeof parentEvents;
+declare const cancelContentEvents: {
+  readonly cancel: "cnl_cancel";
+};
+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/step-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/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: _$zod_v4_core0.$InferOuterFunctionType<_$zod_v4_core0.$ZodFunctionArgs, _$zod_v4_core0.$ZodFunctionOut>;
+    } | undefined;
+  }>;
+}
+//#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/request-context-types.d.ts
+declare const requestContextClassId = "rqst_ctx";
+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/tools-context-types.d.ts
+declare const toolsContextClassId = "tl_ctrl";
+declare const toolContextEvents: {
+  readonly callTool: "tl_run_call";
+  readonly lastToolCallReceived: "tl_rsp_end";
+};
+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/abstract-content-context-types.d.ts
+declare const contentContextEvents: {
+  readonly handleContent: "hnd_cnt";
+};
+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/simple-content-context-types.d.ts
+type SimpleContentContextHandleContentEvent = IEvent<{
+  content: ChatCompletion;
+}, ContentContentEventName['handleContent']>;
+type SimpleContentContextEvent = SimpleContentContextHandleContentEvent;
+interface SimpleContentContextConfig extends ContentContextConfig {
+  events: SimpleContentContextEvent;
+}
+//#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/stream-content-context-types.d.ts
+declare const streamContentContextClassId = "cnt_cxt_str";
+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 = Omit<ContentContextState, 'class'> & {
+  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/stream-content-context-worker-types.d.ts
+declare const streamContentContextWorkerClassId = "str_wrk";
+declare const streamWorkerExits: {
+  readonly chunk: "chunk";
+};
+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/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/content/stream/stream-content-context.d.ts
+declare class StreamContentContext extends AbstractContentContext<StreamContentContextConfig> {
+  static readonly class = "cnt_cxt_str";
+  static getInitialState(): STATE<StreamContentContextConfig>;
+  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;
+  /**
+   * Handles the notification that all response chunks were received from the OpenAI API.
+   */
+  protected onAllContentReceived(): void;
+  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;
+  protected get maxChunkContentLength(): number;
+  protected get debounceDuration(): number;
+}
+//#endregion
+//#region src/threads/history/history-context-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;
+  runStep(): Promise<void>;
+  private cancel;
+  private complete;
+  private getHistory;
+  private get openAiService();
+  private get responseHandler();
+}
+//#endregion
+//#region src/threads/tools/tools-context-worker-types.d.ts
+declare const toolsContextWorkerClassId = "tl_wrk";
+type ToolsContextParsedArguments = Record<string, unknown>;
+type ToolsContextWorkerMergeField = {
+  function: {
+    name: string;
+    arguments: ToolsContextParsedArguments;
+  };
+};
+type ToolsContextWorkerOut = ToolsContextWorkerMergeField;
+type ToolsContextWorkerState = {
+  class: typeof toolsContextWorkerClassId;
+};
+type ToolsContextWorkerLocal = {
+  toolCall: ChatCompletionMessageFunctionToolCall;
+  parsedArguments: ToolsContextParsedArguments;
+} & LOCAL<BaseChildConfig>;
+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/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/tools/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/step.d.ts
+declare class CreateChatCompletionStep extends BaseStep<ChatCompletionConfig> {
+  runStep(): void;
+  initialize(): Promise<void>;
+  onContentContextEnd(event: IActionEvent<ContentContextConfig, ACTION.end>): Promise<void>;
+  onHistoryContextEnd(event: IActionEvent<HistoryContextConfig, ACTION.end>): Promise<void>;
+  onCancel(): Promise<void>;
+  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();
+}
+//#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 { CallToolParameters, CancelContentEventName, CancelContextConfig, CancelContextEvents, CancelContextState, ChatCompletionCancelEvent, ChatCompletionConfig, ChatCompletionEvent, ChatCompletionOut, ChatCompletionState, ContentChunk, ContentChunkEvent, ContentContentEventName, ContentContextConfig, ContentContextEvent, ContentContextHandleContentEvent, ContentContextOkResult, ContentContextResult, ContentContextState, ContentEndEvent, ContentEvent, HistoryContextAppendParameters, HistoryContextConfig, HistoryContextEvent, HistoryContextEventAdjustOnCancel, HistoryContextEventAppendToHistory, HistoryContextEventName, HistoryContextEventPrepareHistory, HistoryContextState, ParentEventName, RequestContextConfig, RequestContextResult, RequestContextResultOk, RequestContextState, SimpleContentContextConfig, SimpleContentContextEvent, SimpleContentContextHandleContentEvent, StreamContentContextConfig, StreamContentContextEvent, StreamContentContextHandleContentEvent, StreamContentContextState, StreamContentContextWorkerConfig, StreamContentContextWorkerOut, StreamContentContextWorkerResult, StreamContentContextWorkerState, TasksMap, ThreadWorkerResult, ThreadWorkerResultOk, ToolCallTask, ToolContextEventName, ToolsContextConfig, ToolsContextEvent, ToolsContextEventCallTool, ToolsContextEventLastToolReceived, ToolsContextParsedArguments, ToolsContextResult, ToolsContextResultOk, ToolsContextState, ToolsContextWorkerConfig, ToolsContextWorkerLocal, ToolsContextWorkerMergeField, ToolsContextWorkerOut, ToolsContextWorkerState, cancelContentEvents, cancelContextClassId, contentContextEvents, historyContextClassId, historyContextEvents, parentEvents, requestContextClassId, states, CreateChatCompletionStep as step, streamContentContextClassId, streamContentContextWorkerClassId, streamWorkerExits, toolContextEvents, toolsContextClassId, toolsContextWorkerClassId };
+//# sourceMappingURL=index.d.mts.map