[JS] Fix structured output test (#2951)

## Description
- Add comparison JavaScript samples with Python.

Ticket: 175278

## Checklist:
- [x] Tests have been updated or added to cover the new code <!--- If
the change isn't maintenance related, update the tests at
https://github.com/openvinotoolkit/openvino.genai/tree/master/tests or
explain in the description why the tests don't need an update. -->
- [x] This patch fully addresses the ticket. <!--- If follow-up pull
requests are needed, specify in description. -->
- [ ] I have made corresponding changes to the documentation

---------

Signed-off-by: Kirill Suvorov <kirill.suvorov@intel.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: Retribution98

samples/js/text_generation/README.md

@@ -175,27 +175,30 @@ If the model does not generate trigger strings there will be no structural const
 The sample is verified with `meta-llama/Llama-3.2-3B-Instruct` model. Other models may not produce the expected results or might require different system prompt.
 
 
-### 9. Compound Grammar Generation Sample (`compound_grammar_generation`)
+### 9. Compound Grammar Generation with Parsing Sample (`compound_grammar_generation`)
 - **Description:**
-  This sample demonstrates advanced structured output generation using compound grammars in OpenVINO GenAI.
-  It showcases how to combine multiple grammar types - Regex, JSONSchema and EBNF - using Union and Concat operations to strictly control LLM output.
+  This sample demonstrates advanced structured output generation and results parsing using compound grammars in OpenVINO GenAI.
+  It showcases how to combine multiple grammar types - Regex, JSONSchema and EBNF - using Union and Concat operations to strictly control LLM output and
+  also shows how to write parsing logic to extract structured data from the generated output.
   It features multi-turn chat, switching grammar constraints between turns (e.g., "yes"/"no" answers and structured tool calls).
   Union operation allows the model to choose which grammar to use during generation. 
   In the sample it is used to combine two regex grammars for `"yes"` or `"no"` answer.
-  Concat operation allows to start with one grammar and continue with another. 
+  Concat operation allows to start with one grammar and continue with another.
+  Also it demonstrates how to write custom parser to extract tool calls from the generated text.
   In the sample it used to create a `phi-4-mini-instruct` style tool calling answer - `functools[{tool_1_json}, ...]` - by combining regex and JSON schema grammars.
 
 - **Main Features:**
   - Create grammar building blocks: Regex, JSONSchema, EBNF grammar
   - Combine grammars with Concat and Union operations
   - Multi-turn chat with grammar switching
   - Structured tool calling using zod schemas
+  - Parse generated output to call tools from extracted structured data
 - **Run Command:**
   ```bash
   node compound_grammar_generation.js model_dir
   ```
 - **Notes:**
-  This sample is ideal for scenarios requiring strict control over LLM outputs, such as building agents that interact with APIs or require validated structured responses. It showcases how to combine regex triggers and JSON schema enforcement for robust output generation.
+  This sample is ideal for scenarios requiring strict control over LLM outputs, such as building agents that interact with APIs or require validated structured responses. It showcases how to combine regex triggers and JSON schema enforcement for robust output generation and parsing resulting output.
   The sample is verified with `microsoft/Phi-4-mini-instruct` model. Other models may not produce the expected results or might require different system prompt.
 
 #### Options

samples/js/text_generation/compound_grammar_generation.js

@@ -1,35 +1,35 @@
 import { z } from 'zod';
-import { LLMPipeline, StructuredOutputConfig as SOC, StreamingStatus } from 'openvino-genai-node';
-import { serialize_json } from './helper.js';
+import { ChatHistory, LLMPipeline, StructuredOutputConfig as SOC, StreamingStatus } from 'openvino-genai-node';
+import { serialize_json, toJSONSchema } from './helper.js';
 
 function streamer(subword) {
     process.stdout.write(subword);
     return StreamingStatus.RUNNING;
 }
 
-const bookingFlightTickets = {
-    name: "booking_flight_tickets",
+const bookFlightTicket = {
+    name: "book_flight_ticket",
     schema: z.object({
         origin_airport_code: z.string().describe("The name of Departure airport code"),
         destination_airport_code: z.string().describe("The name of Destination airport code"),
         departure_date: z.string().describe("The date of outbound flight"),
         return_date: z.string().describe("The date of return flight"),
-    }),
+    }).describe("booking flights"),
 };
 
