@onereach/step-create-chat-completion 0.0.7-rc.5 → 0.0.7-rc.50

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import Step from '@onereach/flow-sdk/step';
-import { CONFIG, IThread, IThreadId, IActionEvent, ACTION, IEvent } from '@onereach/flow-sdk/types';
+import { CONFIG, IThreadId, RESULT, LOCAL, IEvent, IThread, IStepId, STATE, IActionEvent, ACTION } from '@onereach/flow-sdk/types/index.js';
+import { ChatCompletion, ChatCompletionToolMessageParam, ChatCompletionMessageFunctionToolCall, ChatCompletionChunk as ChatCompletionChunk$1, ChatCompletionMessageParam } from 'openai/resources';
 import { z } from 'zod/v4-mini';
-import { ChatCompletionChunk, ChatCompletionMessageToolCall, ChatCompletion, ChatCompletionToolMessageParam, ChatCompletionMessageParam } from 'openai/resources';
+import Step from '@onereach/flow-sdk/step.js';
+import { ChatCompletionMessageFunctionToolCall as ChatCompletionMessageFunctionToolCall$1, ChatCompletionMessageParam as ChatCompletionMessageParam$1, ChatCompletionToolMessageParam as ChatCompletionToolMessageParam$2 } from 'openai/resources.js';
+import { ChatCompletion as ChatCompletion$1, ChatCompletionToolMessageParam as ChatCompletionToolMessageParam$1, ChatCompletionChunk } from 'openai/resources.mjs';
 
 declare const dataInSchema: z.ZodMiniObject<{
     provider: z.ZodMiniString<string>;
     model: z.ZodMiniString<string>;
-    tokenName: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    tokenNameHeader: z.ZodMiniDefault<z.ZodMiniString<string>>;
-    sessionIdHeader: z.ZodMiniDefault<z.ZodMiniString<string>>;
+    accountKey: 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";
@@ -17,24 +17,22 @@ declare const dataInSchema: z.ZodMiniObject<{
     userMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
     switchAssistantsMessage: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
     assistantsFirstMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    userSettings: z.ZodMiniObject<{
-        temperature: z.ZodMiniPromise<z.ZodMiniDefault<z.ZodMiniNumber<unknown>>>;
-        topP: z.ZodMiniPromise<z.ZodMiniOptional<z.ZodMiniNumber<unknown>>>;
-        maxTokens: z.ZodMiniPromise<z.ZodMiniOptional<z.ZodMiniNumber<unknown>>>;
-        presencePenalty: z.ZodMiniPromise<z.ZodMiniOptional<z.ZodMiniNumber<unknown>>>;
-        frequencyPenalty: z.ZodMiniPromise<z.ZodMiniOptional<z.ZodMiniNumber<unknown>>>;
-        stop: z.ZodMiniPromise<z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-            token: z.ZodMiniString<string>;
-        }, z.core.$strip>>>>;
-    }, z.core.$strip>;
-    n: z.ZodMiniDefault<z.ZodMiniNumber<unknown>>;
+    temperature: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>;
+    topP: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>;
+    maxTokens: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>;
+    presencePenalty: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>;
+    frequencyPenalty: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniLiteral<"">, z.ZodMiniNumber<unknown>]>, z.ZodMiniTransform<number | undefined, number | "" | undefined>>;
+    n: 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>>>;
     streamResponse: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
     streamSettings: z.ZodMiniOptional<z.ZodMiniObject<{
-        maxBufferLength: z.ZodMiniPromise<z.ZodMiniNumber<unknown>>;
-        debounceDuration: z.ZodMiniPromise<z.ZodMiniNumber<unknown>>;
+        maxBufferLength: z.ZodMiniNumber<unknown>;
+        debounceDuration: z.ZodMiniNumber<unknown>;
     }, z.core.$strip>>;
     customHistory: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
-    historyRange: z.ZodMiniDefault<z.ZodMiniNumber<unknown>>;
+    historyLength: 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";
@@ -62,7 +60,7 @@ declare const dataInSchema: z.ZodMiniObject<{
         content: z.ZodMiniString<string>;
         name: z.ZodMiniOptional<z.ZodMiniString<string>>;
         tool_call_id: z.ZodMiniString<string>;
-    }, z.core.$strip>]>>>;
+    }, z.core.$strip>], "role">>>;
     historyCode: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
         role: z.ZodMiniLiteral<"system">;
         content: z.ZodMiniString<string>;
