mohdel 0.90.0

package/js/session/adapters/deepseek.js

@@ -0,0 +1,32 @@
+/**
+ * DeepSeek adapter — OpenAI-compatible chat completions against
+ * api.deepseek.com. DeepSeek models occasionally emit tool calls as
+ * DSML XML-style blocks in `content` rather than the native
+ * `tool_calls` array; the shared core handles the fallback parse
+ * when `parseDsml: true`.
+ *
+ * @module session/adapters/deepseek
+ */
+
+import OpenAI from 'openai'
+
+import { runChatCompletions } from './_chat_completions.js'
+
+const BASE_URL = 'https://api.deepseek.com'
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {{client?: any, signal?: AbortSignal, log?: any, span?: any}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * deepseek (envelope, deps = {}) {
+  const client = deps.client ?? new OpenAI({ apiKey: envelope.auth.key, baseURL: envelope.auth.baseURL || BASE_URL })
+  yield * runChatCompletions(envelope, client, {
+    provider: 'deepseek',
+    parseDsml: true
+  }, {
+    signal: deps.signal,
+    log: deps.log,
+    span: deps.span
+  })
+}

package/js/session/adapters/echo.js

@@ -0,0 +1,51 @@
+/**
+ * Echo adapter — deterministic stub. Emits two message deltas and a
+ * `done` event with a synthetic `AnswerResult`. Honors `signal` for
+ * test-controlled cancellation.
+ *
+ * @module session/adapters/echo
+ */
+
+import { STATUS_COMPLETED } from '#core/status.js'
+
+import { cancelledDone } from './_cancelled.js'
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {{signal?: AbortSignal}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * echo (envelope, { signal } = {}) {
+  const start = String(process.hrtime.bigint())
+  let first = null
+  let output = ''
+
+  for (const delta of ['Hello', ', world.']) {
+    if (signal?.aborted) {
+      yield cancelledDone(start, first, envelope, output, 0, 0)
+      return
+    }
+    if (first === null) first = String(process.hrtime.bigint())
+    output += delta
+    yield { type: 'delta', delta: { type: 'message', delta } }
+  }
+
+  if (signal?.aborted) {
+    yield cancelledDone(start, first, envelope, output, 0, 0)
+    return
+  }
+
+  const end = String(process.hrtime.bigint())
+  yield {
+    type: 'done',
+    result: {
+      status: STATUS_COMPLETED,
+      output,
+      inputTokens: 0,
+      outputTokens: 0,
+      thinkingTokens: 0,
+      cost: 0,
+      timestamps: { start, first: first ?? end, end }
+    }
+  }
+}

package/js/session/adapters/fake.js

@@ -0,0 +1,262 @@
+/**
+ * Fake provider — scenario-driven adapter for stress tests,
+ * benchmarks, and bug reproductions. Never calls a real API.
+ *
+ * The envelope's `prompt` field carries a JSON scenario spec; the
+ * `mode` key picks a behavior, the rest are mode-specific params.
+ * Invalid / non-JSON prompts fall through to `mode: "echo"` so ad-hoc
+ * use from scripts Just Works.
+ *
+ * ## Modes
+ *
+ * | mode          | params                         | behavior                                             |
+ * |---------------|--------------------------------|------------------------------------------------------|
+ * | `echo`        | –                              | one short delta + `done` (default fallback)          |
+ * | `slow`        | `tokens`, `delayMs`            | emit N deltas `delayMs` apart                        |
+ * | `volume`      | `tokens`                       | emit N deltas as fast as the event loop allows       |
+ * | `tool`        | `name`, `args`                 | single `tool_use` terminal with one tool call        |
+ * | `incomplete`  | `warning`                      | `done` with status=incomplete + warning              |
+ * | `error`       | `type`, `message`, `retryable` | yield typed error event                              |
+ * | `hang`        | –                              | never emits a terminal (caller aborts via signal)    |
+ * | `cancel_after`| `tokens`                       | emit N deltas then wait for `signal.aborted`         |
+ * | `crash`       | `code`                         | `process.exit(code\|1)` — kills whichever process is running the adapter. Used by the isolation benchmark to demonstrate that via-gate the crash stays in the session subprocess, in-process it takes down the caller. |
+ *
+ * Every mode honors `deps.signal`: when aborted mid-stream, emits a
+ * `cancelled` done event. That keeps consumer behavior uniform with
+ * the real provider adapters.
+ *
+ * @module session/adapters/fake
+ */
+
+import {
+  STATUS_COMPLETED,
+  STATUS_INCOMPLETE,
+  STATUS_TOOL_USE,
+  WARNING_INSUFFICIENT_OUTPUT_BUDGET
+} from '#core/status.js'
+
+import { cancelledDone } from './_cancelled.js'
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {{signal?: AbortSignal, log?: any}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * fake (envelope, deps = {}) {
+  const signal = deps.signal
+  const spec = parseSpec(envelope.prompt)
+  const start = String(process.hrtime.bigint())
+  let first = null
+
+  switch (spec.mode) {
+    case 'error':
+      yield {
+        type: 'error',
+        error: {
+          message: spec.message ?? 'fake error',
+          severity: spec.severity ?? 'error',
+          retryable: spec.retryable ?? false,
+          type: spec.type ?? 'PROVIDER_ERROR'
+        }
+      }
+      return
+
+    case 'hang':
+      // Wait for abort. If the signal is already aborted, yield
+      // cancelled immediately. Otherwise block until it fires.
+      await waitForAbort(signal)
+      yield cancelledDone(start, first, envelope, '', 0, 0)
+      return
+
+    case 'crash': {
+      // Kills whatever process is executing the adapter. In-process
+      // this takes down the caller; via the gate it only takes down
+      // one session subprocess, which the pool respawns.
+      const code = Number.isInteger(spec.code) ? spec.code : 1
+      process.exit(code)
+      // process.exit does not return; this line is unreachable but
+      // the linter can't see that and would flag no-fallthrough.
+      return
+    }
+
+    case 'incomplete': {
+      const warning = spec.warning ?? WARNING_INSUFFICIENT_OUTPUT_BUDGET
+      const text = spec.output ?? 'partial output'
+      first = String(process.hrtime.bigint())
+      yield { type: 'delta', delta: { type: 'message', delta: text } }
+      yield doneEvent({
+        status: STATUS_INCOMPLETE,
+        output: text,
+        warning,
+        start,
+        first,
+        tokens: approxTokens(text)
+      })
+      return
+    }
+
+    case 'tool': {
+      const name = spec.name ?? 'fake_tool'
+      const args = spec.args ?? {}
+      const id = spec.id ?? `fake_call_${Date.now()}`
+      first = String(process.hrtime.bigint())
+      yield {
+        type: 'delta',
+        delta: { type: 'function_call', delta: JSON.stringify(args) }
+      }
+      yield doneEvent({
+        status: STATUS_TOOL_USE,
+        output: null,
+        start,
+        first,
+        tokens: 0,
+        toolCalls: [{ id, name, arguments: args }]
+      })
+      return
+    }
+
+    case 'slow':
+    case 'volume': {
+      const total = clampPositive(spec.tokens, 5)
+      const delayMs = spec.mode === 'slow' ? clampPositive(spec.delayMs, 50) : 0
+      let output = ''
+      for (let i = 0; i < total; i++) {
+        if (signal?.aborted) {
+          yield cancelledDone(start, first, envelope, output, approxTokens(output), approxTokens(output))
+          return
+        }
+        if (first === null) first = String(process.hrtime.bigint())
+        const chunk = spec.chunk ?? `tok${i} `
+        output += chunk
+        yield { type: 'delta', delta: { type: 'message', delta: chunk } }
+        if (delayMs > 0) {
+          await sleep(delayMs, signal)
+          if (signal?.aborted) {
+            yield cancelledDone(start, first, envelope, output, approxTokens(output), approxTokens(output))
+            return
+          }
+        }
+      }
+      yield doneEvent({
+        status: STATUS_COMPLETED,
+        output,
+        start,
+        first,
+        tokens: approxTokens(output)
+      })
+      return
+    }
+
+    case 'cancel_after': {
+      const total = clampPositive(spec.tokens, 3)
+      let output = ''
+      for (let i = 0; i < total; i++) {
+        if (first === null) first = String(process.hrtime.bigint())
+        const chunk = `tok${i} `
+        output += chunk
+        yield { type: 'delta', delta: { type: 'message', delta: chunk } }
+      }
+      await waitForAbort(signal)
+      yield cancelledDone(start, first, envelope, output, approxTokens(output), approxTokens(output))
+      return
+    }
+
+    case 'echo':
+    default: {
+      const text = spec.output ?? 'ok'
+      first = String(process.hrtime.bigint())
+      yield { type: 'delta', delta: { type: 'message', delta: text } }
+      yield doneEvent({
+        status: STATUS_COMPLETED,
+        output: text,
+        start,
+        first,
+        tokens: approxTokens(text)
+      })
+    }
+  }
+}
+
+/**
+ * @param {string | any[]} prompt
+ * @returns {{mode: string, [k: string]: any}}
+ */
+function parseSpec (prompt) {
+  if (typeof prompt !== 'string') return { mode: 'echo' }
+  const trimmed = prompt.trim()
+  if (!trimmed.startsWith('{')) return { mode: 'echo' }
+  try {
+    const obj = JSON.parse(trimmed)
+    if (!obj || typeof obj !== 'object' || !obj.mode) return { mode: 'echo' }
+    return obj
+  } catch {
+    return { mode: 'echo' }
+  }
+}
+
+/**
+ * @param {number | undefined} v
+ * @param {number} fallback
+ */
+function clampPositive (v, fallback) {
+  if (typeof v !== 'number' || !Number.isFinite(v) || v < 0) return fallback
+  return Math.floor(v)
+}
+
+/** Cheap token estimate — 4 chars/token, deterministic across runs. */
+function approxTokens (text) {
+  return Math.max(1, Math.ceil((text?.length ?? 0) / 4))
+}
+
+/**
+ * @param {number} ms
+ * @param {AbortSignal} [signal]
+ */
+function sleep (ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms)
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        clearTimeout(timer)
+        resolve()
+      }, { once: true })
+    }
+  })
+}
+
+/** @param {AbortSignal} [signal] */
+function waitForAbort (signal) {
+  if (!signal) return new Promise(() => {}) // never resolves — caller had better set a timeout
+  if (signal.aborted) return Promise.resolve()
+  return new Promise((resolve) => {
+    signal.addEventListener('abort', () => resolve(), { once: true })
+  })
+}
+
+/**
+ * @param {{
+ *   status: string,
+ *   output: string | null,
+ *   start: string,
+ *   first: string | null,
+ *   tokens: number,
+ *   warning?: string,
+ *   toolCalls?: any[]
+ * }} opts
+ * @returns {import('#core/events.js').DoneEvent}
+ */
+function doneEvent (opts) {
+  const end = String(process.hrtime.bigint())
+  const result = {
+    status: opts.status,
+    output: opts.output,
+    inputTokens: opts.tokens,
+    outputTokens: opts.tokens,
+    thinkingTokens: 0,
+    cost: 0,
+    timestamps: { start: opts.start, first: opts.first ?? end, end }
+  }
+  if (opts.warning) result.warning = opts.warning
+  if (opts.toolCalls) result.toolCalls = opts.toolCalls
+  return { type: 'done', result }
+}

