modelfusion 0.118.0 → 0.119.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## v0.119.0 - 2024-01-07
+
+### Added
+
+- Schema-specific GBNF grammar generator for `LlamaCppCompletionModel`. When using `jsonStructurePrompt`, it automatically uses a GBNF grammar for the JSON schema that you provide. Example:
+
+  ```ts
+  const structure = await generateStructure(
+    llamacpp
+      .CompletionTextGenerator({
+        // run openhermes-2.5-mistral-7b.Q4_K_M.gguf in llama.cpp
+        promptTemplate: llamacpp.prompt.ChatML,
+        maxGenerationTokens: 1024,
+        temperature: 0,
+      })
+      // automatically restrict the output to your schema using GBNF:
+      .asStructureGenerationModel(jsonStructurePrompt.text()),
+
+    zodSchema(
+      z.array(
+        z.object({
+          name: z.string(),
+          class: z
+            .string()
+            .describe("Character class, e.g. warrior, mage, or thief."),
+          description: z.string(),
+        })
+      )
+    ),
+
+    "Generate 3 character descriptions for a fantasy role playing game. "
+  );
+  ```
+
 ## v0.118.0 - 2024-01-07
 
 ### Added

package/model-function/generate-structure/StructureFromTextGenerationModel.cjs

@@ -29,8 +29,17 @@ class StructureFromTextGenerationModel {
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
+    getModelWithJsonOutput(schema) {
+        if (this.template.withJsonOutput != null) {
+            return this.template.withJsonOutput?.({
+                model: this.model,
+                schema,
+            });
+        }
+        return this.model;
+    }
     async doGenerateStructure(schema, prompt, options) {
-        const { rawResponse: response, text } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, schema), {
+        const { rawResponse: response, text } = await (0, generateText_js_1.generateText)(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), {
             ...options,
             fullResponse: true,
         });

package/model-function/generate-structure/StructureFromTextGenerationModel.d.ts

@@ -14,6 +14,7 @@ export declare class StructureFromTextGenerationModel<SOURCE_PROMPT, TARGET_PROM
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): TextGenerationModelSettings;
     get settingsForEvent(): Partial<MODEL["settings"]>;
+    getModelWithJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): MODEL;
     doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
         response: unknown;
         value: unknown;

package/model-function/generate-structure/StructureFromTextGenerationModel.js

@@ -26,8 +26,17 @@ export class StructureFromTextGenerationModel {
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
+    getModelWithJsonOutput(schema) {
+        if (this.template.withJsonOutput != null) {
+            return this.template.withJsonOutput?.({
+                model: this.model,
+                schema,
+            });
+        }
+        return this.model;
+    }
     async doGenerateStructure(schema, prompt, options) {
-        const { rawResponse: response, text } = await generateText(this.model, this.template.createPrompt(prompt, schema), {
+        const { rawResponse: response, text } = await generateText(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), {
             ...options,
             fullResponse: true,
         });

package/model-function/generate-structure/StructureFromTextPromptTemplate.d.ts

@@ -6,6 +6,12 @@ import { InstructionPrompt } from "../generate-text/prompt-template/InstructionP
 export type StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> = {
     createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT;
     extractStructure: (response: string) => unknown;
+    withJsonOutput?({ model, schema, }: {
+        model: {
+            withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): typeof model;
+        };
+        schema: Schema<unknown> & JsonSchemaProducer;
+    }): typeof model;
 };
 export type FlexibleStructureFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_PROMPT> = {
     createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => INTERMEDIATE_PROMPT;
@@ -14,6 +20,11 @@ export type FlexibleStructureFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_
         withTextPrompt(): TextStreamingModel<string>;
         withInstructionPrompt(): TextStreamingModel<InstructionPrompt>;
         withChatPrompt(): TextStreamingModel<ChatPrompt>;
-        withJsonOutput?: () => typeof model;
     }) => TextStreamingModel<INTERMEDIATE_PROMPT>;
+    withJsonOutput?({ model, schema, }: {
+        model: {
+            withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): typeof model;
+        };
+        schema: Schema<unknown> & JsonSchemaProducer;
+    }): typeof model;
 };

