@exvio/os-backend-core 0.4.0

package/src/ai/providers/openai-compatible.ts

@@ -0,0 +1,731 @@
+import { parseSseJson, SseDecodeError } from './sse.ts'
+import { matchesAIJSONSchema } from '../schema.ts'
+import {
+  AIError,
+  aiErrorFromHttpStatus,
+  unsupportedAIProviderOperation,
+} from '../errors.ts'
+import type {
+  AIChatOutput,
+  AIContentPart,
+  AIFinishReason,
+  AIMessage,
+  AIProvider,
+  AIProviderCapabilities,
+  AIProviderChatRequest,
+  AIProviderContentRequest,
+  AIProviderRequestBase,
+  AIProviderTextRequest,
+  AIResult,
+  AIStreamEvent,
+  AIToolCall,
+  AIToolChoice,
+  AIToolDefinition,
+  AIUsage,
+  AIOperation,
+} from '../types.ts'
+
+type Fetch = typeof globalThis.fetch
+
+export interface OpenAICompatibleProviderOptions {
+  name: string
+  apiKey: string
+  /** A complete chat-completions URL, not merely an origin. */
+  endpoint: string
+  fetch: Fetch
+  capabilities?: Partial<AIProviderCapabilities>
+  /** DeepSeek V4 accepts a provider-specific thinking switch. */
+  disableThinkingByDefault?: (model: string) => boolean
+}
+
+interface OpenAIContentPart {
+  type: 'text' | 'image_url'
+  text?: string
+  image_url?: { url: string }
+}
+
+interface OpenAIToolCall {
+  id: string
+  type: 'function'
+  function: { name: string; arguments: string }
+}
+
+interface OpenAIToolCallDelta {
+  index: number
+  id?: string
+  type?: 'function'
+  function?: { name?: string; arguments?: string }
+}
+
+interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string | OpenAIContentPart[] | null
+  name?: string
+  tool_call_id?: string
+  tool_calls?: OpenAIToolCall[]
+}
+
+interface OpenAIUsage {
+  prompt_tokens?: number
+  completion_tokens?: number
+  total_tokens?: number
+  prompt_cache_hit_tokens?: number
+  prompt_cache_miss_tokens?: number
+  prompt_tokens_details?: { cached_tokens?: number }
+  completion_tokens_details?: { reasoning_tokens?: number }
+}
+
+interface OpenAIResponse {
+  id?: string
+  model?: string
+  choices?: Array<{
+    message?: {
+      content?: string | null
+      tool_calls?: OpenAIToolCall[]
+    }
+    delta?: {
+      content?: string | null
+      tool_calls?: OpenAIToolCallDelta[]
+    }
+    finish_reason?: string | null
+  }>
+  usage?: OpenAIUsage | null
+  error?: unknown
+}
+
+/**
+ * Provider for the common POST /chat/completions contract.
+ *
+ * Endpoint allowlisting happens in the runtime before constructing a provider.
+ * This last line of defence still rejects plaintext URLs and URL credentials
+ * before it creates an Authorization header.
+ */
+export class OpenAICompatibleProvider implements AIProvider {
+  readonly name: string
+  readonly capabilities: AIProviderCapabilities
+
+  readonly #apiKey: string
+  readonly #endpoint: string
+  readonly #fetch: Fetch
+  readonly #disableThinkingByDefault: (model: string) => boolean
+
+  constructor(options: OpenAICompatibleProviderOptions) {
+    if (!options.apiKey.trim()) {
+      throw new AIError({
+        code: 'not_configured',
+        message: 'AI provider API key is missing',
+        provider: options.name,
+      })
+    }
+
+    this.name = options.name
+    this.#apiKey = options.apiKey
+    this.#endpoint = validateEndpoint(options.endpoint)
+    this.#fetch = options.fetch
+    this.#disableThinkingByDefault = options.disableThinkingByDefault ?? (() => false)
+    this.capabilities = {
+      text: true,
+      content: true,
+      chat: true,
+      streaming: true,
+      tools: true,
+      object: false,
+      embedding: false,
+      ...options.capabilities,
+    }
+  }
+
+  async generateText(request: AIProviderTextRequest): Promise<AIResult<string>> {
+    const messages = withSystemInstruction(
+      [{ role: 'user', content: request.prompt }],
+      request.systemInstruction,
+    )
+    const response = await this.#post(this.#buildBody(request, messages), request.signal, 'text', request.model)
+    const choice = requireFirstChoice(response.data)
+    if (normalizeFinishReason(choice.finish_reason) === 'content_filter') {
+      throw contentFiltered(this.name, response.data.model || request.model, 'text')
+    }
+    const output = choice.message?.content
+    if (typeof output !== 'string' || output.trim().length === 0) {
+      throw invalidResponse('AI provider returned no text')
+    }
+
+    return this.#result(
+      output.trim(),
+      request.model,
+      response.data,
+      choice.finish_reason,
+      response.requestId,
+    )
+  }
+
+  async generateContent(request: AIProviderContentRequest): Promise<AIResult<string>> {
+    if (!this.capabilities.content) {
+      throw unsupportedAIProviderOperation(this.name, 'content', request.model)
+    }
+
+    const content: OpenAIContentPart[] = request.content.map((part) => {
+      if (part.type === 'text') return { type: 'text', text: part.text }
+      if (part.type === 'image') {
+        return {
+          type: 'image_url',
+          image_url: { url: `data:${validateMimeType(part.mimeType)};base64,${validateBase64(part.data)}` },
+        }
+      }
+      throw unsupportedAIProviderOperation(this.name, 'content', request.model)
+    })
+
+    const messages = withSystemInstruction(
+      [{ role: 'user', content }],
+      request.systemInstruction,
+    )
+    const response = await this.#post(this.#buildBody(request, messages), request.signal, 'content', request.model)
+    const choice = requireFirstChoice(response.data)
+    if (normalizeFinishReason(choice.finish_reason) === 'content_filter') {
+      throw contentFiltered(this.name, response.data.model || request.model, 'content')
+    }
+    const output = choice.message?.content
+    if (typeof output !== 'string' || output.trim().length === 0) {
+      throw invalidResponse('AI provider returned no text')
+    }
+
+    return this.#result(
+      output.trim(),
+      request.model,
+      response.data,
+      choice.finish_reason,
+      response.requestId,
+    )
+  }
+
+  async generateChat(request: AIProviderChatRequest): Promise<AIResult<AIChatOutput>> {
+    const messages = withSystemInstruction(
+      toOpenAIMessages(request.messages),
+      request.systemInstruction,
+    )
+    const response = await this.#post(
+      this.#buildBody(request, messages, false, request.tools, request.toolChoice),
+      request.signal,
+      'chat',
+      request.model,
+    )
+    const choice = requireFirstChoice(response.data)
+    if (normalizeFinishReason(choice.finish_reason) === 'content_filter') {
+      throw contentFiltered(this.name, response.data.model || request.model, 'chat')
+    }
+    const output = {
+      text: typeof choice.message?.content === 'string' ? choice.message.content : '',
+      toolCalls: (choice.message?.tool_calls ?? []).map(call => parseToolCall(call, request.tools)),
+    }
+    if (output.text.length === 0 && output.toolCalls.length === 0) {
+      throw invalidResponse('AI provider returned an empty chat turn')
+    }
+
+    return this.#result(
+      output,
+      request.model,
+      response.data,
+      choice.finish_reason,
+      response.requestId,
+    )
+  }
+
+  async *streamChat(request: AIProviderChatRequest): AsyncGenerator<AIStreamEvent, void, undefined> {
+    const messages = withSystemInstruction(
+      toOpenAIMessages(request.messages),
+      request.systemInstruction,
+    )
+    const response = await this.#postStream(
+      this.#buildBody(request, messages, true, request.tools, request.toolChoice),
+      request.signal,
+      request.model,
+    )
+
+    let actualModel = request.model
+    let requestId = response.requestId
+    let usage: AIUsage | null = null
+    let providerFinishReason: string | undefined
+    let text = ''
+    const pending = new Map<number, { id: string; name: string; arguments: string }>()
+
+    try {
+      for await (const event of parseSseJson<OpenAIResponse>(response.body, { signal: request.signal })) {
+        if (event.type === 'done') break
+        const chunk = event.data
+
+        if (chunk.error !== undefined) {
+          throw providerReportedError(this.name, request.model, 'stream')
+        }
+        if (typeof chunk.model === 'string' && chunk.model.length > 0) actualModel = chunk.model
+        if (typeof chunk.id === 'string' && chunk.id.length > 0) requestId ??= chunk.id
+        if (chunk.usage) usage = normalizeUsage(chunk.usage)
+
+        const choice = chunk.choices?.[0]
+        if (!choice) continue // usage-only terminal chunks are valid
+        if (choice.finish_reason) providerFinishReason = choice.finish_reason
+
+        const delta = choice.delta?.content
+        if (typeof delta === 'string' && delta.length > 0) {
+          text += delta
+          yield { type: 'text-delta', delta }
+        }
+
+        for (const fragment of choice.delta?.tool_calls ?? []) {
+          if (!Number.isSafeInteger(fragment.index) || fragment.index < 0) {
+            throw invalidResponse(
+              'AI provider returned an invalid tool-call index',
+              this.name,
+              request.model,
+              'stream',
+            )
+          }
+          const slot = pending.get(fragment.index) ?? { id: '', name: '', arguments: '' }
+          if (fragment.id) slot.id = fragment.id
+          if (fragment.function?.name) slot.name += fragment.function.name
+          if (fragment.function?.arguments) slot.arguments += fragment.function.arguments
+          pending.set(fragment.index, slot)
+        }
+      }
+    } catch (error) {
+      if (error instanceof AIError) throw error
+      if (request.signal.aborted) throw aborted(this.name, request.model, 'stream')
+      if (error instanceof TypeError) {
+        throw new AIError({
+          code: 'network',
+          message: 'AI provider stream transport failed',
+          provider: this.name,
+          model: request.model,
+          operation: 'stream',
+          retryable: true,
+        })
+      }
+      if (error instanceof SseDecodeError) {
+        throw invalidResponse(
+          'AI provider stream could not be decoded',
+          this.name,
+          request.model,
+          'stream',
+        )
+      }
+      throw invalidResponse(
+        'AI provider stream could not be decoded',
+        this.name,
+        request.model,
+        'stream',
+      )
+    }
+
+    const normalizedReason = normalizeFinishReason(providerFinishReason)
+    if (normalizedReason === 'content_filter') {
+      throw contentFiltered(this.name, actualModel, 'stream')
+    }
+
+    const toolCalls: AIToolCall[] = []
+    for (const [index, pendingCall] of [...pending].sort(([left], [right]) => left - right)) {
+      const toolCall = parseToolCall({
+        id: pendingCall.id || `${this.name}_tool_${index}`,
+        type: 'function',
+        function: { name: pendingCall.name, arguments: pendingCall.arguments },
+      }, request.tools)
+      toolCalls.push(toolCall)
+      yield { type: 'tool-call', toolCall }
+    }
+
+    if (text.length === 0 && toolCalls.length === 0) {
+      throw invalidResponse('AI provider returned an empty stream', this.name, actualModel, 'stream')
+    }
+    const result: AIResult<AIChatOutput> = {
+      output: { text, toolCalls },
+      provider: this.name,
+      model: actualModel,
+      usage,
+      finishReason: normalizedReason,
+      ...(providerFinishReason ? { providerFinishReason } : {}),
+      ...(requestId ? { requestId } : {}),
+    }
+    const finish: AIStreamEvent = {
+      type: 'finish',
+      result,
+    }
+    yield finish
+  }
+
+  #buildBody(
+    request: AIProviderRequestBase,
+    messages: OpenAIMessage[],
+    stream = false,
+    tools?: readonly AIToolDefinition[],
+    toolChoice?: AIToolChoice,
+  ): Record<string, unknown> {
+    const body: Record<string, unknown> = {
+      model: request.model,
+      messages,
+      temperature: request.temperature ?? 0.3,
+      max_tokens: request.maxOutputTokens ?? 4_000,
+    }
+    if (request.topP !== undefined) body['top_p'] = request.topP
+    if (request.stopSequences?.length) body['stop'] = request.stopSequences
+    if (request.responseFormat === 'json') body['response_format'] = { type: 'json_object' }
+    if (stream) {
+      body['stream'] = true
+      body['stream_options'] = { include_usage: true }
+    }
+    if (tools?.length) {
+      body['tools'] = tools.map(toOpenAITool)
+      body['tool_choice'] = typeof toolChoice === 'object'
+        ? { type: 'function', function: { name: toolChoice.name } }
+        : toolChoice ?? 'auto'
+    } else if (toolChoice === 'required') {
+      throw new AIError({
+        code: 'invalid_request',
+        message: 'toolChoice "required" needs at least one tool',
+        provider: this.name,
+        model: request.model,
+      })
+    } else if (typeof toolChoice === 'object') {
+      throw new AIError({
+        code: 'invalid_request',
+        message: 'Named toolChoice needs at least one tool',
+        provider: this.name,
+        model: request.model,
+      })
+    } else if (toolChoice === 'none') {
+      body['tool_choice'] = 'none'
+    }
+
+    const disableThinking = request.disableThinking ?? this.#disableThinkingByDefault(request.model)
+    if (disableThinking) body['thinking'] = { type: 'disabled' }
+    return body
+  }
+
+  async #post(
+    body: Record<string, unknown>,
+    signal: AbortSignal,
+    operation: AIOperation,
+    model: string,
+  ): Promise<{ data: OpenAIResponse; requestId?: string }> {
+    const response = await this.#request(body, signal, false, operation, model)
+    let data: unknown
+    try {
+      data = await response.json()
+    } catch {
+      throw invalidResponse('AI provider returned malformed JSON', this.name, model, operation)
+    }
+    if (!isRecord(data)) {
+      throw invalidResponse('AI provider returned an invalid response', this.name, model, operation)
+    }
+    const parsed = data as OpenAIResponse
+    if (parsed.error !== undefined) throw providerReportedError(this.name, model, operation)
+    const requestId = getRequestId(response, parsed)
+    return requestId ? { data: parsed, requestId } : { data: parsed }
+  }
+
+  async #postStream(
+    body: Record<string, unknown>,
+    signal: AbortSignal,
+    model: string,
+  ): Promise<{ body: ReadableStream<Uint8Array>; requestId?: string }> {
+    const response = await this.#request(body, signal, true, 'stream', model)
+    if (!response.body) {
+      throw invalidResponse('AI provider returned no stream', this.name, model, 'stream')
+    }
+    const contentType = response.headers.get('content-type')?.toLowerCase()
+    if (!contentType?.startsWith('text/event-stream')) {
+      try { await response.body.cancel() } catch { /* best-effort connection cleanup */ }
+      throw invalidResponse('AI provider returned an invalid stream type', this.name, model, 'stream')
+    }
+    const requestId = getRequestId(response)
+    return requestId ? { body: response.body, requestId } : { body: response.body }
+  }
+
+  async #request(
+    body: Record<string, unknown>,
+    signal: AbortSignal,
+    stream: boolean,
+    operation: AIOperation,
+    model: string,
+  ): Promise<Response> {
+    if (signal.aborted) throw aborted(this.name, model, operation)
+
+    let response: Response
+    try {
+      response = await this.#fetch(this.#endpoint, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.#apiKey}`,
+          'Content-Type': 'application/json',
+          Accept: stream ? 'text/event-stream' : 'application/json',
+        },
+        body: JSON.stringify(body),
+        signal,
+        // Never forward a bearer key across a provider-controlled redirect.
+        redirect: 'error',
+      })
+    } catch {
+      if (signal.aborted) throw aborted(this.name, model, operation)
+      // Do not retain the transport error as a cause: some fetch
+      // implementations include request headers or body excerpts in it.
+      throw new AIError({
+        code: 'network',
+        message: 'AI provider request failed',
+        provider: this.name,
+        model,
+        operation,
+        retryable: true,
+      })
+    }
+
+    if (!response.ok) {
+      throw aiErrorFromHttpStatus(response.status, { provider: this.name, model, operation })
+    }
+    return response
+  }
+
+  #result<T>(
+    output: T,
+    requestedModel: string,
+    response: OpenAIResponse,
+    providerFinishReason: string | null | undefined,
+    requestId: string | undefined,
+  ): AIResult<T> {
+    const id = requestId ?? (typeof response.id === 'string' ? response.id : undefined)
+    return {
+      output,
+      provider: this.name,
+      model: response.model || requestedModel,
+      usage: response.usage ? normalizeUsage(response.usage) : null,
+      finishReason: normalizeFinishReason(providerFinishReason),
+      ...(providerFinishReason ? { providerFinishReason } : {}),
+      ...(id ? { requestId: id } : {}),
+    }
+  }
+}
+
+export function validateEndpoint(input: string): string {
+  let url: URL
+  try {
+    url = new URL(input)
+  } catch {
+    throw new AIError({ code: 'endpoint_not_allowed', message: 'AI provider endpoint is invalid' })
+  }
+  if (url.protocol !== 'https:' || url.username || url.password) {
+    throw new AIError({ code: 'endpoint_not_allowed', message: 'AI provider endpoint is not allowed' })
+  }
+  if (url.hash || url.search) {
+    throw new AIError({ code: 'endpoint_not_allowed', message: 'AI provider endpoint is not allowed' })
+  }
+  return url.toString()
+}
+
+function withSystemInstruction(messages: OpenAIMessage[], instruction: string | undefined): OpenAIMessage[] {
+  return instruction
+    ? [{ role: 'system', content: instruction }, ...messages]
+    : messages
+}
+
+function toOpenAIMessages(messages: readonly AIMessage[]): OpenAIMessage[] {
+  return messages.map((message) => {
+    if (message.role === 'system') return { role: 'system', content: message.content }
+    if (message.role === 'user') {
+      return {
+        role: 'user',
+        content: typeof message.content === 'string'
+          ? message.content
+          : message.content.map(toOpenAIContentPart),
+      }
+    }
+    if (message.role === 'assistant') {
+      const converted: OpenAIMessage = { role: 'assistant', content: message.content || null }
+      if (message.toolCalls?.length) {
+        converted.tool_calls = message.toolCalls.map((call) => ({
+          id: call.id,
+          type: 'function',
+          function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+        }))
+      }
+      return converted
+    }
+    const converted: OpenAIMessage = {
+      role: 'tool',
+      content: message.content,
+      tool_call_id: message.toolCallId,
+    }
+    if (message.toolName) converted.name = message.toolName
+    return converted
+  })
+}
+
+function toOpenAIContentPart(part: AIContentPart): OpenAIContentPart {
+  if (part.type === 'text') return { type: 'text', text: part.text }
+  if (part.type === 'image') {
+    return {
+      type: 'image_url',
+      image_url: { url: `data:${validateMimeType(part.mimeType)};base64,${validateBase64(part.data)}` },
+    }
+  }
+  throw new AIError({
+    code: 'unsupported_operation',
+    message: 'OpenAI-compatible chat completions do not support file content',
+    operation: 'content',
+  })
+}
+
+function toOpenAITool(tool: AIToolDefinition): Record<string, unknown> {
+  return {
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description ?? '',
+      parameters: tool.parameters,
+    },
+  }
+}
+
+function parseToolCall(
+  raw: OpenAIToolCall,
+  declarations: readonly AIToolDefinition[] | undefined,
+): AIToolCall {
+  if (!raw || raw.type !== 'function' || typeof raw.id !== 'string' || !raw.id) {
+    throw invalidResponse('AI provider returned an invalid tool call')
+  }
+  const name = raw.function?.name
+  const encoded = raw.function?.arguments
+  if (typeof name !== 'string' || !name || typeof encoded !== 'string' || !encoded) {
+    throw invalidResponse('AI provider returned an invalid tool call')
+  }
+
+  let args: unknown
+  try {
+    args = JSON.parse(encoded)
+  } catch {
+    throw invalidResponse('AI provider returned invalid tool arguments')
+  }
+  if (!isRecord(args)) throw invalidResponse('AI provider returned non-object tool arguments')
+  const declaration = declarations?.find(tool => tool.name === name)
+  if (!declaration || !matchesAIJSONSchema(args, declaration.parameters)) {
+    throw invalidResponse('AI provider returned invalid tool arguments')
+  }
+  return { id: raw.id, name, arguments: args }
+}
+
+function requireFirstChoice(response: OpenAIResponse): NonNullable<OpenAIResponse['choices']>[number] {
+  const choice = response.choices?.[0]
+  if (!choice) throw invalidResponse('AI provider response had no choice')
+  return choice
+}
+
+function normalizeUsage(raw: OpenAIUsage): AIUsage | null {
+  const inputTokens = tokenCount(raw.prompt_tokens)
+  const outputTokens = tokenCount(raw.completion_tokens)
+  const totalTokens = tokenCount(raw.total_tokens)
+  if (inputTokens === undefined || outputTokens === undefined || totalTokens === undefined) return null
+
+  const cachedRaw = raw.prompt_tokens_details?.cached_tokens ?? raw.prompt_cache_hit_tokens
+  const missRaw = raw.prompt_cache_miss_tokens
+  const reasoningRaw = raw.completion_tokens_details?.reasoning_tokens
+  const cachedInputTokens = tokenCount(cachedRaw)
+  const cacheMissInputTokens = tokenCount(missRaw)
+  const reasoningTokens = tokenCount(reasoningRaw)
+  if (
+    (cachedRaw !== undefined && cachedInputTokens === undefined)
+    || (missRaw !== undefined && cacheMissInputTokens === undefined)
+    || (reasoningRaw !== undefined && reasoningTokens === undefined)
+    || totalTokens < inputTokens + outputTokens
+    || (cachedInputTokens ?? 0) + (cacheMissInputTokens ?? 0) > inputTokens
+  ) return null
+
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+    ...(cacheMissInputTokens !== undefined ? { cacheMissInputTokens } : {}),
+    ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+  }
+}
+
+function normalizeFinishReason(raw: string | null | undefined): AIFinishReason {
+  switch (raw) {
+    case 'stop':
+      return 'stop'
+    case 'length':
+    case 'max_tokens':
+      return 'length'
+    case 'tool_calls':
+    case 'function_call':
+      return 'tool_calls'
+    case 'content_filter':
+      return 'content_filter'
+    default:
+      return 'other'
+  }
+}
+
+function getRequestId(response: Response, body?: OpenAIResponse): string | undefined {
+  const fromHeader = response.headers.get('x-request-id') ?? response.headers.get('request-id')
+  if (fromHeader) return fromHeader.slice(0, 256)
+  return typeof body?.id === 'string' ? body.id.slice(0, 256) : undefined
+}
+
+function providerReportedError(provider: string, model: string, operation: AIOperation): AIError {
+  return new AIError({
+    code: 'provider_error',
+    message: 'AI provider reported an error',
+    provider,
+    model,
+    operation,
+  })
+}
+
+function invalidResponse(
+  message: string,
+  provider?: string,
+  model?: string,
+  operation?: AIOperation,
+): AIError {
+  return new AIError({ code: 'invalid_response', message, provider, model, operation })
+}
+
+function contentFiltered(provider: string, model: string, operation: AIOperation): AIError {
+  return new AIError({
+    code: 'content_filtered',
+    message: 'AI provider blocked the response for safety reasons',
+    provider,
+    model,
+    operation,
+  })
+}
+
+function aborted(provider: string, model: string, operation: AIOperation): AIError {
+  return new AIError({
+    code: 'aborted',
+    message: 'AI request was aborted',
+    provider,
+    model,
+    operation,
+  })
+}
+
+function tokenCount(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+    ? value
+    : undefined
+}
+
+function validateMimeType(value: string): string {
+  if (!/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i.test(value)) {
+    throw new AIError({ code: 'invalid_request', message: 'Content MIME type is invalid' })
+  }
+  return value
+}
+
+function validateBase64(value: string): string {
+  if (value.length === 0 || !/^[a-z0-9+/]*={0,2}$/i.test(value) || value.length % 4 !== 0) {
+    throw new AIError({ code: 'invalid_request', message: 'Content data is not valid base64' })
+  }
+  return value
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}