mohdel 0.90.0

package/js/session/adapters/gemini.js

@@ -0,0 +1,381 @@
+/**
+ * Google Gemini (`@google/genai`) adapter.
+ *
+ * Scope:
+ *   - Text in, text out, streaming
+ *   - Status contract (incomplete + warning on MAX_TOKENS)
+ *   - Tools: unified format → Gemini FunctionDeclaration; functionCall
+ *     parts collected per chunk; tool_use terminal state;
+ *     functionResponse parts on the way back in
+ *   - Images (inlineData for base64 / data URIs, fileData for https://)
+ *   - Videos (inline ≤20MB, upload + poll for larger or when
+ *     `cache: true`, content-hashed cache at `~/.cache/mohdel/uploaded-files.json`)
+ *   - AbortSignal forwarded to SDK
+ *
+ * @module session/adapters/gemini
+ */
+
+import { GoogleGenAI } from '@google/genai'
+
+import {
+  STATUS_COMPLETED,
+  STATUS_INCOMPLETE,
+  STATUS_TOOL_USE,
+  WARNING_INSUFFICIENT_OUTPUT_BUDGET
+} from '#core/status.js'
+
+import { cancelledDone } from './_cancelled.js'
+import { getSpec } from './_catalog.js'
+import { classifyProviderError } from './_errors.js'
+import { loadImages } from './_images.js'
+import { loadVideos } from './_videos.js'
+import { costFor } from './_pricing.js'
+import {
+  toGeminiTools,
+  fromGeminiToolCalls,
+  toToolChoice
+} from './_tools.js'
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {{client?: GoogleGenAI, signal?: AbortSignal, log?: any, span?: any}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * gemini (envelope, deps = {}) {
+  const client = deps.client ?? new GoogleGenAI({ apiKey: envelope.auth.key })
+  const signal = deps.signal
+  const log = deps.log
+  const start = String(process.hrtime.bigint())
+  let first = null
+
+  const { systemInstruction, contents } = buildContents(envelope.prompt)
+
+  if (envelope.images?.length) {
+    try {
+      const loaded = await loadImages(envelope.images)
+      const parts = loaded.map(toGeminiImagePart).filter(Boolean)
+      if (parts.length) injectParts(contents, parts)
+    } catch (e) {
+      log?.warn({ err: e }, '[mohdel:gemini] image load failed')
+      yield { type: 'error', error: classifyProviderError(e) }
+      return
+    }
+  }
+
+  if (envelope.videos?.length) {
+    try {
+      const parts = await loadVideos(envelope.videos, {
+        client,
+        useCache: !!envelope.cache,
+        signal
+      })
+      if (parts.length) injectParts(contents, parts)
+    } catch (e) {
+      if (signal?.aborted) {
+        yield cancelledDone(start, first, envelope, '', 0, 0)
+        return
+      }
+      log?.warn({ err: e }, '[mohdel:gemini] video load failed')
+      // `typed` lets _videos.js surface PROVIDER_UNAVAILABLE on
+      // upload-deadline timeouts; fall back to generic classification.
+      const typed = /** @type {any} */(e).typed
+      yield { type: 'error', error: typed || classifyProviderError(e) }
+      return
+    }
+  }
+
+  const request = buildRequest(envelope, contents, systemInstruction)
+
+  // The Google `@google/genai` SDK reads abortSignal exclusively
+  // from `params.config.abortSignal` — a second-arg `{signal}` is
+  // dropped (verified against the compiled SDK at
+  // node_modules/@google/genai/dist/index.cjs). Merge into config
+  // so cancellation actually tears down the HTTPS request, not just
+  // the local loop.
+  if (signal) {
+    request.config = { ...(request.config ?? {}), abortSignal: signal }
+  }
+
+  // F53: accumulate via array + join to avoid per-delta V8 cons-string
+  // churn. Materialized at each exit point.
+  const outputParts = []
+  const currentOutput = () => outputParts.join('')
+  let inputTokens = 0
+  let outputTokens = 0
+  let thinkingTokens = 0
+  let status = STATUS_COMPLETED
+  /** @type {string | undefined} */
+  let warning
+  /** @type {Array<{name: string, args: any}>} */
+  const collectedFunctionCalls = []
+
+  try {
+    const stream = await client.models.generateContentStream(request)
+
+    for await (const chunk of stream) {
+      if (signal?.aborted) {
+        yield cancelledDone(start, first, envelope, currentOutput(), inputTokens, outputTokens)
+        return
+      }
+
+      for (const part of chunk?.candidates?.[0]?.content?.parts ?? []) {
+        if (typeof part.text === 'string' && part.text.length > 0) {
+          if (first === null) first = String(process.hrtime.bigint())
+          outputParts.push(part.text)
+          yield { type: 'delta', delta: { type: 'message', delta: part.text } }
+        } else if (part.functionCall) {
+          if (first === null) first = String(process.hrtime.bigint())
+          // `thoughtSignature` is sibling to `functionCall` on the part.
+          // Hoist it onto the collected object so `fromGeminiToolCalls`
+          // can propagate it through to the unified toolCalls shape,
+          // and any replay of this assistant turn puts the signature
+          // back on the outgoing part (required for gemini to accept
+          // a prior tool call on the next turn).
+          collectedFunctionCalls.push(
+            part.thoughtSignature
+              ? { ...part.functionCall, thoughtSignature: part.thoughtSignature }
+              : part.functionCall
+          )
+          // Gemini sends complete functionCall parts (not streamed args).
+          // Emit a single function_call delta with the serialized args
+          // so consumers that watch for delta chunks see something.
+          const delta = JSON.stringify(part.functionCall.args ?? {})
+          yield {
+            type: 'delta',
+            delta: { type: 'function_call', delta }
+          }
+        }
+      }
+
+      const finish = chunk?.candidates?.[0]?.finishReason
+      if (finish && isIncompleteFinish(finish)) {
+        status = STATUS_INCOMPLETE
+        if (finish === 'MAX_TOKENS') warning = WARNING_INSUFFICIENT_OUTPUT_BUDGET
+      }
+
+      if (chunk?.usageMetadata) {
+        if (typeof chunk.usageMetadata.promptTokenCount === 'number') {
+          inputTokens = chunk.usageMetadata.promptTokenCount
+        }
+        if (typeof chunk.usageMetadata.candidatesTokenCount === 'number') {
+          outputTokens = chunk.usageMetadata.candidatesTokenCount
+        }
+        if (typeof chunk.usageMetadata.thoughtsTokenCount === 'number') {
+          thinkingTokens = chunk.usageMetadata.thoughtsTokenCount
+        }
+      }
+    }
+  } catch (e) {
+    if (signal?.aborted) {
+      yield cancelledDone(start, first, envelope, currentOutput(), inputTokens, outputTokens)
+      return
+    }
+    log?.warn({ err: e }, '[mohdel:gemini] stream failed')
+    yield { type: 'error', error: classifyProviderError(e) }
+    return
+  }
+
+  if (signal?.aborted) {
+    yield cancelledDone(start, first, envelope, currentOutput(), inputTokens, outputTokens)
+    return
+  }
+
+  if (collectedFunctionCalls.length > 0 && status === STATUS_COMPLETED) {
+    status = STATUS_TOOL_USE
+  }
+
+  const end = String(process.hrtime.bigint())
+  /** @type {import('#core/events.js').DoneEvent} */
+  const done = {
+    type: 'done',
+    result: {
+      status,
+      output: currentOutput() || null,
+      inputTokens,
+      outputTokens,
+      thinkingTokens,
+      cost: costFor(
+        `${envelope.provider}/${envelope.model}`,
+        { inputTokens, outputTokens, thinkingTokens }
+      ),
+      timestamps: { start, first: first ?? end, end }
+    }
+  }
+  if (warning) done.result.warning = warning
+  if (collectedFunctionCalls.length > 0) {
+    done.result.toolCalls = fromGeminiToolCalls(collectedFunctionCalls)
+  }
+  yield done
+}
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {Array<{role: string, parts: any[]}>} contents
+ * @param {string} systemInstruction
+ */
+function buildRequest (envelope, contents, systemInstruction) {
+  const spec = getSpec(`${envelope.provider}/${envelope.model}`)
+
+  /** @type {Record<string, any>} */
+  const config = {}
+  if (systemInstruction) config.systemInstruction = systemInstruction
+  if (envelope.outputBudget !== undefined) config.maxOutputTokens = envelope.outputBudget
+  if (envelope.tools?.length) {
+    config.tools = toGeminiTools(envelope.tools)
+    if (envelope.toolChoice) {
+      config.toolConfig = toToolChoice('gemini', envelope.toolChoice)
+    }
+  }
+
+  // Thinking — model-family-dependent shape:
+  //   - gemini-3.x: thinkingConfig = { includeThoughts: true, thinkingLevel: <name> }
+  //   - gemini-2.x: thinkingConfig = { thinkingBudget: <number> }
+  //   - other (e.g. gemini-1.5): thinkingBudget with maxOutputTokens
+  //     adjustment for headroom
+  const effort = envelope.outputEffort ?? spec?.defaultThinkingEffort
+  if (spec?.thinkingEffortLevels && effort && effort !== 'none') {
+    const budget = spec.thinkingEffortLevels[effort]
+    if (/^gemini-3/.test(envelope.model)) {
+      config.thinkingConfig = { includeThoughts: true, thinkingLevel: effort }
+    } else if (/gemini-2/.test(envelope.model)) {
+      if (typeof budget === 'number') {
+        config.thinkingConfig = { thinkingBudget: budget }
+      }
+    } else {
+      if (typeof budget === 'number') {
+        config.thinkingConfig = { thinkingBudget: budget }
+        if (config.maxOutputTokens && budget > 0) {
+          config.maxOutputTokens += budget
+        }
+      }
+    }
+  }
+
+  /** @type {Record<string, any>} */
+  const request = {
+    model: envelope.model,
+    contents
+  }
+  if (Object.keys(config).length > 0) request.config = config
+  return request
+}
+
+/** @param {string | import('#core/envelope.js').Message[]} prompt */
+function buildContents (prompt) {
+  if (typeof prompt === 'string') {
+    return {
+      systemInstruction: '',
+      contents: [{ role: 'user', parts: [{ text: prompt }] }]
+    }
+  }
+  /** @type {string[]} */
+  const systemParts = []
+  /** @type {Array<{role: string, parts: any[]}>} */
+  const contents = []
+  for (const m of prompt) {
+    if (m.role === 'system') {
+      systemParts.push(flattenText(m.content))
+    } else if (m.role === 'tool') {
+      contents.push({
+        role: 'user',
+        parts: [{
+          functionResponse: {
+            name: m.toolName ?? '',
+            response: safeParseToolResult(m.content)
+          }
+        }]
+      })
+    } else if (m.role === 'assistant' && m.toolCalls?.length) {
+      // Gemini expects a single `model` turn carrying both text and
+      // functionCall parts. When replaying a prior assistant turn, the
+      // `thoughtSignature` attached to each tool call by gemini on the
+      // original response must ride back into the part — without it,
+      // the next call is rejected as a hand-constructed history.
+      const parts = []
+      const text = flattenText(m.content)
+      if (text) parts.push({ text })
+      for (const tc of m.toolCalls) {
+        const part = {
+          functionCall: { name: tc.name, args: tc.arguments ?? {} }
+        }
+        if (tc.thoughtSignature) part.thoughtSignature = tc.thoughtSignature
+        parts.push(part)
+      }
+      contents.push({ role: 'model', parts })
+    } else {
+      contents.push({
+        role: mapRole(m.role),
+        parts: toGeminiParts(m.content)
+      })
+    }
+  }
+  return {
+    systemInstruction: systemParts.filter(Boolean).join('\n\n'),
+    contents
+  }
+}
+
+/** @param {string | import('#core/envelope.js').MessagePart[]} content */
+function safeParseToolResult (content) {
+  const text = flattenText(content)
+  try { return JSON.parse(text) } catch { return { result: text } }
+}
+
+/** @param {string} role */
+function mapRole (role) {
+  if (role === 'assistant') return 'model'
+  return role
+}
+
+/** @param {string | import('#core/envelope.js').MessagePart[]} content */
+function flattenText (content) {
+  if (typeof content === 'string') return content
+  return content.filter(p => p.type === 'text' && p.text).map(p => p.text).join('\n')
+}
+
+/** @param {string | import('#core/envelope.js').MessagePart[]} content */
+function toGeminiParts (content) {
+  if (typeof content === 'string') return [{ text: content }]
+  return content.map(p => {
+    if (p.type === 'text') return { text: p.text ?? '' }
+    throw new Error(`unsupported content part type: ${p.type}`)
+  })
+}
+
+/** @param {import('./_images.js').LoadedImage} img */
+function toGeminiImagePart (img) {
+  if (img.base64) {
+    return { inlineData: { mimeType: img.mimeType, data: img.base64 } }
+  }
+  if (img.url) {
+    return { fileData: { mimeType: img.mimeType, fileUri: img.url } }
+  }
+  return null
+}
+
+/**
+ * Append media parts to the LAST user message in `contents`. Used
+ * for both images and videos — Gemini's `parts` array is homogeneous
+ * so the injection logic doesn't care which media type.
+ *
+ * @param {Array<{role: string, parts: any[]}>} contents
+ * @param {Array<any>} parts
+ */
+function injectParts (contents, parts) {
+  for (let i = contents.length - 1; i >= 0; i--) {
+    if (contents[i].role !== 'user') continue
+    contents[i].parts = [...contents[i].parts, ...parts]
+    return
+  }
+  contents.push({ role: 'user', parts })
+}
+
+/** @param {string} reason */
+function isIncompleteFinish (reason) {
+  return reason === 'MAX_TOKENS' ||
+    reason === 'SAFETY' ||
+    reason === 'RECITATION' ||
+    reason === 'BLOCKLIST' ||
+    reason === 'PROHIBITED_CONTENT' ||
+    reason === 'SPII'
+}

package/js/session/adapters/groq.js

@@ -0,0 +1,23 @@
+/**
+ * Groq adapter — OpenAI-compatible chat completions, non-streaming.
+ *
+ * @module session/adapters/groq
+ */
+
+import Groq from 'groq-sdk'
+
+import { runChatCompletions } from './_chat_completions.js'
+
+/**
+ * @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 * groq (envelope, deps = {}) {
+  const client = deps.client ?? new Groq({ apiKey: envelope.auth.key })
+  yield * runChatCompletions(envelope, client, { provider: 'groq' }, {
+    signal: deps.signal,
+    log: deps.log,
+    span: deps.span
+  })
+}

package/js/session/adapters/image/fake.js

@@ -0,0 +1,55 @@
+/**
+ * Fake image adapter — scenario-driven for tests, benchmarks, and
+ * bug reproductions. Never calls a real API.
+ *
+ * Mirrors the `fake` answer adapter shape: the envelope's `prompt`
+ * carries a JSON scenario spec; the `mode` key picks a behavior.
+ * Invalid / non-JSON prompts fall through to `mode: "ok"`.
+ *
+ * ## Modes
+ *
+ * | mode    | params                    | behavior                                    |
+ * |---------|---------------------------|---------------------------------------------|
+ * | `ok`    | `count?` (default 1)      | returns `count` placeholder image URLs      |
+ * | `error` | `type`, `message`         | throws a tagged error                       |
+ *
+ * @module session/adapters/image/fake
+ */
+
+/**
+ * @param {import('#core/image.js').ImageEnvelope} envelope
+ * @returns {Promise<import('#core/image.js').ImageResult>}
+ */
+export async function fakeImage (envelope) {
+  const scenario = parseScenario(envelope.prompt)
+  const mode = scenario.mode ?? 'ok'
+
+  if (mode === 'error') {
+    const err = new Error(scenario.message || 'fake image error')
+    err.typed = {
+      message: scenario.message || 'fake image error',
+      severity: 'error',
+      retryable: !!scenario.retryable,
+      type: scenario.type || 'PROVIDER_ERROR'
+    }
+    throw err
+  }
+
+  const count = Math.max(1, Number(scenario.count) || 1)
+  const now = `${process.hrtime.bigint()}`
+  return {
+    status: 'completed',
+    images: Array.from({ length: count }, (_, i) => ({
+      mimeType: 'image/png',
+      url: `https://fake.example/img-${envelope.callId}-${i}.png`
+    })),
+    seed: envelope.seed ?? null,
+    timestamps: { start: now, first: now, end: now }
+  }
+}
+
+/** @param {unknown} prompt */
+function parseScenario (prompt) {
+  if (typeof prompt !== 'string') return {}
+  try { return JSON.parse(prompt) || {} } catch { return {} }
+}

package/js/session/adapters/image/index.js

@@ -0,0 +1,40 @@
+/**
+ * Image-adapter registry. Mirrors session/adapters/index.js but
+ * scoped to image-generation providers.
+ *
+ * @module session/adapters/image
+ */
+
+import { openaiImage } from './openai.js'
+import { novitaImage } from './novita.js'
+import { fakeImage } from './fake.js'
+
+const IMAGE_ADAPTERS = {
+  openai: openaiImage,
+  novita: novitaImage,
+  fake: fakeImage
+}
+
+/**
+ * @param {string} provider
+ * @returns {(
+ *   env: import('#core/image.js').ImageEnvelope,
+ *   deps?: any
+ * ) => Promise<import('#core/image.js').ImageResult>}
+ */
+export function getImageAdapter (provider) {
+  const adapter = IMAGE_ADAPTERS[provider]
+  if (!adapter) throw new Error(`no image adapter for provider: ${provider}`)
+  return adapter
+}
+
+/**
+ * Whether the provider has an image adapter registered. Used by
+ * `run.js` to distinguish "wrong call path" (image-only provider
+ * invoked via answer) from "truly unknown provider".
+ *
+ * @param {string} provider
+ */
+export function isImageProvider (provider) {
+  return Object.prototype.hasOwnProperty.call(IMAGE_ADAPTERS, provider)
+}

package/js/session/adapters/image/novita.js

@@ -0,0 +1,135 @@
+/**
+ * Novita image adapter.
+ *
+ * Async two-step: submit generation task, poll for completion.
+ *
+ * `spec.imageEndpoint` on the curated entry selects the route
+ * (e.g. `txt2img`, `flux-dev`). `fetch` and `sleep` are injectable
+ * for testability.
+ *
+ * @module session/adapters/image/novita
+ */
+
+import { getSpec } from '../_catalog.js'
+import { classifyProviderError } from '../_errors.js'
+
+const BASE_URL = 'https://api.novita.ai'
+const NOVITA_TASK_POLL_INTERVAL_MS = 1000
+const MAX_POLL_MS = 120_000
+
+/**
+ * @param {import('#core/image.js').ImageEnvelope} envelope
+ * @param {{
+ *   fetch?: typeof fetch,
+ *   sleep?: (ms: number) => Promise<void>,
+ *   now?: () => number,
+ *   spec?: any
+ * }} [deps]
+ * @returns {Promise<import('#core/image.js').ImageResult>}
+ */
+export async function novitaImage (envelope, deps = {}) {
+  const fetchFn = deps.fetch ?? globalThis.fetch
+  const sleep = deps.sleep ?? defaultSleep
+  const now = deps.now ?? Date.now
+
+  const spec = deps.spec ?? getSpec(`${envelope.provider}/${envelope.model}`) ?? {}
+  const endpoint = spec.imageEndpoint
+  if (!endpoint) {
+    throw typedError('image endpoint not configured', 'PROVIDER_ERROR', false)
+  }
+
+  const start = String(process.hrtime.bigint())
+  const apiKey = envelope.auth.key
+
+  const body = { prompt: envelope.prompt }
+  const size = envelope.size || spec.imageDefaultSize
+  if (size) body.size = size.replace('x', '*')
+  if (envelope.seed != null) body.seed = envelope.seed
+
+  const submitUrl = `${BASE_URL}/v3/async/${endpoint}`
+  const submit = await post(fetchFn, submitUrl, body, apiKey)
+
+  const result = await pollTaskResult(fetchFn, sleep, now, submit.task_id, apiKey)
+
+  const images = (result.images || []).map(img => ({
+    mimeType: img.image_type ? `image/${img.image_type}` : 'image/png',
+    url: img.image_url || img.url
+  }))
+
+  const end = String(process.hrtime.bigint())
+  return {
+    status: 'completed',
+    images,
+    seed: result.task?.seed ?? null,
+    timestamps: { start, first: end, end }
+  }
+}
+
+/** @param {number} ms */
+function defaultSleep (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+async function post (fetchFn, url, body, apiKey) {
+  let res
+  try {
+    res = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body)
+    })
+  } catch (e) {
+    throw typedError(classifyProviderError(e).message, 'NET_ERROR', true)
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw fromHttpStatus(res.status, 'novita submit failed', text.slice(0, 120))
+  }
+  return res.json()
+}
+
+async function pollTaskResult (fetchFn, sleep, now, taskId, apiKey) {
+  const url = `${BASE_URL}/v3/async/task-result?task_id=${taskId}`
+  const deadline = now() + MAX_POLL_MS
+
+  while (now() < deadline) {
+    const res = await fetchFn(url, { headers: { Authorization: `Bearer ${apiKey}` } })
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw fromHttpStatus(res.status, 'novita poll failed', text.slice(0, 120))
+    }
+    const data = await res.json()
+    const status = data.task?.status
+    if (status === 'TASK_STATUS_SUCCEED') return data
+    if (status === 'TASK_STATUS_FAILED') {
+      throw typedError(
+        'novita image failed',
+        'PROVIDER_ERROR',
+        false,
+        data.task?.reason || 'unknown'
+      )
+    }
+    await sleep(NOVITA_TASK_POLL_INTERVAL_MS)
+  }
+
+  throw typedError('novita image generation timed out', 'PROVIDER_UNAVAILABLE', true)
+}
+
+function fromHttpStatus (status, message, detail) {
+  const typed = classifyProviderError({ status })
+  // Keep the classifier's message (stable/machine-readable); put the
+  // caller's context + any response-body snippet into `detail`. F45:
+  // never echo provider response bodies into `TypedError.message`.
+  return typedError(typed.message, typed.type, typed.retryable, detail ? `${message}: ${detail}` : message)
+}
+
+function typedError (message, type, retryable, detail) {
+  const err = new Error(message)
+  const typed = { message, severity: retryable ? 'warn' : 'error', retryable, type }
+  if (detail) typed.detail = detail
+  err.typed = typed
+  return err
+}

