mohdel 1.4.0 → 1.5.1

package/js/client/coalesce.js

@@ -0,0 +1,42 @@
+/**
+ * Coalesce the delta events of a `call()` stream, with the facade's
+ * `bufferOpts` rules (`createRealtimeDeltaBuffer`): deltas of one kind
+ * accumulate until `maxChars` is reached or `maxMs` has passed since the
+ * last flush, checked as each delta arrives — there is no timer. A change
+ * of kind, any other event, and the end of the stream flush first, so
+ * order is kept and the terminal event is never held back.
+ *
+ * @module client/coalesce
+ */
+
+/**
+ * @param {AsyncIterable<import('#core/events.js').Event>} events
+ * @param {{maxChars?: number, maxMs?: number}} [bufferOpts]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * coalesce (events, { maxChars = 250, maxMs = 10_000 } = {}) {
+  let buffer = ''
+  let kind = 'message'
+  let lastFlush = Date.now()
+
+  const flush = () => {
+    const ev = { type: 'delta', delta: { type: kind, delta: buffer } }
+    buffer = ''
+    lastFlush = Date.now()
+    return ev
+  }
+
+  for await (const ev of events) {
+    if (ev.type !== 'delta') {
+      if (buffer) yield flush()
+      yield ev
+      continue
+    }
+    if (!ev.delta.delta) continue
+    if (buffer && ev.delta.type !== kind) yield flush()
+    kind = ev.delta.type
+    buffer += ev.delta.delta
+    if (buffer.length >= maxChars || Date.now() - lastFlush >= maxMs) yield flush()
+  }
+  if (buffer) yield flush()
+}

package/js/client/index.js

@@ -14,6 +14,7 @@
  */
 
 export { call } from './call.js'
+export { coalesce } from './coalesce.js'
 export { callImage } from './call_image.js'
 export { callTranscription } from './call_transcription.js'
 export { callEmbedding } from './call_embedding.js'

package/js/session/driver.js

@@ -19,6 +19,7 @@ import { run } from './run.js'
 import { runImage } from './run_image.js'
 import { runTranscription } from './run_transcription.js'
 import { runEmbedding } from './run_embedding.js'
+import { runInfo } from './run_info.js'
 import { setCatalog } from './adapters/_catalog.js'
 
 // Bounded memory for pre-dequeue cancels. Hostile/buggy supervisors
@@ -232,6 +233,13 @@ export async function drive (stdin, stdout) {
         } else {
           await writeLine({ type: 'error', error: out.error })
         }
