mohdel 0.124.0 → 0.125.0

package/README.md

@@ -233,7 +233,7 @@ With no session-bin configured, thin-gate runs in demo mode: `POST /v1/call` ret
 
 ### Calling from JS
 
-The client snippet under [Library Usage](#library-usage) above is the full surface: `call(envelope, { socketPath, signal? })` returns an async iterable of events. Pass an `AbortSignal` to cancel in flight; thin-gate forwards a cancel control message to the session and reuses it on the pool. The envelope is the flat `answer(prompt, options)` surface plus transport metadata (`callId`, `authId`, `auth.key`, optional `traceparent`); see [`js/core/envelope.js`](js/core/envelope.js) for the full field list.
+The client snippet under [Library Usage](#library-usage) above is the full surface: `call(envelope, { socketPath, signal? })` returns an async iterable of events. Pass an `AbortSignal` to cancel in flight; thin-gate forwards a cancel control message to the session and reuses it on the pool, and the client ends the stream with the same cancelled `done` the in-process path returns (status `incomplete`, warning `cancelled`, the partial output it relayed, zero tokens). The envelope is the flat `answer(prompt, options)` surface plus transport metadata (`callId`, `authId`, `auth.key`, optional `traceparent`); see [`js/core/envelope.js`](js/core/envelope.js) for the full field list.
 
 ### Other languages
 

package/js/client/call.js

@@ -1,17 +1,42 @@
 /**
  * Send a CallEnvelope to thin-gate; returns an async iterable of Events.
  *
- * Cancellation: pass an AbortSignal. Aborting destroys the HTTP request;
- * thin-gate infers cancel from connection close and emits
- * `call.cancelled` upstream.
- *
+ * Cancellation: pass an AbortSignal. Aborting closes the HTTP request;
+ * thin-gate infers cancel from connection close and sends the session a
+ * cancel control message. The session's own cancelled terminal is drained
+ * gate-side, so the client synthesizes the same cancelled `done` here —
+ * partial output from the deltas it relayed, zero tokens, zero cost —
+ * giving a caller the same terminal on this path as on the in-process one.
  * @module client/call
  */
 
 import { requestUnix } from './transport.js'
 import { readAll, parseErrorBody } from './response.js'
 import { parseNDJSON } from './ndjson.js'
-import { isEvent, MohdelError } from '#core'
+import { isEvent, MohdelError, STATUS_INCOMPLETE, WARNING_CANCELLED } from '#core'
+
+/**
+ * @param {string} start
+ * @param {string | null} first
+ * @param {string} output
+ * @returns {import('#core/events.js').DoneEvent}
+ */
+function cancelledDone (start, first, output) {
+  const end = String(process.hrtime.bigint())
+  return {
+    type: 'done',
+    result: {
+      status: STATUS_INCOMPLETE,
+      output: output || null,
+      inputTokens: 0,
+      outputTokens: 0,
+      thinkingTokens: 0,
+      cost: 0,
+      timestamps: { start, first: first ?? end, end },
+      warning: WARNING_CANCELLED
+    }
+  }
+}
 
 /**
  * @param {import('#core/envelope.js').CallEnvelope} envelope
@@ -22,26 +47,58 @@ import { isEvent, MohdelError } from '#core'
  * @returns {AsyncGenerator<import('#core/events.js').Event>}
  */
 export async function * call (envelope, { socketPath, signal, path = '/v1/call' }) {
-  const res = await requestUnix({
-    socketPath,
-    path,
-    method: 'POST',
-    body: envelope,
-    signal
-  })
+  const start = String(process.hrtime.bigint())
+  if (signal?.aborted) {
+    yield cancelledDone(start, null, '')
+    return
+  }
+
+  let res
+  try {
+    res = await requestUnix({
+      socketPath,
+      path,
+      method: 'POST',
+      body: envelope,
+      signal
+    })
+  } catch (e) {
+    if (signal?.aborted) {
+      yield cancelledDone(start, null, '')
+      return
+    }
+    throw e
+  }
 
   if (res.statusCode !== 200) {
     const body = await readAll(res)
     throw MohdelError.fromJSON(parseErrorBody(body, res.statusCode ?? 0))
   }
 
-  for await (const obj of parseNDJSON(res)) {
-    if (!isEvent(obj)) {
-      throw new MohdelError(
-        'received non-Event object from thin-gate',
-        { type: 'PROTOCOL_INVALID_EVENT', retryable: false }
-      )
+  const outputParts = []
+  let first = null
+  let sawTerminal = false
+  try {
+    for await (const obj of parseNDJSON(res)) {
+      if (!isEvent(obj)) {
+        throw new MohdelError(
+          'received non-Event object from thin-gate',
+          { type: 'PROTOCOL_INVALID_EVENT', retryable: false }
+        )
+      }
+      if (obj.type === 'delta') {
+        if (first === null) first = String(process.hrtime.bigint())
+        if (obj.delta?.type === 'message') outputParts.push(obj.delta.delta)
+      } else if (obj.type === 'done' || obj.type === 'error') {
+        sawTerminal = true
+      }
+      yield /** @type {import('#core/events.js').Event} */(obj)
     }
-    yield /** @type {import('#core/events.js').Event} */(obj)
+  } catch (e) {
+    if (!signal?.aborted) throw e
+  }
+
+  if (signal?.aborted && !sawTerminal) {
+    yield cancelledDone(start, first, outputParts.join(''))
   }
 }

package/js/session/adapters/_cancelled.js

@@ -2,12 +2,6 @@
  * Shared `cancelledDone` helper for adapters that need to synthesize
  * a terminal `done` event on `signal.aborted` mid-stream.
  *
- * Three adapters (openai, anthropic, gemini) had byte-identical
- * copies of this; consolidated here. `_chat_completions.js`
- * and `run.js` have their own cancel paths — don't migrate them
- * here unless you're certain the shape matches (thinkingTokens,
- * cost, tool_calls semantics can all differ).
- *
  * @module session/adapters/_cancelled
  */
 

package/js/session/adapters/_chat_completions.js

@@ -19,6 +19,7 @@
 import { getSpec } from './_catalog.js'
 import { classifyProviderError } from './_errors.js'
 import { costFor } from './_pricing.js'
+import { cancelledDone } from './_cancelled.js'
 import { catalogKey, bareOf } from '#core/model-id.js'
 import {
   STATUS_COMPLETED,
@@ -98,6 +99,10 @@ export async function * runChatCompletions (envelope, client, config, deps = {})
   try {
     response = await client.chat.completions.create(args, { signal: deps.signal })
   } catch (e) {
+    if (deps.signal?.aborted) {
+      yield cancelledDone(start, null, envelope, '', 0, 0)
+      return
+    }
     deps.log?.warn({ err: e }, `[mohdel:${config.provider}] request failed`)
     yield { type: 'error', error: classifyProviderError(e, envelope.auth?.key, { provider: config.provider }) }
     return
@@ -161,6 +166,10 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
   try {
     stream = await client.chat.completions.create(args, { signal: deps.signal })
   } catch (e) {
+    if (deps.signal?.aborted) {
+      yield cancelledDone(start, null, envelope, '', 0, 0)
+      return
+    }
     deps.log?.warn({ err: e }, `[mohdel:${config.provider}] request failed`)
     yield { type: 'error', error: classifyProviderError(e, envelope.auth?.key, { provider: config.provider }) }
     return
@@ -168,6 +177,10 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
 
   try {
     for await (const chunk of stream) {
+      if (deps.signal?.aborted) {
+        yield cancelledDone(start, first, envelope, contentParts.join(''), 0, 0)
+        return
+      }
       const choice = chunk.choices?.[0]
       // DeepSeek V4 / deepseek-reasoner / Cerebras reasoning models emit
       // `delta.reasoning_content` chunks before visible content. Capture
@@ -225,11 +238,20 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
       if (chunk.usage) usage = chunk.usage
     }
   } catch (e) {
+    if (deps.signal?.aborted) {
+      yield cancelledDone(start, first, envelope, contentParts.join(''), 0, 0)
+      return
+    }
     deps.log?.warn({ err: e }, `[mohdel:${config.provider}] stream failed`)
     yield { type: 'error', error: classifyProviderError(e, envelope.auth?.key, { provider: config.provider }) }
     return
   }
 
+  if (deps.signal?.aborted) {
+    yield cancelledDone(start, first, envelope, contentParts.join(''), 0, 0)
+    return
+  }
+
   const collectedToolCalls = Object.values(toolCallAccum).map(tc => ({
     id: tc.id,
     function: { name: tc.name, arguments: tc.arguments }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "0.124.0",
+  "version": "0.125.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -108,12 +108,12 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.0",
-    "mohdel-thin-gate-linux-x64-gnu": "0.124.0"
+    "mohdel-thin-gate-linux-x64-gnu": "0.125.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.123.0",
     "@cerebras/cerebras_cloud_sdk": "^1.91.0",
-    "@google/genai": "^2.20.0",
+    "@google/genai": "^2.21.0",
     "@opentelemetry/api": "^1.9.1",
     "env-paths": "^4.0.0",
     "groq-sdk": "^1.6.0",