
class AiSdkLLm extends llm.LLM {
  label = () => "AiSdkLLm";
  languageModel: LanguageModel;
  constructor(languageModel: LanguageModel) {
    super();
    this.languageModel = languageModel;
  }
  chat({
    chatCtx,
    toolCtx,
    connOptions,
    parallelToolCalls,
    toolChoice,
    extraKwargs,
  }: {
    chatCtx: llm.ChatContext;
    toolCtx?: llm.ToolContext;
    connOptions?: APIConnectOptions;
    parallelToolCalls?: boolean;
    toolChoice?: llm.ToolChoice;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    extraKwargs?: Record<string, any>;
  }): llm.LLMStream {
    return new AiSdkLLMStream(this.languageModel, this, {
      chatCtx,
      toolCtx,
      connOptions: connOptions ?? new APIConnectOptions({ maxRetry: 0 }),
      parallelToolCalls,
      toolChoice,
      extraKwargs,
    });
  }
}

class AiSdkLLMStream extends llm.LLMStream {
  label = () => "AiSdkLLMStream";
  languageModel: LanguageModel;
  constructor(
    languageModel: LanguageModel,
    llm: llm.LLM,
    context: {
      chatCtx: llm.ChatContext;
      toolCtx?: llm.ToolContext;
      connOptions: APIConnectOptions;
      parallelToolCalls?: boolean;
      toolChoice?: llm.ToolChoice;
      extraKwargs?: Record<string, unknown>;
    },
  ) {
    super(llm, context);
    this.languageModel = languageModel;
  }
  protected async run(): Promise<void> {
    // return super.llmNode(chatCtx, toolCtx, modelSettings);
    // Convert LiveKit chat context to AI SDK messages
    const messages = convertChatContextToAiSdk(this.chatCtx);

    // Convert LiveKit tools to AI SDK tools format
    const tools = this.toolCtx
      ? convertToolContextToAiSdk(this.toolCtx)
      : undefined;

    // Build AI SDK options
    // const jobCtx = getTelemeteredJobContext();

    const streamOptions: Parameters<typeof streamText>[0] = {
      model: this.languageModel,
      messages,
      experimental_telemetry: {
        isEnabled: true,
        functionId: "LLM",
      },
    };

    // Add tools if available
    if (tools && Object.keys(tools).length > 0) {
      streamOptions.tools = tools;
      streamOptions.toolChoice = "auto";
    }

    const transformChunk = (
      chunk: TextStreamPart<ToolSet>,
    ): llm.ChatChunk | undefined => {
      if (chunk.type === "text-delta") {
        return {
          id: chunk.id,
          delta: {
            role: "assistant",
            content: chunk.text,
          },
        };
      } else if (chunk.type === "tool-call") {
        const toolCallId = chunk.toolCallId.replace(/\//g, "-");
        ctx("logger").info("AiSdkLLMStream.transformChunk: tool-call", {
          toolCallId,
          inputToolCall: chunk.toolCallId,
        });
        return {
          id: toolCallId,
          delta: {
            role: "assistant",
            toolCalls: [
              llm.FunctionCall.create({
                callId: toolCallId,
                name: chunk.toolName,
                args: JSON.stringify(chunk.input),
                id: toolCallId,
                createdAt: Date.now(),
              }),
            ],
          },
        };
      }
      // ctx("logger").error("Unknown chunk type:", { chunk });
    };
    // Start streaming
    const result = streamText(streamOptions);

    // Process the full stream which includes text deltas and tool calls
    for await (const chunk of result.fullStream) {
      if (!chunk) {
        this.queue.close();
        return;
      }
      const transformedChunk = transformChunk(chunk);
      if (transformedChunk) this.queue.put(transformedChunk);
    }
  }
}