package/model-function/generate-structure/StructureFromTextStreamingModel.cjs

@@ -3,35 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructureFromTextStreamingModel = void 0;
 const streamText_js_1 = require("../../model-function/generate-text/streamText.cjs");
 const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
-const generateText_js_1 = require("../generate-text/generateText.cjs");
 const StructureFromTextGenerationModel_js_1 = require("./StructureFromTextGenerationModel.cjs");
-const StructureParseError_js_1 = require("./StructureParseError.cjs");
 const parsePartialJson_js_1 = require("./parsePartialJson.cjs");
 class StructureFromTextStreamingModel extends StructureFromTextGenerationModel_js_1.StructureFromTextGenerationModel {
     constructor(options) {
         super(options);
     }
-    async doGenerateStructure(schema, prompt, options) {
-        const { rawResponse: response, text } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, schema), {
-            ...options,
-            fullResponse: true,
-        });
-        try {
-            return {
-                response,
-                value: this.template.extractStructure(text),
-                valueText: text,
-            };
-        }
-        catch (error) {
-            throw new StructureParseError_js_1.StructureParseError({
-                valueText: text,
-                cause: error,
-            });
-        }
-    }
     async doStreamStructure(schema, prompt, options) {
-        const textStream = await (0, streamText_js_1.streamText)(this.model, this.template.createPrompt(prompt, schema), options);
+        const textStream = await (0, streamText_js_1.streamText)(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), options);
         const queue = new AsyncQueue_js_1.AsyncQueue();
         // run async on purpose:
         (async () => {

package/model-function/generate-structure/StructureFromTextStreamingModel.d.ts

@@ -12,11 +12,6 @@ export declare class StructureFromTextStreamingModel<SOURCE_PROMPT, TARGET_PROMP
         model: MODEL;
         template: StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     });
-    doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
-        response: unknown;
-        value: unknown;
-        valueText: string;
-    }>;
     doStreamStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<AsyncQueue<Delta<string>>>;
     extractStructureTextDelta(delta: unknown): string;
     parseAccumulatedStructureText(accumulatedText: string): unknown;

package/model-function/generate-structure/StructureFromTextStreamingModel.js

@@ -1,34 +1,13 @@
 import { streamText } from "../../model-function/generate-text/streamText.js";
 import { AsyncQueue } from "../../util/AsyncQueue.js";
-import { generateText } from "../generate-text/generateText.js";
 import { StructureFromTextGenerationModel } from "./StructureFromTextGenerationModel.js";
-import { StructureParseError } from "./StructureParseError.js";
 import { parsePartialJson } from "./parsePartialJson.js";
 export class StructureFromTextStreamingModel extends StructureFromTextGenerationModel {
     constructor(options) {
         super(options);
     }
-    async doGenerateStructure(schema, prompt, options) {
-        const { rawResponse: response, text } = await generateText(this.model, this.template.createPrompt(prompt, schema), {
-            ...options,
-            fullResponse: true,
-        });
-        try {
-            return {
-                response,
-                value: this.template.extractStructure(text),
-                valueText: text,
-            };
-        }
-        catch (error) {
-            throw new StructureParseError({
-                valueText: text,
-                cause: error,
-            });
-        }
-    }
     async doStreamStructure(schema, prompt, options) {
-        const textStream = await streamText(this.model, this.template.createPrompt(prompt, schema), options);
+        const textStream = await streamText(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), options);
         const queue = new AsyncQueue();
         // run async on purpose:
         (async () => {

package/model-function/generate-structure/jsonStructurePrompt.cjs

@@ -15,12 +15,8 @@ exports.jsonStructurePrompt = {
                 instruction: prompt,
             }),
             extractStructure,
-            adaptModel: (model) => {
-                if (model.withJsonOutput != null) {
-                    model = model.withJsonOutput();
-                }
-                return model.withInstructionPrompt();
-            },
+            adaptModel: (model) => model.withInstructionPrompt(),
+            withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
     },
     instruction({ schemaPrefix, schemaSuffix, } = {}) {
@@ -35,12 +31,8 @@ exports.jsonStructurePrompt = {
                 instruction: prompt.instruction,
             }),
             extractStructure,
-            adaptModel: (model) => {
-                if (model.withJsonOutput != null) {
-                    model = model.withJsonOutput();
-                }
-                return model.withInstructionPrompt();
-            },
+            adaptModel: (model) => model.withInstructionPrompt(),
+            withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
     },
 };

