mohdel 0.90.0

package/js/session/adapters/_images.js

@@ -0,0 +1,60 @@
+/**
+ * Image URI loader.
+ *
+ * Three URI schemes are supported (see INTEGRATION.md §Vision):
+ *   - `file://` → reads from local filesystem, base64-encodes
+ *   - `https://` → passed as URL reference (where the provider accepts it)
+ *   - `data:` → base64 data URI parsed inline
+ *
+ * Each adapter calls `loadImages(images)` to get a normalized
+ * intermediate shape `{mimeType, base64?, url?}`, then formats per
+ * provider. Errors are surfaced — file IO failures bubble up so the
+ * adapter can emit a typed error rather than silently skipping.
+ *
+ * @module session/adapters/_images
+ */
+
+import { readFile } from 'node:fs/promises'
+
+/**
+ * @typedef {object} LoadedImage
+ * @property {string} mimeType
+ * @property {string} [base64]   Raw base64 (no `data:` prefix)
+ * @property {string} [url]      Remote URL (only when source was https://)
+ */
+
+/**
+ * @param {Array<{fileUri: string, mimeType: string}>} images
+ * @returns {Promise<LoadedImage[]>}
+ */
+export async function loadImages (images) {
+  if (!images || !Array.isArray(images)) return []
+  const out = []
+  for (const img of images) {
+    if (!img?.fileUri || !img?.mimeType) continue
+    out.push(await loadImage(img))
+  }
+  return out
+}
+
+/**
+ * @param {{fileUri: string, mimeType: string}} image
+ * @returns {Promise<LoadedImage>}
+ */
+export async function loadImage (image) {
+  const { fileUri, mimeType } = image
+  if (fileUri.startsWith('file://')) {
+    const path = fileUri.replace(/^file:\/\//, '')
+    const buf = await readFile(path)
+    return { mimeType, base64: buf.toString('base64') }
+  }
+  if (fileUri.startsWith('data:')) {
+    const parts = fileUri.split(',')
+    if (parts.length > 1) return { mimeType, base64: parts[1] }
+    throw new Error(`malformed data URI: ${fileUri.slice(0, 32)}…`)
+  }
+  if (fileUri.startsWith('https://') || fileUri.startsWith('http://')) {
+    return { mimeType, url: fileUri }
+  }
+  throw new Error(`unsupported image URI scheme: ${fileUri.slice(0, 32)}…`)
+}

package/js/session/adapters/_lazy_json_cache.js

@@ -0,0 +1,76 @@
+/**
+ * Shared lazy-load-once JSON cache for config files under
+ * `~/.config/mohdel/`. `_catalog.js` and `_providers.js` both had
+ * byte-similar implementations before F62; this helper owns the
+ * pattern.
+ *
+ * Contract:
+ *   - `loadSync(path?)` — synchronous read; used as the lazy
+ *     fallback inside `get()` and by tests that want to parse an
+ *     arbitrary file without touching the shared cache.
+ *   - `initAsync()` — idempotent eager init from the default path.
+ *     Called from `bin.js::main` before `drive()` so the first
+ *     `get()` doesn't stall the event loop on a sync read.
+ *   - `set(table)` — replace the in-memory table (tests + extension
+ *     hook for deployments that source config from elsewhere).
+ *   - `get(key)` — read-through; loads synchronously on first miss.
+ *
+ * A malformed / missing / non-object file resolves to the supplied
+ * `defaultValue` (default `{}`) so callers never have to handle
+ * file-absence explicitly.
+ *
+ * @module session/adapters/_lazy_json_cache
+ */
+
+import fs from 'node:fs'
+
+/**
+ * @template V
+ * @param {() => string} pathFn  Resolves the default file path.
+ * @param {{defaultValue?: V}} [opts]
+ */
+export function createLazyJsonFileCache (pathFn, { defaultValue = /** @type {any} */({}) } = {}) {
+  /** @type {V | null} */
+  let active = null
+
+  /** @param {unknown} parsed */
+  function normalize (parsed) {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return defaultValue
+    }
+    return /** @type {V} */(parsed)
+  }
+
+  /** @param {string} [p] */
+  function loadSync (p) {
+    const file = p ?? pathFn()
+    try {
+      return normalize(JSON.parse(fs.readFileSync(file, 'utf8')))
+    } catch {
+      return defaultValue
+    }
+  }
+
+  async function initAsync () {
+    if (active !== null) return
+    try {
+      const text = await fs.promises.readFile(pathFn(), 'utf8')
+      active = normalize(JSON.parse(text))
+    } catch {
+      active = defaultValue
+    }
+  }
+
+  /** @param {V} table */
+  function set (table) {
+    active = /** @type {V} */({ ...table })
+  }
+
+  /** @param {string} key */
+  function get (key) {
+    if (active === null) active = loadSync()
+    return active[key]
+  }
+
+  return { loadSync, initAsync, set, get }
+}

