@tyvm/knowhow 0.0.144 → 0.0.145

package/src/clients/http.ts

@@ -92,6 +92,33 @@ export class HttpClient implements GenericClient {
     this.pricingMap = pricingMap;
   }
 
+  /**
+   * A stable provider id used to tag/read the provider-agnostic
+   * `_reasoning_details` slot. Reasoning items are opaque and only meaningful
+   * to the provider that produced them, so we key on the client's baseUrl.
+   */
+  protected reasoningProviderId(): string {
+    return `http:${this.baseUrl}`;
+  }
+
+  /**
+   * Resolve the provider-native reasoning items (Responses API `reasoning`
+   * items with encrypted_content) to re-inject for an assistant message,
+   * reading the provider-agnostic `_reasoning_details` slot only when it was
+   * produced by this same client.
+   */
+  protected getReasoningItems(msg: any): any[] {
+    const details = msg?._reasoning_details;
+    if (
+      details &&
+      details.provider === this.reasoningProviderId() &&
+      Array.isArray(details.items)
+    ) {
+      return details.items;
+    }
+    return [];
+  }
+
   /**
    * Returns the pricing entry for a specific model, or all pricing entries if no model is given.
    * Returns undefined for a specific model if no pricing is known.
@@ -299,22 +326,44 @@ export class HttpClient implements GenericClient {
         .trim() || undefined;
 
       // Convert messages to Responses API input format
+      // Responses API hard limit: 10,485,760 chars per function_call_output.output
+      const MAX_TOOL_OUTPUT = 10_485_000;
+      const truncateToolOutput = (s: string) =>
+        s.length > MAX_TOOL_OUTPUT
+          ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+          : s;
       const input: any[] = nonSystemMessages.map((msg) => {
         if (msg.role === "tool") {
           return {
             type: "function_call_output",
             call_id: msg.tool_call_id,
-            output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            output: truncateToolOutput(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)),
           };
         }
         if (msg.role === "assistant" && msg.tool_calls?.length) {
-          return (msg.tool_calls as any[]).map((tc: any) => ({
+          // Re-inject any captured reasoning items (encrypted_content) BEFORE
+          // the function_call items so the model preserves its chain-of-thought
+          // across tool-use turns instead of re-deriving it each turn.
+          const reasoningItems = this.getReasoningItems(msg);
+          return [
+            ...reasoningItems,
+            ...(msg.tool_calls as any[]).map((tc: any) => ({
             type: "function_call",
             id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
             call_id: tc.id,
             name: tc.function.name,
             arguments: tc.function.arguments,
-          }));
+            })),
+          ];
+        }
+        if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+          return [
+            ...this.getReasoningItems(msg),
+            {
+              role: msg.role,
+              content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            },
+          ];
         }
         return {
           role: msg.role,
@@ -336,7 +385,18 @@ export class HttpClient implements GenericClient {
         ...(instructions && { instructions }),
         ...(options.max_tokens && { max_output_tokens: options.max_tokens }),
         ...(tools?.length && { tools, tool_choice: "auto" }),
-        store,
+        // Reasoning persistence: store server-side when requested, otherwise
+        // ask the provider to return encrypted reasoning content so we can
+        // thread the reasoning items back into the next request ourselves.
+        store: options.store === true ? true : store,
+        ...(options.previous_response_id && {
+          previous_response_id: options.previous_response_id,
+        }),
+        ...(options.store !== true &&
+          options.reasoning_effort &&
+          options.reasoning_effort !== "none" && {
+            include: ["reasoning.encrypted_content"],
+          }),
         ...this.extra_body,
       };
 
@@ -368,6 +428,10 @@ export class HttpClient implements GenericClient {
       // Collect text content and tool calls from output items
       let textContent: string | null = null;
       const toolCalls: any[] = [];
+      // Reasoning items (encrypted_content) to thread back into the next turn,
+      // plus a human-readable summary of the model's thinking (if present).
+      const reasoningItems: any[] = [];
+      let reasoningSummary: string | null = null;
 
       for (const item of data.output ?? []) {
         if (item.type === "message") {
@@ -376,6 +440,15 @@ export class HttpClient implements GenericClient {
               textContent = (textContent ?? "") + part.text;
             }
           }
+        } else if (item.type === "reasoning") {
+          reasoningItems.push(item);
+          const summaryParts = item.summary ?? [];
+          for (const part of summaryParts) {
+            const text = typeof part === "string" ? part : part?.text;
+            if (text) {
+              reasoningSummary = (reasoningSummary ?? "") + text;
+            }
+          }
         } else if (item.type === "function_call") {
           toolCalls.push({
             id: item.call_id,
@@ -392,12 +465,20 @@ export class HttpClient implements GenericClient {
               role: "assistant",
               content: textContent,
               ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+              ...(reasoningSummary && { reasoning_summary: reasoningSummary }),
+              ...(reasoningItems.length > 0 && {
+                _reasoning_details: {
+                  provider: this.reasoningProviderId(),
+                  items: reasoningItems,
+                },
+              }),
             },
           },
         ],
         model: data.model ?? options.model,
         usage,
         usd_cost: data.usd_cost ?? this.calculateCost(options.model, usage),
+        response_id: data.id,
       };
     });
   }

package/src/clients/index.ts

@@ -58,6 +58,7 @@ import { GitHubCopilotClient } from "./copilot";
 import { GenericLlamaClient } from "./llama";
 import { GenericFireworksClient } from "./fireworks";
 import { GenericMetaClient } from "./meta";
+import { GenericQwenClient } from "./qwen";
 export {
   OpenAiTextPricing,
   AnthropicTextPricing,
@@ -103,6 +104,7 @@ const BUILT_IN_PROVIDER_REGISTRY: Record<string, ProviderRegistryEntry> = {
   llama: { clientClass: GenericLlamaClient },
   fireworks: { clientClass: GenericFireworksClient },
   meta: { clientClass: GenericMetaClient },
+  qwen: { clientClass: GenericQwenClient },
   knowhow: {
     createClient: (entry: ModelProvider) => {
       const jwt = loadKnowhowJwt();
@@ -134,6 +136,7 @@ const DEFAULT_PROVIDERS: ModelProvider[] = [
   { provider: "llama", envKey: "LLAMA_API_KEY" },
   { provider: "fireworks", envKey: "FIREWORKS_API_KEY" },
   { provider: "meta", envKey: "META_API_KEY" },
+  { provider: "qwen", envKey: "QWEN_CLOUD_API_KEY" },
 ];
 
 export class AIClient {
@@ -1075,3 +1078,4 @@ export * from "./llama";
 export * from "./copilot";
 export * from "./fireworks";
 export * from "./meta";
+export * from "./qwen";

package/src/clients/openai.ts

@@ -22,13 +22,17 @@ import {
   FileUploadResponse,
   FileDownloadOptions,
   FileDownloadResponse,
+  Message,
 } from "./types";
 import {
   ChatCompletionMessageParam,
   ChatCompletionToolMessageParam,
   ChatCompletionMessageToolCall,
 } from "openai/resources/chat";
-import { ResponseFunctionToolCall } from "openai/resources/responses/responses";
+import {
+  ResponseFunctionToolCall,
+  ResponseInputMessageContentList,
+} from "openai/resources/responses/responses";
 
 import {
   EmbeddingModels,
@@ -140,6 +144,75 @@ export class GenericOpenAiClient implements GenericClient {
     return options.reasoning_effort === "none";
   }
 
+  /**
+   * OpenAI only permits image parts on user messages. A Chat Completions
+   * `tool` message may contain text parts, but not `image_url` parts. Keep the
+   * required tool result and attach images in a following user message.
+   */
+  toChatCompletionMessages(
+    messages: CompletionOptions["messages"]
+  ): ChatCompletionMessageParam[] {
+    return messages.flatMap((msg): ChatCompletionMessageParam[] => {
+      if (msg.role !== "tool") return [msg as ChatCompletionMessageParam];
+
+      const parts = Array.isArray(msg.content) ? msg.content : [];
+      const unsupportedPart = parts.find(
+        (part) => part.type !== "text" && part.type !== "image_url"
+      );
+      if (unsupportedPart) {
+        throw new Error(
+          `OpenAI Chat Completions cannot attach ${unsupportedPart.type} content to a tool result.`
+        );
+      }
+      const imageParts = parts.filter((part) => part.type === "image_url");
+      const textParts = parts.filter((part) => part.type === "text");
+      const toolMessage: ChatCompletionToolMessageParam = {
+        role: "tool",
+        tool_call_id: msg.tool_call_id!,
+        content: Array.isArray(msg.content)
+          ? textParts.length
+            ? textParts
+            : [{
+                type: "text",
+                text: "Image output attached in the following user message.",
+              }]
+          : msg.content || "",
+      };
+
+      if (!imageParts.length) return [toolMessage];
+      return [
+        toolMessage,
+        { role: "user", content: imageParts } as ChatCompletionMessageParam,
+      ];
+    });
+  }
+
+  /** Convert the CLI's Chat Completions-style parts to Responses API parts. */
+  toResponseContent(
+    content: Message["content"]
+  ): string | ResponseInputMessageContentList {
+    if (!Array.isArray(content)) return content || "";
+    const result: ResponseInputMessageContentList = [];
+    for (const part of content) {
+      if (part.type === "text") {
+        result.push({ type: "input_text", text: part.text });
+      }
+      else if (part.type === "image_url") {
+        result.push({
+          type: "input_image",
+          image_url: part.image_url.url,
+          detail: part.image_url.detail || "auto",
+        });
+      }
+      else {
+        throw new Error(
+          `OpenAI Responses API conversion does not support ${part.type} content.`
+        );
+      }
+    }
+    return result;
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -148,17 +221,7 @@ export class GenericOpenAiClient implements GenericClient {
       return this.createChatResponse(options);
     }
 
-    const openaiMessages = options.messages.map((msg) => {
-      if (msg.role === "tool") {
-        return {
-          ...msg,
-          content: msg.content || "",
-          role: "tool",
-          tool_call_id: msg.tool_call_id,
-        } as ChatCompletionToolMessageParam;
-      }
-      return msg as ChatCompletionMessageParam;
-    });
+    const openaiMessages = this.toChatCompletionMessages(options.messages);
 
     const response = await this.client.chat.completions.create({
       model: options.model,
@@ -222,17 +285,7 @@ export class GenericOpenAiClient implements GenericClient {
       return;
     }
 
-    const openaiMessages = options.messages.map((msg) => {
-      if (msg.role === "tool") {
-        return {
-          ...msg,
-          content: msg.content || "",
-          role: "tool",
-          tool_call_id: msg.tool_call_id,
-        } as ChatCompletionToolMessageParam;
-      }
-      return msg as ChatCompletionMessageParam;
-    });
+    const openaiMessages = this.toChatCompletionMessages(options.messages);
 
     const stream = await this.client.chat.completions.create({
       model: options.model,
@@ -307,6 +360,20 @@ export class GenericOpenAiClient implements GenericClient {
     }
   }
 
+  /**
+   * Resolve the OpenAI-native reasoning items to re-inject for an assistant
+   * message. Reads the provider-agnostic `_reasoning_details` slot (only when
+   * it was produced by this provider) and falls back to the deprecated
+   * `_reasoning_items` for backward compatibility.
+   */
+  private getReasoningItems(msg: any): any[] {
+    const details = (msg as any)._reasoning_details;
+    if (details && details.provider === "openai" && Array.isArray(details.items)) {
+      return details.items;
+    }
+    return (msg as any)._reasoning_items ?? [];
+  }
+
   async createChatResponse(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -324,30 +391,68 @@ export class GenericOpenAiClient implements GenericClient {
 
     // Convert chat messages to Responses API input items
     // The Responses API accepts: user/assistant/system messages and function_call_output items
+    // OpenAI Responses API hard limit: 10,485,760 chars per function_call_output.output
+    const MAX_TOOL_OUTPUT = 10_485_000;
+    const truncateToolOutput = (s: string) =>
+      s.length > MAX_TOOL_OUTPUT
+        ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+        : s;
     const input: any[] = nonSystemMessages.map((msg) => {
       if (msg.role === "tool") {
-        // tool result → function_call_output
-        return {
+        // OpenAI function outputs cannot directly contain image content. Send
+        // the required function output, then attach images as a user message.
+        const parts = Array.isArray(msg.content) ? msg.content : [];
+        const imageParts = parts.filter((part) => part.type === "image_url");
+        const text = parts
+          .filter((part) => part.type === "text")
+          .map((part: any) => part.text)
+          .join("\n");
+        const toolOutput = {
           type: "function_call_output",
           call_id: msg.tool_call_id,
-          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          output: truncateToolOutput(typeof msg.content === "string"
+            ? msg.content
+            : text || "Image output attached in the following user message."),
         };
+        if (!imageParts.length) return toolOutput;
+        return [
+          toolOutput,
+          { role: "user", content: this.toResponseContent(imageParts) },
+        ];
       }
       if (msg.role === "assistant" && msg.tool_calls?.length) {
-        // assistant message with tool calls → function_call items
-        return msg.tool_calls.map((tc) => ({
+        // assistant message with tool calls → function_call items.
+        // If the prior turn captured reasoning items (encrypted_content path),
+        // re-inject them *before* the function_call items so the model keeps its
+        // chain-of-thought instead of re-deriving it from scratch.
+        const reasoningItems = this.getReasoningItems(msg);
+        return [
+          ...reasoningItems,
+          ...msg.tool_calls.map((tc) => ({
           type: "function_call",
           // id must start with 'fc_'; call_id is the original call_ ID used for function_call_output matching
           id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
           call_id: tc.id,
           name: tc.function.name,
           arguments: tc.function.arguments,
-        }));
+          })),
+        ];
+      }
+      if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+        // assistant message (no tool calls) that carried reasoning items →
+        // re-inject reasoning items, then the visible message content.
+        return [
+          ...this.getReasoningItems(msg),
+          {
+            role: msg.role,
+            content: this.toResponseContent(msg.content),
+          },
+        ];
       }
       // Regular user/assistant message
       return {
         role: msg.role,
-        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        content: this.toResponseContent(msg.content),
       };
     }).flat();
 
@@ -360,10 +465,29 @@ export class GenericOpenAiClient implements GenericClient {
       strict: false,
     }));
 
+    // Reasoning persistence:
+    //  - store === true  → OpenAI persists the response server-side; the next
+    //    turn passes previous_response_id to continue the reasoning chain.
+    //  - store !== true  → stateless; ask OpenAI to return encrypted reasoning
+    //    content so we can thread it back into the next request's input ourselves.
+    const store = options.store === true;
+    const wantsReasoning =
+      OpenAiReasoningModels.includes(options.model) &&
+      !this.isReasoningDisabled(options);
+
     const response = await this.client.responses.create({
       model: options.model as any,
       input,
       ...(instructions && { instructions }),
+      ...(store && { store: true }),
+      ...(!store && { store: false }),
+      ...(options.previous_response_id && {
+        previous_response_id: options.previous_response_id,
+      }),
+      // When stateless, request encrypted reasoning so we can re-inject it next turn.
+      ...(!store && wantsReasoning && {
+        include: ["reasoning.encrypted_content"],
+      }),
       // Don't limit max_output_tokens for Responses API - codex truncates tool call arguments when limited
       ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
         max_output_tokens: Math.max(options.max_tokens || 0, 16000),
@@ -376,7 +500,6 @@ export class GenericOpenAiClient implements GenericClient {
         tools,
         tool_choice: "auto",
       }),
-      store: false,
     } as any);
 
     // Map Responses API usage to Chat Completions usage format
@@ -405,6 +528,10 @@ export class GenericOpenAiClient implements GenericClient {
     // Collect text content and tool calls from the output items
     let textContent: string | null = null;
     const toolCalls: ChatCompletionMessageToolCall[] = [];
+    // Reasoning items (with encrypted_content) to thread back into the next turn,
+    // and a human-readable summary of the model's thinking (when requested).
+    const reasoningItems: any[] = [];
+    let reasoningSummary: string | null = null;
 
     for (const item of response.output) {
       if (item.type === "message") {
@@ -415,6 +542,18 @@ export class GenericOpenAiClient implements GenericClient {
             textContent = (textContent ?? "") + part.text;
           }
         }
+      } else if (item.type === "reasoning") {
+        // ResponseReasoningItem — keep the raw item so we can re-inject it
+        // (it carries encrypted_content when include was requested), and pull
+        // out any human-readable summary text.
+        reasoningItems.push(item);
+        const summaryParts = (item as any).summary ?? [];
+        for (const part of summaryParts) {
+          const text = typeof part === "string" ? part : part?.text;
+          if (text) {
+            reasoningSummary = (reasoningSummary ?? "") + text;
+          }
+        }
       } else if (item.type === "function_call") {
         // ResponseFunctionToolCall
         const fc = item as ResponseFunctionToolCall;
@@ -444,12 +583,21 @@ export class GenericOpenAiClient implements GenericClient {
             role: "assistant",
             content: textContent,
             ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+            ...(reasoningSummary && { reasoning_summary: reasoningSummary }),
+            // Stash the raw reasoning items (encrypted_content) so the next call
+            // to createChatResponse can re-inject them into the input. We populate
+            // both the provider-agnostic slot and the deprecated legacy field.
+            ...(reasoningItems.length > 0 && {
+              _reasoning_items: reasoningItems,
+              _reasoning_details: { provider: "openai", items: reasoningItems },
+            }),
           },
         },
       ],
       model: options.model,
       usage,
       usd_cost: usdCost,
+      response_id: (response as any).id,
     };
   }
 

package/src/clients/pricing/fireworks.ts

@@ -1,4 +1,4 @@
-import { ModelPricing } from "./types";
+import { ModelPricing, ModelCatalogEntry, completions, embeddings } from "./types";
 
 /**
  * Fireworks AI model IDs, pricing, and catalog.
@@ -101,3 +101,52 @@ export const FireworksEmbeddingPricing: Record<string, ModelPricing> = {
   // Qwen3 Reranker 8B — $0.20/M tokens, context 40k
   [FireworksModels.Qwen3Reranker8b]: { input: 0.20, output: 0.20 },
 };
+
+
+// ─── Active text models (non-deprecated) ─────────────────────────────────────
+
+export const FireworksActiveTextModels: string[] = [
+  // Moonshot AI
+  FireworksModels.KimiK3,
+  FireworksModels.KimiK2p7Code,
+  FireworksModels.KimiK2_6,
+  FireworksModels.KimiK2_5,
+  // MiniMax
+  FireworksModels.MinimaxM3,
+  FireworksModels.MinimaxM2_7,
+  FireworksModels.MinimaxM2_5,
+  // Qwen
+  FireworksModels.Qwen3p7Plus,
+  // Z.ai
+  FireworksModels.Glm5p2,
+  FireworksModels.Glm5p1,
+  // DeepSeek AI
+  FireworksModels.DeepseekV4Pro,
+  FireworksModels.DeepseekV4Flash,
+  // OpenAI OSS
+  FireworksModels.GptOss120b,
+];
+
+export const FireworksDeprecatedTextModels: string[] = [
+  FireworksModels.Qwen3_6Plus,
+  FireworksModels.Qwen3p6Plus,
+  FireworksModels.Qwen3Vl30bA3bThinking,
+  FireworksModels.Qwen3Vl30bA3bInstruct,
+  FireworksModels.Qwen3_8b,
+  FireworksModels.Glm5,
+  FireworksModels.Glm4_7,
+  FireworksModels.DeepseekV3_2,
+  FireworksModels.DeepseekV3_1,
+];
+
+// ─── Catalog ──────────────────────────────────────────────────────────────────
+
+export const FIREWORKS_MODEL_CATALOG: ModelCatalogEntry[] = [
+  ...completions(FireworksActiveTextModels, "fireworks", FireworksTextPricing),
+  ...completions(FireworksDeprecatedTextModels, "fireworks", FireworksTextPricing),
+  ...embeddings(
+    [FireworksModels.Qwen3Embedding8b, FireworksModels.Qwen3Reranker8b],
+    "fireworks",
+    FireworksEmbeddingPricing,
+  ),
+];

package/src/clients/pricing/index.ts

@@ -35,7 +35,7 @@ export { GitHubModelsTextPricing } from "./github";
 export { OpenRouterTextPricing } from "./openrouter";
 export { LlamaTextPricing } from "./llama";
 export { CopilotTextPricing, CopilotModelMultipliers } from "./copilot";
-export { FireworksTextPricing } from "./fireworks";
+export { FireworksTextPricing, FireworksEmbeddingPricing, FIREWORKS_MODEL_CATALOG, FireworksActiveTextModels, FireworksDeprecatedTextModels } from "./fireworks";
 export { MetaTextPricing, MetaWebSearchPricingPer1000Queries } from "./meta";
 
 // ─── Combined catalog ─────────────────────────────────────────────────────────

package/src/clients/pricing/models.ts

@@ -7,17 +7,19 @@ import { OPENAI_MODEL_CATALOG } from "./openai";
 import { ANTHROPIC_MODEL_CATALOG } from "./anthropic";
 import { GOOGLE_MODEL_CATALOG } from "./google";
 import { XAI_MODEL_CATALOG } from "./xai";
+import { FIREWORKS_MODEL_CATALOG } from "./fireworks";
 
 export { ModelPricing, ModelType, ModelCatalogEntry };
 
 /** 2.5% platform markup applied on top of all provider base rates */
 export const USAGE_MARKUP_PERCENT = 2.5 / 100;
 
-export { OPENAI_MODEL_CATALOG, ANTHROPIC_MODEL_CATALOG, GOOGLE_MODEL_CATALOG, XAI_MODEL_CATALOG };
+export { OPENAI_MODEL_CATALOG, ANTHROPIC_MODEL_CATALOG, GOOGLE_MODEL_CATALOG, XAI_MODEL_CATALOG, FIREWORKS_MODEL_CATALOG };
 
 export const ALL_MODEL_CATALOG: ModelCatalogEntry[] = [
   ...OPENAI_MODEL_CATALOG,
   ...ANTHROPIC_MODEL_CATALOG,
   ...GOOGLE_MODEL_CATALOG,
   ...XAI_MODEL_CATALOG,
+  ...FIREWORKS_MODEL_CATALOG,
 ];

package/src/clients/pricing/openai.ts

@@ -232,8 +232,8 @@ export const OpenAiSearchModels: string[] = [
 export const OpenAiTextPricing: Record<string, ModelPricing> = {
   // gpt-5.6 series — short context / long context pricing
   [OpenAiModels.GPT_56_Sol]:   { input: 5.0, cached_input: 0.5,  cache_write: 6.25,  output: 30.0, input_gt_200k: 10.0, output_gt_200k: 45.0 },
-  [OpenAiModels.GPT_56_Terra]: { input: 2.5, cached_input: 0.25, cache_write: 3.125, output: 15.0, input_gt_200k: 5.0,  output_gt_200k: 22.5 },
-  [OpenAiModels.GPT_56_Luna]:  { input: 1.0, cached_input: 0.10, cache_write: 1.25,  output: 6.0,  input_gt_200k: 2.0,  output_gt_200k: 9.0  },
+  [OpenAiModels.GPT_56_Terra]: { input: 2.0, cached_input: 0.20, cache_write: 2.5,   output: 12.0, input_gt_200k: 4.0,  output_gt_200k: 18.0 },
+  [OpenAiModels.GPT_56_Luna]:  { input: 0.2, cached_input: 0.02, cache_write: 0.25,  output: 1.2,  input_gt_200k: 0.4,  output_gt_200k: 1.8  },
   [OpenAiModels.GPT_55]: { input: 5.0, cached_input: 0.5, output: 30.0 },
   [OpenAiModels.GPT_55_Pro]: { input: 30.0, cached_input: 0, output: 180.0, reasoningLevels: ["medium", "high", "xhigh"] },
   [OpenAiModels.GPT_54]: { input: 2.5, cached_input: 0.25, output: 15.0 },

package/src/clients/pricing/qwen.ts

@@ -0,0 +1,80 @@
+/**
+ * QWEN Cloud pricing (USD per 1M tokens)
+ * Source: https://home.qwencloud.com/data/api.json?product=AliyunDeliveryService&action=ListModelSeries
+ * International DashScope endpoint: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
+ * Last updated: 2026-08-03
+ *
+ * Notes:
+ * - Several Qwen models use tiered pricing based on input context length.
+ *   We use the standard tier (≤256k) as the base price here.
+ * - DeepSeek and GLM models are also available via QwenCloud's DashScope endpoint.
+ * - Video/image/audio generation models have per-second/per-image pricing (not per-token)
+ *   and are NOT included in QwenTextPricing.
+ */
+
+export const QwenTextPricing: Record<string, { input: number; output: number; cached_input?: number }> = {
+
+  // ---------------------------------------------------------------------------
+  // Qwen3.8 series (newest flagship, released 2026-08)
+  // ---------------------------------------------------------------------------
+  // qwen3.8-max: $2/$6, implicit cache: $0.25, explicit cache creation: $2.5, explicit cache read: $0.17
+  "qwen3.8-max": { input: 2.00, output: 6.00, cached_input: 0.25 },
+
+  // ---------------------------------------------------------------------------
+  // Qwen3.7 series
+  // ---------------------------------------------------------------------------
+  // qwen3.7-plus: tiered — ≤256k: $0.4/$1.6, 256k-1M: $1.2/$4.8
+  // implicit cache: $0.08 (≤256k), explicit cache creation: $0.5, explicit cache read: $0.04
+  "qwen3.7-plus": { input: 0.40, output: 1.60, cached_input: 0.08 },
+  "qwen3.7-plus-2026-05-26": { input: 0.40, output: 1.60, cached_input: 0.08 },
+
+  // qwen3.7-flash: tiered — ≤32k: $0.03/$0.13, 32k-256k: $0.10/$0.40, 256k-1M: $0.20/$0.80
+  "qwen3.7-flash": { input: 0.03, output: 0.13, cached_input: 0.006 },
+  "qwen3.7-flash-2026-07-15": { input: 0.03, output: 0.13, cached_input: 0.006 },
+
+  // qwen3.7-max: $2.50/$7.50, cache: $0.50
+  "qwen3.7-max": { input: 2.50, output: 7.50, cached_input: 0.50 },
+  "qwen3.7-max-2026-06-08": { input: 2.50, output: 7.50, cached_input: 0.50 },
+  "qwen3.7-max-2026-05-20": { input: 2.50, output: 7.50 },
+
+  // ---------------------------------------------------------------------------
+  // Qwen3.6 series
+  // ---------------------------------------------------------------------------
+  // qwen3.6-flash: tiered — ≤256k: $0.25/$1.50, 256k-1M: $1.00/$4.00
+  "qwen3.6-flash": { input: 0.25, output: 1.50, cached_input: 0.025 },
+  "qwen3.6-flash-2026-04-16": { input: 0.25, output: 1.50 },
+  // qwen3.6-plus: tiered — ≤256k: $0.50/$3.00, 256k-1M: $2.00/$6.00
+  "qwen3.6-plus": { input: 0.50, output: 3.00, cached_input: 0.05 },
+  "qwen3.6-plus-2026-04-02": { input: 0.50, output: 3.00 },
+
+  // ---------------------------------------------------------------------------
+  // Legacy alias models (qwen-turbo, qwen-plus, qwen-max, qwen-long)
+  // These are rolling aliases that point to the latest generation.
+  // ---------------------------------------------------------------------------
+  "qwen-turbo": { input: 0.05, output: 0.20, cached_input: 0.005 },
+  "qwen-turbo-latest": { input: 0.05, output: 0.20, cached_input: 0.005 },
+  "qwen-plus": { input: 0.40, output: 1.20, cached_input: 0.04 },
+  "qwen-plus-latest": { input: 0.40, output: 1.20, cached_input: 0.04 },
+  "qwen-max": { input: 0.861, output: 3.44, cached_input: 0.086 },
+  "qwen-max-latest": { input: 0.861, output: 3.44, cached_input: 0.086 },
+  // qwen-long: extended context up to 10M tokens
+  "qwen-long": { input: 0.05, output: 0.20, cached_input: 0.005 },
+
+  // ---------------------------------------------------------------------------
+  // DeepSeek models (available via QwenCloud/DashScope endpoint)
+  // ---------------------------------------------------------------------------
+  // DeepSeek-V4-Flash: lightweight MoE, 284B params, 13B activated, 1M context
+  "deepseek-v4-flash": { input: 0.20, output: 0.40, cached_input: 0.04 },
+  "deepseek-v4-flash-0731": { input: 0.20, output: 0.40, cached_input: 0.04 },
+  // DeepSeek-V4-Pro: flagship MoE, 1.6T params, 49B activated, 1M context
+  "deepseek-v4-pro": { input: 2.40, output: 4.80, cached_input: 0.20 },
+  // DeepSeek-V3.2: sparse attention, 128k context
+  // explicit cache creation: $0.713, explicit cache read: $0.057
+  "deepseek-v3.2": { input: 0.57, output: 1.71, cached_input: 0.114 },
+
+  // ---------------------------------------------------------------------------
+  // GLM models (Zhipu AI, available via QwenCloud/DashScope endpoint)
+  // ---------------------------------------------------------------------------
+  // GLM-5.2-Fast-Preview: 1M context, high-speed inference
+  "glm-5.2-fast-preview": { input: 2.80, output: 8.80, cached_input: 0.56 },
+};