dsh-cline-pass 0.2.4 → 0.2.5

package/lib/adapter.js

@@ -249,31 +249,88 @@ function collectImageParts(blocks, images, target = []) {
 /**
  * Convert the harness conversation to wire messages.
  *
- * Tool results become standalone `{ role: 'tool' }` messages. A user message
- * carrying an image switches to the OpenAI content-part array; a text-only one
- * keeps the plain-string form.
+ * Tool results become standalone `{ role: 'tool' }` messages, in both harness
+ * shapes: the current one, where the result IS a `tool`-role message carrying
+ * `toolCallId`, and the one dsh < 0.2.0 produced, a user message wrapping a
+ * `tool-result` block. A user message carrying an image switches to the OpenAI
+ * content-part array; a text-only one keeps the plain-string form.
  *
  * An image nested in a tool result (read_image, a screenshot tool) has no
  * OpenAI `tool` wire spelling, so it rides a following user message instead —
- * the same shape the shipped adapters use.
+ * the same shape the shipped adapters use. Deferring that message until the
+ * next non-tool message keeps a parallel group's answers contiguous.
+ *
+ * `developer` becomes `system`. The harness uses that role for its own
+ * system-level notices — the tool-registry change it appends when the tool set
+ * moves — and the newer OpenAI spelling is not accepted by every
+ * OpenAI-compatible gateway, while `system` is. Sending it as a user turn (what
+ * an unhandled role fell through to) also misrepresents it as something the user
+ * said.
+ *
+ * The group guard below is the same rule stated once: an assistant message
+ * carrying `tool_calls` must be followed immediately by a `tool` message per id.
+ * Any other message that would land inside that run — a notice, a user turn, the
+ * image message a tool-result image needs — is held back until the group closes,
+ * because a gateway that validates the rule rejects the whole request with
+ * "insufficient tool messages following tool_calls message".
  */
 function serializeMessages(messages, images) {
   const wire = []
   let pendingToolImages = []
+  /** Call ids of the most recent assistant tool_calls still awaiting an answer. */
+  let awaiting = []
+  /** Messages held back so they cannot split the group; emitted in order. */
+  let deferred = []
+
+  const flushDeferred = () => {
+    if (deferred.length === 0) return
+    for (const held of deferred) wire.push(held)
+    deferred = []
+  }
+  /**
+   * Emit a non-tool message.
+   *
+   * A message that is not a tool answer cannot go out while a group is open, so
+   * it waits. With no group open this is a plain push, which is every ordinary
+   * conversation and keeps that output unchanged.
+   */
+  const emit = (message) => {
+    if (awaiting.length > 0) deferred.push(message)
+    else wire.push(message)
+  }
   const flushToolImages = () => {
     if (pendingToolImages.length === 0) return
-    wire.push({ role: 'user', content: [{ type: 'text', text: TOOL_RESULT_IMAGE_TEXT }, ...pendingToolImages] })
+    const message = { role: 'user', content: [{ type: 'text', text: TOOL_RESULT_IMAGE_TEXT }, ...pendingToolImages] }
     pendingToolImages = []
+    emit(message)
   }
+  /** A tool answer: it closes its own id, and the group when it was the last. */
+  const answer = (callId, content) => {
+    wire.push({ role: 'tool', tool_call_id: callId, content: flattenText(content) || '(no output)' })
+    collectImageParts(content, images, pendingToolImages)
+    awaiting = awaiting.filter((id) => id !== callId)
+    if (awaiting.length === 0) flushDeferred()
+  }
+
   for (const message of messages) {
-    if (message.role === 'system') {
+    if (message.role === 'system' || message.role === 'developer') {
       flushToolImages()
-      wire.push({ role: 'system', content: flattenText(message.content) })
+      emit({ role: 'system', content: flattenText(message.content) })
       continue
     }
     if (message.role === 'assistant') {
       flushToolImages()
+      // A turn boundary. Anything still held belongs before the new turn, and an
+      // unanswered group from the previous turn can no longer be answered.
+      flushDeferred()
       wire.push(serializeAssistant(message))
+      awaiting = (message.content ?? []).filter((block) => block.type === 'tool-call').map((block) => block.id)
+      continue
+    }
+    // A harness tool result: the call identity is on the message. No flush here,
+    // so the answers to one assistant message's parallel calls stay adjacent.
+    if (message.role === 'tool') {
+      answer(message.toolCallId, message.content)
       continue
     }
     const toolResults = (message.content ?? []).filter((block) => block.type === 'tool-result')
@@ -286,18 +343,16 @@ function serializeMessages(messages, images) {
     const text = parts.filter((part) => part.type === 'text').map((part) => part.text).join('')
     if (hasImage || text.length > 0 || toolResults.length === 0) {
       flushToolImages()
-      wire.push({ role: 'user', content: hasImage ? parts : text })
+      emit({ role: 'user', content: hasImage ? parts : text })
     }
     for (const result of toolResults) {
-      wire.push({
-        role: 'tool',
-        tool_call_id: result.toolCallId,
-        content: flattenText(result.content) || '(no output)',
-      })
-      collectImageParts(result.content, images, pendingToolImages)
+      answer(result.toolCallId, result.content)
     }
   }
   flushToolImages()
+  // A group the history never closed leaves nothing to wait for; whatever was
+  // held still belongs in the request, just after the answers that do exist.
+  flushDeferred()
   return wire
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cline-pass",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Self-contained Cline Pass provider for dsh: register Cline Pass subscription models on the harness LLM seam, enumerate and validate the upstream channels behind each model, pin or exclude them with failover, and drive an account pool. No proxy process and no external cline-pass-switcher install required.",
   "type": "module",
   "main": "lib/index.js",