@jedylicong/dsh-xinlab 0.0.0-stage → 0.2.2

package/src/runtime.mjs

@@ -0,0 +1,99 @@
+import z from '@deepseek-ai/schemastery'
+import { readFileSync } from 'node:fs'
+import { LlmAdapter } from '@deepseek-ai/dsh-llm'
+import { rejectEmbeddedCredentials } from './catalog.mjs'
+import { assertModelSettings, modelKeyRef, modelProfile, PROTOCOLS } from './model-settings.mjs'
+import { officialAdapter } from './official-adapter.mjs'
+import { ModelKeyPreviews } from './key-preview.mjs'
+import { keyPreviewDescriptor } from './key-preview-protocol.mjs'
+
+export const name = 'xinlab-providers'
+export const inject = ['llm', 'credentials']
+export const Config = z.object({
+  // Deployment-owned catalog is deliberately not volatile: the page edits only
+  // protocol choices. Secrets have no slot in this configuration schema.
+  providers: z.any().required(),
+  protocols: z.dict(z.dict(z.union(PROTOCOLS))).default({}).volatile(),
+})
+
+export class ModelSettingsAdapter extends LlmAdapter {
+  constructor(ctx, providers, protocols) {
+    super()
+    this.ctx = ctx
+    this.providers = structuredClone(providers)
+    this.protocols = protocols
+    this.base = officialAdapter(ctx, this.providers)
+    this.models = new Map()
+  }
+
+  delegate(provider, model) {
+    const profile = this.providers[provider]
+    if (!profile?.models?.some((item) => item.id === model)) throw new Error('未知供应商或模型。')
+    const protocol = this.protocols()[provider]?.[model] ?? profile.api
+    const id = JSON.stringify([provider, model])
+    let current = this.models.get(id)
+    if (!current || current.protocol !== protocol) {
+      const selected = modelProfile(profile, model, protocol)
+      const ref = modelKeyRef(provider, model)
+      const baseRef = selected.apiKeyEnv
+      selected.apiKeyEnv = ref
+      const next = { ...officialAdapter(this.ctx, { [provider]: selected }, { ref, baseRef }), protocol }
+      this.models.set(id, next)
+      // Prepared calls retain their official adapter snapshot; releasing the
+      // composition's listeners does not mutate that snapshot or its auth seam.
+      current?.dispose()
+      current = next
+    }
+    return current.adapter
+  }
+
+  providerInfo(provider) { return this.base.adapter.providerInfo(provider) }
+  providerRetryPolicy(provider) { return this.base.adapter.providerRetryPolicy(provider) }
+  imageRequestPricing(provider, model) { return this.delegate(provider, model).imageRequestPricing(provider, model) }
+  imageRequestTarget(provider, model, image) { return this.delegate(provider, model).imageRequestTarget(provider, model, image) }
+  async listModels(provider) {
+    const delegates = (this.providers[provider]?.models ?? []).map((model) => this.delegate(provider, model.id))
+    const result = []
+    // Bound concurrency on small management nodes and credential file stores.
+    for (const adapter of delegates) result.push(...await adapter.listModels(provider))
+    return result
+  }
+  resolveModel(provider, model, signal) { return this.delegate(provider, model).resolveModel(provider, model, signal) }
+  prepareCall(provider, model, signal) { return this.delegate(provider, model).prepareCall(provider, model, signal) }
+  stream(options) { return this.delegate(options.provider, options.model).stream(options) }
+  async dispose() {
+    await this.base.dispose()
+    for (const entry of this.models.values()) await entry.dispose()
+    this.models.clear()
+  }
+}
+
+export function apply(ctx, config) {
+  rejectEmbeddedCredentials(config.providers)
+  assertModelSettings(config.providers, config.protocols.get())
+  const adapter = new ModelSettingsAdapter(ctx, config.providers, () => config.protocols.get())
+  // Validate every saved protocol before persistence, including protocol-specific
+  // compatibility. A rejected draft never replaces the working configuration.
+  ctx.on('internal/config', (fiber, read) => {
+    const raw = read()
+    if (fiber !== ctx.fiber) return raw
+    const next = Config(raw)
+    assertModelSettings(config.providers, next.protocols.get())
+    for (const [provider, models] of Object.entries(next.protocols.get())) {
+      for (const [model, protocol] of Object.entries(models)) {
+        const check = officialAdapter(ctx, { [provider]: modelProfile(config.providers[provider], model, protocol) })
+        check.dispose()
+      }
+    }
+    return raw
+  })
+  ctx.llm.registerAdapter(Object.keys(config.providers), adapter)
+  ctx.inject(['typert'], (child) => {
+    new ModelKeyPreviews(child, config.providers)
+    const packageName = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).name
+    child.effect(() => child.typert.register({ package: packageName, face: 'host', schemas: [],
+      model: { services: [], events: [], objects: [] }, invocations: [keyPreviewDescriptor(packageName)] }))
+  })
+  ctx.inject(['settings'], (child) => child.effect(() => child.settings.configure({ auto: false }, ctx.fiber)))
+  ctx.effect(() => () => adapter.dispose())
+}