+      } else if (envelope.op === 'info') {
+        const out = await runInfo(envelope)
+        if (out.ok) {
+          await writeLine({ type: 'info_done', result: out.result })
+        } else {
+          await writeLine({ type: 'error', error: out.error })
+        }
       } else {
         for await (const ev of run(envelope, { signal: controller.signal })) {
           await writeLine(ev)

package/js/session/run.js

@@ -61,7 +61,7 @@ import { STATUS_INCOMPLETE, WARNING_CANCELLED } from '#core/status.js'
 // name is checked against the known list before it reaches the import path —
 // it comes off the envelope, and a computed specifier must never take an
 // arbitrary string.
-const loadAdapter = async (provider) => {
+export const loadAdapter = async (provider) => {
   if (!ADAPTER_NAMES.includes(provider)) throw new Error(`unknown provider: ${provider}`)
   const module = await import(`./adapters/${provider}.js`)
   return module[provider]
@@ -85,6 +85,9 @@ export async function * run (envelope, {
   if (norm.error) { yield norm.error; return }
   envelope = norm.envelope
 
+  const cacheErr = cacheMarkerError(envelope.prompt)
+  if (cacheErr) { yield cacheErr; return }
+
   const provider = providerOf(envelope.model)
   const span = openSpan(envelope)
   const log = scopedLogger(logger, envelope, span)
@@ -312,7 +315,7 @@ export async function * run (envelope, {
  *   error?: import('#core/events.js').ErrorEvent
  * }}
  */
-function normalizeModelId (envelope, resolveSpec) {
+export function normalizeModelId (envelope, resolveSpec) {
   // A bare id that itself contains `:` or `@` is a catalog key in its
   // own right; resolving the whole string first stops it being split
   // into a base plus a suffix that was never meant as one.
@@ -357,6 +360,37 @@ function normalizeModelId (envelope, resolveSpec) {
   return { envelope: next, key: base, spec: baseSpec }
 }
 
+/**
+ * A `cache` marker is honoured on `text` parts only, with a TTL the
+ * adapters know. The adapters would ignore any other marker, so it is
+ * refused rather than dropped.
+ *
+ * @param {import('#core/envelope.js').CallEnvelope['prompt']} prompt
+ * @returns {import('#core/events.js').ErrorEvent | undefined}
+ */
+function cacheMarkerError (prompt) {
+  if (!Array.isArray(prompt)) return undefined
+  for (const m of prompt) {
+    if (!Array.isArray(m?.content)) continue
+    for (const p of m.content) {
+      if (p?.cache == null) continue
+      if (p.type !== 'text') {
+        return errorEvent(
+          `\`cache\` is accepted on text parts only, not on a ${p.type} part (${m.role} message)`,
+          'SESSION_INVALID_PROMPT'
+        )
+      }
+      if (p.cache !== '5m' && p.cache !== '1h') {
+        return errorEvent(
+          `\`cache\` on a text part must be '5m' or '1h' (got ${JSON.stringify(p.cache)})`,
+          'SESSION_INVALID_PROMPT'
+        )
+      }
+    }
+  }
+  return undefined
+}
+
 /**
  * The two lane guards, in caller-then-internal order. Returns an
  * error event, or `undefined` when the lane is usable.
@@ -374,7 +408,7 @@ function normalizeModelId (envelope, resolveSpec) {
  * @param {any} adapter
  * @returns {import('#core/events.js').ErrorEvent | undefined}
  */
-function speedError (key, speed, spec, provider, adapter) {
+export function speedError (key, speed, spec, provider, adapter) {
   if (!hasSpeed(spec, speed)) {
     const available = speedNames(spec)
     const detail = available.length

package/js/session/run_info.js

@@ -0,0 +1,58 @@
+/**
+ * Catalog entry lookup for a model id, answered by the session that
+ * holds the catalog. An embedder of the gate supplies or loads the
+ * catalog but never reads it back; this is how it asks.
+ *
+ * The answer is the entry a call with that `model` would run on: the
+ * same lookup and the same effort and speed-lane checks as `run.js`,
+ * so an id this accepts is one a call accepts. Shape follows the
+ * facade's `info()`: the entry, plus `speed` when a lane is named.
+ *
+ * @module session/run_info
+ */
+
+import { getSpec } from './adapters/_catalog.js'
+import { providerOf } from '#core/model-id.js'
+import { loadAdapter, normalizeModelId, speedError } from './run.js'
+
+/**
+ * @param {{model: string}} request
+ * @param {{
+ *   resolveSpec?: (key: string) => any,
+ *   resolveAdapter?: (provider: string) => Promise<any>
+ * }} [options]
+ * @returns {Promise<
+ *   | {ok: true, result: Record<string, any> | null}
+ *   | {ok: false, error: import('#core/errors.js').TypedError}
+ * >}
+ */
+export async function runInfo ({ model }, {
+  resolveSpec = getSpec,
+  resolveAdapter = loadAdapter
+} = {}) {
+  const norm = normalizeModelId(/** @type {any} */({ model }), resolveSpec)
+  if (norm.error) return { ok: false, error: norm.error.error }
+  if (!norm.spec) return { ok: true, result: null }
+
+  const speed = norm.envelope.speed
+  if (!speed) return { ok: true, result: { ...norm.spec } }
+
+  const provider = providerOf(norm.key)
+  let adapter
+  try {
+    adapter = await resolveAdapter(provider)
+  } catch (e) {
+    return {
+      ok: false,
+      error: {
+        message: e instanceof Error ? e.message : String(e),
+        severity: 'error',
+        retryable: false,
+        type: 'SESSION_UNKNOWN_PROVIDER'
+      }
+    }
+  }
+  const denied = speedError(norm.key, speed, norm.spec, provider, adapter)
+  if (denied) return { ok: false, error: denied.error }
+  return { ok: true, result: { ...norm.spec, speed } }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -136,17 +136,17 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.0",
-    "mohdel-thin-gate-linux-x64-gnu": "1.4.0"
+    "mohdel-thin-gate-linux-x64-gnu": "1.5.1"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.125.0",
+    "@anthropic-ai/sdk": "^0.128.0",
     "@cerebras/cerebras_cloud_sdk": "^1.91.0",
     "@clack/prompts": "^1.8.1",
-    "@google/genai": "^2.22.0",
+    "@google/genai": "^2.24.0",
     "@opentelemetry/api": "^1.9.1",
     "env-paths": "^4.0.0",
     "groq-sdk": "^1.6.0",
-    "openai": "^7.15.0",
+    "openai": "^7.23.0",
     "undici": "^7.29.0"
   },
   "lint-staged": {

package/src/lib/utils.js

@@ -64,7 +64,9 @@ export const createRealtimeDeltaBuffer = (handler, opts = {}) => {
 
   const push = (type, delta) => {
     if (!handler || !delta) return
-    lastType = type || lastType || 'message'
+    const kind = type || lastType
+    if (buffer && kind !== lastType) flushInternal(true)
+    lastType = kind
     buffer += delta
     flushInternal(false)
   }