@mofeng2223/dsh-claude-provider 0.2.3 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mofeng2223/dsh-claude-provider",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Custom Claude provider support for DeepSeek Harness",
   "author": "mofeng2223",
   "license": "MIT",
@@ -24,7 +24,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@deepseek-ai/dsh-settings": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": "0.1.0-rc.8",
     "@deepseek-ai/schemastery": "3.18.1"
   },
   "exports": {
@@ -48,7 +48,7 @@
     "node": ">=22.19"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-client-ui-settings-models": "0.1.0-rc.7"
+    "@deepseek-ai/dsh-client-ui-settings-models": "0.1.0-rc.8"
   },
   "dsh": {
     "bundle": {

package/src/index.js

@@ -1,4 +1,3 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
 import z from '@deepseek-ai/schemastery'
 import { settingsNamespace } from '@deepseek-ai/dsh-settings'
 
@@ -13,16 +12,6 @@ const ProviderTypeSettings = z.object({
   providerTypes: z.dict(z.const(CLAUDE_PROVIDER_TYPE)).default({}),
 })
 
-const DEFAULT_EFFORT_MAP = Object.freeze({
-  minimal: 'low',
-  low: 'low',
-  medium: 'medium',
-  high: 'high',
-  xhigh: 'xhigh',
-  max: 'max',
-})
-
-const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14'
 export const CLAUDE_DISCOVERY_API = 'mofeng-anthropic-models'
 
 const PI_AI_SETTINGS_NS = 'llm-pi-ai'
@@ -244,265 +233,14 @@ function installClaudeModelDiscovery(ctx) {
   })
 }
 
-function resolveConfig(config = {}) {
-  const effortMap = { ...DEFAULT_EFFORT_MAP, ...config.effortMap }
-  for (const [level, effort] of Object.entries(effortMap)) {
-    requireNonEmptyString(level, 'effortMap key')
-    requireNonEmptyString(effort, `effortMap.${level}`)
-  }
-
-  return { effortMap, debug: config.debug === true }
-}
-
 /** Whether an explicitly registered provider belongs to this plugin's Claude type. */
 export function isClaudeProviderType(settings, provider) {
   if (typeof provider !== 'string' || provider.length === 0) return false
   return settings?.providerTypes?.[provider] === CLAUDE_PROVIDER_TYPE
 }
 
