fix(friendli): thread abortSignal, split params type, add test assertions

- completePrompt: accept CompletePromptOptions, pass abortSignal to SDK
- split FriendliChatCompletionParams into streaming/non-streaming variants
  so completePrompt no longer needs 'as any' on a streaming-required type
- remove unused modelInfo destructuring in completePrompt
- add include_reasoning assertions to none/disable/completePrompt tests

Address @edelauna review on Zoo-Code-Org#886.

Author: Lee-Si-Yoon

src/api/providers/__tests__/friendli.spec.ts

@@ -485,6 +485,7 @@ describe("FriendliHandler — Friendli-specific reasoning params", () => {
 		expect(callArgs.reasoning_effort).toBeUndefined()
 		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: false })
 		expect(callArgs.parse_reasoning).toBeUndefined()
+		expect(callArgs.include_reasoning).toBeUndefined()
 	})
 
 	it("should send enable_thinking: false when reasoningEffort is disable on controllable model", async () => {
@@ -509,6 +510,7 @@ describe("FriendliHandler — Friendli-specific reasoning params", () => {
 		expect(callArgs.reasoning_effort).toBeUndefined()
 		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: false })
 		expect(callArgs.parse_reasoning).toBeUndefined()
+		expect(callArgs.include_reasoning).toBeUndefined()
 	})
 
 	it("should use model default reasoningEffort when no explicit settings are provided", async () => {
@@ -612,5 +614,6 @@ describe("FriendliHandler — Friendli-specific reasoning params", () => {
 		expect(callArgs.reasoning_effort).toBe("medium")
 		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: true })
 		expect(callArgs.parse_reasoning).toBe(true)
+		expect(callArgs.include_reasoning).toBe(true)
 	})
 })

src/api/providers/friendli.ts

@@ -11,7 +11,7 @@ import { getModelParams } from "../transform/model-params"
 
 import { BaseOpenAiCompatibleProvider } from "./base-openai-compatible-provider"
 import { handleOpenAIError } from "./utils/error-handler"
-import type { ApiHandlerCreateMessageMetadata } from "../index"
+import type { ApiHandlerCreateMessageMetadata, CompletePromptOptions } from "../index"
 
 /**
  * Friendli extends the OpenAI Chat Completions API with these non-standard fields:
@@ -20,8 +20,12 @@ import type { ApiHandlerCreateMessageMetadata } from "../index"
  * - parse_reasoning / include_reasoning: when true, Friendli streams reasoning via
  *   delta.reasoning_content (which extractReasoningFromDelta already handles)
  * - reasoning_budget: integer token budget (not currently surfaced in settings UI)
+ *
+ * The reasoning fields are shared across streaming and non-streaming requests; the base
+ * `ChatCompletionCreateParams` (non-streaming) variant is used for `completePrompt` while the
+ * `ChatCompletionCreateParamsStreaming` variant is used for `createStream`.
  */
-type FriendliChatCompletionParams = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming & {
+type FriendliReasoningParams = {
 	chat_template_kwargs?: { enable_thinking: boolean }
 	parse_reasoning?: boolean
 	include_reasoning?: boolean
@@ -33,6 +37,18 @@ type FriendliChatCompletionParams = OpenAI.Chat.Completions.ChatCompletionCreate
 		| "max"
 }
 
+type FriendliChatCompletionParams = Omit<
+	OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming,
+	"reasoning_effort"
+> &
+	FriendliReasoningParams
+
+type FriendliChatCompletionNonStreamingParams = Omit<
+	OpenAI.Chat.Completions.ChatCompletionCreateParams,
+	"reasoning_effort"
+> &
+	FriendliReasoningParams
+
 /**
  * Handler for the Friendli Model APIs (OpenAI-compatible).
  * Routes chat completions to `https://api.friendli.ai/serverless/v1`.
@@ -85,9 +101,9 @@ export class FriendliHandler extends BaseOpenAiCompatibleProvider<FriendliModelI
 	 * - Non-reasoning models (DeepSeek-V3.2, MiniMax-M2.5): no extra params
 	 *   (reasoning_effort silently ignored).
 	 */
-	private buildFriendliReasoningParams(): Partial<FriendliChatCompletionParams> {
+	private buildFriendliReasoningParams(): Partial<FriendliReasoningParams> {
 		const { info: modelInfo, reasoningEffort } = this.getModel()
-		const extra: Partial<FriendliChatCompletionParams> = {}
+		const extra: Partial<FriendliReasoningParams> = {}
 
 		const isControllableReasoning = Array.isArray(modelInfo.supportsReasoningEffort)
 
@@ -114,7 +130,7 @@ export class FriendliHandler extends BaseOpenAiCompatibleProvider<FriendliModelI
 		extra.chat_template_kwargs = { enable_thinking: true }
 
 		if (reasoningEffort) {
-			extra.reasoning_effort = reasoningEffort as FriendliChatCompletionParams["reasoning_effort"]
+			extra.reasoning_effort = reasoningEffort as FriendliReasoningParams["reasoning_effort"]
 		}
 
 		return extra
@@ -169,19 +185,24 @@ export class FriendliHandler extends BaseOpenAiCompatibleProvider<FriendliModelI
 		}
 	}
 
-	override async completePrompt(prompt: string): Promise<string> {
-		const { id: modelId, info: modelInfo } = this.getModel()
+	override async completePrompt(prompt: string, options?: CompletePromptOptions): Promise<string> {
+		const { id: modelId } = this.getModel()
 		const friendliExtra = this.buildFriendliReasoningParams()
 
-		const params: OpenAI.Chat.Completions.ChatCompletionCreateParams & Partial<FriendliChatCompletionParams> = {
+		const params: FriendliChatCompletionNonStreamingParams = {
 			model: modelId,
 			messages: [{ role: "user", content: prompt }],
 			...friendliExtra,
 		}
 
 		try {
-			const response = await this.client.chat.completions.create(params as any)
-
+			const requestOptions: OpenAI.RequestOptions | undefined = options?.abortSignal
+				? { signal: options.abortSignal }
+				: undefined
+			const response = (await this.client.chat.completions.create(
+				params as OpenAI.Chat.Completions.ChatCompletionCreateParams,
+				requestOptions,
+			)) as OpenAI.Chat.Completions.ChatCompletion
 			return response.choices?.[0]?.message.content || ""
 		} catch (error) {
 			throw handleOpenAIError(error, this.providerName)