mohdel 3.8.0 → 3.9.0

package/js/core/envelope.js

@@ -122,6 +122,13 @@
  * @property {('text'|'reasoning'|'image')} type
  * @property {string} [text]
  *   Required on `text` and `reasoning` parts.
+ * @property {string} [encrypted]
+ *   On a `reasoning` part: the provider's opaque reasoning, replayed only
+ *   to `model` and dropped for any other.
+ * @property {string} [id]
+ *   On a `reasoning` part carrying `encrypted`: the provider's item id.
+ * @property {string} [model]
+ *   On a `reasoning` part carrying `encrypted`: the model that produced it.
  * @property {string} [fileUri]
  *   Required on `image` parts. Same schemes and local-read rules as
  *   an envelope `images` ref. Accepted on `user` and `tool` messages.

package/js/core/events.js

@@ -101,6 +101,10 @@
  *   `'insufficientOutputBudget' | 'aborted' | ...` additive union.
  * @property {ToolCall[]} [toolCalls]
  *   Present when `status === 'tool_use'`.
+ * @property {import('./envelope.js').MessagePart[]} [reasoningParts]
+ *   Reasoning parts carrying `encrypted`, from a provider that returns its
+ *   reasoning to be replayed. A multi-turn caller puts them at the head
+ *   of the assistant message it records for this result.
  * @property {number} [maxInterFrameMs]
  *   Longest gap (ms) between adapter events during the call —
  *   from `startedAt` to the first frame, between consecutive

package/js/session/adapters/_chat_completions.js

@@ -262,6 +262,11 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
     return
   }
 
+  if (finishReason === null) {
+    yield { type: 'error', error: classifyProviderError(new Error(`${config.provider} stream ended before completion`), envelope.auth?.key, { provider: config.provider }) }
+    return
+  }
+
   const collectedToolCalls = Object.values(toolCallAccum).map(tc => ({
     id: tc.id,
     function: { name: tc.name, arguments: tc.arguments }
@@ -557,7 +562,7 @@ function flattenText (content) {
 /** @param {string | import('#core/envelope.js').MessagePart[]} content */
 function extractReasoning (content) {
   if (typeof content === 'string' || !Array.isArray(content)) return null
-  const parts = content.filter(p => p.type === 'reasoning' && p.text).map(p => p.text)
+  const parts = content.filter(p => p.type === 'reasoning' && p.text && !p.encrypted).map(p => p.text)
   return parts.length ? parts.join('\n') : null
 }
 

package/js/session/adapters/openai.js

@@ -70,7 +70,8 @@ export async function * openai (envelope, deps = {}) {
   }
 
   const { instructions, input } = splitPrompt(envelope.prompt, imageParts, {
-    toolResultImages: ['openai', 'chatgpt'].includes(providerOf(envelope.model))
+    toolResultImages: ['openai', 'chatgpt'].includes(providerOf(envelope.model)),
+    model: envelope.model
   })
   if (imageInputs.length) injectImageParts(input, imageInputs)
 
@@ -94,6 +95,8 @@ export async function * openai (envelope, deps = {}) {
   // Tool-call accumulation: itemId → {call_id, name, arguments}
   /** @type {Map<string, {call_id: string, name: string, arguments: string}>} */
   const toolItems = new Map()
+  /** @type {import('#core/envelope.js').MessagePart[]} */
+  const reasoningParts = []
 
   try {
     const stream = await client.responses.stream(request, { signal })
@@ -122,6 +125,18 @@ export async function * openai (envelope, deps = {}) {
           }
           break
 
+        case 'response.output_item.done':
+          if (event.item?.type === 'reasoning' && event.item.encrypted_content) {
+            reasoningParts.push({
+              type: 'reasoning',
+              text: (event.item.summary ?? []).map(s => s.text).join('\n'),
+              id: event.item.id,
+              encrypted: event.item.encrypted_content,
+              model: envelope.model
+            })
+          }
+          break
+
         case 'response.function_call_arguments.delta':
           if (event.item_id && event.delta) {
             const t = toolItems.get(event.item_id)
@@ -167,12 +182,12 @@ export async function * openai (envelope, deps = {}) {
           }
           break
 
-        case 'response.failed':
-          if (providerOf(envelope.model) === 'chatgpt') {
-            yield { type: 'error', error: classifyProviderError(new Error('ChatGPT response failed'), envelope.auth?.key, { provider: 'chatgpt' }) }
-            return
-          }
-          break
+        case 'response.failed': {
+          const provider = providerOf(envelope.model)
+          const failure = Object.assign(new Error(`${provider} response failed`), { error: event.response?.error })
+          yield { type: 'error', error: classifyProviderError(failure, envelope.auth?.key, { provider }) }
+          return
+        }
 
         default:
           break
@@ -194,8 +209,9 @@ export async function * openai (envelope, deps = {}) {
   }
 
   const end = String(process.hrtime.bigint())
-  if (providerOf(envelope.model) === 'chatgpt' && !terminalResponse) {
-    yield { type: 'error', error: classifyProviderError(new Error('ChatGPT stream ended before completion'), envelope.auth?.key, { provider: 'chatgpt' }) }
+  if (!terminalResponse) {
+    const provider = providerOf(envelope.model)
+    yield { type: 'error', error: classifyProviderError(new Error(`${provider} stream ended before completion`), envelope.auth?.key, { provider }) }
     return
   }
   // OpenAI Responses reports `output_tokens` INCLUDING reasoning
@@ -239,6 +255,7 @@ export async function * openai (envelope, deps = {}) {
     }
   }
   if (warning) done.result.warning = warning
+  if (reasoningParts.length) done.result.reasoningParts = reasoningParts
   if (toolItems.size > 0) {
     done.result.toolCalls = fromOpenAIToolCalls(Array.from(toolItems.values()))
   }
@@ -345,6 +362,7 @@ function buildRequest (envelope, input, instructions) {
         request.max_output_tokens += headroom
       }
       request.reasoning = { effort }
+      if (effort !== 'none') request.include = ['reasoning.encrypted_content']
     }
   }
 
@@ -391,7 +409,7 @@ function buildRequest (envelope, input, instructions) {
  *
  * @param {string | import('#core/envelope.js').Message[]} prompt
  * @param {Map<object, import('./_images.js').LoadedImage>} imageParts
- * @param {{toolResultImages: boolean}} opts
+ * @param {{toolResultImages: boolean, model: string}} opts
  */
 function splitPrompt (prompt, imageParts, opts) {
   if (typeof prompt === 'string') {
@@ -409,6 +427,18 @@ function splitPrompt (prompt, imageParts, opts) {
   }
   for (const m of prompt) {
     if (m.role !== 'tool') flushHoisted()
+    if (m.role === 'assistant' && Array.isArray(m.content)) {
+      for (const p of m.content) {
+        if (p.type === 'reasoning' && p.encrypted && p.model === opts.model) {
+          input.push({
+            type: 'reasoning',
+            id: p.id,
+            summary: p.text ? [{ type: 'summary_text', text: p.text }] : [],
+            encrypted_content: p.encrypted
+          })
+        }
+      }
+    }
     if (m.role === 'system') {
       systemParts.push(flattenText(m.content))
     } else if (m.role === 'tool') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -144,7 +144,7 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.1",
-    "mohdel-thin-gate-linux-x64-gnu": "3.8.0"
+    "mohdel-thin-gate-linux-x64-gnu": "3.9.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.129.0",