@acosmi/sdk-ts 2.19.3 → 2.19.5

package/dist/node/adapters/openai.mjs

@@ -12,7 +12,6 @@ var BusinessError = class extends Error {
     this.code = code;
   }
 };
-new OpenAIAdapter();
 
 // src/models/adapters/openai.ts
 var OpenAIAdapter = class {
@@ -180,16 +179,19 @@ function convertOpenAIToChatResponse(oai) {
     role: "assistant",
     content: [],
     stop_reason: "",
+    // [W-SDK-OPENAI-PARITY] 缺 usage 的响应按 0 计数, 而不是让 `oai.usage.prompt_tokens`
+    // 抛 TypeError 把整条响应打死 —— 上游不计量是常见形态, 正文照样是有效的。
+    // 与 Go 侧同名函数逐字同语义 (那里 Usage 是值类型, 缺席即零值)。
     usage: {
-      input_tokens: oai.usage.prompt_tokens,
-      output_tokens: oai.usage.completion_tokens
+      input_tokens: oai.usage?.prompt_tokens ?? 0,
+      output_tokens: oai.usage?.completion_tokens ?? 0
     },
     tokenRemaining: -1,
     callRemaining: -1,
     modelTokenRemaining: -1,
     modelTokenRemainingETU: -1
   };
-  if (oai.choices.length > 0) {
+  if (Array.isArray(oai.choices) && oai.choices.length > 0) {
     const choice = oai.choices[0];
     switch (choice.finish_reason) {
       case "stop":
@@ -263,12 +265,14 @@ function parseOpenAIResponseToAnthropic(raw) {
     content: [],
     model: oaiResp.model,
     stop_reason: "",
+    // [W-SDK-OPENAI-PARITY] 同 convertOpenAIToChatResponse: 缺 usage 按 0 计数, 不抛。
+    // 两处都要改 —— 只改一处等于「非流式路径修好了一半」, 而两条路径是同一族上游响应。
     usage: {
-      input_tokens: oaiResp.usage.prompt_tokens,
-      output_tokens: oaiResp.usage.completion_tokens
+      input_tokens: oaiResp.usage?.prompt_tokens ?? 0,
+      output_tokens: oaiResp.usage?.completion_tokens ?? 0
     }
   };
-  if (oaiResp.choices.length > 0) {
+  if (Array.isArray(oaiResp.choices) && oaiResp.choices.length > 0) {
     const choice = oaiResp.choices[0];
     switch (choice.finish_reason) {
       case "stop":
@@ -306,6 +310,21 @@ function parseOpenAIResponseToAnthropic(raw) {
   }
   return resp;
 }
+function readStreamUsage(chunk) {
+  const raw = chunk.usage;
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const { prompt_tokens: promptTokens, completion_tokens: completionTokens } = raw;
+  const usage = {};
+  if (typeof promptTokens === "number" && Number.isFinite(promptTokens)) {
+    usage.input_tokens = promptTokens;
+  }
+  if (typeof completionTokens === "number" && Number.isFinite(completionTokens)) {
+    usage.output_tokens = completionTokens;
+  }
+  return usage;
+}
 var OpenAIStreamConverter = class {
   messageStarted = false;
   thinkingStarted = false;
@@ -324,8 +343,18 @@ var OpenAIStreamConverter = class {
   toolArgsAccum = /* @__PURE__ */ new Map();
   /** 上一次解析出的 tool 键，供缺 index 且缺 id 的后续增量沿用。 */
   lastToolKey = null;
-  /** 已发出 message_delta/message_stop，避免 finish_reason 与 `[DONE]` 各收一次。 */
+  /** 已发出 message_delta/message_stop，避免 finish_reason、usage 尾帧、`[DONE]` 与
+   *  {@link flush} 重复收口 —— 整条流恰好一个 message_stop。 */
   messageClosed = false;
+  /** 已为仍打开的块发出 content_block_stop。与 {@link messageClosed} 分开记：块在
+   *  finish_reason 帧上就关，message_delta/message_stop 却可能推迟到之后的帧。 */
+  blocksClosed = false;
+  /** [W-QUAD-CHAIN-20260914] finish_reason 已到、但 message_delta/message_stop 因等待
+   *  usage 尾帧而推迟时记下的 stop_reason；没有推迟中的收尾时为 null。 */
+  pendingStopReason = null;
+  /** [W-QUAD-CHAIN-20260914] 最近一次带 usage 对象的帧搬出的 usage（后到覆盖先到）；
+   *  整条流从未出现 usage 对象时为 null，收尾 message_delta 据此不写 usage 键。 */
+  usage = null;
   /**
    * 解析一条 tool_call delta 归属的块键。
    *
@@ -350,15 +379,18 @@ var OpenAIStreamConverter = class {
     return 0;
   }
   /**
-   * 关闭仍打开的 text / thinking / tool 块，并收口 message。
+   * 关闭仍打开的 text / thinking / tool 块（整条流只关一次）。
    *
    * 由 `finish_reason` 分支与 `[DONE]` 分支共用：上游断流或只发 `[DONE]` 而不发
    * `finish_reason` 时，此前一个 `content_block_stop` 都不会发，下游拿到的是一个
    * 永不闭合的 tool_use 块。
+   *
+   * [W-QUAD-CHAIN-20260914] 此前关块与 message_delta/message_stop 是同一个方法里同一时刻
+   * 的事；usage 尾帧要求收尾推迟，于是拆成本方法与 {@link emitMessageEnd} 两段，各自防重。
    */
-  closeOpenBlocks(events, stopReason) {
-    if (this.messageClosed) return;
-    this.messageClosed = true;
+  closeContentBlocks(events) {
+    if (this.blocksClosed) return;
+    this.blocksClosed = true;
     if (this.textStarted) {
       events.push({
         event: "content_block_stop",
@@ -378,10 +410,23 @@ var OpenAIStreamConverter = class {
         data: JSON.stringify({ type: "content_block_stop", index: idx })
       });
     }
-    events.push({
-      event: "message_delta",
-      data: JSON.stringify({ type: "message_delta", delta: { stop_reason: stopReason } })
-    });
+  }
+  /**
+   * 发出 message_delta + message_stop，整条流只发一次；同时清掉推迟中的收尾。
+   *
+   * 见过 usage 对象就把它放进 message_delta：usage 必须出现在唯一的 message_stop 之前，
+   * message_stop 之后下游已无处安放用量。整条流从未出现 usage 对象时不写 usage 键 ——
+   * 缺席表示「上游没给」，不是 0。
+   */
+  emitMessageEnd(events, stopReason) {
+    if (this.messageClosed) return;
+    this.messageClosed = true;
+    this.pendingStopReason = null;
+    const messageDelta = { type: "message_delta", delta: { stop_reason: stopReason } };
+    if (this.usage !== null) {
+      messageDelta.usage = this.usage;
+    }
+    events.push({ event: "message_delta", data: JSON.stringify(messageDelta) });
     events.push({
       event: "message_stop",
       data: JSON.stringify({ type: "message_stop" })
@@ -394,8 +439,11 @@ var OpenAIStreamConverter = class {
   convert(data) {
     if (data === "[DONE]") {
       const events2 = [];
-      if (this.messageStarted) {
-        this.closeOpenBlocks(events2, "end_turn");
+      if (this.pendingStopReason !== null) {
+        this.emitMessageEnd(events2, this.pendingStopReason);
+      } else if (this.messageStarted) {
+        this.closeContentBlocks(events2);
+        this.emitMessageEnd(events2, "end_turn");
       }
       return { events: events2, done: true };
     }
@@ -406,10 +454,18 @@ var OpenAIStreamConverter = class {
       throw new Error(`parse openai stream chunk: ${e instanceof Error ? e.message : String(e)}`);
     }
     const events = [];
+    const frameUsage = readStreamUsage(chunk);
+    if (frameUsage !== null) {
+      this.usage = frameUsage;
+    }
     if (!Array.isArray(chunk.choices) || chunk.choices.length === 0) {
+      if (frameUsage !== null && this.pendingStopReason !== null) {
+        this.emitMessageEnd(events, this.pendingStopReason);
+      }
       return { events, done: false };
     }
     const choice = chunk.choices[0];
+    const delta = choice.delta ?? {};
     if (!this.messageStarted) {
       this.messageStarted = true;
       const msgJSON = JSON.stringify({
@@ -424,8 +480,17 @@ var OpenAIStreamConverter = class {
       });
       events.push({ event: "message_start", data: msgJSON });
     }
-    if (choice.delta.reasoning_content && choice.delta.reasoning_content !== "") {
+    if (delta.reasoning_content && delta.reasoning_content !== "") {
       if (!this.thinkingStarted) {
+        if (this.textStarted) {
+          const stopJSON = JSON.stringify({
+            type: "content_block_stop",
+            index: this.blockIndex
+          });
+          events.push({ event: "content_block_stop", data: stopJSON });
+          this.blockIndex++;
+          this.textStarted = false;
+        }
         this.thinkingStarted = true;
         this.thinkingBlockIndex = this.blockIndex;
         const blockJSON = JSON.stringify({
@@ -438,11 +503,11 @@ var OpenAIStreamConverter = class {
       const deltaJSON = JSON.stringify({
         type: "content_block_delta",
         index: this.thinkingBlockIndex,
-        delta: { type: "thinking_delta", thinking: choice.delta.reasoning_content }
+        delta: { type: "thinking_delta", thinking: delta.reasoning_content }
       });
       events.push({ event: "content_block_delta", data: deltaJSON });
     }
-    if (choice.delta.content && choice.delta.content !== "") {
+    if (delta.content && delta.content !== "") {
       if (this.thinkingStarted && !this.thinkingStopped) {
         this.thinkingStopped = true;
         const stopJSON = JSON.stringify({
@@ -464,11 +529,11 @@ var OpenAIStreamConverter = class {
       const deltaJSON = JSON.stringify({
         type: "content_block_delta",
         index: this.blockIndex,
-        delta: { type: "text_delta", text: choice.delta.content }
+        delta: { type: "text_delta", text: delta.content }
       });
       events.push({ event: "content_block_delta", data: deltaJSON });
     }
-    for (const tc of choice.delta.tool_calls ?? []) {
+    for (const tc of delta.tool_calls ?? []) {
       const fn = tc.function;
       const toolKey = this.resolveToolKey(tc);
       if (!this.toolBlockIndex.has(toolKey)) {
@@ -543,10 +608,35 @@ var OpenAIStreamConverter = class {
         default:
           stopReason = choice.finish_reason;
       }
-      this.closeOpenBlocks(events, stopReason);
+      if (!this.messageClosed && this.pendingStopReason === null) {
+        this.closeContentBlocks(events);
+        if (this.usage !== null) {
+          this.emitMessageEnd(events, stopReason);
+        } else {
+          this.pendingStopReason = stopReason;
+        }
+      }
+    }
+    if (frameUsage !== null && this.pendingStopReason !== null) {
+      this.emitMessageEnd(events, this.pendingStopReason);
     }
     return { events, done: false };
   }
+  /**
+   * 流在**没有** `[DONE]` 的情况下结束 (EOF) 时, 由驱动方在读循环结束后调用一次。
+   *
+   * 只补发「finish_reason 已到、仅因等待 usage 尾帧而推迟」的 message_delta + message_stop。
+   * 从未收到 finish_reason 的流是被截断的流, 这里刻意**不**替它伪造正常结束 —— 一个
+   * `end_turn` 的 message_stop 会把被截断的回答当成完整回答交给下游。
+   * 已经收口 (usage 帧 / `[DONE]` / 上一次 flush) 后再调用返回空数组, 不会发出第二个 message_stop。
+   */
+  flush() {
+    const events = [];
+    if (this.pendingStopReason !== null) {
+      this.emitMessageEnd(events, this.pendingStopReason);
+    }
+    return events;
+  }
 };
 function newOpenAIStreamConverter() {
   return new OpenAIStreamConverter();