package/src/state.mjs

@@ -0,0 +1,40 @@
+import { randomBytes } from 'node:crypto'
+import { closeSync, constants, fchmodSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, writeFileSync } from 'node:fs'
+import { isAbsolute, join } from 'node:path'
+
+function privateFile(path, initial, minimumBytes = 0) {
+  let fd
+  try {
+    try {
+      fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600)
+      writeFileSync(fd, initial)
+      fsyncSync(fd)
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error
+      fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW)
+    }
+    const stat = fstatSync(fd)
+    if (!stat.isFile() || stat.size < minimumBytes) throw new Error('vLLM 状态文件类型或长度不正确')
+    if (process.getuid && stat.uid !== process.getuid()) throw new Error('vLLM 状态文件不属于当前运行用户')
+    // Enforce the same file modes as the managed deployment without rotating state.
+    fchmodSync(fd, 0o600)
+  } finally {
+    if (fd !== undefined) closeSync(fd)
+  }
+}
+
+export function ensureUUIDState(directory) {
+  if (typeof directory !== 'string' || !isAbsolute(directory)) throw new Error('vLLM 状态目录必须使用绝对路径')
+  mkdirSync(directory, { recursive: true, mode: 0o700 })
+  const stat = lstatSync(directory)
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('vLLM 状态目录必须是实际目录')
+  if (process.getuid && stat.uid !== process.getuid()) throw new Error('vLLM 状态目录不属于当前运行用户')
+  // Open the directory itself to avoid chmod following a substituted leaf symlink.
+  const fd = openSync(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW)
+  try { fchmodSync(fd, 0o700) } finally { closeSync(fd) }
+  const keyFile = join(directory, 'key')
+  const warmFile = join(directory, 'warm-uuids')
+  privateFile(keyFile, randomBytes(32), 32)
+  privateFile(warmFile, '')
+  return { keyFile, warmFile }
+}

package/src/vllm-mm-uuid.mjs

@@ -0,0 +1,14 @@
+import { apply as applyManagedUUID } from '../vendor/vllm-mm-uuid.mjs'
+import { ensureUUIDState } from './state.mjs'
+
+export const name = 'xinlab-vllm-mm-uuid'
+export const inject = ['llm', 'attachments']
+
+export function apply(ctx, config) {
+  const endpoint = new URL(config.endpoint)
+  if (!['http:', 'https:'].includes(endpoint.protocol) || !endpoint.pathname.endsWith('/chat/completions')) {
+    throw new Error('vLLM UUID 插件需要准确的 Chat Completions 地址')
+  }
+  const files = ensureUUIDState(config.stateDir)
+  applyManagedUUID(ctx, { ...files, endpoint: endpoint.href, providers: ['vllm'] })
+}

package/vendor/vllm-mm-uuid.mjs