package/js/session/adapters/image/openai.js

@@ -0,0 +1,50 @@
+/**
+ * OpenAI DALL-E image adapter.
+ *
+ * Single-shot generation — no streaming. Returns an `ImageResult`.
+ *
+ * @module session/adapters/image/openai
+ */
+
+import OpenAI from 'openai'
+
+import { getSpec } from '../_catalog.js'
+import { classifyProviderError } from '../_errors.js'
+
+/**
+ * @param {import('#core/image.js').ImageEnvelope} envelope
+ * @param {{client?: OpenAI, spec?: any}} [deps]
+ * @returns {Promise<import('#core/image.js').ImageResult>}
+ */
+export async function openaiImage (envelope, deps = {}) {
+  const client = deps.client ?? new OpenAI({ apiKey: envelope.auth.key })
+  const spec = deps.spec ?? getSpec(`${envelope.provider}/${envelope.model}`) ?? {}
+  const start = String(process.hrtime.bigint())
+
+  const args = { model: envelope.model, prompt: envelope.prompt }
+  const size = envelope.size || spec.imageDefaultSize
+  if (size) args.size = size
+
+  let response
+  try {
+    response = await client.images.generate(args)
+  } catch (e) {
+    throw Object.assign(new Error(classifyProviderError(e).message), {
+      typed: classifyProviderError(e)
+    })
+  }
+
+  const images = (response.data || []).map(img => ({
+    mimeType: 'image/png',
+    url: img.url || undefined,
+    base64: img.b64_json || undefined
+  }))
+
+  const end = String(process.hrtime.bigint())
+  return {
+    status: 'completed',
+    images,
+    seed: null,
+    timestamps: { start, first: end, end }
+  }
+}