package/js/session/adapters/_pricing.js

@@ -0,0 +1,67 @@
+/**
+ * Cost computation from curated catalog spec.
+ *
+ * Reads `inputPrice` / `outputPrice` / `thinkingPrice` from the
+ * catalog spec (loaded via `_catalog.js`). Returns a single number
+ * (USD) written to `AnswerResult.cost`. Unknown models or specs
+ * without prices return `0` — graceful degradation.
+ *
+ * @module session/adapters/_pricing
+ */
+
+import { getSpec, setCatalog } from './_catalog.js'
+
+/**
+ * Pure cost computation from spec + usage.
+ *
+ * @param {any} spec  Catalog entry (with `inputPrice`/`outputPrice`/`thinkingPrice`),
+ *                    or `undefined`.
+ * @param {{inputTokens?: number, outputTokens?: number, thinkingTokens?: number}} usage
+ * @returns {number}
+ */
+export function computeCost (spec, usage) {
+  if (!spec) return 0
+  const ip = spec.inputPrice
+  const op = spec.outputPrice
+  if (typeof ip !== 'number' || typeof op !== 'number') return 0
+  const i = usage.inputTokens ?? 0
+  const o = usage.outputTokens ?? 0
+  const t = usage.thinkingTokens ?? 0
+  const tp = typeof spec.thinkingPrice === 'number' ? spec.thinkingPrice : op
+  const total = (i * ip + o * op + t * tp) / 1_000_000
+  return round(total)
+}
+
+/**
+ * @param {string} model  Fully-qualified `<provider>/<model>`.
+ * @param {{inputTokens?: number, outputTokens?: number, thinkingTokens?: number}} usage
+ * @returns {number}
+ */
+export function costFor (model, usage) {
+  return computeCost(getSpec(model), usage)
+}
+
+/**
+ * Test convenience: inject pricing-only specs by model id. Wraps
+ * `setCatalog` with the `{input, output, thinking?}` shape used in
+ * existing tests, translating to spec fields.
+ *
+ * @param {Record<string, {input: number, output: number, thinking?: number}>} table
+ */
+export function setPricing (table) {
+  /** @type {Record<string, any>} */
+  const wrapped = {}
+  for (const [k, v] of Object.entries(table)) {
+    wrapped[k] = {
+      inputPrice: v.input,
+      outputPrice: v.output,
+      ...(v.thinking != null && { thinkingPrice: v.thinking })
+    }
+  }
+  setCatalog(wrapped)
+}
+
+/** @param {number} n */
+function round (n) {
+  return Math.round(n * 1e6) / 1e6
+}

package/js/session/adapters/_providers.js