package/model-function/generate-structure/jsonStructurePrompt.js

@@ -12,12 +12,8 @@ export const jsonStructurePrompt = {
                 instruction: prompt,
             }),
             extractStructure,
-            adaptModel: (model) => {
-                if (model.withJsonOutput != null) {
-                    model = model.withJsonOutput();
-                }
-                return model.withInstructionPrompt();
-            },
+            adaptModel: (model) => model.withInstructionPrompt(),
+            withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
     },
     instruction({ schemaPrefix, schemaSuffix, } = {}) {
@@ -32,12 +28,8 @@ export const jsonStructurePrompt = {
                 instruction: prompt.instruction,
             }),
             extractStructure,
-            adaptModel: (model) => {
-                if (model.withJsonOutput != null) {
-                    model = model.withJsonOutput();
-                }
-                return model.withInstructionPrompt();
-            },
+            adaptModel: (model) => model.withInstructionPrompt(),
+            withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
     },
 };

package/model-function/generate-text/PromptTemplateTextGenerationModel.cjs

@@ -68,6 +68,12 @@ class PromptTemplateTextGenerationModel {
             template: promptTemplate,
         });
     }
+    withJsonOutput(schema) {
+        return new PromptTemplateTextGenerationModel({
+            model: this.model.withJsonOutput(schema),
+            promptTemplate: this.promptTemplate,
+        });
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextGenerationModel({
             model: this.withSettings({

package/model-function/generate-text/PromptTemplateTextGenerationModel.d.ts

@@ -1,4 +1,6 @@
 import { FunctionCallOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
 import { TextGenerationToolCallModel, ToolCallPromptTemplate } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
 import { TextGenerationToolCallsModel } from "../../tool/generate-tool-calls/TextGenerationToolCallsModel.js";
 import { ToolCallsPromptTemplate } from "../../tool/generate-tool-calls/ToolCallsPromptTemplate.js";
@@ -40,6 +42,7 @@ export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SET
     asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallModel<INPUT_PROMPT, PROMPT, this>;
     asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallsModel<INPUT_PROMPT, PROMPT, this>;
     asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextGenerationModel<INPUT_PROMPT, PROMPT, this>;
+    withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): this;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/model-function/generate-text/PromptTemplateTextGenerationModel.js

@@ -65,6 +65,12 @@ export class PromptTemplateTextGenerationModel {
             template: promptTemplate,
         });
     }
+    withJsonOutput(schema) {
+        return new PromptTemplateTextGenerationModel({
+            model: this.model.withJsonOutput(schema),
+            promptTemplate: this.promptTemplate,
+        });
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextGenerationModel({
             model: this.withSettings({

package/model-function/generate-text/PromptTemplateTextStreamingModel.cjs

@@ -20,6 +20,12 @@ class PromptTemplateTextStreamingModel extends PromptTemplateTextGenerationModel
             template: promptTemplate,
         });
     }
+    withJsonOutput(schema) {
+        return new PromptTemplateTextStreamingModel({
+            model: this.model.withJsonOutput(schema),
+            promptTemplate: this.promptTemplate,
+        });
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel({
             model: this.withSettings({

package/model-function/generate-text/PromptTemplateTextStreamingModel.d.ts

@@ -1,4 +1,6 @@
 import { FunctionCallOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
 import { StructureFromTextPromptTemplate } from "../generate-structure/StructureFromTextPromptTemplate.js";
 import { StructureFromTextStreamingModel } from "../generate-structure/StructureFromTextStreamingModel.js";
 import { PromptTemplateTextGenerationModel } from "./PromptTemplateTextGenerationModel.js";
@@ -12,6 +14,7 @@ export declare class PromptTemplateTextStreamingModel<PROMPT, MODEL_PROMPT, SETT
     doStreamText(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<AsyncIterable<import("../Delta.js").Delta<unknown>>>;
     extractTextDelta(delta: unknown): string | undefined;
     asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextStreamingModel<INPUT_PROMPT, PROMPT, this>;
+    withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): this;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/model-function/generate-text/PromptTemplateTextStreamingModel.js

@@ -17,6 +17,12 @@ export class PromptTemplateTextStreamingModel extends PromptTemplateTextGenerati
             template: promptTemplate,
         });
     }
+    withJsonOutput(schema) {
+        return new PromptTemplateTextStreamingModel({
+            model: this.model.withJsonOutput(schema),
+            promptTemplate: this.promptTemplate,
+        });
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel({
             model: this.withSettings({

package/model-function/generate-text/TextGenerationModel.d.ts

@@ -1,4 +1,6 @@
 import { FunctionCallOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
 import { Delta } from "../Delta.js";
 import { Model, ModelSettings } from "../Model.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
@@ -82,9 +84,10 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
     };
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationModel<INPUT_PROMPT, SETTINGS>;
     /**
-     * Optional. When available, forces the model to return JSON as the text output.
+     * When possible, limit the output generation to the specified JSON schema,
+     * or super sets of it (e.g. JSON in general).
      */
-    withJsonOutput?(): this;
+    withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): this;
 }
 export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
     doStreamText(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -182,6 +182,9 @@ class CohereTextGenerationModel extends AbstractModel_js_1.AbstractModel {
     withChatPrompt(options) {
         return this.withPromptTemplate((0, TextPromptTemplate_js_1.chat)(options));
     }
+    withJsonOutput() {
+        return this;
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel_js_1.PromptTemplateTextStreamingModel({
             model: this.withSettings({

package/model-provider/cohere/CohereTextGenerationModel.d.ts

@@ -152,6 +152,7 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
         user?: string;
         assistant?: string;
     }): PromptTemplateTextStreamingModel<import("../../index.js").ChatPrompt, string, CohereTextGenerationModelSettings, this>;
+    withJsonOutput(): this;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, string>): PromptTemplateTextStreamingModel<INPUT_PROMPT, string, CohereTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<CohereTextGenerationModelSettings>): this;
 }

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -179,6 +179,9 @@ export class CohereTextGenerationModel extends AbstractModel {
     withChatPrompt(options) {
         return this.withPromptTemplate(chat(options));
     }
+    withJsonOutput() {
+        return this;
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel({
             model: this.withSettings({

package/model-provider/huggingface/HuggingFaceTextGenerationModel.cjs

@@ -125,6 +125,9 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             })),
         };
     }
+    withJsonOutput() {
+        return this;
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextGenerationModel_js_1.PromptTemplateTextGenerationModel({
             model: this, // stop tokens are not supported by this model

package/model-provider/huggingface/HuggingFaceTextGenerationModel.d.ts

@@ -69,6 +69,7 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
             finishReason: "unknown";
         }[];
     };
+    withJsonOutput(): this;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, string>): PromptTemplateTextGenerationModel<INPUT_PROMPT, string, HuggingFaceTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<HuggingFaceTextGenerationModelSettings>): this;
 }

package/model-provider/huggingface/HuggingFaceTextGenerationModel.js

@@ -122,6 +122,9 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
             })),
         };
     }
+    withJsonOutput() {
+        return this;
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextGenerationModel({
             model: this, // stop tokens are not supported by this model

package/model-provider/llamacpp/LlamaCppCompletionModel.cjs

@@ -15,9 +15,9 @@ const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../util/streaming/parseEventSourceStream.cjs");
 const LlamaCppApiConfiguration_js_1 = require("./LlamaCppApiConfiguration.cjs");
 const LlamaCppError_js_1 = require("./LlamaCppError.cjs");
-const LlamaCppGrammars_js_1 = require("./LlamaCppGrammars.cjs");
 const LlamaCppPrompt_js_1 = require("./LlamaCppPrompt.cjs");
 const LlamaCppTokenizer_js_1 = require("./LlamaCppTokenizer.cjs");
+const convertJsonSchemaToGBNF_js_1 = require("./convertJsonSchemaToGBNF.cjs");
 class LlamaCppCompletionModel extends AbstractModel_js_1.AbstractModel {
     constructor(settings = {}) {
         super({ settings });
@@ -181,11 +181,15 @@ class LlamaCppCompletionModel extends AbstractModel_js_1.AbstractModel {
                 template: promptTemplate,
             });
     }
-    withJsonOutput() {
-        // don't override the grammar if it's already set (to support more restrictive grammars)
-        return this.settings.grammar == null
-            ? this.withSettings({ grammar: LlamaCppGrammars_js_1.json })
-            : this;
+    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 = (0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)(schema.getJsonSchema());
+        return this.withSettings({
+            grammar: grammar,
+        });
     }
     get promptTemplateProvider() {
         return this.settings.promptTemplate ?? LlamaCppPrompt_js_1.Text;

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

@@ -2,6 +2,8 @@ import { z } from "zod";
 import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { Delta } from "../../model-function/Delta.js";
 import { FlexibleStructureFromTextPromptTemplate, StructureFromTextPromptTemplate } from "../../model-function/generate-structure/StructureFromTextPromptTemplate.js";
@@ -386,7 +388,7 @@ export declare class LlamaCppCompletionModel<CONTEXT_WINDOW_SIZE extends number
     }>>>;
     extractTextDelta(delta: unknown): string;
     asStructureGenerationModel<INPUT_PROMPT, LlamaCppPrompt>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, LlamaCppPrompt> | FlexibleStructureFromTextPromptTemplate<INPUT_PROMPT, unknown>): StructureFromTextStreamingModel<INPUT_PROMPT, unknown, TextStreamingModel<unknown, TextGenerationModelSettings>> | StructureFromTextStreamingModel<INPUT_PROMPT, LlamaCppPrompt, TextStreamingModel<LlamaCppPrompt, TextGenerationModelSettings>>;
-    withJsonOutput(): this;
+    withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): this;
     private get promptTemplateProvider();
     withTextPrompt(): PromptTemplateTextStreamingModel<string, LlamaCppCompletionPrompt, LlamaCppCompletionModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     withInstructionPrompt(): PromptTemplateTextStreamingModel<InstructionPrompt, LlamaCppCompletionPrompt, LlamaCppCompletionModelSettings<CONTEXT_WINDOW_SIZE>, this>;

package/model-provider/llamacpp/LlamaCppCompletionModel.js

@@ -12,9 +12,9 @@ import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseEventSourceStream } from "../../util/streaming/parseEventSourceStream.js";
 import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
 import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
-import { json } from "./LlamaCppGrammars.js";
 import { Text } from "./LlamaCppPrompt.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
+import { convertJsonSchemaToGBNF } from "./convertJsonSchemaToGBNF.js";
 export class LlamaCppCompletionModel extends AbstractModel {
     constructor(settings = {}) {
         super({ settings });
@@ -178,11 +178,15 @@ export class LlamaCppCompletionModel extends AbstractModel {
                 template: promptTemplate,
             });
     }
-    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;
+    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,
+        });
     }
     get promptTemplateProvider() {
         return this.settings.promptTemplate ?? Text;

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/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]);
+    }
+}

package/model-provider/llamacpp/convertJsonSchemaToGBNF.test.cjs

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convertJsonSchemaToGBNF_js_1 = require("./convertJsonSchemaToGBNF.cjs");
+describe("primitives", () => {
+    it("should convert string", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "string",
+        })).toMatchSnapshot();
+    });
+    it("should convert number", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "number",
+        })).toMatchSnapshot();
+    });
+    it("should convert integer", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "integer",
+        })).toMatchSnapshot();
+    });
+    it("should convert boolean", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "boolean",
+        })).toMatchSnapshot();
+    });
+    it("should convert null", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "null",
+        })).toMatchSnapshot();
+    });
+});
+describe("array", () => {
+    it("should convert array of string", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "array",
+            items: {
+                type: "string",
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert array of array of string", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "array",
+            items: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert array of object", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                    },
+                    age: {
+                        type: "number",
+                    },
+                },
+            },
+        })).toMatchSnapshot();
+    });
+});
+describe("object", () => {
+    it("should convert object", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert object with required properties", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            required: ["name"],
+        })).toMatchSnapshot();
+    });
+    it("should convert object with additional properties", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            additionalProperties: true,
+        })).toMatchSnapshot();
+    });
+    it("should convert object with additional properties of string", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            additionalProperties: {
+                type: "string",
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert object with additional properties of object", () => {
+        expect((0, convertJsonSchemaToGBNF_js_1.convertJsonSchemaToGBNF)({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            additionalProperties: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                    },
+                    age: {
+                        type: "number",
+                    },
+                },
+            },
+        })).toMatchSnapshot();
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/model-provider/llamacpp/convertJsonSchemaToGBNF.test.js

