modelfusion 0.117.0 → 0.119.0

package/model-provider/llamacpp/LlamaCppCompletionModel.js

@@ -5,14 +5,16 @@ import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { parseJSON } from "../../core/schema/parseJSON.js";
 import { validateTypes } from "../../core/schema/validateTypes.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
 import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
 import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseEventSourceStream } from "../../util/streaming/parseEventSourceStream.js";
 import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
 import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
+import { Text } from "./LlamaCppPrompt.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
-import { json } from "./LlamaCppGrammars.js";
+import { convertJsonSchemaToGBNF } from "./convertJsonSchemaToGBNF.js";
 export class LlamaCppCompletionModel extends AbstractModel {
     constructor(settings = {}) {
         super({ settings });
@@ -137,23 +139,23 @@ export class LlamaCppCompletionModel extends AbstractModel {
             schema: zodSchema(llamaCppTextGenerationResponseSchema),
         }));
     }
-    processTextGenerationResponse(response) {
+    processTextGenerationResponse(rawResponse) {
         return {
-            response,
+            rawResponse,
             textGenerationResults: [
                 {
-                    text: response.content,
-                    finishReason: response.stopped_eos || response.stopped_word
+                    text: rawResponse.content,
+                    finishReason: rawResponse.stopped_eos || rawResponse.stopped_word
                         ? "stop"
-                        : response.stopped_limit
+                        : rawResponse.stopped_limit
                             ? "length"
                             : "unknown",
                 },
             ],
             usage: {
-                promptTokens: response.tokens_evaluated,
-                completionTokens: response.tokens_predicted,
-                totalTokens: response.tokens_evaluated + response.tokens_predicted,
+                promptTokens: rawResponse.tokens_evaluated,
+                completionTokens: rawResponse.tokens_predicted,
+                totalTokens: rawResponse.tokens_evaluated + rawResponse.tokens_predicted,
             },
         };
     }
@@ -165,33 +167,38 @@ export class LlamaCppCompletionModel extends AbstractModel {
     extractTextDelta(delta) {
         return delta.content;
     }
-    withJsonOutput() {
-        // don't override the grammar if it's already set (to support more restrictive grammars)
-        return this.settings.grammar == null
-            ? this.withSettings({ grammar: json })
-            : this;
+    asStructureGenerationModel(promptTemplate) {
+        return "adaptModel" in promptTemplate
+            ? new StructureFromTextStreamingModel({
+                model: promptTemplate.adaptModel(this),
+                template: promptTemplate,
+            })
+            : new StructureFromTextStreamingModel({
+                model: this,
+                template: promptTemplate,
+            });
     }
-    withTextPrompt() {
-        return this.withPromptTemplate({
-            format(prompt) {
-                return { text: prompt };
-            },
-            stopSequences: [],
+    withJsonOutput(schema) {
+        // don't override the grammar if it's already set (to allow user to override)
+        if (this.settings.grammar != null) {
+            return this;
+        }
+        const grammar = convertJsonSchemaToGBNF(schema.getJsonSchema());
+        return this.withSettings({
+            grammar: grammar,
         });
     }
-    /**
-     * Maps the prompt for a text version of the Llama.cpp prompt template (without image support).
-     */
-    withTextPromptTemplate(promptTemplate) {
-        return new PromptTemplateTextStreamingModel({
-            model: this.withTextPrompt().withSettings({
-                stopSequences: [
-                    ...(this.settings.stopSequences ?? []),
-                    ...promptTemplate.stopSequences,
-                ],
-            }),
-            promptTemplate,
-        });
+    get promptTemplateProvider() {
+        return this.settings.promptTemplate ?? Text;
+    }
+    withTextPrompt() {
+        return this.withPromptTemplate(this.promptTemplateProvider.text());
+    }
+    withInstructionPrompt() {
+        return this.withPromptTemplate(this.promptTemplateProvider.instruction());
+    }
+    withChatPrompt() {
+        return this.withPromptTemplate(this.promptTemplateProvider.chat());
     }
     /**
      * Maps the prompt for the full Llama.cpp prompt template (incl. image support).

package/model-provider/llamacpp/LlamaCppFacade.cjs

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.grammar = exports.Tokenizer = exports.TextEmbedder = exports.TextGenerator = exports.Api = void 0;
+exports.prompt = exports.grammar = exports.Tokenizer = exports.TextEmbedder = exports.CompletionTextGenerator = exports.Api = void 0;
 const LlamaCppApiConfiguration_js_1 = require("./LlamaCppApiConfiguration.cjs");
 const LlamaCppCompletionModel_js_1 = require("./LlamaCppCompletionModel.cjs");
 const LlamaCppTextEmbeddingModel_js_1 = require("./LlamaCppTextEmbeddingModel.cjs");
@@ -36,10 +36,10 @@ function Api(settings) {
     return new LlamaCppApiConfiguration_js_1.LlamaCppApiConfiguration(settings);
 }
 exports.Api = Api;
-function TextGenerator(settings = {}) {
+function CompletionTextGenerator(settings = {}) {
     return new LlamaCppCompletionModel_js_1.LlamaCppCompletionModel(settings);
 }
-exports.TextGenerator = TextGenerator;
+exports.CompletionTextGenerator = CompletionTextGenerator;
 function TextEmbedder(settings = {}) {
     return new LlamaCppTextEmbeddingModel_js_1.LlamaCppTextEmbeddingModel(settings);
 }
@@ -52,3 +52,4 @@ exports.Tokenizer = Tokenizer;
  * GBNF grammars. You can use them in the `grammar` option of the `TextGenerator` model.
  */
 exports.grammar = __importStar(require("./LlamaCppGrammars.cjs"));
+exports.prompt = __importStar(require("./LlamaCppPrompt.cjs"));

package/model-provider/llamacpp/LlamaCppFacade.d.ts

@@ -9,10 +9,11 @@ import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
  * It calls the API at http://127.0.0.1:8080 by default.
  */
 export declare function Api(settings: PartialBaseUrlPartsApiConfigurationOptions): LlamaCppApiConfiguration;
-export declare function TextGenerator<CONTEXT_WINDOW_SIZE extends number>(settings?: LlamaCppCompletionModelSettings<CONTEXT_WINDOW_SIZE>): LlamaCppCompletionModel<CONTEXT_WINDOW_SIZE>;
+export declare function CompletionTextGenerator<CONTEXT_WINDOW_SIZE extends number>(settings?: LlamaCppCompletionModelSettings<CONTEXT_WINDOW_SIZE>): LlamaCppCompletionModel<CONTEXT_WINDOW_SIZE>;
 export declare function TextEmbedder(settings?: LlamaCppTextEmbeddingModelSettings): LlamaCppTextEmbeddingModel;
 export declare function Tokenizer(api?: ApiConfiguration): LlamaCppTokenizer;
 /**
  * GBNF grammars. You can use them in the `grammar` option of the `TextGenerator` model.
  */
 export * as grammar from "./LlamaCppGrammars.js";
+export * as prompt from "./LlamaCppPrompt.js";

package/model-provider/llamacpp/LlamaCppFacade.js

@@ -9,7 +9,7 @@ import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
 export function Api(settings) {
     return new LlamaCppApiConfiguration(settings);
 }
-export function TextGenerator(settings = {}) {
+export function CompletionTextGenerator(settings = {}) {
     return new LlamaCppCompletionModel(settings);
 }
 export function TextEmbedder(settings = {}) {
@@ -22,3 +22,4 @@ export function Tokenizer(api = new LlamaCppApiConfiguration()) {
  * GBNF grammars. You can use them in the `grammar` option of the `TextGenerator` model.
  */
 export * as grammar from "./LlamaCppGrammars.js";
+export * as prompt from "./LlamaCppPrompt.js";

package/model-provider/llamacpp/LlamaCppGrammars.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.list = exports.jsonArray = exports.json = void 0;
+exports.fromJsonSchema = exports.list = exports.jsonArray = exports.json = void 0;
 /**
  * GBNF grammar for JSON.
  *
@@ -82,3 +82,5 @@ root ::= item+
 # Excludes various line break characters
 item ::= "- " [^\r\n\x0b\x0c\x85\u2028\u2029]+ "\n"
 `;
+var convertJsonSchemaToGBNF_1 = require("./convertJsonSchemaToGBNF");
+Object.defineProperty(exports, "fromJsonSchema", { enumerable: true, get: function () { return convertJsonSchemaToGBNF_1.convertJsonSchemaToGBNF; } });

package/model-provider/llamacpp/LlamaCppGrammars.d.ts

@@ -16,3 +16,4 @@ export declare const jsonArray: string;
  * @see https://github.com/ggerganov/llama.cpp/blob/master/grammars/list.gbnf
  */
 export declare const list: string;
+export { convertJsonSchemaToGBNF as fromJsonSchema } from "./convertJsonSchemaToGBNF";

package/model-provider/llamacpp/LlamaCppGrammars.js

@@ -79,3 +79,4 @@ root ::= item+
 # Excludes various line break characters
 item ::= "- " [^\r\n\x0b\x0c\x85\u2028\u2029]+ "\n"
 `;
+export { convertJsonSchemaToGBNF as fromJsonSchema } from "./convertJsonSchemaToGBNF";

package/model-provider/llamacpp/LlamaCppPrompt.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BakLLaVA1 = exports.Vicuna = exports.Alpaca = exports.NeuralChat = exports.Llama2 = exports.ChatML = exports.Mistral = exports.Text = exports.asLlamaCppTextPromptTemplateProvider = exports.asLlamaCppPromptTemplate = void 0;
+const alpacaPrompt = __importStar(require("../../model-function/generate-text/prompt-template/AlpacaPromptTemplate.cjs"));
+const chatMlPrompt = __importStar(require("../../model-function/generate-text/prompt-template/ChatMLPromptTemplate.cjs"));
+const llama2Prompt = __importStar(require("../../model-function/generate-text/prompt-template/Llama2PromptTemplate.cjs"));
+const mistralPrompt = __importStar(require("../../model-function/generate-text/prompt-template/MistralInstructPromptTemplate.cjs"));
+const neuralChatPrompt = __importStar(require("../../model-function/generate-text/prompt-template/NeuralChatPromptTemplate.cjs"));
+const textPrompt = __importStar(require("../../model-function/generate-text/prompt-template/TextPromptTemplate.cjs"));
+const vicunaPrompt = __importStar(require("../../model-function/generate-text/prompt-template/VicunaPromptTemplate.cjs"));
+const LlamaCppBakLLaVA1Prompt = __importStar(require("./LlamaCppBakLLaVA1PromptTemplate.cjs"));
+function asLlamaCppPromptTemplate(promptTemplate) {
+    return {
+        format: (prompt) => ({
+            text: promptTemplate.format(prompt),
+        }),
+        stopSequences: promptTemplate.stopSequences,
+    };
+}
+exports.asLlamaCppPromptTemplate = asLlamaCppPromptTemplate;
+function asLlamaCppTextPromptTemplateProvider(promptTemplateProvider) {
+    return {
+        text: () => asLlamaCppPromptTemplate(promptTemplateProvider.text()),
+        instruction: () => asLlamaCppPromptTemplate(promptTemplateProvider.instruction()),
+        chat: () => asLlamaCppPromptTemplate(promptTemplateProvider.chat()),
+    };
+}
+exports.asLlamaCppTextPromptTemplateProvider = asLlamaCppTextPromptTemplateProvider;
+exports.Text = asLlamaCppTextPromptTemplateProvider(textPrompt);
+exports.Mistral = asLlamaCppTextPromptTemplateProvider(mistralPrompt);
+exports.ChatML = asLlamaCppTextPromptTemplateProvider(chatMlPrompt);
+exports.Llama2 = asLlamaCppTextPromptTemplateProvider(llama2Prompt);
+exports.NeuralChat = asLlamaCppTextPromptTemplateProvider(neuralChatPrompt);
+exports.Alpaca = asLlamaCppTextPromptTemplateProvider(alpacaPrompt);
+exports.Vicuna = asLlamaCppTextPromptTemplateProvider(vicunaPrompt);
+exports.BakLLaVA1 = LlamaCppBakLLaVA1Prompt;

package/model-provider/llamacpp/LlamaCppPrompt.d.ts

@@ -0,0 +1,14 @@
+import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
+import { TextGenerationPromptTemplateProvider } from "../../model-function/generate-text/prompt-template/PromptTemplateProvider.js";
+import * as LlamaCppBakLLaVA1Prompt from "./LlamaCppBakLLaVA1PromptTemplate.js";
+import { LlamaCppCompletionPrompt } from "./LlamaCppCompletionModel.js";
+export declare function asLlamaCppPromptTemplate<SOURCE_PROMPT>(promptTemplate: TextGenerationPromptTemplate<SOURCE_PROMPT, string>): TextGenerationPromptTemplate<SOURCE_PROMPT, LlamaCppCompletionPrompt>;
+export declare function asLlamaCppTextPromptTemplateProvider(promptTemplateProvider: TextGenerationPromptTemplateProvider<string>): TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const Text: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const Mistral: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const ChatML: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const Llama2: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const NeuralChat: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const Alpaca: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const Vicuna: TextGenerationPromptTemplateProvider<LlamaCppCompletionPrompt>;
+export declare const BakLLaVA1: typeof LlamaCppBakLLaVA1Prompt;

package/model-provider/llamacpp/LlamaCppPrompt.js

@@ -0,0 +1,31 @@
+import * as alpacaPrompt from "../../model-function/generate-text/prompt-template/AlpacaPromptTemplate.js";
+import * as chatMlPrompt from "../../model-function/generate-text/prompt-template/ChatMLPromptTemplate.js";
+import * as llama2Prompt from "../../model-function/generate-text/prompt-template/Llama2PromptTemplate.js";
+import * as mistralPrompt from "../../model-function/generate-text/prompt-template/MistralInstructPromptTemplate.js";
+import * as neuralChatPrompt from "../../model-function/generate-text/prompt-template/NeuralChatPromptTemplate.js";
+import * as textPrompt from "../../model-function/generate-text/prompt-template/TextPromptTemplate.js";
+import * as vicunaPrompt from "../../model-function/generate-text/prompt-template/VicunaPromptTemplate.js";
+import * as LlamaCppBakLLaVA1Prompt from "./LlamaCppBakLLaVA1PromptTemplate.js";
+export function asLlamaCppPromptTemplate(promptTemplate) {
+    return {
+        format: (prompt) => ({
+            text: promptTemplate.format(prompt),
+        }),
+        stopSequences: promptTemplate.stopSequences,
+    };
+}
+export function asLlamaCppTextPromptTemplateProvider(promptTemplateProvider) {
+    return {
+        text: () => asLlamaCppPromptTemplate(promptTemplateProvider.text()),
+        instruction: () => asLlamaCppPromptTemplate(promptTemplateProvider.instruction()),
+        chat: () => asLlamaCppPromptTemplate(promptTemplateProvider.chat()),
+    };
+}
+export const Text = asLlamaCppTextPromptTemplateProvider(textPrompt);
+export const Mistral = asLlamaCppTextPromptTemplateProvider(mistralPrompt);
+export const ChatML = asLlamaCppTextPromptTemplateProvider(chatMlPrompt);
+export const Llama2 = asLlamaCppTextPromptTemplateProvider(llama2Prompt);
+export const NeuralChat = asLlamaCppTextPromptTemplateProvider(neuralChatPrompt);
+export const Alpaca = asLlamaCppTextPromptTemplateProvider(alpacaPrompt);
+export const Vicuna = asLlamaCppTextPromptTemplateProvider(vicunaPrompt);
+export const BakLLaVA1 = LlamaCppBakLLaVA1Prompt;

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.cjs

@@ -80,10 +80,10 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         };
     }
     async doEmbedValues(texts, options) {
-        const response = await this.callAPI(texts, options);
+        const rawResponse = await this.callAPI(texts, options);
         return {
-            response,
-            embeddings: [response.embedding],
+            rawResponse,
+            embeddings: [rawResponse.embedding],
         };
     }
     withSettings(additionalSettings) {

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.d.ts

@@ -21,7 +21,7 @@ export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTe
     callAPI(texts: Array<string>, callOptions: FunctionCallOptions): Promise<LlamaCppTextEmbeddingResponse>;
     get settingsForEvent(): Partial<LlamaCppTextEmbeddingModelSettings>;
     doEmbedValues(texts: string[], options: FunctionCallOptions): Promise<{
-        response: {
+        rawResponse: {
             embedding: number[];
         };
         embeddings: number[][];

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.js

@@ -77,10 +77,10 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
         };
     }
     async doEmbedValues(texts, options) {
-        const response = await this.callAPI(texts, options);
+        const rawResponse = await this.callAPI(texts, options);
         return {
-            response,
-            embeddings: [response.embedding],
+            rawResponse,
+            embeddings: [rawResponse.embedding],
         };
     }
     withSettings(additionalSettings) {

package/model-provider/llamacpp/convertJsonSchemaToGBNF.cjs

@@ -0,0 +1,113 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertJsonSchemaToGBNF = void 0;
+/**
+ * Convert JSON Schema to a GBNF grammar.
+ *
+ * This is a modified version of
+ * https://github.com/ggerganov/llama.cpp/blob/master/examples/server/public/json-schema-to-grammar.mjs
+ */
+function convertJsonSchemaToGBNF(schema) {
+    const rules = new RuleMap();
+    rules.add("space", SPACE_RULE);
+    visit(schema, undefined, rules);
+    return rules.toGBNF();
+}
+exports.convertJsonSchemaToGBNF = convertJsonSchemaToGBNF;
+const SPACE_RULE = '" "?';
+const PRIMITIVE_RULES = {
+    boolean: '("true" | "false") space',
+    number: '("-"? ([0-9] | [1-9] [0-9]*)) ("." [0-9]+)? ([eE] [-+]? [0-9]+)? space',
+    integer: '("-"? ([0-9] | [1-9] [0-9]*)) space',
+    string: ` "\\"" ( [^"\\\\] | "\\\\" (["\\\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]) )* "\\"" space`,
+    null: '"null" space',
+};
+class RuleMap {
+    constructor() {
+        Object.defineProperty(this, "rules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    add(name, rule) {
+        const escapedName = this.escapeRuleName(name, rule);
+        this.rules.set(escapedName, rule);
+        return escapedName;
+    }
+    /**
+     * Replace invalid characters in rule name with hyphens.
+     * Disambiguate the name if it already exists.
+     */
+    escapeRuleName(name, rule) {
+        const baseName = name.replace(/[^\dA-Za-z-]+/g, "-");
+        if (!this.rules.has(baseName) || this.rules.get(baseName) === rule) {
+            return baseName;
+        }
+        let i = 0;
+        while (this.rules.has(`${baseName}${i}`)) {
+            if (this.rules.get(`${baseName}${i}`) === rule) {
+                return `${baseName}${i}`;
+            }
+            i++;
+        }
+        return `${baseName}${i}`;
+    }
+    toGBNF() {
+        return Array.from(this.rules)
+            .map(([name, rule]) => `${name} ::= ${rule}`)
+            .join("\n");
+    }
+}
+const GRAMMAR_LITERAL_ESCAPES = {
+    "\r": "\\r",
+    "\n": "\\n",
+    '"': '\\"',
+};
+function formatLiteral(literal) {
+    const escaped = JSON.stringify(literal).replace(/[\n\r"]/g, (m) => GRAMMAR_LITERAL_ESCAPES[m]);
+    return `"${escaped}"`;
+}
+function visit(schema, name, rules) {
+    const schemaType = schema.type;
+    const ruleName = name || "root";
+    if (schema.oneOf || schema.anyOf) {
+        const rule = (schema.oneOf || schema.anyOf)
+            .map((altSchema, i) => visit(altSchema, `${name}${name ? "-" : ""}${i}`, rules))
+            .join(" | ");
+        return rules.add(ruleName, rule);
+    }
+    else if ("const" in schema) {
+        return rules.add(ruleName, formatLiteral(schema.const));
+    }
+    else if ("enum" in schema) {
+        const rule = schema.enum.map(formatLiteral).join(" | ");
+        return rules.add(ruleName, rule);
+    }
+    else if (schemaType === "object" && "properties" in schema) {
+        const propPairs = Object.entries(schema.properties);
+        let rule = '"{" space';
+        propPairs.forEach(([propName, propSchema], i) => {
+            const propRuleName = visit(propSchema, `${name ?? ""}${name ? "-" : ""}${propName}`, rules);
+            if (i > 0) {
+                rule += ' "," space';
+            }
+            rule += ` ${formatLiteral(propName)} space ":" space ${propRuleName}`;
+        });
+        rule += ' "}" space';
+        return rules.add(ruleName, rule);
+    }
+    else if (schemaType === "array" && "items" in schema) {
+        const itemRuleName = visit(schema.items, `${name ?? ""}${name ? "-" : ""}item`, rules);
+        const rule = `"[" space (${itemRuleName} ("," space ${itemRuleName})*)? "]" space`;
+        return rules.add(ruleName, rule);
+    }
+    else {
+        if (!PRIMITIVE_RULES[schemaType]) {
+            throw new Error(`Unrecognized schema: ${JSON.stringify(schema)}`);
+        }
+        return rules.add(ruleName === "root" ? "root" : schemaType, PRIMITIVE_RULES[schemaType]);
+    }
+}

package/model-provider/llamacpp/convertJsonSchemaToGBNF.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert JSON Schema to a GBNF grammar.
+ *
+ * This is a modified version of
+ * https://github.com/ggerganov/llama.cpp/blob/master/examples/server/public/json-schema-to-grammar.mjs
+ */
+export declare function convertJsonSchemaToGBNF(schema: unknown): string;

package/model-provider/llamacpp/convertJsonSchemaToGBNF.js

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Convert JSON Schema to a GBNF grammar.
+ *
+ * This is a modified version of
+ * https://github.com/ggerganov/llama.cpp/blob/master/examples/server/public/json-schema-to-grammar.mjs
+ */
+export function convertJsonSchemaToGBNF(schema) {
+    const rules = new RuleMap();
+    rules.add("space", SPACE_RULE);
+    visit(schema, undefined, rules);
+    return rules.toGBNF();
+}
+const SPACE_RULE = '" "?';
+const PRIMITIVE_RULES = {
+    boolean: '("true" | "false") space',
+    number: '("-"? ([0-9] | [1-9] [0-9]*)) ("." [0-9]+)? ([eE] [-+]? [0-9]+)? space',
+    integer: '("-"? ([0-9] | [1-9] [0-9]*)) space',
+    string: ` "\\"" ( [^"\\\\] | "\\\\" (["\\\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]) )* "\\"" space`,
+    null: '"null" space',
+};
+class RuleMap {
+    constructor() {
+        Object.defineProperty(this, "rules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    add(name, rule) {
+        const escapedName = this.escapeRuleName(name, rule);
+        this.rules.set(escapedName, rule);
+        return escapedName;
+    }
+    /**
+     * Replace invalid characters in rule name with hyphens.
+     * Disambiguate the name if it already exists.
+     */
+    escapeRuleName(name, rule) {
+        const baseName = name.replace(/[^\dA-Za-z-]+/g, "-");
+        if (!this.rules.has(baseName) || this.rules.get(baseName) === rule) {
+            return baseName;
+        }
+        let i = 0;
+        while (this.rules.has(`${baseName}${i}`)) {
+            if (this.rules.get(`${baseName}${i}`) === rule) {
+                return `${baseName}${i}`;
+            }
+            i++;
+        }
+        return `${baseName}${i}`;
+    }
+    toGBNF() {
+        return Array.from(this.rules)
+            .map(([name, rule]) => `${name} ::= ${rule}`)
+            .join("\n");
+    }
+}
+const GRAMMAR_LITERAL_ESCAPES = {
+    "\r": "\\r",
+    "\n": "\\n",
+    '"': '\\"',
+};
+function formatLiteral(literal) {
+    const escaped = JSON.stringify(literal).replace(/[\n\r"]/g, (m) => GRAMMAR_LITERAL_ESCAPES[m]);
+    return `"${escaped}"`;
+}
+function visit(schema, name, rules) {
+    const schemaType = schema.type;
+    const ruleName = name || "root";
+    if (schema.oneOf || schema.anyOf) {
+        const rule = (schema.oneOf || schema.anyOf)
+            .map((altSchema, i) => visit(altSchema, `${name}${name ? "-" : ""}${i}`, rules))
+            .join(" | ");
+        return rules.add(ruleName, rule);
+    }
+    else if ("const" in schema) {
+        return rules.add(ruleName, formatLiteral(schema.const));
+    }
+    else if ("enum" in schema) {
+        const rule = schema.enum.map(formatLiteral).join(" | ");
+        return rules.add(ruleName, rule);
+    }
+    else if (schemaType === "object" && "properties" in schema) {
+        const propPairs = Object.entries(schema.properties);
+        let rule = '"{" space';
+        propPairs.forEach(([propName, propSchema], i) => {
+            const propRuleName = visit(propSchema, `${name ?? ""}${name ? "-" : ""}${propName}`, rules);
+            if (i > 0) {
+                rule += ' "," space';
+            }
+            rule += ` ${formatLiteral(propName)} space ":" space ${propRuleName}`;
+        });
+        rule += ' "}" space';
+        return rules.add(ruleName, rule);
+    }
+    else if (schemaType === "array" && "items" in schema) {
+        const itemRuleName = visit(schema.items, `${name ?? ""}${name ? "-" : ""}item`, rules);
+        const rule = `"[" space (${itemRuleName} ("," space ${itemRuleName})*)? "]" space`;
+        return rules.add(ruleName, rule);
+    }
+    else {
+        if (!PRIMITIVE_RULES[schemaType]) {
+            throw new Error(`Unrecognized schema: ${JSON.stringify(schema)}`);
+        }
+        return rules.add(ruleName === "root" ? "root" : schemaType, PRIMITIVE_RULES[schemaType]);
+    }
+}