@@ -0,0 +1,60 @@
+/**
+ * Provider-level configuration reader.
+ *
+ * Per-provider rate limits live in `~/.config/mohdel/providers.json`
+ * as `{ <provider>: { rpmLimit, tpmLimit } }`. These are
+ * per-account values (different plans get different limits), so
+ * they live in user config — not source code.
+ *
+ * Sessions load once and cache in-process.
+ *
+ * @module session/adapters/_providers
+ */
+
+import envPaths from 'env-paths'
+
+import { createLazyJsonFileCache } from './_lazy_json_cache.js'
+
+/**
+ * @typedef {object} ProviderLimits
+ * @property {number} [rpmLimit]
+ * @property {number} [tpmLimit]
+ */
+
+const cache = createLazyJsonFileCache(
+  // `{ suffix: null }` — see `_catalog.js` for the rationale (stay
+  // in lockstep with the CLI's `CONFIG_DIR`, avoid the `-nodejs`
+  // suffix env-paths appends by default).
+  () => `${envPaths('mohdel', { suffix: null }).config}/providers.json`
+)
+
+/**
+ * @param {string} path
+ * @returns {Record<string, ProviderLimits>}
+ */
+export function loadProviders (path) {
+  return cache.loadSync(path)
+}
+
+/**
+ * Eager async initialization from the default providers path. Called
+ * from `bin.js::main` before `drive()` so `getProviderLimits` doesn't
+ * stall the event loop on a sync read mid-call. Idempotent; respects
+ * a prior `setProviders` (tests).
+ */
+export async function initProvidersFromDefault () {
+  await cache.initAsync()
+}
+
+/** @param {Record<string, ProviderLimits>} table */
+export function setProviders (table) {
+  cache.set(table)
+}
+
+/**
+ * @param {string} provider
+ * @returns {ProviderLimits | undefined}
+ */
+export function getProviderLimits (provider) {
+  return cache.get(provider)
+}

package/js/session/adapters/_tools.js