@@ -0,0 +1,148 @@
+import { convertJsonSchemaToGBNF } from "./convertJsonSchemaToGBNF.js";
+describe("primitives", () => {
+    it("should convert string", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "string",
+        })).toMatchSnapshot();
+    });
+    it("should convert number", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "number",
+        })).toMatchSnapshot();
+    });
+    it("should convert integer", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "integer",
+        })).toMatchSnapshot();
+    });
+    it("should convert boolean", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "boolean",
+        })).toMatchSnapshot();
+    });
+    it("should convert null", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "null",
+        })).toMatchSnapshot();
+    });
+});
+describe("array", () => {
+    it("should convert array of string", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "array",
+            items: {
+                type: "string",
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert array of array of string", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "array",
+            items: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert array of object", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                    },
+                    age: {
+                        type: "number",
+                    },
+                },
+            },
+        })).toMatchSnapshot();
+    });
+});
+describe("object", () => {
+    it("should convert object", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert object with required properties", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            required: ["name"],
+        })).toMatchSnapshot();
+    });
+    it("should convert object with additional properties", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            additionalProperties: true,
+        })).toMatchSnapshot();
+    });
+    it("should convert object with additional properties of string", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            additionalProperties: {
+                type: "string",
+            },
+        })).toMatchSnapshot();
+    });
+    it("should convert object with additional properties of object", () => {
+        expect(convertJsonSchemaToGBNF({
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                age: {
+                    type: "number",
+                },
+            },
+            additionalProperties: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                    },
+                    age: {
+                        type: "number",
+                    },
+                },
+            },
+        })).toMatchSnapshot();
+    });
+});