@@ -0,0 +1,239 @@
+import { createHmac } from 'node:crypto'
+import { appendFileSync, readFileSync } from 'node:fs'
+
+const CACHE_MISS = /Cache miss for image at index \d+ but data is not provided\./
+const DATA_IMAGE = /^data:image\/(?:png|jpeg|webp|gif);base64,/
+const ATTACHMENT_FAILURES = new Set([
+  'ATTACHMENT_NOT_FOUND',
+  'ATTACHMENT_CORRUPT',
+  'ATTACHMENT_READ_FAILED',
+])
+const RECOVERY = Symbol('vllm-mm-uuid-recovery')
+const PLACEHOLDER = '[historical image unavailable in the local attachment store]'
+
+export const name = 'vllm-mm-uuid'
+export const inject = ['llm', 'attachments']
+
+function stableUuid(key, dataUrl) {
+  const bytes = createHmac('sha256', key).update(dataUrl).digest().subarray(0, 16)
+  bytes[6] = (bytes[6] & 0x0f) | 0x40
+  bytes[8] = (bytes[8] & 0x3f) | 0x80
+  const hex = bytes.toString('hex')
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+}
+
+function visitImageParts(raw, projected, key, seen, uuids) {
+  if (Array.isArray(raw)) {
+    for (let index = 0; index < raw.length; index += 1) {
+      visitImageParts(raw[index], projected[index], key, seen, uuids)
+    }
+    return
+  }
+  if (!raw || typeof raw !== 'object') return
+
+  const url = raw.type === 'image_url' && raw.image_url && typeof raw.image_url.url === 'string'
+    ? raw.image_url.url
+    : undefined
+  if (url && DATA_IMAGE.test(url)) {
+    const uuid = stableUuid(key, url)
+    raw.uuid = uuid
+    projected.uuid = uuid
+    if (seen.has(uuid)) projected.image_url = null
+    uuids.add(uuid)
+    return
+  }
+
+  for (const field of Object.keys(raw)) {
+    if (projected[field] !== undefined) visitImageParts(raw[field], projected[field], key, seen, uuids)
+  }
+}
+
+export function preparePayload(text, key, seen) {
+  const raw = JSON.parse(text)
+  const projected = structuredClone(raw)
+  const uuids = new Set()
+  visitImageParts(raw, projected, key, seen, uuids)
+  if (uuids.size === 0) return undefined
+  return {
+    projected: JSON.stringify(projected),
+    raw: JSON.stringify(raw),
+    uuids: [...uuids],
+  }
+}
+
+function requestUrl(input) {
+  return typeof input === 'string' || input instanceof URL ? String(input) : input.url
+}
+
+async function requestBody(input, init) {
+  if (typeof init?.body === 'string') return init.body
+  if (input instanceof Request) return input.clone().text()
+  return undefined
+}
+
+function withBody(input, init, body) {
+  const headers = new Headers(input instanceof Request ? input.headers : init?.headers)
+  headers.delete('content-length')
+  if (input instanceof Request) return [new Request(input, { body, headers }), undefined]
+  return [input, { ...init, body, headers }]
+}
+
+async function isUuidCacheMiss(response) {
+  if (response.status !== 400) return false
+  return CACHE_MISS.test(await response.clone().text())
+}
+
+export function createFetchWrapper(nativeFetch, { endpoint, key, seen, remember }) {
+  const expected = new URL(endpoint).href
+  return async function vllmUuidFetch(input, init) {
+    if (new URL(requestUrl(input)).href !== expected) return nativeFetch(input, init)
+
+    const text = await requestBody(input, init)
+    if (text === undefined) return nativeFetch(input, init)
+
+    let payload
+    try {
+      payload = preparePayload(text, key, seen)
+    } catch {
+      return nativeFetch(input, init)
+    }
+    if (payload === undefined) return nativeFetch(input, init)
+
+    let request = withBody(input, init, payload.projected)
+    let response = await nativeFetch(...request)
+    if (await isUuidCacheMiss(response)) {
+      request = withBody(input, init, payload.raw)
+      response = await nativeFetch(...request)
+    }
+    if (response.ok) remember(payload.uuids)
+    return response
+  }
+}
+
+function replaceMissingBlocks(blocks, missing) {
+  return blocks.map((block) => {
+    if (block.type === 'image' && missing.has(String(block.attachment.attachmentId))) {
+      return { type: 'text', text: PLACEHOLDER }
+    }
+    if (block.type === 'tool-result') return { ...block, content: replaceMissingBlocks(block.content, missing) }
+    return block
+  })
+}
+
+export function projectMissingMessages(messages, missing) {
+  return messages.map((message) => ({ ...message, content: replaceMissingBlocks(message.content, missing) }))
+}
+
+function collectImageRefs(blocks, refs) {
+  for (const block of blocks) {
+    if (block.type === 'image') refs.set(String(block.attachment.attachmentId), block.attachment)
+    if (block.type === 'tool-result') collectImageRefs(block.content, refs)
+  }
+}
+
+async function unavailableAttachments(ctx, options) {
+  const refs = new Map()
+  for (const message of options.messages) collectImageRefs(message.content, refs)
+  const missing = new Set()
+  await Promise.all([...refs].map(async ([id, ref]) => {
+    try {
+      await ctx.attachments.readImage(ref, options.signal)
+    } catch (error) {
+      if (options.signal?.aborted) throw error
+      missing.add(id)
+    }
+  }))
+  return missing
+}
+
+function attachmentFailure(chunk) {
+  return chunk.type === 'finish'
+    && chunk.reason.kind === 'error'
+    && ATTACHMENT_FAILURES.has(chunk.reason.failure.code)
+}
+
+function retryStream(ctx, options, messages) {
+  const retry = { ...options, messages }
+  Object.defineProperty(retry, RECOVERY, { value: true })
+  return ctx.llm.stream(retry)
+}
+
+function recoverAttachmentFailures(ctx, options, next, knownMissing) {
+  return (async function* () {
+    const alreadyMissing = new Set()
+    for (const message of options.messages) {
+      const refs = new Map()
+      collectImageRefs(message.content, refs)
+      for (const id of refs.keys()) if (knownMissing.has(id)) alreadyMissing.add(id)
+    }
+    if (alreadyMissing.size > 0) {
+      yield* retryStream(ctx, options, projectMissingMessages(options.messages, alreadyMissing))
+      return
+    }
+
+    let emitted = false
+    for await (const chunk of next()) {
+      if (!emitted && attachmentFailure(chunk)) {
+        const missing = await unavailableAttachments(ctx, options)
+        for (const id of missing) knownMissing.add(id)
+        yield* retryStream(
+          ctx,
+          options,
+          missing.size === 0 ? options.messages : projectMissingMessages(options.messages, missing),
+        )
+        return
+      }
+      emitted = true
+      yield chunk
+    }
+  })()
+}
+
+function readState(config) {
+  const key = readFileSync(config.keyFile)
+  if (key.length < 32) throw new Error('vllm-mm-uuid: keyFile must contain at least 32 bytes')
+  const seen = new Set()
+  try {
+    for (const line of readFileSync(config.warmFile, 'utf8').split('\n')) if (line) seen.add(line)
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
+  return { key, seen }
+}
+
+export function apply(ctx, config) {
+  if (!config || typeof config.endpoint !== 'string' || !config.endpoint) {
+    throw new Error('vllm-mm-uuid: endpoint is required')
+  }
+  if (typeof config.keyFile !== 'string' || typeof config.warmFile !== 'string') {
+    throw new Error('vllm-mm-uuid: keyFile and warmFile are required')
+  }
+  const providers = new Set(config.providers ?? ['vllm'])
+  const { key, seen } = readState(config)
+  const knownMissing = new Set()
+  const remember = (uuids) => {
+    const added = uuids.filter((uuid) => !seen.has(uuid))
+    if (added.length === 0) return
+    for (const uuid of added) seen.add(uuid)
+    appendFileSync(config.warmFile, `${added.join('\n')}\n`, { mode: 0o600 })
+  }
+
+  ctx.effect(() => {
+    const nativeFetch = globalThis.fetch
+    const wrapped = createFetchWrapper(nativeFetch, {
+      endpoint: config.endpoint,
+      key,
+      seen,
+      remember,
+    })
+    globalThis.fetch = wrapped
+    return () => {
+      if (globalThis.fetch === wrapped) globalThis.fetch = nativeFetch
+    }
+  }, 'vllm-mm-uuid: fetch wrapper')
+
+  ctx.on('llm/stream', (options, next) => {
+    if (!providers.has(options.provider) || options[RECOVERY]) return next()
+    return recoverAttachmentFailures(ctx, options, next, knownMissing)
+  })
+}

package/vendor/vllm-reasoning-only-retry.mjs

@@ -0,0 +1,41 @@
+const EMPTY_RESPONSE = {
+  message: 'vllm returned reasoning without text or tool calls',
+  code: 'EMPTY_RESPONSE',
+}
+
+export const name = 'vllm-reasoning-only-retry'
+export const inject = ['llm']
+
+function hasText(value) {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+export async function* classifyReasoningOnly(stream) {
+  let reasoning = false
+  let output = false
+
+  for await (const chunk of stream) {
+    if (chunk.type === 'reasoning-delta' && hasText(chunk.text)) reasoning = true
+    if (chunk.type === 'text-delta' && hasText(chunk.text)) output = true
+    if (chunk.type === 'tool-call-delta') output = true
+    if (chunk.type === 'block-start' && chunk.blockType === 'tool-call') output = true
+    if (chunk.type === 'block-end') {
+      if (chunk.block.type === 'reasoning' && hasText(chunk.block.text)) reasoning = true
+      if (chunk.block.type === 'text' && hasText(chunk.block.text)) output = true
+      if (chunk.block.type === 'tool-call') output = true
+    }
+
+    if (chunk.type === 'finish' && chunk.reason.kind === 'stop' && reasoning && !output) {
+      yield { ...chunk, reason: { kind: 'error', failure: EMPTY_RESPONSE } }
+    } else {
+      yield chunk
+    }
+  }
+}
+
+export function apply(ctx) {
+  ctx.on('llm/stream', (options, next) => {
+    if (options.provider !== 'vllm') return next()
+    return classifyReasoningOnly(next())
+  })
+}