-const bookingHotels = {
-    name: "booking_hotels",
+const bookHotel = {
+    name: "book_hotel",
     schema: z.object({
         destination: z.string().describe("The name of the city"),
         check_in_date: z.string().describe("The date of check in"),
         checkout_date: z.string().describe("The date of check out"),
-    }),
+    }).describe("booking hotel"),
 };
 
 // Helper functions
 function toolToDict(tool, withDescription = true) {
-    const deleteDescription = (schema) => delete schema.jsonSchema['description'];
-    const jsonSchema = z.toJSONSchema(
+    const deleteDescription = (ctx) => delete ctx.jsonSchema['description'];
+    const jsonSchema = toJSONSchema(
         tool.schema,
         withDescription
             ? undefined
@@ -46,11 +46,6 @@ function toolToDict(tool, withDescription = true) {
     };
 }
 
-/** Generate part of the system prompt with available tools */
-function generateSystemPromptTools(...tools) {
-    return `<|tool|>${serialize_json(tools.map(toolToDict))}</|tool|>`;
-}
-
 function toolsToArraySchema(...tools) {
     return serialize_json({
         type: "array",
@@ -60,22 +55,49 @@ function toolsToArraySchema(...tools) {
     });
 }
 
+/** parser to extract tool calls from the model output. */
+function parse(answer) {
+    answer.parsed = [];
+    for (const content of answer.texts) {
+        const startTag = "functools";
+        const startIndex = content.indexOf(startTag);
+        if (startIndex === -1) return;
+
+        try {
+            const jsonPart = content.slice(startIndex + startTag.length);
+            const toolCalls = JSON.parse(jsonPart);
+            answer.parsed.push(toolCalls);
+        } catch {
+            answer.parsed.push([]);
+        }
+    }
+
+    return;
+}
+
+function printToolCall(answer) {
+    for (const toolCall of answer.parsed[0]) {
+        const args = Object.keys(toolCall["arguments"])
+            .map((key) => `${key}="${toolCall["arguments"][key]}"`);
+        console.log(`${toolCall["name"]}(${args.join(", ")})`);
+    }
+}
+
 // System message
 let sysMessage = `You are a helpful AI assistant.
 You can answer yes or no to questions, or you can choose to call one or more of the provided functions.
 
 Use the following rule to decide when to call a function:
     * if the response can be generated from your internal knowledge, do so, but use only yes or no as the response
     * if you need external information that can be obtained by calling one or more of the provided functions, generate function calls
-    
+
 If you decide to call functions:
     * prefix function calls with functools marker (no closing marker required)
     * all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
     * follow the provided JSON schema. Do not hallucinate arguments or values. Do not blindly copy values from the provided samples
     * respect the argument type formatting. E.g., if the type is number and format is float, write value 7 as 7.0
     * make sure you pick the right functions that match the user intent
 `;
-sysMessage += generateSystemPromptTools(bookingFlightTickets, bookingHotels);
 
 async function main() {
     const modelDir = process.argv[2];
@@ -86,7 +108,9 @@ async function main() {
 
     const pipe = await LLMPipeline(modelDir, "CPU");
     const tokenizer = await pipe.getTokenizer();
-    const chatHistory = [{ role: "system", content: sysMessage }];
+    const chatHistory = new ChatHistory([{ role: "system", content: sysMessage }]);
+    const tools = [bookFlightTicket, bookHotel].map((tool) => toolToDict(tool, true));
+    chatHistory.setTools(tools);
 
     const generationConfig = {
         return_decoded_results: true,
@@ -104,27 +128,31 @@ async function main() {
     const yesOrNo = SOC.Union(SOC.Regex("yes"), SOC.Regex("no"));
     generationConfig.structured_output_config = new SOC({ structural_tags_config: yesOrNo });
     process.stdout.write("Assistant: ");
-    const answer = await pipe.generate(modelInput, generationConfig, streamer);
-    chatHistory.push({ role: "assistant", content: answer.texts[0] });
+    const answer1 = await pipe.generate(modelInput, generationConfig, streamer);
+    chatHistory.push({ role: "assistant", content: answer1.texts[0] });
     console.log();
 
     const userText2 =
-        "book flight ticket from Beijing to Paris(using airport code) in 2025-12-04 to 2025-12-10 , "
+        "book flight ticket from Beijing to Paris(using airport code) in 2025-12-04 to 2025-12-10, "
         + "then book hotel from 2025-12-04 to 2025-12-10 in Paris";
     console.log("User: ", userText2);
     chatHistory.push({ role: "user", content: userText2 });
     const modelInput2 = tokenizer.applyChatTemplate(chatHistory, true);
 
     const startToolCallTag = SOC.ConstString("functools");
     const toolsJson = SOC.JSONSchema(
-        toolsToArraySchema(bookingFlightTickets, bookingHotels)
+        toolsToArraySchema(bookFlightTicket, bookHotel)
     );
     const toolCall = SOC.Concat(startToolCallTag, toolsJson);
 
     generationConfig.structured_output_config.structural_tags_config = toolCall;
 
     process.stdout.write("Assistant: ");
-    await pipe.generate(modelInput2, generationConfig, streamer);
+    const answer2 = await pipe.generate(modelInput2, generationConfig);
+    parse(answer2);
+    console.log("\n\nThe following tool calls were generated:")
+    printToolCall(answer2)
+    console.log();
 }
 
 main();

samples/js/text_generation/helper.js

@@ -1,10 +1,35 @@
 // Copyright(C) 2025 Intel Corporation
 // SPDX - License - Identifier: Apache - 2.0
 
+import { z } from 'zod';
+
 /** Serialize a JavaScript object to a JSON string
  * with specific formatting to align with Python. */
 export function serialize_json(object) {
     return JSON.stringify(object)
-        .replaceAll('":', '": ')
-        .replaceAll('",', '", ');
+        // Add a space after every colon or comma not already followed by a space
+        .replace(/(:|,)(?! )/g, '$1 ');
 }
+
+/** Convert a Zod schema to a JSON Schema
+ * with specific formatting to align with Python */
+export function toJSONSchema(zodSchema, params) {
+    const jsonSchema = z.toJSONSchema(
+        zodSchema,
+        {
+            override: (ctx) => {
+                if (params && params.override) {
+                    params.override(ctx);
+                }
+                const keys = Object.keys(ctx.jsonSchema).sort();
+                for (const key of keys) {
+                    const value = ctx.jsonSchema[key];
+                    delete ctx.jsonSchema[key];
+                    ctx.jsonSchema[key] = value;
+                }
+            }
+        });
+    delete jsonSchema.$schema;
+    delete jsonSchema.additionalProperties;
+    return jsonSchema;
+}

samples/js/text_generation/structural_tags_generation.js

@@ -9,19 +9,19 @@ import { serialize_json } from './helper.js';
 const getWeatherTool = {
     name: "get_weather",
     schema: z.object({
-        city: z.string().describe("City name"),
-        country: z.string().describe("Country name"),
-        date: z.string().regex(/2\d{3}-[0-1]\d-[0-3]\d/).describe("Date in YYYY-MM-DD format")
-    }),
+        city: z.string().describe("City name").meta({ title: "City" }),
+        country: z.string().describe("Country name").meta({ title: "Country" }),
+        date: z.string().regex(/2\d\d\d-[0-1]\d-[0-3]\d/).describe("Date in YYYY-MM-DD format").meta({ title: "Date" })
+    }).meta({ title: "WeatherRequest" }),
 };
 
 const getCurrencyExchangeTool = {
     name: "get_currency_exchange",
     schema: z.object({
-        from_currency: z.string().describe("Currency to convert from"),
-        to_currency: z.string().describe("Currency to convert to"),
-        amount: z.number().describe("Amount to convert")
-    }),
+        from_currency: z.string().describe("Currency to convert from").meta({ title: "From Currency" }),
+        to_currency: z.string().describe("Currency to convert to").meta({ title: "To Currency" }),
+        amount: z.number().describe("Amount to convert").meta({ title: "Amount" })
+    }).meta({ title: "CurrencyExchangeRequest" }),
 };
 
 const tools = [getWeatherTool, getCurrencyExchangeTool];
@@ -35,7 +35,8 @@ ${tools.map(tool => `<function_name=\"${tool.name}\">, arguments=${serialize_jso
 Please, only use the following format for tool calling in your responses:
 <function=\"function_name\">{"argument1": "value1", ...}</function>
 Use the tool name and arguments as defined in the tool schema.
-If you don't know the answer, just say that you don't know, but try to call the tool if it helps to answer the question.`;
+If you don't know the answer, just say that you don't know, but try to call the tool if it helps to answer the question.
+`;
 
 const functionPattern = /<function="([^"]+)">(.*?)<\/function>/gs;
 
@@ -57,6 +58,16 @@ function streamer(subword) {
     return StreamingStatus.RUNNING;
 }
 
+function centerString(str, width) {
+    if (str.length >= width) {
+        return str;
+    }
+    const totalPadding = width - str.length;
+    const paddingStart = Math.floor(totalPadding / 2);
+    const paddingEnd = totalPadding - paddingStart;
+    return ' '.repeat(paddingStart) + str + ' '.repeat(paddingEnd);
+}
+
 async function main() {
     const defaultPrompt = "What is the weather in London today and in Paris yesterday, and how many pounds can I get for 100 euros?";
 
@@ -78,11 +89,11 @@ async function main() {
     const device = "CPU"; // GPU can be used as well
     const pipe = await LLMPipeline(modelDir, device);
 
-    console.log(`User prompt: ${prompt} `);
+    console.log(`User prompt: ${prompt}`);
 
     for (const useStructuralTags of [false, true]) {
         console.log("=".repeat(80));
-        console.log(`${useStructuralTags ? "Using structural tags" : "Using no structural tags"} `.padStart(40).padEnd(80));
+        console.log(`${centerString(useStructuralTags ? "Using structural tags" : "Using no structural tags", 80)}`);
         console.log("=".repeat(80));
 
         const generation_config = {};
@@ -101,8 +112,8 @@ async function main() {
                     triggers: ["<function="]
                 })
             };
+            generation_config.do_sample = true;
         };
-        generation_config.do_sample = true;
 
         const response = await pipe.generate(prompt, generation_config, streamer);
         await pipe.finishChat();