@xalia/agent 0.6.10 → 0.6.11

package/src/agent/openAILLMStreaming.ts

@@ -1,648 +0,0 @@
-import { OpenAI } from "openai";
-import { strict as assert } from "assert";
-
-import { getLogger } from "@xalia/xmcp/sdk";
-
-import {
-  ILLM,
-  Message,
-  XALIA_APP_HEADER,
-  MessageToolCall,
-  Choice,
-  Completion,
-  MessageParam,
-  ToolDescriptor,
-} from "./llm";
-import {
-  Reasoning,
-  ChatCompletionChunkChoiceDeltaWithReasoning,
-  choiceDeltaExtractReasoning,
-} from "./openAI";
-
-const logger = getLogger();
-
-function initialToolCallFunction(
-  deltaFn:
-    | OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall.Function
-    | undefined
-): OpenAI.Chat.Completions.ChatCompletionMessageFunctionToolCall.Function {
-  //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
-  //     arguments?: string;
-  //     name?: string;
-  //   }
-  //
-  // ->
-  //
-  //   export interface Function {
-  //     arguments: string;
-  //     name: string;
-  //   }
-
-  return {
-    arguments: deltaFn?.arguments || "",
-    name: deltaFn?.name || "",
-  };
-}
-
-function updateToolCallFunction(
-  existingFn: OpenAI.Chat.Completions.ChatCompletionMessageFunctionToolCall.Function, // eslint-disable-line
-  deltaFn: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall.Function // eslint-disable-line
-) {
-  //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
-  //     arguments?: string;
-  //     name?: string;
-  //   }
-  // ->
-  //   export interface Function {
-  //     arguments: string;
-  //     name: string;
-  //   }
-
-  // The function can have either (or possibly both) field(s) empty.
-  // `arguments` has been observered to arrive in chunks.  The same is
-  // probably true of `name`.
-
-  if (deltaFn.name) {
-    existingFn.name += deltaFn.name;
-  }
-  if (deltaFn.arguments) {
-    existingFn.arguments += deltaFn.arguments;
-  }
-}
-
-function initialToolCall(
-  delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall
-): MessageToolCall {
-  return {
-    id: delta.id || "",
-    function: initialToolCallFunction(delta.function),
-    type: "function",
-  };
-}
-
-function updateToolCall(
-  existing: MessageToolCall,
-  delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall
-) {
-  //   export interface ChatCompletionChunk.Choice.Delta.ToolCall {
-  //     index: number;
-  //     id?: string;
-  //     function?: ToolCall.Function;
-  //     type?: 'function';
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletionMessageToolCall {
-  //     id: string;
-  //     function: ChatCompletionMessageToolCall.Function;
-  //     type: 'function';
-  //   }
-
-  if (delta.id) {
-    if (existing.id.length > 0) {
-      assert(delta.id == existing.id);
-    } else {
-      existing.id = delta.id;
-    }
-  }
-
-  if (delta.function) {
-    updateToolCallFunction(existing.function, delta.function);
-  }
-
-  if (delta.type) {
-    assert((delta.type = "function"));
-  }
-}
-
-function updateToolCalls(
-  toolCalls: MessageToolCall[] | undefined,
-  deltaToolCall: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta.ToolCall // eslint-disable-line
-): MessageToolCall[] {
-  //   export interface ChatCompletionChunk.Choice.Delta.ToolCall {
-  //     index: number;
-  //     id?: string;
-  //     function?: ToolCall.Function;
-  //     type?: 'function';
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletionMessageToolCall {
-  //     id: string;
-  //     function: ChatCompletionMessageToolCall.Function;
-  //     type: 'function';
-  //   }
-
-  // The delta can arrive with any or none of the given fields.  Only `index`
-  // can be relied upon.
-
-  if (typeof toolCalls === "undefined") {
-    toolCalls = [];
-  }
-  if (
-    deltaToolCall.index >= toolCalls.length ||
-    !toolCalls[deltaToolCall.index]
-  ) {
-    toolCalls[deltaToolCall.index] = initialToolCall(deltaToolCall);
-  } else {
-    updateToolCall(toolCalls[deltaToolCall.index], deltaToolCall);
-  }
-  return toolCalls;
-}
-
-function initializeCompletionMessage(
-  delta: OpenAI.Chat.Completions.ChatCompletionChunk.Choice.Delta
-): Message {
-  assert(delta.role === undefined || delta.role == "assistant");
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  assert(!delta.function_call);
-
-  //   export interface ChatCompletionChunk.Choice.Delta {
-  //     content?: string | null;
-  //     function_call?: Delta.FunctionCall;
-  //     refusal?: string | null;
-  //     role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
-  //     tool_calls?: Array<Delta.ToolCall>;
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletionMessage {
-  //     content: string | null;
-  //     refusal: string | null;
-  //     role: 'assistant';
-  //     annotations?: Array<ChatCompletionMessage.Annotation>;
-  //     audio?: ChatCompletionAudio | null;
-  //     function_call?: ChatCompletionMessage.FunctionCall | null;
-  //     tool_calls?: Array<ChatCompletionMessageToolCall>;
-  //   }
-
-  let toolCalls: MessageToolCall[] | undefined = undefined;
-  if (delta.tool_calls) {
-    for (const t of delta.tool_calls) {
-      toolCalls = updateToolCalls(toolCalls, t);
-    }
-  }
-
-  return {
-    content: delta.content || null,
-    refusal: delta.refusal || null,
-    role: "assistant",
-    // annotations?: Array<ChatCompletionMessage.Annotation>;
-    // audio?: ChatCompletionAudio | null;
-    // function_call: delta.function_call,
-    tool_calls: toolCalls,
-  };
-}
-
-function updateReasoning(message: Message, reasoning: string) {
-  if (!message.reasoning) {
-    message.reasoning = reasoning;
-  } else {
-    message.reasoning += reasoning;
-  }
-}
-
-function updateCompletionMessage(
-  message: Message,
-  delta: ChatCompletionChunkChoiceDeltaWithReasoning
-) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  assert(message.role === "assistant");
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  assert(!message.function_call);
-  assert(!message.audio);
-  assert(
-    message.tool_calls instanceof Array ||
-      typeof message.tool_calls === "undefined"
-  );
-
-  //   export interface ChatCompletionChunkChoiceDeltaWithReasoning {
-  //     content?: string | null;
-  //     function_call?: Delta.FunctionCall;
-  //     refusal?: string | null;
-  //     role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
-  //     tool_calls?: Array<Delta.ToolCall>;
-  //
-  //     reasoning?: string;
-  //     reasoning_details?: {
-  //       type: "reasoning.text",
-  //       text?: string,
-  //       format?: string,
-  //       index?:0
-  //     }[]
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletionMessage {
-  //     content: string | null;
-  //     refusal: string | null;
-  //     role: 'assistant';
-  //     annotations?: Array<ChatCompletionMessage.Annotation>;
-  //     audio?: ChatCompletionAudio | null;
-  //     function_call?: ChatCompletionMessage.FunctionCall | null;
-  //     tool_calls?: Array<ChatCompletionMessageToolCall>;
-  //
-  //     reasoning?: string;
-  //   }
-
-  if (delta.content) {
-    if (message.content) {
-      message.content += delta.content;
-    } else {
-      message.content = delta.content;
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  assert(!delta.function_call);
-  if (delta.refusal) {
-    if (message.refusal) {
-      message.refusal += delta.refusal;
-    } else {
-      message.refusal = delta.refusal;
-    }
-  }
-  assert(delta.role === undefined || delta.role == "assistant");
-  if (delta.tool_calls) {
-    for (const t of delta.tool_calls) {
-      message.tool_calls = updateToolCalls(message.tool_calls, t);
-    }
-  }
-
-  const reasoning = choiceDeltaExtractReasoning(delta);
-  if (reasoning) {
-    updateReasoning(message, reasoning);
-  }
-}
-
-function initializeCompletionChoice(
-  chunkChoice: OpenAI.Chat.Completions.ChatCompletionChunk.Choice
-): { choice: Choice; done: boolean } {
-  //   export interface ChatCompletionChunk.Choice {
-  //     delta: Choice.Delta;
-  //     finish_reason:
-  //       'stop'|'length'|'tool_calls'|'content_filter'|'function_call'|null;
-  //     index: number;
-  //     logprobs?: Choice.Logprobs | null;
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletion.Choice {
-  //     message: CompletionsCompletionsAPI.ChatCompletionMessage;
-  //     finish_reason:
-  //         'stop'|'length'|'tool_calls'|'content_filter'|'function_call';
-  //     index: number;
-  //     logprobs: Choice.Logprobs | null;
-  //   }
-
-  const message = initializeCompletionMessage(chunkChoice.delta);
-  return {
-    choice: {
-      message,
-      // We use `null` to signal that `finish_reason` is unset
-      finish_reason: chunkChoice.finish_reason || (null as unknown as "stop"),
-      index: chunkChoice.index,
-      logprobs: chunkChoice.logprobs || null,
-    },
-    done: !!chunkChoice.finish_reason,
-  };
-}
-
-function updateCompletionChoice(
-  completionChoice: Choice,
-  chunkChoice: OpenAI.Chat.Completions.ChatCompletionChunk.Choice
-): boolean {
-  //   export interface ChatCompletionChunk.Choice {
-  //     delta: Choice.Delta;
-  //     finish_reason:
-  //       'stop'|'length'|'tool_calls'|'content_filter'|'function_call'|null;
-  //     index: number;
-  //     logprobs?: Choice.Logprobs | null;
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletion.Choice {
-  //     message: CompletionsCompletionsAPI.ChatCompletionMessage;
-  //     finish_reason:
-  //         'stop'|'length'|'tool_calls'|'content_filter'|'function_call';
-  //     index: number;
-  //     logprobs: Choice.Logprobs | null;
-  //   }
-
-  // TODO: logprobs
-
-  assert(completionChoice.index === chunkChoice.index);
-  updateCompletionMessage(completionChoice.message, chunkChoice.delta);
-  if (chunkChoice.finish_reason) {
-    assert(
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      completionChoice.finish_reason === null,
-      `finish_reason already set: (${completionChoice.finish_reason})`
-    );
-    completionChoice.finish_reason = chunkChoice.finish_reason;
-    return true;
-  }
-  return false;
-}
-
-function initializeCompletionChoices(
-  chunkChoices: OpenAI.Chat.Completions.ChatCompletionChunk.Choice[]
-): { choices: Choice[]; done: boolean } {
-  // Technically, one choice could be done and the other still have some
-  // content to stream.  We keep it simple for now and allow zero or one
-  // choice per chunk, which allows us to mark everything as done if any
-  // choice we hit is done. Zero choices can occur in usage-only chunks at
-  // the end of the stream.
-  assert(chunkChoices.length < 2);
-
-  let msgDone = false;
-  const choices: Choice[] = [];
-  for (const chunkChoice of chunkChoices) {
-    const { choice, done } = initializeCompletionChoice(chunkChoice);
-    if (done) {
-      msgDone = true;
-    }
-    choices[chunkChoice.index] = choice;
-  }
-
-  return { choices, done: msgDone };
-}
-
-function updateCompletionChoices(
-  completionChoices: Choice[],
-  chunkChoices: OpenAI.Chat.Completions.ChatCompletionChunk.Choice[]
-): boolean {
-  // Technically, one choice could be done and the other still have some
-  // content to stream.  We keep it simple for now and allow zero or one
-  // choice per chunk, which allows us to mark everything as done if any
-  // choice we hit is done. Zero choices can occur in usage-only chunks at
-  // the end of the stream.
-  assert(chunkChoices.length < 2);
-  assert(completionChoices.length === 1);
-
-  let msgDone = false;
-  for (const chunkChoice of chunkChoices) {
-    const choiceIdx = chunkChoice.index;
-    const done = updateCompletionChoice(
-      completionChoices[choiceIdx],
-      chunkChoice
-    );
-    if (done) {
-      msgDone = true;
-    }
-  }
-
-  return msgDone;
-}
-
-export function initializeCompletion(
-  chunk: OpenAI.Chat.Completions.ChatCompletionChunk
-): { initMessage: Completion; done: boolean } {
-  //   export interface ChatCompletionChunk {
-  //     id: string;
-  //     choices: Array<ChatCompletionChunk.Choice>;
-  //     created: number;
-  //     model: string;
-  //     object: 'chat.completion.chunk';
-  //     service_tier?: 'auto' | 'default' | 'flex' | null;
-  //     system_fingerprint?: string;
-  //     usage?: CompletionsAPI.CompletionUsage | null;
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletion {
-  //     id: string;
-  //     choices: Array<ChatCompletion.Choice>;
-  //     created: number;
-  //     model: string;
-  //     object: 'chat.completion';
-  //     service_tier?: 'auto'|'default'|'flex'|null;
-  //     system_fingerprint?: string;
-  //     usage?: CompletionsAPI.CompletionUsage;
-  //   }
-
-  const { choices, done } = initializeCompletionChoices(chunk.choices);
-  return {
-    initMessage: {
-      id: chunk.id,
-      choices,
-      created: chunk.created,
-      model: chunk.model,
-      object: "chat.completion",
-      service_tier: chunk.service_tier,
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      system_fingerprint: chunk.system_fingerprint,
-      usage: chunk.usage ?? undefined,
-    },
-    done,
-  };
-}
-
-export function updateCompletion(
-  completion: Completion,
-  chunk: OpenAI.Chat.Completions.ChatCompletionChunk
-): boolean {
-  //   export interface ChatCompletionChunk {
-  //     id: string;
-  //     choices: Array<ChatCompletionChunk.Choice>;
-  //     created: number;
-  //     model: string;
-  //     object: 'chat.completion.chunk';
-  //     service_tier?: 'auto' | 'default' | 'flex' | null;
-  //     system_fingerprint?: string;
-  //     usage?: CompletionsAPI.CompletionUsage | null;
-  //   }
-  //
-  // ->
-  //
-  //   export interface ChatCompletion {
-  //     id: string;
-  //     choices: Array<ChatCompletion.Choice>;
-  //     created: number;
-  //     model: string;
-  //     object: 'chat.completion';
-  //     service_tier?: 'auto'|'default'|'flex'|null;
-  //     system_fingerprint?: string;
-  //     usage?: CompletionsAPI.CompletionUsage;
-  //   }
-
-  assert(completion.id === chunk.id);
-  assert(completion.model === chunk.model);
-  completion.service_tier = completion.service_tier || chunk.service_tier;
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  completion.system_fingerprint =
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    completion.system_fingerprint || chunk.system_fingerprint;
-  completion.usage = completion.usage || chunk.usage || undefined;
-
-  return updateCompletionChoices(completion.choices, chunk.choices);
-}
-
-export class OpenAILLMStreaming implements ILLM {
-  private readonly openai: OpenAI;
-  private model: string;
-
-  constructor(apiKey: string, apiUrl: string | undefined, model: string) {
-    this.openai = new OpenAI({
-      apiKey,
-      baseURL: apiUrl,
-      dangerouslyAllowBrowser: true,
-      defaultHeaders: XALIA_APP_HEADER,
-    });
-    this.model = model;
-  }
-
-  public setModel(model: string) {
-    this.model = model;
-  }
-
-  getModel(): string {
-    return this.model;
-  }
-
-  getUrl(): string {
-    return this.openai.baseURL;
-  }
-
-  public async getConversationResponse(
-    messages: MessageParam[],
-    tools?: ToolDescriptor[],
-    onMessage?: (msg: string, end: boolean) => Promise<void>,
-    onReasoning?: (reasoning: string) => Promise<void>
-  ): Promise<{ stop: (msg: string) => void; completion: Promise<Completion> }> {
-    return OpenAILLMStreaming.makeRequest(
-      this.openai,
-      this.model,
-      messages,
-      tools,
-      onMessage,
-      onReasoning
-    );
-  }
-
-  public static async makeRequest(
-    openai: OpenAI,
-    model: string,
-    messages: MessageParam[],
-    tools?: ToolDescriptor[],
-    onMessage?: (msg: string, end: boolean) => Promise<void>,
-    onReasoning?: (reasoning: string) => Promise<void>
-  ): Promise<{ stop: (msg: string) => void; completion: Promise<Completion> }> {
-    const reasoning: Reasoning = {
-      effort: "medium",
-      enabled: true,
-    };
-    const chunks = await openai.chat.completions.create({
-      model: model,
-      messages,
-      tools,
-      stream: true,
-      stream_options: {
-        include_usage: true,
-      },
-      extra_body: { reasoning },
-    } as OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming);
-
-    // Check the type casting above
-    if (!(chunks as unknown as { iterator: unknown }).iterator) {
-      throw new Error("not a stream");
-    }
-
-    let stopMsg: string | undefined = undefined;
-
-    const stop = (msg: string) => {
-      stopMsg = msg;
-    };
-
-    const completion: Promise<Completion> = (async () => {
-      // Completion built up over successive calls to processChunk.
-      let aggregatedMessage: Completion | undefined;
-
-      const processChunk = async (
-        chunk: OpenAI.Chat.Completions.ChatCompletionChunk
-      ) => {
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (chunk.object !== "chat.completion.chunk") {
-          // logger.warn("[stream]: unexpected message");
-          return;
-        }
-
-        if (!aggregatedMessage) {
-          logger.debug(`[stream] first}`);
-          const { initMessage } = initializeCompletion(chunk);
-          aggregatedMessage = initMessage;
-        } else {
-          updateCompletion(aggregatedMessage, chunk);
-        }
-
-        if (onMessage) {
-          // Inform the call of a message fragment if it contains any text.
-          // Note: chunks may have zero choices (e.g., usage-only chunks), so
-          // we safely access the first choice.
-
-          const delta = chunk.choices[0]?.delta;
-          // eslint-disable-next-line
-          if (delta?.content) {
-            await onMessage(delta.content, false);
-          }
-        }
-
-        if (onReasoning) {
-          const delta = chunk.choices[0]
-            ?.delta as ChatCompletionChunkChoiceDeltaWithReasoning;
-          const reasoning = choiceDeltaExtractReasoning(delta);
-          if (reasoning) {
-            await onReasoning(reasoning);
-          }
-        }
-      };
-
-      // Process each chunk, checking for a stop signal.
-      for await (const chunk of chunks) {
-        logger.debug(`[stream] chunk: ${JSON.stringify(chunk)}`);
-        await processChunk(chunk);
-
-        /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-        if (stopMsg) {
-          const choice: OpenAI.Chat.Completions.ChatCompletionChunk.Choice = {
-            delta: { content: stopMsg },
-            finish_reason:
-              aggregatedMessage && aggregatedMessage.choices[0].finish_reason
-                ? null
-                : "stop",
-            index: 0,
-          };
-
-          await processChunk({
-            id: aggregatedMessage?.id || "user_stop_chunk",
-            created: aggregatedMessage?.created || Date.now(),
-            model: aggregatedMessage?.model || model,
-            object: "chat.completion.chunk",
-            choices: [choice],
-          });
-          break;
-        }
-        /* eslint-enable @typescript-eslint/no-unnecessary-condition */
-      }
-
-      if (onMessage) {
-        await onMessage("", true);
-      }
-
-      logger.debug(
-        `[stream] final message: ${JSON.stringify(aggregatedMessage)}`
-      );
-
-      assert(aggregatedMessage);
-      return aggregatedMessage;
-    })();
-
-    return { stop, completion };
-  }
-}