package/js/session/adapters/fireworks.js

@@ -0,0 +1,46 @@
+/**
+ * Fireworks adapter — OpenAI-compatible chat completions with
+ * streaming, over api.fireworks.ai/inference/v1.
+ *
+ * Fireworks model IDs carry an `accounts/fireworks/models/` prefix;
+ * envelopes can supply either form. The `mutateArgs` hook normalizes
+ * `args.model` before the request leaves the adapter.
+ *
+ * Implementation uses the OpenAI SDK with a custom baseURL — the
+ * wire shape is identical and the SDK's streaming iterator matches
+ * what `_chat_completions.js` expects.
+ *
+ * @module session/adapters/fireworks
+ */
+
+import OpenAI from 'openai'
+
+import { runChatCompletions } from './_chat_completions.js'
+
+const BASE_URL = 'https://api.fireworks.ai/inference/v1'
+const MODEL_PREFIX = 'accounts/fireworks/models/'
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {{client?: any, signal?: AbortSignal, log?: any, span?: any}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * fireworks (envelope, deps = {}) {
+  const client = deps.client ?? new OpenAI({
+    apiKey: envelope.auth.key,
+    baseURL: envelope.auth.baseURL || BASE_URL
+  })
+  yield * runChatCompletions(envelope, client, {
+    provider: 'fireworks',
+    stream: true,
+    mutateArgs: (env, args) => {
+      if (!args.model.includes('/')) {
+        args.model = `${MODEL_PREFIX}${args.model}`
+      }
+    }
+  }, {
+    signal: deps.signal,
+    log: deps.log,
+    span: deps.span
+  })
+}