@@ -0,0 +1,185 @@
+/**
+ * Tool format conversion — provider-agnostic JSON-shape converters
+ * used by adapters to translate between the unified `ToolSpec` /
+ * `ToolCall` envelope shapes and each provider's native wire format.
+ *
+ * @module session/adapters/_tools
+ */
+
+const argsObj = (args) => args || {}
+
+// Tool argument parse failures are expected (models routinely send
+// malformed JSON before retrying with corrections). Fall back to
+// returning the raw string — downstream adapter code handles the
+// type mismatch. Logging here would create warn-level noise.
+const parseArgs = (_name, args) => {
+  if (typeof args !== 'string') return argsObj(args)
+  try {
+    return JSON.parse(args)
+  } catch {
+    return args
+  }
+}
+
+/**
+ * Convert unified tool format to Anthropic's native format.
+ * @param {Array} tools  Array of unified tool definitions.
+ * @returns {Array} Anthropic-formatted tools.
+ */
+export const toAnthropicTools = (tools) => tools.map(t => ({
+  name: t.name,
+  description: t.description,
+  input_schema: t.parameters
+}))
+
+/**
+ * Convert unified tool format to OpenAI's native format.
+ * @param {Array} tools  Array of unified tool definitions.
+ * @returns {Array} OpenAI-formatted tools.
+ */
+export const toOpenAITools = (tools) => tools.map(t => ({
+  type: 'function',
+  name: t.name,
+  description: t.description,
+  parameters: t.parameters
+}))
+
+/**
+ * Convert unified tool format to Cerebras's native format (classic
+ * OpenAI chat completions).
+ * @param {Array} tools  Array of unified tool definitions.
+ * @returns {Array} Cerebras-formatted tools.
+ */
+export const toCerebrasTools = (tools) => tools.map(t => ({
+  type: 'function',
+  function: {
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  }
+}))
+
+/**
+ * Convert unified tool format to Gemini's native format (wrapped in
+ * `functionDeclarations`).
+ * @param {Array} tools  Array of unified tool definitions.
+ * @returns {Array} Gemini-formatted tools.
+ */
+export const toGeminiTools = (tools) => [{
+  functionDeclarations: tools.map(t => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  }))
+}]
+
+/**
+ * Normalize Anthropic tool_use blocks to unified format.
+ * @param {Array} blocks  Array of `tool_use` content blocks.
+ * @returns {Array} Unified toolCalls format.
+ */
+export const fromAnthropicToolCalls = (blocks) => blocks.map(block => ({
+  id: block.id,
+  name: block.name,
+  arguments: block.input
+}))
+
+/**
+ * Normalize OpenAI function calls to unified format.
+ * @param {Array} calls  Array of OpenAI function call outputs.
+ * @returns {Array} Unified toolCalls format.
+ */
+export const fromOpenAIToolCalls = (calls) => calls.map(call => ({
+  id: call.call_id || call.id,
+  name: call.name,
+  arguments: parseArgs(call.name, call.arguments)
+}))
+
+/**
+ * Normalize Cerebras tool calls to unified format. Cerebras uses
+ * the classic OpenAI chat-completions shape `{id, function: {name,
+ * arguments}}`.
+ * @param {Array} calls  Array of Cerebras tool_calls.
+ * @returns {Array} Unified toolCalls format.
+ */
+export const fromCerebrasToolCalls = (calls) => calls.map(call => ({
+  id: call.id,
+  name: call.function.name,
+  arguments: parseArgs(call.function.name, call.function.arguments)
+}))
+
+/**
+ * Normalize Gemini function calls to unified format. Gemini doesn't
+ * provide IDs, so we generate them.
+ * @param {Array} calls  Array of Gemini `functionCall` parts.
+ * @returns {Array} Unified toolCalls format.
+ */
+export const fromGeminiToolCalls = (calls) => calls.map((call, index) => {
+  const tc = {
+    id: `gemini_call_${Date.now()}_${index}_${Math.random().toString(36).slice(2, 6)}`,
+    name: call.name,
+    arguments: call.args || {}
+  }
+  if (call.thoughtSignature) tc.thoughtSignature = call.thoughtSignature
+  return tc
+})
+
+/**
+ * Convert tool choice to provider-specific format.
+ * @param {string} provider  Provider name (`'anthropic'`, `'openai'`,
+ *   `'cerebras'`, `'mistral'`, `'gemini'`).
+ * @param {string|object} choice  Tool choice (`'auto'`, `'required'`,
+ *   `'none'`, or a specific tool name).
+ * @returns {any} Provider-formatted tool choice.
+ */
+export const toToolChoice = (provider, choice) => {
+  if (!choice) return undefined
+
+  switch (provider) {
+    case 'anthropic':
+      if (choice === 'auto') return { type: 'auto' }
+      if (choice === 'required') return { type: 'any' }
+      if (choice === 'none') return { type: 'none' }
+      if (typeof choice === 'string') return { type: 'tool', name: choice }
+      return choice
+
+    case 'openai':
+      if (choice === 'auto') return 'auto'
+      if (choice === 'required') return 'required'
+      if (choice === 'none') return 'none'
+      if (typeof choice === 'string') return { type: 'function', function: { name: choice } }
+      return choice
+
+    case 'cerebras':
+      if (choice === 'auto') return 'auto'
+      if (choice === 'required') return 'required'
+      if (choice === 'none') return 'none'
+      if (typeof choice === 'string') return { type: 'function', function: { name: choice } }
+      return choice
+
+    case 'mistral':
+      if (choice === 'auto') return 'auto'
+      if (choice === 'required') return 'any'
+      if (choice === 'none') return 'none'
+      if (typeof choice === 'string') return { type: 'function', function: { name: choice } }
+      return choice
+
+    case 'gemini':
+      // Gemini uses toolConfig.functionCallingConfig
+      if (choice === 'auto') return { functionCallingConfig: { mode: 'AUTO' } }
+      if (choice === 'required') return { functionCallingConfig: { mode: 'ANY' } }
+      if (choice === 'none') return { functionCallingConfig: { mode: 'NONE' } }
+      if (typeof choice === 'string') {
+        return {
+          functionCallingConfig: {
+            mode: 'ANY',
+            allowedFunctionNames: [choice]
+          }
+        }
+      }
+      return choice
+
+    default:
+      return choice
+  }
+}