export type NativeEmbeddingParams = {
  embd_normalize?: number
}

export type NativeSpeculativeType =
  | 'none'
  | 'draft-mtp'
  /**
   * Alias for draft-mtp.
   */
  | 'mtp'

export type NativeSpeculativeParams = {
  enabled?: boolean
  type?: NativeSpeculativeType
  types?: Array<NativeSpeculativeType>
  n_max?: number
  n_min?: number
  p_min?: number
  p_split?: number
  draft?: {
    /**
     * Optional separate draft model path for MTP/speculative decoding.
     * When omitted, MTP uses the loaded target model's embedded draft layers.
     */
    model?: string
    path?: string
    model_draft?: string
    draft_model?: string
    n_max?: number
    n_min?: number
    p_min?: number
    p_split?: number
    n_gpu_layers?: number
    cache_type_k?: string
    cache_type_v?: string
  }
}

export type NativeSpeculativeConfig =
  | NativeSpeculativeParams
  | NativeSpeculativeType
  | boolean

export type NativeContextParams = {
  model: string
  /**
   * Optional separate draft model path for MTP/speculative decoding.
   * Leave unset for hybrid/embedded MTP models such as Qwen MTP.
   */
  model_draft?: string
  /**
   * Alias for model_draft.
   */
  draft_model?: string
  is_model_draft_asset?: boolean
  /**
   * Chat template to override the default one from the model.
   */
  chat_template?: string

  is_model_asset?: boolean
  use_progress_callback?: boolean

  n_ctx?: number
  n_batch?: number
  n_ubatch?: number
  /**
   * Number of parallel sequences to support (sets n_seq_max).
   * This determines the maximum number of parallel slots that can be used.
   * Default: 8
   */
  n_parallel?: number

  n_threads?: number

  /**
   * CPU affinity mask string (e.g., "0-3" or "0,2,4,6").
   * Specifies which CPU cores to use for inference.
   */
  cpu_mask?: string

  /**
   * Use strict CPU placement.
   * When true, enforces strict CPU core affinity.
   * Default: false
   */
  cpu_strict?: boolean

  /**
   * Number of layers to store in VRAM (Currently only for iOS)
   */
  n_gpu_layers?: number

  /**
   * Backend devices choice to use. Default equals to result of `getBackendDevicesInfo.
   */
  devices?: Array<string>

  /**
   * Skip GPU devices (iOS only) (Deprecated: Please set devices params instead)
   */
  no_gpu_devices?: boolean

  /**
   * Enable flash attention, only recommended in GPU device.
   */
  flash_attn_type?: string

  /**
   * Enable flash attention, only recommended in GPU device
   * Deprecated: use flash_attn_type instead
   */
  flash_attn?: boolean

  /**
   * KV cache data type for the K (Experimental in llama.cpp)
   */
  cache_type_k?: string
  /**
   * KV cache data type for the V (Experimental in llama.cpp)
   */
  cache_type_v?: string

  use_mlock?: boolean
  use_mmap?: boolean
  vocab_only?: boolean

  /**
   * Disable extra buffer types for weight repacking.
   * Reduces memory usage at the cost of slower prompt processing.
   * Default: false
   */
  no_extra_bufts?: boolean

  /**
   * Single LoRA adapter path
   */
  lora?: string
  /**
   * Single LoRA adapter scale
   */
  lora_scaled?: number
  /**
   * LoRA adapter list
   */
  lora_list?: Array<{ path: string; scaled?: number }>

  rope_freq_base?: number
  rope_freq_scale?: number

  /**
   * Enable speculative decoding support at context creation time.
   * MTP on recurrent/hybrid models must be enabled here so llama.cpp can
   * allocate recurrent-state rollback slots.
   */
  speculative?: NativeSpeculativeConfig
  spec_type?: NativeSpeculativeType | Array<NativeSpeculativeType>
  spec_draft_n_max?: number
  spec_draft_n_min?: number
  spec_draft_p_min?: number
  spec_draft_p_split?: number
  spec_draft_n_gpu_layers?: number
  spec_draft_cache_type_k?: string
  spec_draft_cache_type_v?: string

  pooling_type?: number

  /**
   * Enable context shifting to handle prompts larger than context size
   */
  ctx_shift?: boolean

  /**
   * Use a unified buffer across the input sequences when computing the attention.
   * Try to disable when n_seq_max > 1 for improved performance when the sequences do not share a large prefix.
   */
  kv_unified?: boolean

  /**
   * Use full-size SWA cache (https://github.com/ggml-org/llama.cpp/pull/13194#issuecomment-2868343055)
   */
  swa_full?: boolean

  /**
   * Number of layers to keep MoE weights on CPU
   */
  n_cpu_moe?: number

  /**
   * Memory budget (MiB) for the cross-turn KV prefix cache on recurrent/hybrid
   * models. 0 disables it; no-op on pure-attention models. Default 160.
   */
  state_cache_budget_mb?: number

  /**
   * Max snapshots to keep (secondary cap; the byte budget is primary).
   * 0 = no count cap. Default 8.
   */
  state_cache_max_checkpoints?: number

  // Embedding params
  embedding?: boolean
  embd_normalize?: number
}

export type NativeCompletionParams = {
  prompt: string
  n_threads?: number
  /**
   * Enable Jinja. Default: true if supported by the model
   */
  jinja?: boolean
  /**
   * JSON schema for convert to grammar for structured JSON output.
   * It will be override by grammar if both are set.
   */
  json_schema?: string
  /**
   * Set grammar for grammar-based sampling.  Default: no grammar
   */
  grammar?: string
  /**
   * Lazy grammar sampling, trigger by grammar_triggers. Default: false
   */
  grammar_lazy?: boolean
  /**
   * Enable thinking if jinja is enabled. Default: true
   */
  enable_thinking?: boolean
  /**
   * Force thinking to be open. Default: false
   */
  thinking_forced_open?: boolean
  /**
   * Maximum number of tokens allowed inside a thinking block before forcing it to close.
   * Only applies when chat formatting exposes thinking tags.
   */
  thinking_budget_tokens?: number
  /**
   * Message injected before the thinking end tag when the thinking budget is exhausted.
   */
  thinking_budget_message?: string
  /**
   * Assistant generation prompt returned by jinja chat formatting.
   * Used for PEG chat parsing and grammar prefill.
   */
  generation_prompt?: string
  /**
   * Serialized PEG parser for chat output parsing.
   * Required for COMMON_CHAT_FORMAT_PEG_* formats.
   * This is typically obtained from getFormattedChat with jinja enabled.
   */
  chat_parser?: string
  /**
   * Lazy grammar triggers. Default: []
   */
  grammar_triggers?: Array<{
    type: number
    value: string
    token: number
  }>
  preserved_tokens?: Array<string>
  chat_format?: number
  reasoning_format?: 'none' | 'auto' | 'deepseek'
  /**
   * Path to an image file to process before generating text.
   * When provided, the image will be processed and added to the context.
   * Requires multimodal support to be enabled via initMultimodal.
   */
  media_paths?: Array<string>
  /**
   * Specify a JSON array of stopping strings.
   * These words will not be included in the completion, so make sure to add them to the prompt for the next iteration. Default: `[]`
   */
  stop?: Array<string>
  /**
   * Set the maximum number of tokens to predict when generating text.
   * **Note:** May exceed the set limit slightly if the last token is a partial multibyte character.
   * When 0,no tokens will be generated but the prompt is evaluated into the cache. Default: `-1`, where `-1` is infinity.
   */
  n_predict?: number
  /**
   * If greater than 0, the response also contains the probabilities of top N tokens for each generated token given the sampling settings.
   * Note that for temperature < 0 the tokens are sampled greedily but token probabilities are still being calculated via a simple softmax of the logits without considering any other sampler settings.
   * Default: `0`
   */
  n_probs?: number
  /**
   * Per-completion speculative decoding override. For MTP on recurrent/hybrid
   * models, load the model with matching MTP options first.
   */
  speculative?: NativeSpeculativeConfig
  spec_type?: NativeSpeculativeType | Array<NativeSpeculativeType>
  spec_draft_n_max?: number
  spec_draft_n_min?: number
  spec_draft_p_min?: number
  spec_draft_p_split?: number
  /**
   * Limit the next token selection to the K most probable tokens.  Default: `40`
   */
  top_k?: number
  /**
   * Limit the next token selection to a subset of tokens with a cumulative probability above a threshold P. Default: `0.95`
   */
  top_p?: number
  /**
   * The minimum probability for a token to be considered, relative to the probability of the most likely token. Default: `0.05`
   */
  min_p?: number
  /**
   * Set the chance for token removal via XTC sampler. Default: `0.0`, which is disabled.
   */
  xtc_probability?: number
  /**
   * Set a minimum probability threshold for tokens to be removed via XTC sampler. Default: `0.1` (> `0.5` disables XTC)
   */
  xtc_threshold?: number
  /**
   * Enable locally typical sampling with parameter p. Default: `1.0`, which is disabled.
   */
  typical_p?: number
  /**
   * Adjust the randomness of the generated text. Default: `0.8`
   */
  temperature?: number
  /**
   * Last n tokens to consider for penalizing repetition. Default: `64`, where `0` is disabled and `-1` is ctx-size.
   */
  penalty_last_n?: number
  /**
   * Control the repetition of token sequences in the generated text. Default: `1.0`
   */
  penalty_repeat?: number
  /**
   * Repeat alpha frequency penalty. Default: `0.0`, which is disabled.
   */
  penalty_freq?: number
  /**
   * Repeat alpha presence penalty. Default: `0.0`, which is disabled.
   */
  penalty_present?: number
  /**
   * Enable Mirostat sampling, controlling perplexity during text generation. Default: `0`, where `0` is disabled, `1` is Mirostat, and `2` is Mirostat 2.0.
   */
  mirostat?: number
  /**
   * Set the Mirostat target entropy, parameter tau. Default: `5.0`
   */
  mirostat_tau?: number
  /**
   * Set the Mirostat learning rate, parameter eta. Default: `0.1`
   */
  mirostat_eta?: number
  /**
   * Set the DRY (Don't Repeat Yourself) repetition penalty multiplier. Default: `0.0`, which is disabled.
   */
  dry_multiplier?: number
  /**
   * Set the DRY repetition penalty base value. Default: `1.75`
   */
  dry_base?: number
  /**
   * Tokens that extend repetition beyond this receive exponentially increasing penalty: multiplier * base ^ (length of repeating sequence before token - allowed length). Default: `2`
   */
  dry_allowed_length?: number
  /**
   * How many tokens to scan for repetitions. Default: `-1`, where `0` is disabled and `-1` is context size.
   */
  dry_penalty_last_n?: number
  /**
   * Specify an array of sequence breakers for DRY sampling. Only a JSON array of strings is accepted. Default: `['\n', ':', '"', '*']`
   */
  dry_sequence_breakers?: Array<string>
  /**
   * Top n sigma sampling as described in academic paper "Top-nσ: Not All Logits Are You Need" https://arxiv.org/pdf/2411.07641. Default: `-1.0` (Disabled)
   */
  top_n_sigma?: number

  /**
   * Ignore end of stream token and continue generating. Default: `false`
   */
  ignore_eos?: boolean
  /**
   * Modify the likelihood of a token appearing in the generated text completion.
   * For example, use `"logit_bias": [[15043,1.0]]` to increase the likelihood of the token 'Hello', or `"logit_bias": [[15043,-1.0]]` to decrease its likelihood.
   * Setting the value to false, `"logit_bias": [[15043,false]]` ensures that the token `Hello` is never produced. The tokens can also be represented as strings,
   * e.g.`[["Hello, World!",-0.5]]` will reduce the likelihood of all the individual tokens that represent the string `Hello, World!`, just like the `presence_penalty` does.
   * Default: `[]`
   */
  logit_bias?: Array<Array<number>>
  /**
   * Set the random number generator (RNG) seed. Default: `-1`, which is a random seed.
   */
  seed?: number

  /**
   * Output token embeddings during generation.
   * When enabled, completion results include generated token embeddings and their dimension.
   * Default: `false`
   */
  embedding?: boolean

  emit_partial_completion: boolean
}