@@ -86,240 +84,162 @@ declare const dataInSchema: z.ZodMiniObject<{
         content: z.ZodMiniString<string>;
         name: z.ZodMiniOptional<z.ZodMiniString<string>>;
         tool_call_id: z.ZodMiniString<string>;
-    }, z.core.$strip>]>>>;
+    }, 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>>;
     processError: z.ZodMiniBoolean<boolean>;
     processTimeout: z.ZodMiniBoolean<boolean>;
     timeoutDuration: z.ZodMiniString<string>;
 }, z.core.$strip>;
 type DataIn = z.infer<typeof dataInSchema>;
 
-declare class StreamWorker extends Step<StreamWorkerConfig> {
-    static readonly class = "str_wrk";
-    static start(step: Step<StreamControllerConfig>, event: ContentChunk): Promise<void>;
-    static isBusy(step: Step<StreamControllerConfig>): boolean;
-    static getThread(step: Step<StreamControllerConfig>): IThread<StreamWorkerConfig> | undefined;
-    static getThreadId(step: Step<StreamControllerConfig>): IThreadId;
-    runStep(): void;
-}
-type ContentChunk = {
-    content: string;
-    index: number;
-    ts: number;
-};
-type StreamWorkerOut = {
-    chunk: ContentChunk;
-};
-type StreamWorkerState = {
-    class: typeof StreamWorker.class;
-    event: ContentChunk;
-};
-interface StreamWorkerConfig extends CONFIG {
+interface BaseConfig extends CONFIG {
     dataIn: DataIn;
-    dataOut: StreamWorkerOut;
-    state: StreamWorkerState;
 }
 
-declare class StreamController extends Step<StreamControllerConfig> {
-    static readonly class = "str_ctrl";
-    static start(step: Step<ChatCompletionConfig>): Promise<void>;
-    static handleChunk(step: Step<ChatCompletionConfig>, chunk: ChatCompletionChunk): Promise<void>;
-    static lastChunkReceived(step: Step<ChatCompletionConfig>): Promise<void>;
-    static getThreadId(step: Step): IThreadId;
-    runStep(): void;
-    /**
-     * Handler of the worker thread end event.
-     */
-    onWorkerThreadEnd(event: IActionEvent<StreamWorkerConfig, ACTION.end>): void;
-    /**
-     * Handles a single chunk of the streaming response from the OpenAI API.
-     */
-    onStreamChunk(event: IEvent<StreamChunkParams, EventName$2.handleChunk>): void;
-    protected handleMultipleChoices(choice: ChatCompletionChunk.Choice): void;
-    protected handleLengthFinishReason(choice: ChatCompletionChunk.Choice): void;
-    protected onToolCall(toolCall: ChatCompletionMessageToolCall): void;
-    /**
-     * 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.
-     */
-    tryRunWorker(): void;
-    private isEventReady;
-    private getEventToProcess;
-    /**
-     * Handles the notification that all response chunks were received from the OpenAI API.
-     */
-    onLastStreamChunkReceived(): Promise<void>;
-    protected get maxChunkContentLength(): number;
-    protected get debounceDuration(): number;
-}
-declare enum EventName$2 {
-    handleChunk = "add_chunk",
-    lastStreamChunkReceived = "llm_rsp_end"
-}
-type ContentChunkEvent = {
-    content: string;
-    index: number;
-    ts: number;
+type ManagedThreadLocal = {
+    active: boolean;
+    parent: IThreadId;
 };
-type ContentEndEvent = {
-    lastChunkReceived: true;
-};
-type ContentEvent = ContentChunkEvent | ContentEndEvent;
-type StreamChunkParams = {
-    chunk: ChatCompletionChunk;
-};
-type StreamControllerEvents = IEvent<StreamChunkParams, 'add_chunk'> | IEvent<unknown, 'llm_rsp_end'>;
-type StreamControllerState = {
-    class: typeof StreamController.class;
-    completionResult: Partial<ChatCompletion>;
-    events: ContentEvent[];
-    index: number;
-    lastChunkReceived: boolean;
-    debounceId?: NodeJS.Timeout;
-    skipIndexWarning: boolean;
-};
-type StreamControllerResult = {
-    status: 'ok';
-    completion: ChatCompletion;
+
+type BaseChildResultCancel = {
+    status: 'cancel';
 };
-interface StreamControllerConfig extends CONFIG {
-    dataIn: DataIn;
-    state: StreamControllerState;
-    result: StreamControllerResult;
-    events: StreamControllerEvents;
+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;
 }
 
-declare class ToolsWorker<TArgs extends ParsedArguments, TResult> extends Step<ToolsWorkerConfig<TArgs, TResult>> {
-    static readonly class = "tl_wrk";
-    static start<TArgs extends ParsedArguments, TResult>(step: Step<ToolsControllerConfig<TResult>>, toolCall: ChatCompletionMessageToolCall): Promise<void>;
-    static getThreadId(toolCall: ChatCompletionMessageToolCall): IThreadId;
-    /**
-     * Initializes the tool worker thread to handle processing of repackaged content chunks.
-     */
-    runStep(): void;
-    protected getExitName(toolCall: ChatCompletionMessageToolCall): string;
-}
-type ParsedArguments<TArgs extends Record<string, unknown> = Record<string, unknown>> = TArgs;
-type ToolCallWithParsedArgs<TArgs extends ParsedArguments> = {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: TArgs;
-    };
-};
-type ToolsWorkerMergeField<TArgs extends ParsedArguments> = {
-    toolCall: ToolCallWithParsedArgs<TArgs>;
-};
-type ToolsWorkerOut<TArgs extends ParsedArguments> = ToolsWorkerMergeField<TArgs>;
-type ToolsWorkerState = {
-    class: typeof ToolsWorker.class;
+declare const cancelContextClassId = "cncl_ctrl";
+declare const parentEvents: {
+    readonly cancel: "st_cancel";
 };
-type ToolsWorkerLocal<TArgs extends ParsedArguments> = {
-    toolCall: ChatCompletionMessageToolCall;
-    parsedArguments: TArgs;
+type ParentEventName = typeof parentEvents;
+declare const cancelContentEvents: {
+    readonly cancel: "cnl_cancel";
 };
-type ThreadWorkerResult<TResult> = {
-    toolCallId: string;
-    data: TResult;
+type CancelContentEventName = typeof cancelContentEvents;
+type CancelContextEvents = IEvent<unknown, CancelContentEventName['cancel']>;
+type CancelContextState = {
+    class: typeof cancelContextClassId;
 };
-interface ToolsWorkerConfig<TArgs extends ParsedArguments, TResult> extends CONFIG {
-    dataIn: DataIn;
-    dataOut: ToolsWorkerOut<TArgs>;
-    state: ToolsWorkerState;
-    result: ThreadWorkerResult<TResult>;
-    local: ToolsWorkerLocal<TArgs>;
+interface CancelContextConfig extends BaseChildConfig {
+    state: CancelContextState;
+    events: CancelContextEvents;
 }
 
-declare class ToolsController<TArgs extends ParsedArguments, TResult> extends Step<ToolsControllerConfig<TResult>> {
-    static readonly class = "tl_ctrl";
-    static start<TResult>(step: Step<ChatCompletionConfig>): Promise<void>;
-    static callTool<T extends ChatCompletionConfig | StreamControllerConfig>(step: Step<T>, toolCall: ChatCompletionMessageToolCall): Promise<void>;
-    static lastToolCallReceived<T extends ChatCompletionConfig | StreamControllerConfig>(step: Step<T>): Promise<void>;
-    static getThreadId<T extends CONFIG>(step: Step<T>): IThreadId;
-    runStep(): void;
-    onCallTool(event: IEvent<CallToolParams, EventName$1.callTool>): void;
-    onLastToolCallReceived(): void;
-    /**
-     * Starts the tool worker thread to process the tool call.
-     */
-    protected startToolWorkerThread(toolCall: ChatCompletionMessageToolCall): void;
-    onToolWorkerThreadEnd(event: IActionEvent<ToolsWorkerConfig<TArgs, TResult>, ACTION.end>): void;
-    protected setToolCallResult(toolCallId: string, result: TResult): void;
-    protected tryEndToolsControllerThread(): void;
-    protected get messages(): ChatCompletionToolMessageParam[];
-}
-declare enum EventName$1 {
-    callTool = "tl_run_call",
-    lastToolCallReceived = "tl_rsp_end"
-}
-type ToolCallTask<TResult> = {
-    status: 'pending' | 'completed' | 'failed';
-    call: ChatCompletionMessageToolCall;
-    result?: TResult;
-};
-type TasksMap<TResult> = Record<ChatCompletionMessageToolCall['id'], ToolCallTask<TResult>>;
-type ToolsControllerResult = {
-    status: 'ok';
-    messages: ChatCompletionToolMessageParam[];
-};
-type CallToolParams = {
-    toolCall: ChatCompletionMessageToolCall;
-};
-type ToolsControllerEvents = IEvent<CallToolParams, EventName$1.callTool> | IEvent<never, EventName$1.lastToolCallReceived>;
-type ToolsControllerState<TResult> = {
-    tasks: TasksMap<TResult>;
-    expectMoreTasks: boolean;
+type ChatCompletionOut = ChatCompletion;
+type ChatCompletionState = {
+    cancelled: boolean;
+    contentReady: boolean;
+    chatCompletion?: ChatCompletion;
+    toolsResults: ChatCompletionToolMessageParam[];
 };
-interface ToolsControllerConfig<TResult> extends CONFIG {
-    dataIn: DataIn;
-    state: ToolsControllerState<TResult>;
-    result: ToolsControllerResult;
-    events: ToolsControllerEvents;
+type ChatCompletionCancelEvent = IEvent<unknown, ParentEventName['cancel']>;
+type ChatCompletionEvent = ChatCompletionCancelEvent;
+interface ChatCompletionConfig extends BaseConfig {
+    dataOut: ChatCompletionOut;
+    state: ChatCompletionState;
+    events: ChatCompletionEvent;
 }
 
-declare class CreateChatCompletionStep<TResult> extends Step<ChatCompletionConfig> {
+declare class BaseStep<T extends BaseConfig> extends Step<T> {
     resolveDataIn(): Promise<{
         provider: string;
         model: string;
-        tokenNameHeader: string;
-        sessionIdHeader: string;
+        accountKey: string | undefined;
         typeOfStep: "chat" | "completion";
         switchAssistantsMessage: boolean;
-        userSettings: {
-            temperature: number;
-            topP: number | undefined;
-            maxTokens: number | undefined;
-            presencePenalty: number | undefined;
-            frequencyPenalty: number | undefined;
-            stop: {
-                token: string;
-            }[] | undefined;
-        };
-        n: number;
+        temperature: number | undefined;
+        topP: number | undefined;
+        maxTokens: number | undefined;
+        presencePenalty: number | undefined;
+        frequencyPenalty: number | undefined;
+        n: number | undefined;
         streamResponse: boolean;
         customHistory: boolean;
-        historyRange: number;
+        historyLength: number | undefined;
+        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;
-        tokenName?: string | undefined;
         systemMessage?: string | undefined;
         userMessage?: string | undefined;
         assistantsFirstMessage?: string | undefined;
+        stop?: {
+            token: string;
+        }[] | undefined;
         streamSettings?: {
             maxBufferLength: number;
             debounceDuration: number;
@@ -374,73 +294,382 @@ declare class CreateChatCompletionStep<TResult> extends Step<ChatCompletionConfi
             name?: string | undefined;
         })[] | undefined;
     }>;
+}
+
+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;
-    initRequest(): Promise<void>;
-    private handleResponse;
-    private handleStreamResponse;
-    onToolsControllerEnd(event: IActionEvent<ToolsControllerConfig<TResult>, ACTION.end>): Promise<void>;
-    onStreamControllerThreadEnd(event: IActionEvent<StreamControllerConfig, ACTION.end>): Promise<void>;
-    private tryToExitStep;
-    private get history();
-    private get openAiService();
+    initialize(): void;
+    onCancel(): void;
 }
-type ChatCompletionOut = ChatCompletion & {
-    _history: ChatCompletionMessageParam[];
+
+declare const requestContextClassId = "rqst_ctx";
+type RequestContextState = {
+    class: typeof requestContextClassId;
 };
-type ChatCompletionState = {
-    toolsReady: boolean;
-    contentReady: boolean;
-    chatCompletion?: ChatCompletion;
-    toolsResults: ChatCompletionToolMessageParam[];
+type RequestContextResultOk = {
+    status: 'ok';
 };
-interface ChatCompletionConfig extends CONFIG {
-    dataIn: DataIn;
-    dataOut: ChatCompletionOut;
-    state: ChatCompletionState;
+type RequestContextResult = RequestContextResultOk | RESULT<BaseChildConfig>;
+interface RequestContextConfig extends BaseChildConfig<RequestContextResult> {
+    state: RequestContextState;
+    result: RequestContextResult;
 }
 
-declare class HistoryController extends Step<HistoryControllerConfig> {
-    static readonly class = "hst_ctrl";
-    static start(step: Step<ChatCompletionConfig>): Promise<void>;
-    static appendToHistory(step: Step, message: ChatCompletionMessageParam | ChatCompletionMessageParam[]): Promise<void>;
-    static getHistory(step: Step): ChatCompletionMessageParam[];
-    static getThreadId(step: Step): IThreadId;
-    runStep(): void;
+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;
+}
+
+declare const contentContextEvents: {
+    readonly handleContent: "hnd_cnt";
+};
+type ContentContentEventName = typeof contentContextEvents;
+type ContentContextHandleContentEvent = IEvent<{
+    content: ChatCompletionChunk | 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$1[];
+};
+type ContentContextOkResult = {
+    status: 'ok';
+    chatCompletion: ChatCompletion$1;
+    toolsResults: ChatCompletionToolMessageParam$1[];
+};
+type ContentContextResult = ContentContextOkResult | RESULT<BaseChildConfig>;
+interface ContentContextConfig extends BaseChildConfig<ContentContextResult> {
+    state: ContentContextState;
+    result: ContentContextResult;
+    events: ContentContextEvent;
+}
+
+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;
-    onAppendToHistory(event: IEvent<HistoryControllerAppendParams, EventName.appendToHistory>): 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;
+}
+
+type SimpleContentContextHandleContentEvent = IEvent<{
+    content: ChatCompletion;
+}, ContentContentEventName['handleContent']>;
+type SimpleContentContextEvent = SimpleContentContextHandleContentEvent;
+interface SimpleContentContextConfig extends ContentContextConfig {
+    events: SimpleContentContextEvent;
+}
+
+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;
+}
+
+declare const streamContentContextClassId = "cnt_cxt_str";
+type StreamContentContextHandleContentEvent = IEvent<{
+    content: ChatCompletionChunk$1;
+}, 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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
     /**
-     * Adds a message to the managed history of this step
+     * Handles a single chunk of the streaming response from the OpenAI API.
      */
-    protected appendToManagedHistory(messages: ChatCompletionMessageParam[]): void;
+    onHandleContent(event: StreamContentContextHandleContentEvent): void;
     /**
-     * Returns the messages to be sent to the OpenAI API.
+     * Handles the notification that all response chunks were received from the OpenAI API.
      */
-    protected get initialMessages(): ChatCompletionMessageParam[];
-}
-declare enum EventName {
-    appendToHistory = "hst_append"
+    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;
 }
-type HistoryControllerAppendParams = {
+
+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 HistoryControllerEvents = IEvent<HistoryControllerAppendParams, EventName.appendToHistory>;
-type HistoryControllerState = {
-    class: typeof HistoryController.class;
+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 HistoryControllerConfig extends CONFIG {
-    dataIn: DataIn;
-    state: HistoryControllerState;
-    events: HistoryControllerEvents;
+interface HistoryContextConfig extends BaseConfig {
+    state: HistoryContextState;
+    events: HistoryContextEvent;
+}
+
+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;
+}
+
+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 get history();
+    private get openAiService();
+    private get responseHandler();
+}
+
+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;
+}
+
+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;
+}
+
+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$2[];
+}
+
+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();
 }
 
-declare const step: typeof CreateChatCompletionStep;
 declare const states: {
-    hst_ctrl: typeof HistoryController;
-    tl_ctrl: typeof ToolsController;
-    tl_wrk: typeof ToolsWorker;
-    str_ctrl: typeof StreamController;
-    str_wrk: typeof StreamWorker;
+    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;
 };
 
-export { states, step };
+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 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, cancelContentEvents, cancelContextClassId, contentContextEvents, historyContextClassId, historyContextEvents, parentEvents, requestContextClassId, states, CreateChatCompletionStep as step, streamContentContextClassId, streamContentContextWorkerClassId, streamWorkerExits, toolContextEvents, toolsContextClassId, toolsContextWorkerClassId };