cui-llama.rn 1.5.0 → 1.6.0

package/src/grammar.ts

@@ -1,854 +1,854 @@
-/* eslint-disable no-restricted-syntax */
-/* eslint-disable no-underscore-dangle */
-
-// NOTE: Deprecated, please use tools or response_format with json_schema instead
-
-const SPACE_RULE = '" "?'
-
-function buildRepetition(
-  itemRule: string,
-  minItems: number,
-  maxItems: number | undefined,
-  opts: {
-    separatorRule?: string
-    itemRuleIsLiteral?: boolean
-  } = {},
-) {
-  const separatorRule = opts.separatorRule ?? ''
-  const itemRuleIsLiteral = opts.itemRuleIsLiteral ?? false
-
-  if (separatorRule === '') {
-    if (minItems === 0 && maxItems === 1) {
-      return `${itemRule}?`
-    } else if (minItems === 1 && maxItems === undefined) {
-      return `${itemRule}+`
-    }
-  }
-
-  let result = ''
-  if (minItems > 0) {
-    if (itemRuleIsLiteral && separatorRule === '') {
-      result = `"${itemRule.slice(1, -1).repeat(minItems)}"`
-    } else {
-      result = Array.from({ length: minItems }, () => itemRule).join(
-        separatorRule !== '' ? ` ${separatorRule} ` : ' ',
-      )
-    }
-  }
-
-  const optRepetitions = (upToN: number, prefixWithSep = false): string => {
-    const content =
-      separatorRule !== '' && prefixWithSep
-        ? `${separatorRule} ${itemRule}`
-        : itemRule
-    if (upToN === 0) {
-      return ''
-    } else if (upToN === 1) {
-      return `(${content})?`
-    } else if (separatorRule !== '' && !prefixWithSep) {
-      return `(${content} ${optRepetitions(upToN - 1, true)})?`
-    } else {
-      return (
-        Array.from({ length: upToN }, () => `(${content}`)
-          .join(' ')
-          .trim() + Array.from({ length: upToN }, () => ')?').join('')
-      )
-    }
-  }
-
-  if (minItems > 0 && maxItems !== minItems) {
-    result += ' '
-  }
-
-  if (maxItems !== undefined) {
-    result += optRepetitions(maxItems - minItems, minItems > 0)
-  } else {
-    const itemOperator = `(${
-      separatorRule !== '' ? `${separatorRule} ` : ''
-    }${itemRule})`
-
-    if (minItems === 0 && separatorRule !== '') {
-      result = `(${itemRule} ${itemOperator}*)?`
-    } else {
-      result += `${itemOperator}*`
-    }
-  }
-
-  return result
-}
-
-export class SchemaGrammarConverterBuiltinRule {
-  content: string
-
-  deps: string[]
-
-  constructor(content: string, deps: string[]) {
-    this.content = content
-    this.deps = deps || []
-  }
-}
-
-const BuiltinRule = SchemaGrammarConverterBuiltinRule
-
-const UP_TO_15_DIGITS = buildRepetition('[0-9]', 0, 15)
-
-const PRIMITIVE_RULES: { [key: string]: SchemaGrammarConverterBuiltinRule } = {
-  boolean: new BuiltinRule('("true" | "false") space', []),
-  'decimal-part': new BuiltinRule(`[0-9] ${UP_TO_15_DIGITS}`, []),
-  'integral-part': new BuiltinRule(`[0-9] | [1-9] ${UP_TO_15_DIGITS}`, []),
-  number: new BuiltinRule(
-    '("-"? integral-part) ("." decimal-part)? ([eE] [-+]? integral-part)? space',
-    ['integral-part', 'decimal-part'],
-  ),
-  integer: new BuiltinRule('("-"? integral-part) space', ['integral-part']),
-  value: new BuiltinRule('object | array | string | number | boolean | null', [
-    'object',
-    'array',
-    'string',
-    'number',
-    'boolean',
-    'null',
-  ]),
-  object: new BuiltinRule(
-    '"{" space ( string ":" space value ("," space string ":" space value)* )? "}" space',
-    ['string', 'value'],
-  ),
-  array: new BuiltinRule('"[" space ( value ("," space value)* )? "]" space', [
-    'value',
-  ]),
-  uuid: new BuiltinRule(
-    `"\\"" ${[8, 4, 4, 4, 12]
-      .map((n) => [...new Array(n)].map((_) => '[0-9a-fA-F]').join(''))
-      .join(' "-" ')} "\\"" space`,
-    [],
-  ),
-  char: new BuiltinRule(
-    `[^"\\\\] | "\\\\" (["\\\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F])`,
-    [],
-  ),
-  string: new BuiltinRule(`"\\"" char* "\\"" space`, ['char']),
-  null: new BuiltinRule('"null" space', []),
-}
-
-// TODO: support "uri", "email" string formats
-const STRING_FORMAT_RULES: { [key: string]: SchemaGrammarConverterBuiltinRule } = {
-  date: new BuiltinRule(
-    '[0-9] [0-9] [0-9] [0-9] "-" ( "0" [1-9] | "1" [0-2] ) "-" ( "0" [1-9] | [1-2] [0-9] | "3" [0-1] )',
-    [],
-  ),
-  time: new BuiltinRule(
-    '([01] [0-9] | "2" [0-3]) ":" [0-5] [0-9] ":" [0-5] [0-9] ( "." [0-9] [0-9] [0-9] )? ( "Z" | ( "+" | "-" ) ( [01] [0-9] | "2" [0-3] ) ":" [0-5] [0-9] )',
-    [],
-  ),
-  'date-time': new BuiltinRule('date "T" time', ['date', 'time']),
-  'date-string': new BuiltinRule('"\\"" date "\\"" space', ['date']),
-  'time-string': new BuiltinRule('"\\"" time "\\"" space', ['time']),
-  'date-time-string': new BuiltinRule('"\\"" date-time "\\"" space', [
-    'date-time',
-  ]),
-}
-
-const RESERVED_NAMES = {
-  root: true,
-  ...PRIMITIVE_RULES,
-  ...STRING_FORMAT_RULES,
-}
-
-const INVALID_RULE_CHARS_RE = /[^\dA-Za-z-]+/g
-const GRAMMAR_LITERAL_ESCAPE_RE = /[\n\r"]/g
-const GRAMMAR_LITERAL_ESCAPES: any = {
-  '\r': '\\r',
-  '\n': '\\n',
-  '"': '\\"',
-  '-': '\\-',
-  ']': '\\]',
-}
-
-const NON_LITERAL_SET = new Set('|.()[]{}*+?')
-const ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS = new Set('[]()|{}*+?')
-
-const formatLiteral = (literal: string): string => {
-  const escaped = literal.replace(
-    GRAMMAR_LITERAL_ESCAPE_RE,
-    (m) => GRAMMAR_LITERAL_ESCAPES[m] || '',
-  )
-  return `"${escaped}"`
-}
-
-const generateConstantRule = (value: any): string =>
-  formatLiteral(JSON.stringify(value))
-
-export interface SchemaGrammarConverterPropOrder {
-  [key: string]: number
-}
-
-// Helper function to group elements by a key function
-function* groupBy(iterable: Iterable<any>, keyFn: (x: any) => any) {
-  let lastKey = null
-  let group = []
-  for (const element of iterable) {
-    const key = keyFn(element)
-    if (lastKey !== null && key !== lastKey) {
-      yield [lastKey, group]
-      group = []
-    }
-    group.push(element)
-    lastKey = key
-  }
-  if (group.length > 0) {
-    yield [lastKey, group]
-  }
-}
-
-export class SchemaGrammarConverter {
-  private _propOrder: SchemaGrammarConverterPropOrder
-
-  private _allowFetch: boolean
-
-  private _dotall: boolean
-
-  private _rules: { [key: string]: string }
-
-  private _refs: { [key: string]: any }
-
-  private _refsBeingResolved: Set<string>
-
-  constructor(options: {
-    prop_order?: SchemaGrammarConverterPropOrder
-    allow_fetch?: boolean
-    dotall?: boolean
-  }) {
-    this._propOrder = options.prop_order || {}
-    this._allowFetch = options.allow_fetch || false
-    this._dotall = options.dotall || false
-    this._rules = { space: SPACE_RULE }
-    this._refs = {}
-    this._refsBeingResolved = new Set()
-  }
-
-  _addRule(name: string, rule: string): string {
-    const escName = name.replace(INVALID_RULE_CHARS_RE, '-')
-    let key = escName
-
-    if (escName in this._rules) {
-      if (this._rules[escName] === rule) {
-        return key
-      }
-
-      let i = 0
-      while (
-        `${escName}${i}` in this._rules &&
-        this._rules[`${escName}${i}`] !== rule
-      ) {
-        i += 1
-      }
-      key = `${escName}${i}`
-    }
-
-    this._rules[key] = rule
-    return key
-  }
-
-  async resolveRefs(schema: any, url: string): Promise<any> {
-    const visit: any = async (n: any) => {
-      if (Array.isArray(n)) {
-        return Promise.all(n.map(visit))
-      } else if (typeof n === 'object' && n !== null) {
-        let ref = n.$ref
-        let target
-        if (ref !== undefined && !this._refs[ref]) {
-          if (ref.startsWith('https://')) {
-            if (!this._allowFetch) {
-              throw new Error(
-                'Fetching remote schemas is not allowed (use --allow-fetch for force)',
-              )
-            }
-
-            const fragSplit = ref.split('#')
-            const baseUrl = fragSplit[0]
-
-            target = this._refs[baseUrl]
-            if (!target) {
-              target = await this.resolveRefs(
-                await fetch(ref).then((res) => res.json()),
-                baseUrl,
-              )
-              this._refs[baseUrl] = target
-            }
-
-            if (
-              fragSplit.length === 1 ||
-              fragSplit[fragSplit.length - 1] === ''
-            ) {
-              return target
-            }
-          } else if (ref.startsWith('#/')) {
-            target = schema
-            ref = `${url}${ref}`
-            n.$ref = ref
-          } else {
-            throw new Error(`Unsupported ref ${ref}`)
-          }
-
-          const selectors = ref.split('#')[1].split('/').slice(1)
-          for (const sel of selectors) {
-            if (!target || !(sel in target)) {
-              throw new Error(
-                `Error resolving ref ${ref}: ${sel} not in ${JSON.stringify(
-                  target,
-                )}`,
-              )
-            }
-            target = target[sel]
-          }
-
-          this._refs[ref] = target
-        } else {
-          await Promise.all(Object.values(n).map(visit))
-        }
-      }
-
-      return n
-    }
-
-    return visit(schema)
-  }
-
-  _generateUnionRule(name: string, altSchemas: any[]): string {
-    return altSchemas
-      .map((altSchema, i) =>
-        this.visit(
-          altSchema,
-          `${name ?? ''}${name ? '-' : 'alternative-'}${i}`,
-        ),
-      )
-      .join(' | ')
-  }
-
-  _visitPattern(pattern: string, name: string): string {
-    if (!pattern.startsWith('^') || !pattern.endsWith('$')) {
-      throw new Error('Pattern must start with "^" and end with "$"')
-    }
-    pattern = pattern.slice(1, -1)
-    const subRuleIds: { [key: string]: string } = {}
-
-    let i = 0
-    const { length } = pattern
-
-    const getDot = () => {
-      let rule
-      if (this._dotall) {
-        rule = '[\\U00000000-\\U0010FFFF]'
-      } else {
-        // Accept any character... except \n and \r line break chars (\x0A and \xOD)
-        rule = '[^\\x0A\\x0D]'
-      }
-      return this._addRule('dot', rule)
-    }
-
-    const toRule = ([s, isLiteral]: [string, boolean]) =>
-      isLiteral ? `"${s}"` : s
-
-    const transform = () => {
-      const start = i
-      // For each component of this sequence, store its string representation and whether it's a literal.
-      // We only need a flat structure here to apply repetition operators to the last item, and
-      // to merge literals at the and (we're parsing grouped ( sequences ) recursively and don't treat '|' specially
-      // (GBNF's syntax is luckily very close to regular expressions!)
-      const seq: Array<[string, boolean]> = []
-
-      const joinSeq = () => {
-        const ret = []
-        for (const [isLiteral, g] of groupBy(seq, (x) => x[1])) {
-          if (isLiteral) {
-            ret.push([[...g].map((x) => x[0]).join(''), true])
-          } else {
-            ret.push(...g)
-          }
-        }
-        if (ret.length === 1) {
-          return ret[0]
-        }
-        return [ret.map((x) => toRule(x)).join(' '), false]
-      }
-
-      while (i < length) {
-        const c = pattern[i]
-        if (c === '.') {
-          seq.push([getDot(), false])
-          i += 1
-        } else if (c === '(') {
-          i += 1
-          if (i < length) {
-            if (pattern[i] === '?') {
-              throw new Error(
-                `Unsupported pattern syntax "${pattern[i]}" at index ${i} of /${pattern}/`,
-              )
-            }
-          }
-          seq.push([`(${toRule(transform())})`, false])
-        } else if (c === ')') {
-          i += 1
-          if (start <= 0 || pattern[start - 1] !== '(') {
-            throw new Error(
-              `Unbalanced parentheses; start = ${start}, i = ${i}, pattern = ${pattern}`,
-            )
-          }
-          return joinSeq()
-        } else if (c === '[') {
-          let squareBrackets = c
-          i += 1
-          while (i < length && pattern[i] !== ']') {
-            if (pattern[i] === '\\') {
-              squareBrackets += pattern.slice(i, i + 2)
-              i += 2
-            } else {
-              squareBrackets += pattern[i]
-              i += 1
-            }
-          }
-          if (i >= length) {
-            throw new Error(
-              `Unbalanced square brackets; start = ${start}, i = ${i}, pattern = ${pattern}`,
-            )
-          }
-          squareBrackets += ']'
-          i += 1
-          seq.push([squareBrackets, false])
-        } else if (c === '|') {
-          seq.push(['|', false])
-          i += 1
-        } else if (c === '*' || c === '+' || c === '?') {
-          seq[seq.length - 1] = [
-            toRule(seq[seq.length - 1] || ['', false]) + c,
-            false,
-          ]
-          i += 1
-        } else if (c === '{') {
-          let curlyBrackets = c
-          i += 1
-          while (i < length && pattern[i] !== '}') {
-            curlyBrackets += pattern[i]
-            i += 1
-          }
-          if (i >= length) {
-            throw new Error(
-              `Unbalanced curly brackets; start = ${start}, i = ${i}, pattern = ${pattern}`,
-            )
-          }
-          curlyBrackets += '}'
-          i += 1
-          const nums = curlyBrackets
-            .slice(1, -1)
-            .split(',')
-            .map((s) => s.trim())
-          let minTimes: number
-          let maxTimes: number | undefined
-          if (nums.length === 1) {
-            minTimes = parseInt(nums[0] as string, 10)
-            maxTimes = minTimes
-          } else {
-            if (nums.length !== 2) {
-              throw new Error(`Invalid quantifier ${curlyBrackets}`)
-            }
-            minTimes = nums[0] ? parseInt(nums[0], 10) : 0
-            maxTimes = nums[1] ? parseInt(nums[1], 10) : Infinity
-          }
-
-          let [sub] = seq[seq.length - 1] || ['', false]
-          const [, subIsLiteral] = seq[seq.length - 1] || ['', false]
-
-          if (!subIsLiteral) {
-            let id = subRuleIds[sub]
-            if (id === undefined) {
-              id = this._addRule(
-                `${name}-${Object.keys(subRuleIds).length + 1}`,
-                sub,
-              )
-              subRuleIds[sub] = id
-            }
-            sub = id
-          }
-
-          seq[seq.length - 1] = [
-            buildRepetition(
-              subIsLiteral ? `"${sub}"` : sub,
-              minTimes,
-              maxTimes,
-              { itemRuleIsLiteral: subIsLiteral },
-            ),
-            false,
-          ]
-        } else {
-          let literal = ''
-          while (i < length) {
-            if (pattern[i] === '\\' && i < length - 1) {
-              const next = pattern[i + 1]
-              if (ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.has(next || '')) {
-                i += 1
-                literal += pattern[i]
-                i += 1
-              } else {
-                literal += pattern.slice(i, i + 2)
-                i += 2
-              }
-            } else if (pattern[i] === '"') {
-              literal += '\\"'
-              i += 1
-            } else if (
-              !NON_LITERAL_SET.has(pattern[i] || '') &&
-              (i === length - 1 ||
-                literal === '' ||
-                pattern[i + 1] === '.' ||
-                !NON_LITERAL_SET.has(pattern[i + 1] || ''))
-            ) {
-              literal += pattern[i]
-              i += 1
-            } else {
-              break
-            }
-          }
-          if (literal !== '') {
-            seq.push([literal, true])
-          }
-        }
-      }
-
-      return joinSeq()
-    }
-
-    return this._addRule(name, `"\\"" ${toRule(transform())} "\\"" space`)
-  }
-
-  _resolveRef(ref: string): string {
-    let refName = ref.split('/').pop() || ''
-    if (!(refName in this._rules) && !this._refsBeingResolved.has(ref)) {
-      this._refsBeingResolved.add(ref)
-      const resolved = this._refs[ref]
-      refName = this.visit(resolved, refName)
-      this._refsBeingResolved.delete(ref)
-    }
-    return refName
-  }
-
-  visit(schema: any, name: string): string {
-    const schemaType = schema.type
-    const schemaFormat = schema.format
-    const isRoot = name in RESERVED_NAMES ? `${name}-` : name == ''
-    const ruleName = isRoot ? 'root' : name
-
-    const ref = schema.$ref
-    if (ref !== undefined) {
-      return this._addRule(ruleName, this._resolveRef(ref))
-    } else if (schema.oneOf || schema.anyOf) {
-      return this._addRule(
-        ruleName,
-        this._generateUnionRule(name, schema.oneOf || schema.anyOf),
-      )
-    } else if (Array.isArray(schemaType)) {
-      return this._addRule(
-        ruleName,
-        this._generateUnionRule(
-          name,
-          schemaType.map((t) => ({ type: t })),
-        ),
-      )
-    } else if ('const' in schema) {
-      return this._addRule(ruleName, generateConstantRule(schema.const))
-    } else if ('enum' in schema) {
-      const rule = schema.enum
-        .map((v: any) => generateConstantRule(v))
-        .join(' | ')
-      return this._addRule(ruleName, rule)
-    } else if (
-      (schemaType === undefined || schemaType === 'object') &&
-      ('properties' in schema ||
-        ('additionalProperties' in schema &&
-          schema.additionalProperties !== true))
-    ) {
-      const required: Set<string> = new Set(schema.required || [])
-      const properties = Object.entries(schema.properties ?? {})
-      return this._addRule(
-        ruleName,
-        this._buildObjectRule(
-          properties,
-          required,
-          name,
-          schema.additionalProperties,
-        ),
-      )
-    } else if (
-      (schemaType === undefined || schemaType === 'object') &&
-      'allOf' in schema
-    ) {
-      const required: Set<string> = new Set()
-      const properties: Array<[string, any]> = []
-      const addComponent = (compSchema: any, isRequired: boolean) => {
-        if (compSchema.$ref !== undefined) {
-          compSchema = this._refs[compSchema.$ref]
-        }
-
-        if ('properties' in compSchema) {
-          for (const [propName, propSchema] of Object.entries(
-            compSchema.properties,
-          )) {
-            properties.push([propName, propSchema])
-            if (isRequired) {
-              required.add(propName)
-            }
-          }
-        }
-      }
-
-      for (const t of schema.allOf) {
-        if ('anyOf' in t) {
-          for (const tt of t.anyOf) {
-            addComponent(tt, false)
-          }
-        } else {
-          addComponent(t, true)
-        }
-      }
-
-      return this._addRule(
-        ruleName,
-        this._buildObjectRule(
-          properties,
-          required,
-          name,
-          /* additionalProperties= */ false,
-        ),
-      )
-    } else if (
-      (schemaType === undefined || schemaType === 'array') &&
-      ('items' in schema || 'prefixItems' in schema)
-    ) {
-      const items = schema.items ?? schema.prefixItems
-      if (Array.isArray(items)) {
-        const rules = items
-          .map((item, i) =>
-            this.visit(item, `${name ?? ''}${name ? '-' : ''}tuple-${i}`),
-          )
-          .join(' "," space ')
-        return this._addRule(ruleName, `"[" space ${rules} "]" space`)
-      } else {
-        const itemRuleName = this.visit(
-          items,
-          `${name ?? ''}${name ? '-' : ''}item`,
-        )
-        const minItems = schema.minItems || 0
-        const { maxItems } = schema
-        return this._addRule(
-          ruleName,
-          `"[" space ${buildRepetition(itemRuleName, minItems, maxItems, {
-            separatorRule: '"," space',
-          })} "]" space`,
-        )
-      }
-    } else if (
-      (schemaType === undefined || schemaType === 'string') &&
-      'pattern' in schema
-    ) {
-      return this._visitPattern(schema.pattern, ruleName)
-    } else if (
-      (schemaType === undefined || schemaType === 'string') &&
-      /^uuid[1-5]?$/.test(schema.format || '')
-    ) {
-      return this._addPrimitive(
-        ruleName === 'root' ? 'root' : schemaFormat,
-        PRIMITIVE_RULES['uuid'],
-      )
-    } else if (
-      (schemaType === undefined || schemaType === 'string') &&
-      `${schema.format}-string` in STRING_FORMAT_RULES
-    ) {
-      const primName = `${schema.format}-string`
-      return this._addRule(
-        ruleName,
-        this._addPrimitive(primName, STRING_FORMAT_RULES[primName]),
-      )
-    } else if (
-      schemaType === 'string' &&
-      ('minLength' in schema || 'maxLength' in schema)
-    ) {
-      const charRuleName = this._addPrimitive('char', PRIMITIVE_RULES['char'])
-      const minLen = schema.minLength || 0
-      const maxLen = schema.maxLength
-      return this._addRule(
-        ruleName,
-        `"\\"" ${buildRepetition(charRuleName, minLen, maxLen)} "\\"" space`,
-      )
-    } else if (schemaType === 'object' || Object.keys(schema).length === 0) {
-      return this._addRule(
-        ruleName,
-        this._addPrimitive('object', PRIMITIVE_RULES['object']),
-      )
-    } else {
-      if (!(schemaType in PRIMITIVE_RULES)) {
-        throw new Error(`Unrecognized schema: ${JSON.stringify(schema)}`)
-      }
-      // TODO: support minimum, maximum, exclusiveMinimum, exclusiveMaximum at least for zero
-      return this._addPrimitive(
-        ruleName === 'root' ? 'root' : schemaType,
-        PRIMITIVE_RULES[schemaType],
-      )
-    }
-  }
-
-  _addPrimitive(name: string, rule: SchemaGrammarConverterBuiltinRule | undefined) {
-    if (!rule) {
-      throw new Error(`Rule ${name} not known`)
-    }
-    const n = this._addRule(name, rule.content)
-    for (const dep of rule.deps) {
-      const depRule = PRIMITIVE_RULES[dep] || STRING_FORMAT_RULES[dep]
-      if (!depRule) {
-        throw new Error(`Rule ${dep} not known`)
-      }
-      if (!(dep in this._rules)) {
-        this._addPrimitive(dep, depRule)
-      }
-    }
-    return n
-  }
-
-  _buildObjectRule(
-    properties: any[],
-    required: Set<string>,
-    name: string,
-    additionalProperties: any,
-  ) {
-    const propOrder = this._propOrder
-    // sort by position in prop_order (if specified) then by original order
-    const sortedProps = properties
-      .map(([k]) => k)
-      .sort((a, b) => {
-        const orderA = propOrder[a] || Infinity
-        const orderB = propOrder[b] || Infinity
-        return (
-          orderA - orderB ||
-          properties.findIndex(([k]) => k === a) -
-            properties.findIndex(([k]) => k === b)
-        )
-      })
-
-    const propKvRuleNames: { [key: string]: string } = {}
-    for (const [propName, propSchema] of properties) {
-      const propRuleName = this.visit(
-        propSchema,
-        `${name ?? ''}${name ? '-' : ''}${propName}`,
-      )
-      propKvRuleNames[propName] = this._addRule(
-        `${name ?? ''}${name ? '-' : ''}${propName}-kv`,
-        `${formatLiteral(
-          JSON.stringify(propName),
-        )} space ":" space ${propRuleName}`,
-      )
-    }
-    const requiredProps = sortedProps.filter((k) => required.has(k))
-    const optionalProps = sortedProps.filter((k) => !required.has(k))
-
-    if (
-      typeof additionalProperties === 'object' ||
-      additionalProperties === true
-    ) {
-      const subName = `${name ?? ''}${name ? '-' : ''}additional`
-      const valueRule = this.visit(
-        additionalProperties === true ? {} : additionalProperties,
-        `${subName}-value`,
-      )
-      propKvRuleNames['*'] = this._addRule(
-        `${subName}-kv`,
-        `${this._addPrimitive(
-          'string',
-          PRIMITIVE_RULES['string'],
-        )} ":" space ${valueRule}`,
-      )
-      optionalProps.push('*')
-    }
-
-    let rule = '"{" space '
-    rule += requiredProps.map((k) => propKvRuleNames[k]).join(' "," space ')
-
-    if (optionalProps.length > 0) {
-      rule += ' ('
-      if (requiredProps.length > 0) {
-        rule += ' "," space ( '
-      }
-
-      const getRecursiveRefs = (ks: any[], firstIsOptional: boolean) => {
-        const [k, ...rest] = ks
-        const kvRuleName = propKvRuleNames[k]
-        let res
-        if (k === '*') {
-          res = this._addRule(
-            `${name ?? ''}${name ? '-' : ''}additional-kvs`,
-            `${kvRuleName} ( "," space ${kvRuleName} )*`,
-          )
-        } else if (firstIsOptional) {
-          res = `( "," space ${kvRuleName} )?`
-        } else {
-          res = kvRuleName
-        }
-        if (rest.length > 0) {
-          res += ` ${this._addRule(
-            `${name ?? ''}${name ? '-' : ''}${k}-rest`,
-            getRecursiveRefs(rest, true) || '',
-          )}`
-        }
-        return res
-      }
-
-      rule += optionalProps
-        .map((_: any, i: number) =>
-          getRecursiveRefs(optionalProps.slice(i), false),
-        )
-        .join(' | ')
-      if (requiredProps.length > 0) {
-        rule += ' )'
-      }
-      rule += ' )?'
-    }
-
-    rule += ' "}" space'
-
-    return rule
-  }
-
-  formatGrammar() {
-    let grammar = ''
-    for (const [name, rule] of Object.entries(this._rules).sort(([a], [b]) =>
-      a.localeCompare(b),
-    )) {
-      grammar += `${name} ::= ${rule}\n`
-    }
-    return grammar
-  }
-}
-
-export const convertJsonSchemaToGrammar = ({
-  schema,
-  propOrder,
-  dotall,
-  allowFetch,
-}: {
-  schema: any
-  propOrder?: SchemaGrammarConverterPropOrder
-  dotall?: boolean
-  allowFetch?: boolean
-}): string | Promise<string> => {
-  const converter = new SchemaGrammarConverter({
-    prop_order: propOrder,
-    dotall,
-    allow_fetch: allowFetch,
-  })
-
-  if (allowFetch) {
-    return converter.resolveRefs(schema, '').then(() => {
-      converter.visit(schema, '')
-      return converter.formatGrammar()
-    })
-  }
-  converter.visit(schema, '')
-  return converter.formatGrammar()
-}
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-underscore-dangle */
+
+// NOTE: Deprecated, please use tools or response_format with json_schema instead
+
+const SPACE_RULE = '" "?'
+
+function buildRepetition(
+  itemRule: string,
+  minItems: number,
+  maxItems: number | undefined,
+  opts: {
+    separatorRule?: string
+    itemRuleIsLiteral?: boolean
+  } = {},
+) {
+  const separatorRule = opts.separatorRule ?? ''
+  const itemRuleIsLiteral = opts.itemRuleIsLiteral ?? false
+
+  if (separatorRule === '') {
+    if (minItems === 0 && maxItems === 1) {
+      return `${itemRule}?`
+    } else if (minItems === 1 && maxItems === undefined) {
+      return `${itemRule}+`
+    }
+  }
+
+  let result = ''
+  if (minItems > 0) {
+    if (itemRuleIsLiteral && separatorRule === '') {
+      result = `"${itemRule.slice(1, -1).repeat(minItems)}"`
+    } else {
+      result = Array.from({ length: minItems }, () => itemRule).join(
+        separatorRule !== '' ? ` ${separatorRule} ` : ' ',
+      )
+    }
+  }
+
+  const optRepetitions = (upToN: number, prefixWithSep = false): string => {
+    const content =
+      separatorRule !== '' && prefixWithSep
+        ? `${separatorRule} ${itemRule}`
+        : itemRule
+    if (upToN === 0) {
+      return ''
+    } else if (upToN === 1) {
+      return `(${content})?`
+    } else if (separatorRule !== '' && !prefixWithSep) {
+      return `(${content} ${optRepetitions(upToN - 1, true)})?`
+    } else {
+      return (
+        Array.from({ length: upToN }, () => `(${content}`)
+          .join(' ')
+          .trim() + Array.from({ length: upToN }, () => ')?').join('')
+      )
+    }
+  }
+
+  if (minItems > 0 && maxItems !== minItems) {
+    result += ' '
+  }
+
+  if (maxItems !== undefined) {
+    result += optRepetitions(maxItems - minItems, minItems > 0)
+  } else {
+    const itemOperator = `(${
+      separatorRule !== '' ? `${separatorRule} ` : ''
+    }${itemRule})`
+
+    if (minItems === 0 && separatorRule !== '') {
+      result = `(${itemRule} ${itemOperator}*)?`
+    } else {
+      result += `${itemOperator}*`
+    }
+  }
+
+  return result
+}
+
+export class SchemaGrammarConverterBuiltinRule {
+  content: string
+
+  deps: string[]
+
+  constructor(content: string, deps: string[]) {
+    this.content = content
+    this.deps = deps || []
+  }
+}
+
+const BuiltinRule = SchemaGrammarConverterBuiltinRule
+
+const UP_TO_15_DIGITS = buildRepetition('[0-9]', 0, 15)
+
+const PRIMITIVE_RULES: { [key: string]: SchemaGrammarConverterBuiltinRule } = {
+  boolean: new BuiltinRule('("true" | "false") space', []),
+  'decimal-part': new BuiltinRule(`[0-9] ${UP_TO_15_DIGITS}`, []),
+  'integral-part': new BuiltinRule(`[0-9] | [1-9] ${UP_TO_15_DIGITS}`, []),
+  number: new BuiltinRule(
+    '("-"? integral-part) ("." decimal-part)? ([eE] [-+]? integral-part)? space',
+    ['integral-part', 'decimal-part'],
+  ),
+  integer: new BuiltinRule('("-"? integral-part) space', ['integral-part']),
+  value: new BuiltinRule('object | array | string | number | boolean | null', [
+    'object',
+    'array',
+    'string',
+    'number',
+    'boolean',
+    'null',
+  ]),
+  object: new BuiltinRule(
+    '"{" space ( string ":" space value ("," space string ":" space value)* )? "}" space',
+    ['string', 'value'],
+  ),
+  array: new BuiltinRule('"[" space ( value ("," space value)* )? "]" space', [
+    'value',
+  ]),
+  uuid: new BuiltinRule(
+    `"\\"" ${[8, 4, 4, 4, 12]
+      .map((n) => [...new Array(n)].map((_) => '[0-9a-fA-F]').join(''))
+      .join(' "-" ')} "\\"" space`,
+    [],
+  ),
+  char: new BuiltinRule(
+    `[^"\\\\] | "\\\\" (["\\\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F])`,
+    [],
+  ),
+  string: new BuiltinRule(`"\\"" char* "\\"" space`, ['char']),
+  null: new BuiltinRule('"null" space', []),
+}
+
+// TODO: support "uri", "email" string formats
+const STRING_FORMAT_RULES: { [key: string]: SchemaGrammarConverterBuiltinRule } = {
+  date: new BuiltinRule(
+    '[0-9] [0-9] [0-9] [0-9] "-" ( "0" [1-9] | "1" [0-2] ) "-" ( "0" [1-9] | [1-2] [0-9] | "3" [0-1] )',
+    [],
+  ),
+  time: new BuiltinRule(
+    '([01] [0-9] | "2" [0-3]) ":" [0-5] [0-9] ":" [0-5] [0-9] ( "." [0-9] [0-9] [0-9] )? ( "Z" | ( "+" | "-" ) ( [01] [0-9] | "2" [0-3] ) ":" [0-5] [0-9] )',
+    [],
+  ),
+  'date-time': new BuiltinRule('date "T" time', ['date', 'time']),
+  'date-string': new BuiltinRule('"\\"" date "\\"" space', ['date']),
+  'time-string': new BuiltinRule('"\\"" time "\\"" space', ['time']),
+  'date-time-string': new BuiltinRule('"\\"" date-time "\\"" space', [
+    'date-time',
+  ]),
+}
+
+const RESERVED_NAMES = {
+  root: true,
+  ...PRIMITIVE_RULES,
+  ...STRING_FORMAT_RULES,
+}
+
+const INVALID_RULE_CHARS_RE = /[^\dA-Za-z-]+/g
+const GRAMMAR_LITERAL_ESCAPE_RE = /[\n\r"]/g
+const GRAMMAR_LITERAL_ESCAPES: any = {
+  '\r': '\\r',
+  '\n': '\\n',
+  '"': '\\"',
+  '-': '\\-',
+  ']': '\\]',
+}
+
+const NON_LITERAL_SET = new Set('|.()[]{}*+?')
+const ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS = new Set('[]()|{}*+?')
+
+const formatLiteral = (literal: string): string => {
+  const escaped = literal.replace(
+    GRAMMAR_LITERAL_ESCAPE_RE,
+    (m) => GRAMMAR_LITERAL_ESCAPES[m] || '',
+  )
+  return `"${escaped}"`
+}
+
+const generateConstantRule = (value: any): string =>
+  formatLiteral(JSON.stringify(value))
+
+export interface SchemaGrammarConverterPropOrder {
+  [key: string]: number
+}
+
+// Helper function to group elements by a key function
+function* groupBy(iterable: Iterable<any>, keyFn: (x: any) => any) {
+  let lastKey = null
+  let group = []
+  for (const element of iterable) {
+    const key = keyFn(element)
+    if (lastKey !== null && key !== lastKey) {
+      yield [lastKey, group]
+      group = []
+    }
+    group.push(element)
+    lastKey = key
+  }
+  if (group.length > 0) {
+    yield [lastKey, group]
+  }
+}
+
+export class SchemaGrammarConverter {
+  private _propOrder: SchemaGrammarConverterPropOrder
+
+  private _allowFetch: boolean
+
+  private _dotall: boolean
+
+  private _rules: { [key: string]: string }
+
+  private _refs: { [key: string]: any }
+
+  private _refsBeingResolved: Set<string>
+
+  constructor(options: {
+    prop_order?: SchemaGrammarConverterPropOrder
+    allow_fetch?: boolean
+    dotall?: boolean
+  }) {
+    this._propOrder = options.prop_order || {}
+    this._allowFetch = options.allow_fetch || false
+    this._dotall = options.dotall || false
+    this._rules = { space: SPACE_RULE }
+    this._refs = {}
+    this._refsBeingResolved = new Set()
+  }
+
+  _addRule(name: string, rule: string): string {
+    const escName = name.replace(INVALID_RULE_CHARS_RE, '-')
+    let key = escName
+
+    if (escName in this._rules) {
+      if (this._rules[escName] === rule) {
+        return key
+      }
+
+      let i = 0
+      while (
+        `${escName}${i}` in this._rules &&
+        this._rules[`${escName}${i}`] !== rule
+      ) {
+        i += 1
+      }
+      key = `${escName}${i}`
+    }
+
+    this._rules[key] = rule
+    return key
+  }
+
+  async resolveRefs(schema: any, url: string): Promise<any> {
+    const visit: any = async (n: any) => {
+      if (Array.isArray(n)) {
+        return Promise.all(n.map(visit))
+      } else if (typeof n === 'object' && n !== null) {
+        let ref = n.$ref
+        let target
+        if (ref !== undefined && !this._refs[ref]) {
+          if (ref.startsWith('https://')) {
+            if (!this._allowFetch) {
+              throw new Error(
+                'Fetching remote schemas is not allowed (use --allow-fetch for force)',
+              )
+            }
+
+            const fragSplit = ref.split('#')
+            const baseUrl = fragSplit[0]
+
+            target = this._refs[baseUrl]
+            if (!target) {
+              target = await this.resolveRefs(
+                await fetch(ref).then((res) => res.json()),
+                baseUrl,
+              )
+              this._refs[baseUrl] = target
+            }
+
+            if (
+              fragSplit.length === 1 ||
+              fragSplit[fragSplit.length - 1] === ''
+            ) {
+              return target
+            }
+          } else if (ref.startsWith('#/')) {
+            target = schema
+            ref = `${url}${ref}`
+            n.$ref = ref
+          } else {
+            throw new Error(`Unsupported ref ${ref}`)
+          }
+
+          const selectors = ref.split('#')[1].split('/').slice(1)
+          for (const sel of selectors) {
+            if (!target || !(sel in target)) {
+              throw new Error(
+                `Error resolving ref ${ref}: ${sel} not in ${JSON.stringify(
+                  target,
+                )}`,
+              )
+            }
+            target = target[sel]
+          }
+
+          this._refs[ref] = target
+        } else {
+          await Promise.all(Object.values(n).map(visit))
+        }
+      }
+
+      return n
+    }
+
+    return visit(schema)
+  }
+
+  _generateUnionRule(name: string, altSchemas: any[]): string {
+    return altSchemas
+      .map((altSchema, i) =>
+        this.visit(
+          altSchema,
+          `${name ?? ''}${name ? '-' : 'alternative-'}${i}`,
+        ),
+      )
+      .join(' | ')
+  }
+
+  _visitPattern(pattern: string, name: string): string {
+    if (!pattern.startsWith('^') || !pattern.endsWith('$')) {
+      throw new Error('Pattern must start with "^" and end with "$"')
+    }
+    pattern = pattern.slice(1, -1)
+    const subRuleIds: { [key: string]: string } = {}
+
+    let i = 0
+    const { length } = pattern
+
+    const getDot = () => {
+      let rule
+      if (this._dotall) {
+        rule = '[\\U00000000-\\U0010FFFF]'
+      } else {
+        // Accept any character... except \n and \r line break chars (\x0A and \xOD)
+        rule = '[^\\x0A\\x0D]'
+      }
+      return this._addRule('dot', rule)
+    }
+
+    const toRule = ([s, isLiteral]: [string, boolean]) =>
+      isLiteral ? `"${s}"` : s
+
+    const transform = () => {
+      const start = i
+      // For each component of this sequence, store its string representation and whether it's a literal.
+      // We only need a flat structure here to apply repetition operators to the last item, and
+      // to merge literals at the and (we're parsing grouped ( sequences ) recursively and don't treat '|' specially
+      // (GBNF's syntax is luckily very close to regular expressions!)
+      const seq: Array<[string, boolean]> = []
+
+      const joinSeq = () => {
+        const ret = []
+        for (const [isLiteral, g] of groupBy(seq, (x) => x[1])) {
+          if (isLiteral) {
+            ret.push([[...g].map((x) => x[0]).join(''), true])
+          } else {
+            ret.push(...g)
+          }
+        }
+        if (ret.length === 1) {
+          return ret[0]
+        }
+        return [ret.map((x) => toRule(x)).join(' '), false]
+      }
+
+      while (i < length) {
+        const c = pattern[i]
+        if (c === '.') {
+          seq.push([getDot(), false])
+          i += 1
+        } else if (c === '(') {
+          i += 1
+          if (i < length) {
+            if (pattern[i] === '?') {
+              throw new Error(
+                `Unsupported pattern syntax "${pattern[i]}" at index ${i} of /${pattern}/`,
+              )
+            }
+          }
+          seq.push([`(${toRule(transform())})`, false])
+        } else if (c === ')') {
+          i += 1
+          if (start <= 0 || pattern[start - 1] !== '(') {
+            throw new Error(
+              `Unbalanced parentheses; start = ${start}, i = ${i}, pattern = ${pattern}`,
+            )
+          }
+          return joinSeq()
+        } else if (c === '[') {
+          let squareBrackets = c
+          i += 1
+          while (i < length && pattern[i] !== ']') {
+            if (pattern[i] === '\\') {
+              squareBrackets += pattern.slice(i, i + 2)
+              i += 2
+            } else {
+              squareBrackets += pattern[i]
+              i += 1
+            }
+          }
+          if (i >= length) {
+            throw new Error(
+              `Unbalanced square brackets; start = ${start}, i = ${i}, pattern = ${pattern}`,
+            )
+          }
+          squareBrackets += ']'
+          i += 1
+          seq.push([squareBrackets, false])
+        } else if (c === '|') {
+          seq.push(['|', false])
+          i += 1
+        } else if (c === '*' || c === '+' || c === '?') {
+          seq[seq.length - 1] = [
+            toRule(seq[seq.length - 1] || ['', false]) + c,
+            false,
+          ]
+          i += 1
+        } else if (c === '{') {
+          let curlyBrackets = c
+          i += 1
+          while (i < length && pattern[i] !== '}') {
+            curlyBrackets += pattern[i]
+            i += 1
+          }
+          if (i >= length) {
+            throw new Error(
+              `Unbalanced curly brackets; start = ${start}, i = ${i}, pattern = ${pattern}`,
+            )
+          }
+          curlyBrackets += '}'
+          i += 1
+          const nums = curlyBrackets
+            .slice(1, -1)
+            .split(',')
+            .map((s) => s.trim())
+          let minTimes: number
+          let maxTimes: number | undefined
+          if (nums.length === 1) {
+            minTimes = parseInt(nums[0] as string, 10)
+            maxTimes = minTimes
+          } else {
+            if (nums.length !== 2) {
+              throw new Error(`Invalid quantifier ${curlyBrackets}`)
+            }
+            minTimes = nums[0] ? parseInt(nums[0], 10) : 0
+            maxTimes = nums[1] ? parseInt(nums[1], 10) : Infinity
+          }
+
+          let [sub] = seq[seq.length - 1] || ['', false]
+          const [, subIsLiteral] = seq[seq.length - 1] || ['', false]
+
+          if (!subIsLiteral) {
+            let id = subRuleIds[sub]
+            if (id === undefined) {
+              id = this._addRule(
+                `${name}-${Object.keys(subRuleIds).length + 1}`,
+                sub,
+              )
+              subRuleIds[sub] = id
+            }
+            sub = id
+          }
+
+          seq[seq.length - 1] = [
+            buildRepetition(
+              subIsLiteral ? `"${sub}"` : sub,
+              minTimes,
+              maxTimes,
+              { itemRuleIsLiteral: subIsLiteral },
+            ),
+            false,
+          ]
+        } else {
+          let literal = ''
+          while (i < length) {
+            if (pattern[i] === '\\' && i < length - 1) {
+              const next = pattern[i + 1]
+              if (ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.has(next || '')) {
+                i += 1
+                literal += pattern[i]
+                i += 1
+              } else {
+                literal += pattern.slice(i, i + 2)
+                i += 2
+              }
+            } else if (pattern[i] === '"') {
+              literal += '\\"'
+              i += 1
+            } else if (
+              !NON_LITERAL_SET.has(pattern[i] || '') &&
+              (i === length - 1 ||
+                literal === '' ||
+                pattern[i + 1] === '.' ||
+                !NON_LITERAL_SET.has(pattern[i + 1] || ''))
+            ) {
+              literal += pattern[i]
+              i += 1
+            } else {
+              break
+            }
+          }
+          if (literal !== '') {
+            seq.push([literal, true])
+          }
+        }
+      }
+
+      return joinSeq()
+    }
+
+    return this._addRule(name, `"\\"" ${toRule(transform())} "\\"" space`)
+  }
+
+  _resolveRef(ref: string): string {
+    let refName = ref.split('/').pop() || ''
+    if (!(refName in this._rules) && !this._refsBeingResolved.has(ref)) {
+      this._refsBeingResolved.add(ref)
+      const resolved = this._refs[ref]
+      refName = this.visit(resolved, refName)
+      this._refsBeingResolved.delete(ref)
+    }
+    return refName
+  }
+
+  visit(schema: any, name: string): string {
+    const schemaType = schema.type
+    const schemaFormat = schema.format
+    const isRoot = name in RESERVED_NAMES ? `${name}-` : name == ''
+    const ruleName = isRoot ? 'root' : name
+
+    const ref = schema.$ref
+    if (ref !== undefined) {
+      return this._addRule(ruleName, this._resolveRef(ref))
+    } else if (schema.oneOf || schema.anyOf) {
+      return this._addRule(
+        ruleName,
+        this._generateUnionRule(name, schema.oneOf || schema.anyOf),
+      )
+    } else if (Array.isArray(schemaType)) {
+      return this._addRule(
+        ruleName,
+        this._generateUnionRule(
+          name,
+          schemaType.map((t) => ({ type: t })),
+        ),
+      )
+    } else if ('const' in schema) {
+      return this._addRule(ruleName, generateConstantRule(schema.const))
+    } else if ('enum' in schema) {
+      const rule = schema.enum
+        .map((v: any) => generateConstantRule(v))
+        .join(' | ')
+      return this._addRule(ruleName, rule)
+    } else if (
+      (schemaType === undefined || schemaType === 'object') &&
+      ('properties' in schema ||
+        ('additionalProperties' in schema &&
+          schema.additionalProperties !== true))
+    ) {
+      const required: Set<string> = new Set(schema.required || [])
+      const properties = Object.entries(schema.properties ?? {})
+      return this._addRule(
+        ruleName,
+        this._buildObjectRule(
+          properties,
+          required,
+          name,
+          schema.additionalProperties,
+        ),
+      )
+    } else if (
+      (schemaType === undefined || schemaType === 'object') &&
+      'allOf' in schema
+    ) {
+      const required: Set<string> = new Set()
+      const properties: Array<[string, any]> = []
+      const addComponent = (compSchema: any, isRequired: boolean) => {
+        if (compSchema.$ref !== undefined) {
+          compSchema = this._refs[compSchema.$ref]
+        }
+
+        if ('properties' in compSchema) {
+          for (const [propName, propSchema] of Object.entries(
+            compSchema.properties,
+          )) {
+            properties.push([propName, propSchema])
+            if (isRequired) {
+              required.add(propName)
+            }
+          }
+        }
+      }
+
+      for (const t of schema.allOf) {
+        if ('anyOf' in t) {
+          for (const tt of t.anyOf) {
+            addComponent(tt, false)
+          }
+        } else {
+          addComponent(t, true)
+        }
+      }
+
+      return this._addRule(
+        ruleName,
+        this._buildObjectRule(
+          properties,
+          required,
+          name,
+          /* additionalProperties= */ false,
+        ),
+      )
+    } else if (
+      (schemaType === undefined || schemaType === 'array') &&
+      ('items' in schema || 'prefixItems' in schema)
+    ) {
+      const items = schema.items ?? schema.prefixItems
+      if (Array.isArray(items)) {
+        const rules = items
+          .map((item, i) =>
+            this.visit(item, `${name ?? ''}${name ? '-' : ''}tuple-${i}`),
+          )
+          .join(' "," space ')
+        return this._addRule(ruleName, `"[" space ${rules} "]" space`)
+      } else {
+        const itemRuleName = this.visit(
+          items,
+          `${name ?? ''}${name ? '-' : ''}item`,
+        )
+        const minItems = schema.minItems || 0
+        const { maxItems } = schema
+        return this._addRule(
+          ruleName,
+          `"[" space ${buildRepetition(itemRuleName, minItems, maxItems, {
+            separatorRule: '"," space',
+          })} "]" space`,
+        )
+      }
+    } else if (
+      (schemaType === undefined || schemaType === 'string') &&
+      'pattern' in schema
+    ) {
+      return this._visitPattern(schema.pattern, ruleName)
+    } else if (
+      (schemaType === undefined || schemaType === 'string') &&
+      /^uuid[1-5]?$/.test(schema.format || '')
+    ) {
+      return this._addPrimitive(
+        ruleName === 'root' ? 'root' : schemaFormat,
+        PRIMITIVE_RULES['uuid'],
+      )
+    } else if (
+      (schemaType === undefined || schemaType === 'string') &&
+      `${schema.format}-string` in STRING_FORMAT_RULES
+    ) {
+      const primName = `${schema.format}-string`
+      return this._addRule(
+        ruleName,
+        this._addPrimitive(primName, STRING_FORMAT_RULES[primName]),
+      )
+    } else if (
+      schemaType === 'string' &&
+      ('minLength' in schema || 'maxLength' in schema)
+    ) {
+      const charRuleName = this._addPrimitive('char', PRIMITIVE_RULES['char'])
+      const minLen = schema.minLength || 0
+      const maxLen = schema.maxLength
+      return this._addRule(
+        ruleName,
+        `"\\"" ${buildRepetition(charRuleName, minLen, maxLen)} "\\"" space`,
+      )
+    } else if (schemaType === 'object' || Object.keys(schema).length === 0) {
+      return this._addRule(
+        ruleName,
+        this._addPrimitive('object', PRIMITIVE_RULES['object']),
+      )
+    } else {
+      if (!(schemaType in PRIMITIVE_RULES)) {
+        throw new Error(`Unrecognized schema: ${JSON.stringify(schema)}`)
+      }
+      // TODO: support minimum, maximum, exclusiveMinimum, exclusiveMaximum at least for zero
+      return this._addPrimitive(
+        ruleName === 'root' ? 'root' : schemaType,
+        PRIMITIVE_RULES[schemaType],
+      )
+    }
+  }
+
+  _addPrimitive(name: string, rule: SchemaGrammarConverterBuiltinRule | undefined) {
+    if (!rule) {
+      throw new Error(`Rule ${name} not known`)
+    }
+    const n = this._addRule(name, rule.content)
+    for (const dep of rule.deps) {
+      const depRule = PRIMITIVE_RULES[dep] || STRING_FORMAT_RULES[dep]
+      if (!depRule) {
+        throw new Error(`Rule ${dep} not known`)
+      }
+      if (!(dep in this._rules)) {
+        this._addPrimitive(dep, depRule)
+      }
+    }
+    return n
+  }
+
+  _buildObjectRule(
+    properties: any[],
+    required: Set<string>,
+    name: string,
+    additionalProperties: any,
+  ) {
+    const propOrder = this._propOrder
+    // sort by position in prop_order (if specified) then by original order
+    const sortedProps = properties
+      .map(([k]) => k)
+      .sort((a, b) => {
+        const orderA = propOrder[a] || Infinity
+        const orderB = propOrder[b] || Infinity
+        return (
+          orderA - orderB ||
+          properties.findIndex(([k]) => k === a) -
+            properties.findIndex(([k]) => k === b)
+        )
+      })
+
+    const propKvRuleNames: { [key: string]: string } = {}
+    for (const [propName, propSchema] of properties) {
+      const propRuleName = this.visit(
+        propSchema,
+        `${name ?? ''}${name ? '-' : ''}${propName}`,
+      )
+      propKvRuleNames[propName] = this._addRule(
+        `${name ?? ''}${name ? '-' : ''}${propName}-kv`,
+        `${formatLiteral(
+          JSON.stringify(propName),
+        )} space ":" space ${propRuleName}`,
+      )
+    }
+    const requiredProps = sortedProps.filter((k) => required.has(k))
+    const optionalProps = sortedProps.filter((k) => !required.has(k))
+
+    if (
+      typeof additionalProperties === 'object' ||
+      additionalProperties === true
+    ) {
+      const subName = `${name ?? ''}${name ? '-' : ''}additional`
+      const valueRule = this.visit(
+        additionalProperties === true ? {} : additionalProperties,
+        `${subName}-value`,
+      )
+      propKvRuleNames['*'] = this._addRule(
+        `${subName}-kv`,
+        `${this._addPrimitive(
+          'string',
+          PRIMITIVE_RULES['string'],
+        )} ":" space ${valueRule}`,
+      )
+      optionalProps.push('*')
+    }
+
+    let rule = '"{" space '
+    rule += requiredProps.map((k) => propKvRuleNames[k]).join(' "," space ')
+
+    if (optionalProps.length > 0) {
+      rule += ' ('
+      if (requiredProps.length > 0) {
+        rule += ' "," space ( '
+      }
+
+      const getRecursiveRefs = (ks: any[], firstIsOptional: boolean) => {
+        const [k, ...rest] = ks
+        const kvRuleName = propKvRuleNames[k]
+        let res
+        if (k === '*') {
+          res = this._addRule(
+            `${name ?? ''}${name ? '-' : ''}additional-kvs`,
+            `${kvRuleName} ( "," space ${kvRuleName} )*`,
+          )
+        } else if (firstIsOptional) {
+          res = `( "," space ${kvRuleName} )?`
+        } else {
+          res = kvRuleName
+        }
+        if (rest.length > 0) {
+          res += ` ${this._addRule(
+            `${name ?? ''}${name ? '-' : ''}${k}-rest`,
+            getRecursiveRefs(rest, true) || '',
+          )}`
+        }
+        return res
+      }
+
+      rule += optionalProps
+        .map((_: any, i: number) =>
+          getRecursiveRefs(optionalProps.slice(i), false),
+        )
+        .join(' | ')
+      if (requiredProps.length > 0) {
+        rule += ' )'
+      }
+      rule += ' )?'
+    }
+
+    rule += ' "}" space'
+
+    return rule
+  }
+
+  formatGrammar() {
+    let grammar = ''
+    for (const [name, rule] of Object.entries(this._rules).sort(([a], [b]) =>
+      a.localeCompare(b),
+    )) {
+      grammar += `${name} ::= ${rule}\n`
+    }
+    return grammar
+  }
+}
+
+export const convertJsonSchemaToGrammar = ({
+  schema,
+  propOrder,
+  dotall,
+  allowFetch,
+}: {
+  schema: any
+  propOrder?: SchemaGrammarConverterPropOrder
+  dotall?: boolean
+  allowFetch?: boolean
+}): string | Promise<string> => {
+  const converter = new SchemaGrammarConverter({
+    prop_order: propOrder,
+    dotall,
+    allow_fetch: allowFetch,
+  })
+
+  if (allowFetch) {
+    return converter.resolveRefs(schema, '').then(() => {
+      converter.visit(schema, '')
+      return converter.formatGrammar()
+    })
+  }
+  converter.visit(schema, '')
+  return converter.formatGrammar()
+}