/**
 * Parameters for parallel completion requests (queueCompletion).
 * Extends NativeCompletionParams with parallel-mode specific options.
 */
export type NativeParallelCompletionParams = NativeCompletionParams & {
  /**
   * File path to load state from before processing.
   * This allows you to resume from a previously saved completion state.
   * Use with `save_state_path` to enable conversation continuity across requests.
   * Example: `'/path/to/state.bin'` or `'file:///path/to/state.bin'`
   */
  load_state_path?: string

  /**
   * File path to save state to after completion.
   * The state will be saved to this file path when the completion finishes.
   * You can then pass this path to `load_state_path` in a subsequent request to resume.
   * For multimodal conversations a `<path>.meta` sidecar file is written next
   * to the state file (media identity); keep the two files together.
   * Example: `'/path/to/state.bin'` or `'file:///path/to/state.bin'`
   */
  save_state_path?: string

  /**
   * File path to save prompt-only state to after prompt processing.
   * Useful for fast prompt reuse (especially for recurrent/hybrid models).
   * Example: `'/path/to/prompt_state.bin'` or `'file:///path/to/prompt_state.bin'`
   */
  save_prompt_state_path?: string

  /**
   * Number of tokens to load when loading state.
   * If not specified or <= 0, all tokens from the state file will be loaded.
   * Use this to limit how much of a saved state is restored.
   * Example: `512` to load only the first 512 tokens from the state file
   */
  load_state_size?: number

  /**
   * Number of tokens to save when saving state.
   * If not specified or <= 0, all tokens will be saved.
   * Use this to limit the size of saved state files.
   * Example: `512` to save only the last 512 tokens
   */
  save_state_size?: number
}

export type NativeCompletionTokenProbItem = {
  tok_str: string
  prob: number
}

export type NativeCompletionTokenProb = {
  content: string
  probs: Array<NativeCompletionTokenProbItem>
}