package/model-provider/mistral/MistralChatModel.cjs

@@ -144,6 +144,9 @@ class MistralChatModel extends AbstractModel_js_1.AbstractModel {
     withChatPrompt() {
         return this.withPromptTemplate((0, MistralChatPromptTemplate_js_1.chat)());
     }
+    withJsonOutput() {
+        return this;
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel_js_1.PromptTemplateTextStreamingModel({
             model: this, // stop tokens are not supported by this model

package/model-provider/mistral/MistralChatModel.d.ts

@@ -161,6 +161,7 @@ export declare class MistralChatModel extends AbstractModel<MistralChatModelSett
      * Returns this model with a chat prompt template.
      */
     withChatPrompt(): PromptTemplateTextStreamingModel<import("../../index.js").ChatPrompt, MistralChatPrompt, MistralChatModelSettings, this>;
+    withJsonOutput(): this;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, MistralChatPrompt>): PromptTemplateTextStreamingModel<INPUT_PROMPT, MistralChatPrompt, MistralChatModelSettings, this>;
     withSettings(additionalSettings: Partial<MistralChatModelSettings>): this;
 }

package/model-provider/mistral/MistralChatModel.js

@@ -141,6 +141,9 @@ export class MistralChatModel extends AbstractModel {
     withChatPrompt() {
         return this.withPromptTemplate(chat());
     }
+    withJsonOutput() {
+        return this;
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel({
             model: this, // stop tokens are not supported by this model

package/model-provider/ollama/OllamaCompletionModel.cjs

@@ -163,6 +163,9 @@ class OllamaCompletionModel extends AbstractModel_js_1.AbstractModel {
             template: promptTemplate,
         });
     }
+    withJsonOutput() {
+        return this;
+    }
     withTextPrompt() {
         return this.withPromptTemplate({
             format(prompt) {

package/model-provider/ollama/OllamaCompletionModel.d.ts

@@ -130,6 +130,7 @@ export declare class OllamaCompletionModel<CONTEXT_WINDOW_SIZE extends number |
     extractTextDelta(delta: unknown): string | undefined;
     asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, OllamaCompletionPrompt>): TextGenerationToolCallModel<INPUT_PROMPT, OllamaCompletionPrompt, this>;
     asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsPromptTemplate<INPUT_PROMPT, OllamaCompletionPrompt>): TextGenerationToolCallsModel<INPUT_PROMPT, OllamaCompletionPrompt, this>;
+    withJsonOutput(): this;
     withTextPrompt(): PromptTemplateTextStreamingModel<string, OllamaCompletionPrompt, OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     /**
      * Maps the prompt for a text version of the Ollama completion prompt template (without image support).

package/model-provider/ollama/OllamaCompletionModel.js

@@ -160,6 +160,9 @@ export class OllamaCompletionModel extends AbstractModel {
             template: promptTemplate,
         });
     }
+    withJsonOutput() {
+        return this;
+    }
     withTextPrompt() {
         return this.withPromptTemplate({
             format(prompt) {

package/model-provider/openai/AbstractOpenAICompletionModel.cjs

@@ -120,6 +120,9 @@ class AbstractOpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
         }
         return chunk.choices[0].text;
     }
+    withJsonOutput() {
+        return this;
+    }
 }
 exports.AbstractOpenAICompletionModel = AbstractOpenAICompletionModel;
 const OpenAICompletionResponseSchema = zod_1.z.object({

package/model-provider/openai/AbstractOpenAICompletionModel.d.ts

@@ -103,6 +103,7 @@ export declare abstract class AbstractOpenAICompletionModel<SETTINGS extends Abs
         system_fingerprint?: string | undefined;
     }>>>;
     extractTextDelta(delta: unknown): string | undefined;
+    withJsonOutput(): this;
 }
 declare const OpenAICompletionResponseSchema: z.ZodObject<{
     id: z.ZodString;

package/model-provider/openai/AbstractOpenAICompletionModel.js

@@ -117,6 +117,9 @@ export class AbstractOpenAICompletionModel extends AbstractModel {
         }
         return chunk.choices[0].text;
     }
+    withJsonOutput() {
+        return this;
+    }
 }
 const OpenAICompletionResponseSchema = z.object({
     id: z.string(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building AI applications.",
-  "version": "0.118.0",
+  "version": "0.119.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [