Function step

packages/kosong/test/fixtures/step.ts:70–146

(
  provider: ChatProvider,
  systemPrompt: string,
  toolset: Toolset,
  history: Message[],
  callbacks?: StepCallbacks,
  options?: GenerateOptions,
)

 * @throws {ChatProviderError} (and subtypes) on provider failures.
 */
export async function step(
  provider: ChatProvider,
  systemPrompt: string,
  toolset: Toolset,
  history: Message[],
  callbacks?: StepCallbacks,
  options?: GenerateOptions,
): Promise<StepResult> {
  const toolCalls: ToolCall[] = [];
  const toolResultPromises = new Map<string, Promise<ToolResult>>();

  async function onToolCall(toolCall: ToolCall): Promise<void> {
    toolCalls.push(toolCall);

    const handleResult = toolset.handle(toolCall);

    // Normalise to a Promise regardless of whether handle() returned sync.
    const promise: Promise<ToolResult> =
      handleResult instanceof Promise ? handleResult : Promise.resolve(handleResult);

    // When the promise resolves, fire the onToolResult callback.
    const tracked = promise.then((result) => {
      if (callbacks?.onToolResult !== undefined) {
        callbacks.onToolResult(result);
      }
      return result;
    });

    toolResultPromises.set(toolCall.id, tracked);
    void tracked.catch(() => {});
  }

  let result: GenerateResult;
  try {
    const generateCallbacks: GenerateCallbacks = { onToolCall };
    if (callbacks?.onMessagePart !== undefined) {
      generateCallbacks.onMessagePart = callbacks.onMessagePart;
    }
    result = await generate(
      provider,
      systemPrompt,
      toolset.tools,
      history,
      generateCallbacks,
      options,
    );
  } catch (error: unknown) {
    // On provider or cancellation errors, cancel/await all pending tool
    // result promises to avoid dangling work.
    await cleanupPromises(toolResultPromises);
    throw error;
  }

  return {
    id: result.id,
    message: result.message,
    usage: result.usage,
    finishReason: result.finishReason,