export type NativeCompletionResultTimings = {
  cache_n: number
  prompt_n: number
  prompt_ms: number
  prompt_per_token_ms: number
  prompt_per_second: number
  predicted_n: number
  predicted_ms: number
  predicted_per_token_ms: number
  predicted_per_second: number
}

export type NativeCompletionResult = {
  /**
   * Original text (Ignored reasoning_content / tool_calls)
   */
  text: string
  /**
   * Reasoning content (parsed for reasoning model)
   */
  reasoning_content: string
  /**
   * Tool calls
   */
  tool_calls: Array<{
    type: 'function'
    function: {
      name: string
      arguments: string
    }
    id?: string
  }>
  /**
   * Content text (Filtered text by reasoning_content / tool_calls)
   */
  content: string

  chat_format: number

  tokens_predicted: number
  tokens_evaluated: number
  draft_tokens: number
  draft_tokens_accepted: number
  truncated: boolean
  stopped_eos: boolean
  stopped_word: string
  stopped_limit: number
  stopping_word: string
  context_full: boolean
  interrupted: boolean
  tokens_cached: number
  timings: NativeCompletionResultTimings

  completion_probabilities?: Array<NativeCompletionTokenProb>
  embeddings?: Array<number>
  embedding_dim?: number
  audio_tokens?: Array<number>
}

export type NativeTokenizeResult = {
  tokens: Array<number>
  /**
   * Whether the tokenization contains media
   */
  has_media: boolean
  /**
   * Bitmap hashes of the media
   */
  bitmap_hashes: Array<number>
  /**
   * Chunk positions of the text and media
   */
  chunk_pos: Array<number>
  /**
   * Chunk positions of the media
   */
  chunk_pos_media: Array<number>
}

export type NativeEmbeddingResult = {
  embedding: Array<number>
}

export type NativeLlamaContext = {
  contextId: number
  model: {
    desc: string
    size: number
    nEmbd: number
    nParams: number
    is_recurrent: boolean
    is_hybrid: boolean
    chatTemplates: {
      llamaChat: boolean // Chat template in llama-chat.cpp
      jinja: {
        // Chat template supported by jinja engine
        default: boolean
        defaultCaps: {
          tools: boolean
          toolCalls: boolean
          systemRole: boolean
          parallelToolCalls: boolean
        }
        toolUse: boolean
        toolUseCaps?: {
          tools: boolean
          toolCalls: boolean
          systemRole: boolean
          parallelToolCalls: boolean
        }
      }
    }
    metadata: Object
    isChatTemplateSupported: boolean // Deprecated
  }
  /**
   * Loaded library name for Android
   */
  androidLib?: string
  /**
   * Name of the GPU device used on Android/iOS (if available)
   */
  devices?: Array<string>
  gpu: boolean
  reasonNoGPU: string
  systemInfo: string
}

export type NativeSessionLoadResult = {
  tokens_loaded: number
  prompt: string
}

export type NativeLlamaMessagePart = {
  type: 'text'
  text: string
}

export type NativeLlamaChatMessage = {
  role: string
  content: string | Array<NativeLlamaMessagePart>
}

export type FormattedChatResult = {
  type: 'jinja' | 'llama-chat'
  prompt: string
  has_media: boolean
  media_paths?: Array<string>
}

export type JinjaFormattedChatResult = FormattedChatResult & {
  chat_format?: number
  grammar?: string
  grammar_lazy?: boolean
  grammar_triggers?: Array<{
    type: number
    value: string
    token: number
  }>
  generation_prompt?: string
  thinking_forced_open?: boolean
  thinking_start_tag?: string
  thinking_end_tag?: string
  preserved_tokens?: Array<string>
  additional_stops?: Array<string>
  /**
   * Serialized PEG parser for chat output parsing.
   * Required for COMMON_CHAT_FORMAT_PEG_* formats.
   */
  chat_parser?: string
}

export type NativeImageProcessingResult = {
  success: boolean
  prompt: string
  error?: string
}

export type NativeRerankParams = {
  normalize?: number
}

export type NativeRerankResult = {
  score: number
  index: number
}

export type NativeBackendDeviceInfo = {
  backend: string
  type: string
  deviceName: string
  maxMemorySize: number
  metadata?: Record<string, any>
}

export type ParallelRequestStatus = {
  request_id: number
  type: 'completion' | 'embedding' | 'rerank'
  state: 'queued' | 'processing_prompt' | 'generating' | 'done'
  prompt_length: number
  tokens_generated: number
  prompt_ms: number
  generation_ms: number
  tokens_per_second: number
}

export type ParallelStatus = {
  n_parallel: number
  active_slots: number
  queued_requests: number
  requests: ParallelRequestStatus[]
}