-/** Give typed Claude routes a concrete default and readable labels for toggle-only models. */
-export function withClaudeProviderReasoningDefaults(modelInfo) {
-  const reasoning = modelInfo?.reasoning
-  if (reasoning === undefined || !Array.isArray(reasoning.efforts)) return modelInfo
-  const ids = new Set(reasoning.efforts.map(effort => String(effort.id)))
-  const toggleOnly = ids.size === 2 && ids.has('off') && ids.has('high')
-  return {
-    ...modelInfo,
-    reasoning: {
-      ...reasoning,
-      defaultEffort: 'high',
-      efforts: toggleOnly
-        ? reasoning.efforts.map(effort => ({
-            ...effort,
-            name: effort.id === 'off' ? 'Off' : effort.id === 'high' ? 'On' : effort.name,
-          }))
-        : reasoning.efforts,
-    },
-  }
-}
-
-function installClaudeModelInfoDefaults(ctx, providerTypes) {
-  const llm = ctx.llm
-  const upstream = llm.resolveModelInfo
-  const wrapped = async function (provider, model, signal) {
-    const info = await upstream.call(this, provider, model, signal)
-    return isClaudeProviderType(providerTypes.get(), provider)
-      ? withClaudeProviderReasoningDefaults(info)
-      : info
-  }
-  llm.resolveModelInfo = wrapped
-  ctx.effect(() => () => {
-    if (llm.resolveModelInfo === wrapped) llm.resolveModelInfo = upstream
-  })
-}
-
-/** Four- and five-level model profiles are adaptive; the two-level toggle is legacy budget thinking. */
-export function shouldUseAdaptiveThinking(modelInfo) {
-  const efforts = modelInfo?.reasoning?.efforts
-  if (!Array.isArray(efforts)) return false
-  const ids = new Set(efforts.map(effort => String(effort.id)))
-  return ids.has('low') && ids.has('medium') && ids.has('high') && ids.has('max')
-}
-
-function hasAdaptiveEffortMap(map) {
-  if (map === null || typeof map !== 'object' || Array.isArray(map)) return false
-  return ['low', 'medium', 'high', 'max'].every(level => typeof map[level] === 'string' && map[level].length > 0)
-}
-
-/** Whether a pi-ai catalog model should be serialized with adaptive thinking. */
-export function piModelHasAdaptiveEfforts(model) {
-  return hasAdaptiveEffortMap(model?.thinkingLevelMap)
-}
-
-/**
- * Stamp `compat.forceAdaptiveThinking` onto a pi-ai model so the Anthropic
- * adapter builds `thinking.type: adaptive` before `@anthropic-ai/sdk` sees the
- * payload. That is what removes the SDK deprecation warning for Opus 4.6.
- */
-export function withForcedAdaptiveThinking(model, provider, settings) {
-  if (!isClaudeProviderType(settings, provider)) return model
-  if (model === null || typeof model !== 'object' || Array.isArray(model)) return model
-  if (model.compat?.forceAdaptiveThinking === true) return model
-  if (!piModelHasAdaptiveEfforts(model)) return model
-  return {
-    ...model,
-    compat: { ...model.compat, forceAdaptiveThinking: true },
-  }
-}
-
-function installForceAdaptiveThinking(ctx, providerTypes) {
-  const llm = ctx.llm
-  if (typeof llm.listProviders !== 'function' || typeof llm.registration !== 'function') return
-
-  const patched = new WeakSet()
-  const wrap = () => {
-    for (const provider of llm.listProviders()) {
-      const id = provider?.id
-      if (typeof id !== 'string' || id.length === 0) continue
-      let adapter
-      try {
-        adapter = llm.registration(id).adapter
-      } catch {
-        continue
-      }
-      if (adapter === null || typeof adapter !== 'object' || typeof adapter.modelOf !== 'function') continue
-      if (patched.has(adapter)) continue
-      const original = adapter.modelOf.bind(adapter)
-      adapter.modelOf = (snapshot, providerId, modelId) => (
-        withForcedAdaptiveThinking(original(snapshot, providerId, modelId), providerId, providerTypes.get())
-      )
-      patched.add(adapter)
-    }
-  }
-
-  wrap()
-  ctx.effect(() => ctx.on('llm/adapters-updated', wrap), 'claude-provider: force adaptive thinking')
-}
-
-function effortFromBudget(budget) {
-  if (typeof budget !== 'number' || !Number.isFinite(budget)) return 'high'
-  if (budget <= 2048) return 'low'
-  if (budget <= 8192) return 'medium'
-  return 'high'
-}
-
-function selectedEffort(state, thinking) {
-  if (state.level !== undefined && state.level !== 'off') {
-    return state.effortMap[state.level] ?? state.level
-  }
-  return effortFromBudget(thinking.budget_tokens)
-}
-
-/**
- * Convert one matching Anthropic Messages body from legacy extended thinking
- * to adaptive thinking. The input object is never mutated.
- */
-export function rewriteAnthropicPayload(payload, state) {
-  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return payload
-  if (payload.model !== state.model) return payload
-  const thinking = payload.thinking
-  if (thinking === null || typeof thinking !== 'object' || Array.isArray(thinking)) return payload
-
-  if (thinking.type === 'disabled') {
-    const rewritten = { ...payload }
-    delete rewritten.thinking
-    delete rewritten.output_config
-    return rewritten
-  }
-
-  if (thinking.type !== 'enabled') return payload
-  const { budget_tokens: _budgetTokens, ...preservedThinking } = thinking
-  return {
-    ...payload,
-    thinking: { ...preservedThinking, type: 'adaptive' },
-    output_config: {
-      ...(payload.output_config ?? {}),
-      effort: selectedEffort(state, thinking),
-    },
-  }
-}
-
-function withoutLegacyThinkingBeta(headers) {
-  if (headers === undefined) return undefined
-  const rewritten = new Headers(headers)
-  const value = rewritten.get('anthropic-beta')
-  if (value === null) return rewritten
-  const features = value.split(',').map(feature => feature.trim()).filter(Boolean)
-  const kept = features.filter(feature => feature !== INTERLEAVED_THINKING_BETA)
-  if (kept.length === features.length) return rewritten
-  if (kept.length === 0) rewritten.delete('anthropic-beta')
-  else rewritten.set('anthropic-beta', kept.join(','))
-  return rewritten
-}
-
-function decodeBody(body) {
-  if (typeof body === 'string') return body
-  if (body instanceof Uint8Array) return new TextDecoder().decode(body)
-  if (body instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(body))
-  if (ArrayBuffer.isView(body)) {
-    return new TextDecoder().decode(new Uint8Array(body.buffer, body.byteOffset, body.byteLength))
-  }
-  return undefined
-}
-
-function rewriteJsonBody(body, state) {
-  const text = decodeBody(body)
-  if (text === undefined) return undefined
-  let parsed
-  try {
-    parsed = JSON.parse(text)
-  } catch {
-    return undefined
-  }
-  const rewritten = rewriteAnthropicPayload(parsed, state)
-  return rewritten === parsed ? undefined : JSON.stringify(rewritten)
-}
-
-async function rewriteFetchArguments(input, init, state) {
-  if (init?.body !== undefined && init.body !== null) {
-    const body = rewriteJsonBody(init.body, state)
-    if (body === undefined) return undefined
-    return [input, { ...init, body, headers: withoutLegacyThinkingBeta(init.headers) }]
-  }
-
-  if (typeof Request !== 'undefined' && input instanceof Request && input.body !== null) {
-    const text = await input.clone().text()
-    const body = rewriteJsonBody(text, state)
-    if (body === undefined) return undefined
-    const requestInit = {
-      body,
-      headers: withoutLegacyThinkingBeta(input.headers),
-    }
-    if (input.method !== 'GET' && input.method !== 'HEAD') requestInit.duplex = 'half'
-    return [new Request(input, requestInit), init]
-  }
-
-  return undefined
-}
-
-function contextualStream(storage, state, next) {
-  return {
-    [Symbol.asyncIterator]() {
-      let iterator
-      const invoke = (method, value) => storage.run(state, () => {
-        iterator ??= next()[Symbol.asyncIterator]()
-        const operation = iterator[method]
-        if (operation === undefined) return Promise.resolve({ done: true, value })
-        return operation.call(iterator, value)
-      })
-      return {
-        next: value => invoke('next', value),
-        return: value => invoke('return', value),
-        throw: error => invoke('throw', error),
-      }
-    },
-  }
-}
-
-async function* modelAwareStream(ctx, storage, resolved, options, next) {
-  let modelInfo
-  try {
-    modelInfo = await ctx.llm.resolveModelInfo(options.provider, options.model, options.signal)
-  } catch {
-    yield* next()
-    return
-  }
-  if (!shouldUseAdaptiveThinking(modelInfo)) {
-    yield* next()
-    return
-  }
-  const state = {
-    provider: options.provider,
-    model: options.model,
-    level: options.reasoningEffort === undefined ? undefined : String(options.reasoningEffort),
-    effortMap: resolved.effortMap,
-  }
-  yield* contextualStream(storage, state, next)
-}
-
-export function apply(ctx, config) {
-  const resolved = resolveConfig(config)
-  const providerTypes = ctx.settings.register(
+export function apply(ctx) {
+  ctx.settings.register(
     CLAUDE_PROVIDER_SETTINGS_NS,
     ProviderTypeSettings,
     { base: { providerTypes: {} } },
@@ -513,38 +251,5 @@ export function apply(ctx, config) {
     settingsNs: CLAUDE_PROVIDER_SETTINGS_NS,
     settingsPath: ['providerTypes'],
   }])
-  installClaudeModelInfoDefaults(ctx, providerTypes)
-  installForceAdaptiveThinking(ctx, providerTypes)
   installClaudeModelDiscovery(ctx)
-  const storage = new AsyncLocalStorage()
-  const upstreamFetch = globalThis.fetch
-  if (typeof upstreamFetch !== 'function') {
-    throw new Error('claude-provider: global fetch is unavailable')
-  }
-
-  const adaptiveFetch = async (input, init) => {
-    const state = storage.getStore()
-    if (state === undefined) return upstreamFetch(input, init)
-    const rewritten = await rewriteFetchArguments(input, init, state)
-    if (rewritten !== undefined && resolved.debug) {
-      process.stderr.write(
-        `[claude-provider] rewrote ${state.provider}/${state.model}`
-        + ` effort=${state.level ?? 'inferred'}\n`,
-      )
-    }
-    return rewritten === undefined
-      ? upstreamFetch(input, init)
-      : upstreamFetch(rewritten[0], rewritten[1])
-  }
-
-  globalThis.fetch = adaptiveFetch
-  ctx.effect(() => () => {
-    storage.disable()
-    if (globalThis.fetch === adaptiveFetch) globalThis.fetch = upstreamFetch
-  })
-
-  ctx.on('llm/stream', (options, next) => {
-    if (!isClaudeProviderType(providerTypes.get(), options.provider)) return next()
-    return modelAwareStream(ctx, storage, resolved, options, next)
-  })
 }