llmist 0.8.0 → 1.1.0

package/dist/testing/index.cjs

@@ -110,12 +110,13 @@ var init_logger = __esm({
 });
 
 // src/core/constants.ts
-var GADGET_START_PREFIX, GADGET_END_PREFIX, DEFAULT_GADGET_OUTPUT_LIMIT, DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT, CHARS_PER_TOKEN, FALLBACK_CONTEXT_WINDOW;
+var GADGET_START_PREFIX, GADGET_END_PREFIX, GADGET_ARG_PREFIX, DEFAULT_GADGET_OUTPUT_LIMIT, DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT, CHARS_PER_TOKEN, FALLBACK_CONTEXT_WINDOW;
 var init_constants = __esm({
   "src/core/constants.ts"() {
     "use strict";
     GADGET_START_PREFIX = "!!!GADGET_START:";
     GADGET_END_PREFIX = "!!!GADGET_END";
+    GADGET_ARG_PREFIX = "!!!ARG:";
     DEFAULT_GADGET_OUTPUT_LIMIT = true;
     DEFAULT_GADGET_OUTPUT_LIMIT_PERCENT = 15;
     CHARS_PER_TOKEN = 4;
@@ -448,17 +449,12 @@ var init_prompt_config = __esm({
         "EACH MARKER MUST START WITH A NEWLINE."
       ].join("\n"),
       criticalUsage: "INVOKE gadgets using the markers - do not describe what you want to do.",
-      formatDescriptionYaml: "Parameters in YAML format (one per line)",
-      formatDescriptionJson: "Parameters in JSON format (valid JSON object)",
-      formatDescriptionToml: "Parameters in TOML format (key = value pairs, use heredoc for multiline: key = <<<EOF ... EOF)",
+      formatDescription: (ctx) => `Parameters using ${ctx.argPrefix}name markers (value on next line(s), no escaping needed)`,
       rules: () => [
         "Output ONLY plain text with the exact markers - never use function/tool calling",
         "You can invoke multiple gadgets in a single response",
         "For dependent gadgets, invoke the first one and wait for the result"
       ],
-      schemaLabelJson: "\n\nInput Schema (JSON):",
-      schemaLabelYaml: "\n\nInput Schema (YAML):",
-      schemaLabelToml: "\n\nInput Schema (TOML):",
       customExamples: null
     };
   }
@@ -475,6 +471,7 @@ var init_messages = __esm({
       messages = [];
       startPrefix = GADGET_START_PREFIX;
       endPrefix = GADGET_END_PREFIX;
+      argPrefix = GADGET_ARG_PREFIX;
       promptConfig;
       constructor(promptConfig) {
         this.promptConfig = promptConfig ?? {};
@@ -483,26 +480,32 @@ var init_messages = __esm({
        * Set custom prefixes for gadget markers.
        * Used to configure history builder to match system prompt markers.
        */
-      withPrefixes(startPrefix, endPrefix) {
+      withPrefixes(startPrefix, endPrefix, argPrefix) {
         this.startPrefix = startPrefix;
         this.endPrefix = endPrefix;
+        if (argPrefix) {
+          this.argPrefix = argPrefix;
+        }
         return this;
       }
       addSystem(content, metadata) {
         this.messages.push({ role: "system", content, metadata });
         return this;
       }
-      addGadgets(gadgets, parameterFormat = "json", options) {
+      addGadgets(gadgets, options) {
         if (options?.startPrefix) {
           this.startPrefix = options.startPrefix;
         }
         if (options?.endPrefix) {
           this.endPrefix = options.endPrefix;
         }
+        if (options?.argPrefix) {
+          this.argPrefix = options.argPrefix;
+        }
         const context = {
-          parameterFormat,
           startPrefix: this.startPrefix,
           endPrefix: this.endPrefix,
+          argPrefix: this.argPrefix,
           gadgetCount: gadgets.length,
           gadgetNames: gadgets.map((g) => g.name ?? g.constructor.name)
         };
@@ -513,26 +516,19 @@ var init_messages = __esm({
           context
         );
         parts.push(mainInstruction);
-        parts.push(this.buildGadgetsSection(gadgets, parameterFormat));
-        parts.push(this.buildUsageSection(parameterFormat, context));
+        parts.push(this.buildGadgetsSection(gadgets));
+        parts.push(this.buildUsageSection(context));
         this.messages.push({ role: "system", content: parts.join("") });
         return this;
       }
-      buildGadgetsSection(gadgets, parameterFormat) {
+      buildGadgetsSection(gadgets) {
         const parts = [];
         parts.push("\n\nAVAILABLE GADGETS");
         parts.push("\n=================\n");
         for (const gadget of gadgets) {
           const gadgetName = gadget.name ?? gadget.constructor.name;
-          const instruction = gadget.getInstruction(parameterFormat);
-          const schemaMarkers = {
-            yaml: "\n\nInput Schema (YAML):",
-            json: "\n\nInput Schema (JSON):",
-            toml: "\n\nInput Schema (TOML):",
-            auto: "\n\nInput Schema (JSON):"
-            // auto defaults to JSON schema display
-          };
-          const schemaMarker = schemaMarkers[parameterFormat];
+          const instruction = gadget.getInstruction(this.argPrefix);
+          const schemaMarker = "\n\nInput Schema (BLOCK):";
           const schemaIndex = instruction.indexOf(schemaMarker);
           const description = (schemaIndex !== -1 ? instruction.substring(0, schemaIndex) : instruction).trim();
           const schema = schemaIndex !== -1 ? instruction.substring(schemaIndex + schemaMarker.length).trim() : "";
@@ -543,35 +539,20 @@ ${description}`);
           if (schema) {
             parts.push(`
 
-PARAMETERS (${parameterFormat.toUpperCase()}):
+PARAMETERS (BLOCK):
 ${schema}`);
           }
           parts.push("\n\n---");
         }
         return parts.join("");
       }
-      buildUsageSection(parameterFormat, context) {
+      buildUsageSection(context) {
         const parts = [];
-        const formatDescriptionMap = {
-          yaml: {
-            config: this.promptConfig.formatDescriptionYaml,
-            defaultValue: DEFAULT_PROMPTS.formatDescriptionYaml
-          },
-          json: {
-            config: this.promptConfig.formatDescriptionJson,
-            defaultValue: DEFAULT_PROMPTS.formatDescriptionJson
-          },
-          toml: {
-            config: this.promptConfig.formatDescriptionToml,
-            defaultValue: DEFAULT_PROMPTS.formatDescriptionToml
-          },
-          auto: {
-            config: this.promptConfig.formatDescriptionJson,
-            defaultValue: DEFAULT_PROMPTS.formatDescriptionJson
-          }
-        };
-        const { config, defaultValue } = formatDescriptionMap[parameterFormat];
-        const formatDescription = resolvePromptTemplate(config, defaultValue, context);
+        const formatDescription = resolvePromptTemplate(
+          this.promptConfig.formatDescription,
+          DEFAULT_PROMPTS.formatDescription,
+          context
+        );
         parts.push("\n\nHOW TO INVOKE GADGETS");
         parts.push("\n=====================\n");
         const criticalUsage = resolvePromptTemplate(
@@ -589,124 +570,90 @@ CRITICAL: ${criticalUsage}
   2. ${formatDescription}`);
         parts.push(`
   3. End marker: ${this.endPrefix}`);
-        parts.push(this.buildExamplesSection(parameterFormat, context));
+        parts.push(this.buildExamplesSection(context));
         parts.push(this.buildRulesSection(context));
         parts.push("\n");
         return parts.join("");
       }
-      buildExamplesSection(parameterFormat, context) {
+      buildExamplesSection(context) {
         if (this.promptConfig.customExamples) {
           return this.promptConfig.customExamples(context);
         }
         const parts = [];
-        const singleExamples = {
-          yaml: `${this.startPrefix}translate
-from: English
-to: Polish
-content: "Paris is the capital of France: a beautiful city."
-${this.endPrefix}`,
-          json: `${this.startPrefix}translate
-{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
-${this.endPrefix}`,
-          toml: `${this.startPrefix}translate
-from = "English"
-to = "Polish"
-content = "Paris is the capital of France: a beautiful city."
-${this.endPrefix}`,
-          auto: `${this.startPrefix}translate
-{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
-${this.endPrefix}`
-        };
+        const singleExample = `${this.startPrefix}translate
+${this.argPrefix}from
+English
+${this.argPrefix}to
+Polish
+${this.argPrefix}content
+Paris is the capital of France: a beautiful city.
+${this.endPrefix}`;
         parts.push(`
 
 EXAMPLE (Single Gadget):
 
-${singleExamples[parameterFormat]}`);
-        const multipleExamples = {
-          yaml: `${this.startPrefix}translate
-from: English
-to: Polish
-content: "Paris is the capital of France: a beautiful city."
+${singleExample}`);
+        const multipleExample = `${this.startPrefix}translate
+${this.argPrefix}from
+English
+${this.argPrefix}to
+Polish
+${this.argPrefix}content
+Paris is the capital of France: a beautiful city.
 ${this.endPrefix}
 ${this.startPrefix}analyze
-type: economic_analysis
-matter: "Polish Economy"
-question: <<<EOF
+${this.argPrefix}type
+economic_analysis
+${this.argPrefix}matter
+Polish Economy
+${this.argPrefix}question
 Analyze the following:
 - Polish arms exports 2025
 - Economic implications
-EOF
-${this.endPrefix}`,
-          json: `${this.startPrefix}translate
-{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
-${this.endPrefix}
-${this.startPrefix}analyze
-{"type": "economic_analysis", "matter": "Polish Economy", "question": "Analyze the following: Polish arms exports 2025, economic implications"}
-${this.endPrefix}`,
-          toml: `${this.startPrefix}translate
-from = "English"
-to = "Polish"
-content = "Paris is the capital of France: a beautiful city."
-${this.endPrefix}
-${this.startPrefix}analyze
-type = "economic_analysis"
-matter = "Polish Economy"
-question = <<<EOF
-Analyze the following:
-- Polish arms exports 2025
-- Economic implications
-EOF
-${this.endPrefix}`,
-          auto: `${this.startPrefix}translate
-{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
-${this.endPrefix}
-${this.startPrefix}analyze
-{"type": "economic_analysis", "matter": "Polish Economy", "question": "Analyze the following: Polish arms exports 2025, economic implications"}
-${this.endPrefix}`
-        };
+${this.endPrefix}`;
         parts.push(`
 
 EXAMPLE (Multiple Gadgets):
 
-${multipleExamples[parameterFormat]}`);
-        if (parameterFormat === "yaml") {
-          parts.push(`
-
-YAML HEREDOC SYNTAX:
-For string values with multiple lines, use heredoc syntax (<<<DELIMITER...DELIMITER):
+${multipleExample}`);
+        parts.push(`
 
-filePath: "README.md"
-content: <<<EOF
-# Project Title
+BLOCK FORMAT SYNTAX:
+Block format uses ${this.argPrefix}name markers. Values are captured verbatim until the next marker.
 
-This content can contain:
-- Markdown lists
-- Special characters: # : -
-- Multiple paragraphs
-EOF
+${this.argPrefix}filename
+calculator.ts
+${this.argPrefix}code
+class Calculator {
+  private history: string[] = [];
 
-The delimiter (EOF) can be any identifier. The closing delimiter must be on its own line.
-No indentation is required for the content.`);
-        } else if (parameterFormat === "toml") {
-          parts.push(`
-
-TOML HEREDOC SYNTAX:
-For string values with multiple lines, use heredoc syntax (<<<DELIMITER...DELIMITER):
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(\`\${a} + \${b} = \${result}\`);
+    return result;
+  }
+}
 
-filePath = "README.md"
-content = <<<EOF
-# Project Title
+BLOCK FORMAT RULES:
+- Each parameter starts with ${this.argPrefix}parameterName on its own line
+- The value starts on the NEXT line after the marker
+- Value ends when the next ${this.argPrefix} or ${this.endPrefix} appears
+- NO escaping needed - write values exactly as they should appear
+- Perfect for code, JSON, markdown, or any content with special characters
 
-This content can contain:
-- Markdown lists
-- Special characters: # : -
-- Multiple paragraphs
-EOF
+NESTED OBJECTS (use / separator):
+${this.argPrefix}config/timeout
+30
+${this.argPrefix}config/retries
+3
+Produces: { "config": { "timeout": "30", "retries": "3" } }
 
-The delimiter (EOF) can be any identifier. The closing delimiter must be on its own line.
-IMPORTANT: Content inside heredoc is LITERAL - do NOT escape backticks, dollar signs, or any characters.
-NEVER use TOML triple-quote strings ("""). ALWAYS use heredoc syntax (<<<EOF...EOF) for multiline content.`);
-        }
+ARRAYS (use numeric indices):
+${this.argPrefix}items/0
+first
+${this.argPrefix}items/1
+second
+Produces: { "items": ["first", "second"] }`);
         return parts.join("");
       }
       buildRulesSection(context) {
@@ -727,8 +674,8 @@ NEVER use TOML triple-quote strings ("""). ALWAYS use heredoc syntax (<<<EOF...E
         this.messages.push({ role: "assistant", content, metadata });
         return this;
       }
-      addGadgetCall(gadget, parameters, result, parameterFormat = "json") {
-        const paramStr = this.formatParameters(parameters, parameterFormat);
+      addGadgetCall(gadget, parameters, result) {
+        const paramStr = this.formatBlockParameters(parameters, "");
         this.messages.push({
           role: "assistant",
           content: `${this.startPrefix}${gadget}
@@ -741,26 +688,32 @@ ${this.endPrefix}`
         });
         return this;
       }
-      formatParameters(parameters, format) {
-        if (format === "yaml") {
-          return Object.entries(parameters).map(([key, value]) => {
-            if (typeof value === "string") {
-              return `${key}: ${value}`;
-            }
-            return `${key}: ${JSON.stringify(value)}`;
-          }).join("\n");
-        }
-        if (format === "toml") {
-          return Object.entries(parameters).map(([key, value]) => {
-            if (typeof value === "string" && value.includes("\n")) {
-              return `${key} = <<<EOF
-${value}
-EOF`;
-            }
-            return `${key} = ${JSON.stringify(value)}`;
-          }).join("\n");
+      /**
+       * Format parameters as Block format with JSON Pointer paths.
+       * Uses the configured argPrefix for consistency with system prompt.
+       */
+      formatBlockParameters(params, prefix) {
+        const lines = [];
+        for (const [key, value] of Object.entries(params)) {
+          const fullPath = prefix ? `${prefix}/${key}` : key;
+          if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+              const itemPath = `${fullPath}/${index}`;
+              if (typeof item === "object" && item !== null) {
+                lines.push(this.formatBlockParameters(item, itemPath));
+              } else {
+                lines.push(`${this.argPrefix}${itemPath}`);
+                lines.push(String(item));
+              }
+            });
+          } else if (typeof value === "object" && value !== null) {
+            lines.push(this.formatBlockParameters(value, fullPath));
+          } else {
+            lines.push(`${this.argPrefix}${fullPath}`);
+            lines.push(String(value));
+          }
         }
-        return JSON.stringify(parameters);
+        return lines.join("\n");
       }
       build() {
         return [...this.messages];
@@ -853,134 +806,72 @@ var init_schema_to_json = __esm({
 });
 
 // src/gadgets/gadget.ts
-function findSafeDelimiter(content) {
-  const lines = content.split("\n");
-  for (const delimiter of HEREDOC_DELIMITERS) {
-    const regex = new RegExp(`^${delimiter}\\s*$`);
-    const isUsed = lines.some((line) => regex.test(line));
-    if (!isUsed) {
-      return delimiter;
-    }
-  }
-  let counter = 1;
-  while (counter < 1e3) {
-    const delimiter = `__GADGET_PARAM_${counter}__`;
-    const regex = new RegExp(`^${delimiter}\\s*$`);
-    const isUsed = lines.some((line) => regex.test(line));
-    if (!isUsed) {
-      return delimiter;
-    }
-    counter++;
-  }
-  return "HEREDOC_FALLBACK";
-}
-function formatYamlValue(value, indent = "") {
-  if (typeof value === "string") {
-    const lines = value.split("\n");
-    if (lines.length === 1 && !value.includes(":") && !value.startsWith("-")) {
-      return value;
-    }
-    const delimiter = findSafeDelimiter(value);
-    return `<<<${delimiter}
-${value}
-${delimiter}`;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  if (value === null || value === void 0) {
-    return "null";
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    const items = value.map((item) => `${indent}- ${formatYamlValue(item, indent + "  ")}`);
-    return "\n" + items.join("\n");
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value);
-    if (entries.length === 0) return "{}";
-    const lines = entries.map(([k, v]) => {
-      const formattedValue = formatYamlValue(v, indent + "  ");
-      if (formattedValue.startsWith("\n") || formattedValue.startsWith("|")) {
-        return `${indent}${k}: ${formattedValue}`;
-      }
-      return `${indent}${k}: ${formattedValue}`;
-    });
-    return "\n" + lines.join("\n");
-  }
-  return yaml.dump(value).trimEnd();
-}
-function formatParamsAsYaml(params) {
+function formatParamsAsBlock(params, prefix = "", argPrefix = GADGET_ARG_PREFIX) {
   const lines = [];
   for (const [key, value] of Object.entries(params)) {
-    const formattedValue = formatYamlValue(value, "");
-    if (formattedValue.startsWith("\n")) {
-      lines.push(`${key}:${formattedValue}`);
+    const fullPath = prefix ? `${prefix}/${key}` : key;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const itemPath = `${fullPath}/${index}`;
+        if (typeof item === "object" && item !== null) {
+          lines.push(formatParamsAsBlock(item, itemPath, argPrefix));
+        } else {
+          lines.push(`${argPrefix}${itemPath}`);
+          lines.push(String(item));
+        }
+      });
+    } else if (typeof value === "object" && value !== null) {
+      lines.push(formatParamsAsBlock(value, fullPath, argPrefix));
     } else {
-      lines.push(`${key}: ${formattedValue}`);
+      lines.push(`${argPrefix}${fullPath}`);
+      lines.push(String(value));
     }
   }
   return lines.join("\n");
 }
-function formatTomlInlineTable(obj) {
-  const entries = Object.entries(obj).map(([k, v]) => `${k} = ${formatTomlValue(v)}`);
-  return `{ ${entries.join(", ")} }`;
-}
-function formatTomlValue(value) {
-  if (typeof value === "string") {
-    if (value.includes("\n")) {
-      const delimiter = findSafeDelimiter(value);
-      return `<<<${delimiter}
-${value}
-${delimiter}`;
-    }
-    return JSON.stringify(value);
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  if (value === null || value === void 0) {
-    return '""';
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    const items = value.map((item) => {
-      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
-        return formatTomlInlineTable(item);
-      }
-      return formatTomlValue(item);
-    });
-    return `[${items.join(", ")}]`;
-  }
-  if (typeof value === "object") {
-    return formatTomlInlineTable(value);
-  }
-  return JSON.stringify(value);
-}
-function formatParamsAsToml(params) {
+function formatSchemaAsPlainText(schema, indent = "") {
   const lines = [];
-  for (const [key, value] of Object.entries(params)) {
-    lines.push(`${key} = ${formatTomlValue(value)}`);
+  const properties = schema.properties || {};
+  const required = schema.required || [];
+  for (const [key, prop] of Object.entries(properties)) {
+    const propObj = prop;
+    const type = propObj.type;
+    const description = propObj.description;
+    const isRequired = required.includes(key);
+    const enumValues = propObj.enum;
+    let line = `${indent}- ${key}`;
+    if (type === "array") {
+      const items = propObj.items;
+      const itemType = items?.type || "any";
+      line += ` (array of ${itemType})`;
+    } else if (type === "object" && propObj.properties) {
+      line += " (object)";
+    } else {
+      line += ` (${type})`;
+    }
+    if (isRequired) {
+      line += " [required]";
+    }
+    if (description) {
+      line += `: ${description}`;
+    }
+    if (enumValues) {
+      line += ` - one of: ${enumValues.map((v) => `"${v}"`).join(", ")}`;
+    }
+    lines.push(line);
+    if (type === "object" && propObj.properties) {
+      lines.push(formatSchemaAsPlainText(propObj, indent + "  "));
+    }
   }
   return lines.join("\n");
 }
-var yaml, HEREDOC_DELIMITERS, BaseGadget;
+var BaseGadget;
 var init_gadget = __esm({
   "src/gadgets/gadget.ts"() {
     "use strict";
-    yaml = __toESM(require("js-yaml"), 1);
+    init_constants();
     init_schema_to_json();
     init_schema_validator();
-    HEREDOC_DELIMITERS = [
-      "__GADGET_PARAM_EOF__",
-      "__GADGET_PARAM_END__",
-      "__GADGET_PARAM_DOC__",
-      "__GADGET_PARAM_CONTENT__",
-      "__GADGET_PARAM_TEXT__",
-      "__GADGET_PARAM_HEREDOC__",
-      "__GADGET_PARAM_DATA__",
-      "__GADGET_PARAM_BLOCK__"
-    ];
     BaseGadget = class {
       /**
        * The name of the gadget. Used for identification when LLM calls it.
@@ -1011,19 +902,19 @@ var init_gadget = __esm({
       /**
        * Auto-generated instruction text for the LLM.
        * Combines name, description, and parameter schema into a formatted instruction.
-       * @deprecated Use getInstruction(format) instead for format-specific schemas
+       * @deprecated Use getInstruction() instead
        */
       get instruction() {
-        return this.getInstruction("yaml");
+        return this.getInstruction();
       }
       /**
-       * Generate instruction text for the LLM with format-specific schema.
+       * Generate instruction text for the LLM.
        * Combines name, description, and parameter schema into a formatted instruction.
        *
-       * @param format - Format for the schema representation ('json' | 'yaml' | 'toml' | 'auto')
+       * @param argPrefix - Optional custom argument prefix for block format examples
        * @returns Formatted instruction string
        */
-      getInstruction(format = "json") {
+      getInstruction(argPrefix) {
         const parts = [];
         parts.push(this.description);
         if (this.parameterSchema) {
@@ -1032,20 +923,12 @@ var init_gadget = __esm({
           const jsonSchema = schemaToJSONSchema(this.parameterSchema, {
             target: "draft-7"
           });
-          if (format === "json" || format === "auto") {
-            parts.push("\n\nInput Schema (JSON):");
-            parts.push(JSON.stringify(jsonSchema, null, 2));
-          } else if (format === "toml") {
-            parts.push("\n\nInput Schema (TOML):");
-            parts.push(JSON.stringify(jsonSchema, null, 2));
-          } else {
-            const yamlSchema = yaml.dump(jsonSchema).trimEnd();
-            parts.push("\n\nInput Schema (YAML):");
-            parts.push(yamlSchema);
-          }
+          parts.push("\n\nParameters:");
+          parts.push(formatSchemaAsPlainText(jsonSchema));
         }
         if (this.examples && this.examples.length > 0) {
           parts.push("\n\nExamples:");
+          const effectiveArgPrefix = argPrefix ?? GADGET_ARG_PREFIX;
           this.examples.forEach((example, index) => {
             if (index > 0) {
               parts.push("");
@@ -1054,13 +937,7 @@ var init_gadget = __esm({
               parts.push(`# ${example.comment}`);
             }
             parts.push("Input:");
-            if (format === "json" || format === "auto") {
-              parts.push(JSON.stringify(example.params, null, 2));
-            } else if (format === "toml") {
-              parts.push(formatParamsAsToml(example.params));
-            } else {
-              parts.push(formatParamsAsYaml(example.params));
-            }
+            parts.push(formatParamsAsBlock(example.params, "", effectiveArgPrefix));
             if (example.output !== void 0) {
               parts.push("Output:");
               parts.push(example.output);
@@ -1337,14 +1214,12 @@ var init_conversation_manager = __esm({
       baseMessages;
       initialMessages;
       historyBuilder;
-      parameterFormat;
       constructor(baseMessages, initialMessages, options = {}) {
         this.baseMessages = baseMessages;
         this.initialMessages = initialMessages;
-        this.parameterFormat = options.parameterFormat ?? "json";
         this.historyBuilder = new LLMMessageBuilder();
         if (options.startPrefix && options.endPrefix) {
-          this.historyBuilder.withPrefixes(options.startPrefix, options.endPrefix);
+          this.historyBuilder.withPrefixes(options.startPrefix, options.endPrefix, options.argPrefix);
         }
       }
       addUserMessage(content) {
@@ -1354,7 +1229,7 @@ var init_conversation_manager = __esm({
         this.historyBuilder.addAssistant(content);
       }
       addGadgetCall(gadgetName, parameters, result) {
-        this.historyBuilder.addGadgetCall(gadgetName, parameters, result, this.parameterFormat);
+        this.historyBuilder.addGadgetCall(gadgetName, parameters, result);
       }
       getMessages() {
         return [...this.baseMessages, ...this.initialMessages, ...this.historyBuilder.build()];
@@ -1377,7 +1252,7 @@ async function runWithHandlers(agentGenerator, handlers) {
           await handlers.onGadgetCall({
             gadgetName: event.call.gadgetName,
             parameters: event.call.parameters,
-            parametersYaml: event.call.parametersYaml
+            parametersRaw: event.call.parametersRaw
           });
         }
         break;
@@ -1571,6 +1446,89 @@ var init_hook_validators = __esm({
   }
 });
 
+// src/gadgets/error-formatter.ts
+var GadgetErrorFormatter;
+var init_error_formatter = __esm({
+  "src/gadgets/error-formatter.ts"() {
+    "use strict";
+    init_constants();
+    GadgetErrorFormatter = class {
+      argPrefix;
+      startPrefix;
+      endPrefix;
+      constructor(options = {}) {
+        this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
+        this.startPrefix = options.startPrefix ?? GADGET_START_PREFIX;
+        this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
+      }
+      /**
+       * Format a Zod validation error with full gadget instructions.
+       *
+       * @param gadgetName - Name of the gadget that was called
+       * @param zodError - The Zod validation error
+       * @param gadget - The gadget instance (for generating instructions)
+       * @returns Formatted error message with usage instructions
+       */
+      formatValidationError(gadgetName, zodError, gadget) {
+        const parts = [];
+        parts.push(`Error: Invalid parameters for '${gadgetName}':`);
+        for (const issue of zodError.issues) {
+          const path = issue.path.join(".") || "root";
+          parts.push(`  - ${path}: ${issue.message}`);
+        }
+        parts.push("");
+        parts.push("Gadget Usage:");
+        parts.push(gadget.getInstruction(this.argPrefix));
+        return parts.join("\n");
+      }
+      /**
+       * Format a parse error with block format reference.
+       *
+       * @param gadgetName - Name of the gadget that was called
+       * @param parseError - The parse error message
+       * @param gadget - The gadget instance if found (for generating instructions)
+       * @returns Formatted error message with format reference
+       */
+      formatParseError(gadgetName, parseError, gadget) {
+        const parts = [];
+        parts.push(`Error: Failed to parse parameters for '${gadgetName}':`);
+        parts.push(`  ${parseError}`);
+        if (gadget) {
+          parts.push("");
+          parts.push("Gadget Usage:");
+          parts.push(gadget.getInstruction(this.argPrefix));
+        }
+        parts.push("");
+        parts.push("Block Format Reference:");
+        parts.push(`  ${this.startPrefix}${gadgetName}`);
+        parts.push(`  ${this.argPrefix}parameterName`);
+        parts.push("  parameter value here");
+        parts.push(`  ${this.endPrefix}`);
+        return parts.join("\n");
+      }
+      /**
+       * Format a registry error (gadget not found) with available gadgets list.
+       *
+       * @param gadgetName - Name of the gadget that was not found
+       * @param availableGadgets - List of available gadget names
+       * @returns Formatted error message with available gadgets
+       */
+      formatRegistryError(gadgetName, availableGadgets) {
+        const parts = [];
+        parts.push(`Error: Gadget '${gadgetName}' not found.`);
+        if (availableGadgets.length > 0) {
+          parts.push("");
+          parts.push(`Available gadgets: ${availableGadgets.join(", ")}`);
+        } else {
+          parts.push("");
+          parts.push("No gadgets are currently registered.");
+        }
+        return parts.join("\n");
+      }
+    };
+  }
+});
+
 // src/gadgets/exceptions.ts
 var BreakLoopException, HumanInputException, TimeoutException;
 var init_exceptions = __esm({
@@ -1609,15 +1567,18 @@ var init_executor = __esm({
   "src/gadgets/executor.ts"() {
     "use strict";
     init_logger();
+    init_error_formatter();
     init_exceptions();
     GadgetExecutor = class {
-      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs) {
+      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions) {
         this.registry = registry;
         this.onHumanInputRequired = onHumanInputRequired;
         this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
         this.logger = logger ?? createLogger({ name: "llmist:executor" });
+        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
       }
       logger;
+      errorFormatter;
       /**
        * Creates a promise that rejects with a TimeoutException after the specified timeout.
        */
@@ -1642,11 +1603,12 @@ var init_executor = __esm({
           const gadget = this.registry.get(call.gadgetName);
           if (!gadget) {
             this.logger.error("Gadget not found", { gadgetName: call.gadgetName });
+            const availableGadgets = this.registry.getNames();
             return {
               gadgetName: call.gadgetName,
               invocationId: call.invocationId,
               parameters: call.parameters ?? {},
-              error: `Gadget '${call.gadgetName}' not found in registry`,
+              error: this.errorFormatter.formatRegistryError(call.gadgetName, availableGadgets),
               executionTimeMs: Date.now() - startTime
             };
           }
@@ -1654,27 +1616,28 @@ var init_executor = __esm({
             this.logger.error("Gadget parameter parse error", {
               gadgetName: call.gadgetName,
               parseError: call.parseError,
-              rawParameters: call.parametersYaml
+              rawParameters: call.parametersRaw
             });
+            const parseErrorMessage = call.parseError ?? "Failed to parse parameters";
             return {
               gadgetName: call.gadgetName,
               invocationId: call.invocationId,
               parameters: {},
-              error: call.parseError ?? "Failed to parse parameters",
+              error: this.errorFormatter.formatParseError(call.gadgetName, parseErrorMessage, gadget),
               executionTimeMs: Date.now() - startTime
             };
           }
           if (gadget.parameterSchema) {
             const validationResult = gadget.parameterSchema.safeParse(rawParameters);
             if (!validationResult.success) {
-              const formattedIssues = validationResult.error.issues.map((issue) => {
-                const path = issue.path.join(".") || "root";
-                return `${path}: ${issue.message}`;
-              }).join("; ");
-              const validationError = `Invalid parameters: ${formattedIssues}`;
+              const validationError = this.errorFormatter.formatValidationError(
+                call.gadgetName,
+                validationResult.error,
+                gadget
+              );
               this.logger.error("Gadget parameter validation failed", {
                 gadgetName: call.gadgetName,
-                error: validationError
+                issueCount: validationResult.error.issues.length
               });
               return {
                 gadgetName: call.gadgetName,
@@ -1816,168 +1779,107 @@ var init_executor = __esm({
   }
 });
 
-// src/gadgets/parser.ts
-function preprocessYaml(yamlStr) {
-  const lines = yamlStr.split("\n");
-  const result = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    const heredocMatch = line.match(/^(\s*)([\w-]+):\s*<<<([A-Za-z_][A-Za-z0-9_]*)\s*$/);
-    if (heredocMatch) {
-      const [, indent, key, delimiter] = heredocMatch;
-      const bodyLines = [];
-      i++;
-      const closingRegex = new RegExp(`^${delimiter}\\s*$`);
-      while (i < lines.length && !closingRegex.test(lines[i])) {
-        bodyLines.push(lines[i]);
-        i++;
-      }
-      if (i < lines.length) {
-        i++;
-      }
-      result.push(`${indent}${key}: |`);
-      for (const bodyLine of bodyLines) {
-        result.push(`${indent}  ${bodyLine}`);
+// src/gadgets/block-params.ts
+function parseBlockParams(content, options) {
+  const argPrefix = options?.argPrefix ?? GADGET_ARG_PREFIX;
+  const result = {};
+  const seenPointers = /* @__PURE__ */ new Set();
+  const parts = content.split(argPrefix);
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    const newlineIndex = part.indexOf("\n");
+    if (newlineIndex === -1) {
+      const pointer2 = part.trim();
+      if (pointer2) {
+        if (seenPointers.has(pointer2)) {
+          throw new Error(`Duplicate pointer: ${pointer2}`);
+        }
+        seenPointers.add(pointer2);
+        setByPointer(result, pointer2, "");
       }
       continue;
     }
-    const match = line.match(/^(\s*)([\w-]+):\s+(.+)$/);
-    if (match) {
-      const [, indent, key, value] = match;
-      if (value === "|" || value === ">" || value === "|-" || value === ">-") {
-        result.push(line);
-        i++;
-        const keyIndentLen2 = indent.length;
-        const blockLines = [];
-        let minContentIndent = Infinity;
-        while (i < lines.length) {
-          const blockLine = lines[i];
-          const blockIndentMatch = blockLine.match(/^(\s*)/);
-          const blockIndentLen = blockIndentMatch ? blockIndentMatch[1].length : 0;
-          if (blockLine.trim() === "") {
-            blockLines.push({ content: "", originalIndent: 0 });
-            i++;
-            continue;
-          }
-          if (blockIndentLen > keyIndentLen2) {
-            const content = blockLine.substring(blockIndentLen);
-            blockLines.push({ content, originalIndent: blockIndentLen });
-            if (content.trim().length > 0) {
-              minContentIndent = Math.min(minContentIndent, blockIndentLen);
-            }
-            i++;
-          } else {
-            break;
-          }
-        }
-        const targetIndent = keyIndentLen2 + 2;
-        for (const blockLine of blockLines) {
-          if (blockLine.content === "") {
-            result.push("");
-          } else {
-            result.push(" ".repeat(targetIndent) + blockLine.content);
-          }
-        }
-        continue;
-      }
-      if (value.startsWith('"') || value.startsWith("'") || value === "true" || value === "false" || /^-?\d+(\.\d+)?$/.test(value)) {
-        result.push(line);
-        i++;
-        continue;
-      }
-      const keyIndentLen = indent.length;
-      const continuationLines = [];
-      let j = i + 1;
-      while (j < lines.length) {
-        const nextLine = lines[j];
-        if (nextLine.trim() === "") {
-          continuationLines.push(nextLine);
-          j++;
-          continue;
-        }
-        const nextIndentMatch = nextLine.match(/^(\s*)/);
-        const nextIndentLen = nextIndentMatch ? nextIndentMatch[1].length : 0;
-        if (nextIndentLen > keyIndentLen) {
-          continuationLines.push(nextLine);
-          j++;
-        } else {
-          break;
-        }
-      }
-      if (continuationLines.length > 0 && continuationLines.some((l) => l.trim().length > 0)) {
-        result.push(`${indent}${key}: |`);
-        result.push(`${indent}  ${value}`);
-        for (const contLine of continuationLines) {
-          if (contLine.trim() === "") {
-            result.push("");
-          } else {
-            const contIndentMatch = contLine.match(/^(\s*)/);
-            const contIndent = contIndentMatch ? contIndentMatch[1] : "";
-            const contContent = contLine.substring(contIndent.length);
-            result.push(`${indent}  ${contContent}`);
-          }
-        }
-        i = j;
-        continue;
-      }
-      if (value.includes(": ") || value.endsWith(":")) {
-        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-        result.push(`${indent}${key}: "${escaped}"`);
-        i++;
-        continue;
-      }
+    const pointer = part.substring(0, newlineIndex).trim();
+    let value = part.substring(newlineIndex + 1);
+    if (value.endsWith("\n")) {
+      value = value.slice(0, -1);
     }
-    result.push(line);
-    i++;
+    if (!pointer) {
+      continue;
+    }
+    if (seenPointers.has(pointer)) {
+      throw new Error(`Duplicate pointer: ${pointer}`);
+    }
+    seenPointers.add(pointer);
+    setByPointer(result, pointer, value);
   }
-  return result.join("\n");
+  return result;
 }
-function unescapeHeredocContent(content) {
-  return content.replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\{/g, "{").replace(/\\}/g, "}");
+function coerceValue(value) {
+  if (value.includes("\n")) {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed !== "" && /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    const num = Number(trimmed);
+    if (!isNaN(num) && isFinite(num)) {
+      return num;
+    }
+  }
+  return value;
 }
-function preprocessTomlHeredoc(tomlStr) {
-  const lines = tomlStr.split("\n");
-  const result = [];
-  let i = 0;
-  const heredocStartRegex = /^(\s*)([\w-]+)\s*=\s*<<<([A-Za-z_][A-Za-z0-9_]*)\s*$/;
-  while (i < lines.length) {
-    const line = lines[i];
-    const match = line.match(heredocStartRegex);
-    if (match) {
-      const [, indent, key, delimiter] = match;
-      const bodyLines = [];
-      i++;
-      const closingRegex = new RegExp(`^${delimiter}\\s*$`);
-      let foundClosing = false;
-      while (i < lines.length) {
-        const bodyLine = lines[i];
-        if (closingRegex.test(bodyLine)) {
-          foundClosing = true;
-          i++;
-          break;
-        }
-        bodyLines.push(bodyLine);
-        i++;
-      }
-      if (bodyLines.length === 0) {
-        result.push(`${indent}${key} = ''''''`);
-      } else {
-        result.push(`${indent}${key} = '''`);
-        for (let j = 0; j < bodyLines.length - 1; j++) {
-          result.push(unescapeHeredocContent(bodyLines[j]));
-        }
-        result.push(`${unescapeHeredocContent(bodyLines[bodyLines.length - 1])}'''`);
-      }
-      if (!foundClosing) {
+function setByPointer(obj, pointer, value) {
+  const segments = pointer.split("/");
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const nextSegment = segments[i + 1];
+    const nextIsArrayIndex = /^\d+$/.test(nextSegment);
+    if (Array.isArray(current)) {
+      const index = parseInt(segment, 10);
+      if (isNaN(index) || index < 0) {
+        throw new Error(`Invalid array index: ${segment}`);
+      }
+      if (index > current.length) {
+        throw new Error(`Array index gap: expected ${current.length}, got ${index}`);
+      }
+      if (current[index] === void 0) {
+        current[index] = nextIsArrayIndex ? [] : {};
+      }
+      current = current[index];
+    } else {
+      const rec = current;
+      if (rec[segment] === void 0) {
+        rec[segment] = nextIsArrayIndex ? [] : {};
       }
-      continue;
+      current = rec[segment];
+    }
+  }
+  const lastSegment = segments[segments.length - 1];
+  const coercedValue = coerceValue(value);
+  if (Array.isArray(current)) {
+    const index = parseInt(lastSegment, 10);
+    if (isNaN(index) || index < 0) {
+      throw new Error(`Invalid array index: ${lastSegment}`);
+    }
+    if (index > current.length) {
+      throw new Error(`Array index gap: expected ${current.length}, got ${index}`);
     }
-    result.push(line);
-    i++;
+    current[index] = coercedValue;
+  } else {
+    current[lastSegment] = coercedValue;
   }
-  return result.join("\n");
 }
+var init_block_params = __esm({
+  "src/gadgets/block-params.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/gadgets/parser.ts
 function stripMarkdownFences(content) {
   let cleaned = content.trim();
   const openingFence = /^```(?:toml|yaml|json)?\s*\n/i;
@@ -1986,24 +1888,23 @@ function stripMarkdownFences(content) {
   cleaned = cleaned.replace(closingFence, "");
   return cleaned.trim();
 }
-var yaml2, import_js_toml, globalInvocationCounter, StreamParser;
+var globalInvocationCounter, StreamParser;
 var init_parser = __esm({
   "src/gadgets/parser.ts"() {
     "use strict";
-    yaml2 = __toESM(require("js-yaml"), 1);
-    import_js_toml = require("js-toml");
     init_constants();
+    init_block_params();
     globalInvocationCounter = 0;
     StreamParser = class {
       buffer = "";
       lastReportedTextLength = 0;
       startPrefix;
       endPrefix;
-      parameterFormat;
+      argPrefix;
       constructor(options = {}) {
         this.startPrefix = options.startPrefix ?? GADGET_START_PREFIX;
         this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
-        this.parameterFormat = options.parameterFormat ?? "json";
+        this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
       }
       takeTextUntil(index) {
         if (index <= this.lastReportedTextLength) {
@@ -2025,56 +1926,22 @@ var init_parser = __esm({
         return { actualName: gadgetName, invocationId: `gadget_${++globalInvocationCounter}` };
       }
       /**
-       * Truncate verbose parse errors to avoid context overflow.
-       * Keeps first meaningful line and limits total length.
+       * Extract the error message from a parse error.
+       * Preserves full message since the error formatter adds contextual help
+       * that benefits from precise, detailed error information.
        */
-      truncateParseError(error, format) {
-        const message = error instanceof Error ? error.message : String(error);
-        const firstLine = message.split("\n")[0];
-        const maxLen = 200;
-        if (firstLine.length <= maxLen) {
-          return firstLine;
-        }
-        return `${firstLine.slice(0, maxLen)}... (${message.length} chars total)`;
+      extractParseError(error) {
+        return error instanceof Error ? error.message : String(error);
       }
       /**
-       * Parse parameter string according to configured format
+       * Parse parameter string using block format
        */
       parseParameters(raw) {
         const cleaned = stripMarkdownFences(raw);
-        if (this.parameterFormat === "json") {
-          try {
-            return { parameters: JSON.parse(cleaned) };
-          } catch (error) {
-            return { parseError: this.truncateParseError(error, "JSON") };
-          }
-        }
-        if (this.parameterFormat === "yaml") {
-          try {
-            return { parameters: yaml2.load(preprocessYaml(cleaned)) };
-          } catch (error) {
-            return { parseError: this.truncateParseError(error, "YAML") };
-          }
-        }
-        if (this.parameterFormat === "toml") {
-          try {
-            return { parameters: (0, import_js_toml.load)(preprocessTomlHeredoc(cleaned)) };
-          } catch (error) {
-            return { parseError: this.truncateParseError(error, "TOML") };
-          }
-        }
         try {
-          return { parameters: JSON.parse(cleaned) };
-        } catch {
-          try {
-            return { parameters: (0, import_js_toml.load)(preprocessTomlHeredoc(cleaned)) };
-          } catch {
-            try {
-              return { parameters: yaml2.load(preprocessYaml(cleaned)) };
-            } catch (error) {
-              return { parseError: this.truncateParseError(error, "auto") };
-            }
-          }
+          return { parameters: parseBlockParams(cleaned, { argPrefix: this.argPrefix }) };
+        } catch (error) {
+          return { parseError: this.extractParseError(error) };
         }
       }
       // Feed a chunk of text and get parsed events
@@ -2133,8 +2000,7 @@ var init_parser = __esm({
             call: {
               gadgetName: actualGadgetName,
               invocationId,
-              parametersYaml: parametersRaw,
-              // Keep property name for backward compatibility
+              parametersRaw,
               parameters,
               parseError
             }
@@ -2168,7 +2034,7 @@ var init_parser = __esm({
               call: {
                 gadgetName: actualGadgetName,
                 invocationId,
-                parametersYaml: parametersRaw,
+                parametersRaw,
                 parameters,
                 parseError
               }
@@ -2219,9 +2085,9 @@ var init_stream_processor = __esm({
         this.stopOnGadgetError = options.stopOnGadgetError ?? true;
         this.shouldContinueAfterError = options.shouldContinueAfterError;
         this.parser = new StreamParser({
-          parameterFormat: options.parameterFormat,
           startPrefix: options.gadgetStartPrefix,
-          endPrefix: options.gadgetEndPrefix
+          endPrefix: options.gadgetEndPrefix,
+          argPrefix: options.gadgetArgPrefix
         });
         this.executor = new GadgetExecutor(
           options.registry,
@@ -2375,7 +2241,7 @@ var init_stream_processor = __esm({
           this.logger.warn("Gadget has parse error", {
             gadgetName: call.gadgetName,
             error: call.parseError,
-            rawParameters: call.parametersYaml
+            rawParameters: call.parametersRaw
           });
           const shouldContinue = await this.checkContinueAfterError(
             call.parseError,
@@ -2611,9 +2477,9 @@ var init_agent = __esm({
       hooks;
       conversation;
       registry;
-      parameterFormat;
       gadgetStartPrefix;
       gadgetEndPrefix;
+      gadgetArgPrefix;
       onHumanInputRequired;
       textOnlyHandler;
       textWithGadgetsHandler;
@@ -2642,9 +2508,9 @@ var init_agent = __esm({
         this.temperature = options.temperature;
         this.logger = options.logger ?? createLogger({ name: "llmist:agent" });
         this.registry = options.registry;
-        this.parameterFormat = options.parameterFormat ?? "json";
         this.gadgetStartPrefix = options.gadgetStartPrefix;
         this.gadgetEndPrefix = options.gadgetEndPrefix;
+        this.gadgetArgPrefix = options.gadgetArgPrefix;
         this.onHumanInputRequired = options.onHumanInputRequired;
         this.textOnlyHandler = options.textOnlyHandler ?? "terminate";
         this.textWithGadgetsHandler = options.textWithGadgetsHandler;
@@ -2666,9 +2532,10 @@ var init_agent = __esm({
         if (options.systemPrompt) {
           baseBuilder.addSystem(options.systemPrompt);
         }
-        baseBuilder.addGadgets(this.registry.getAll(), this.parameterFormat, {
+        baseBuilder.addGadgets(this.registry.getAll(), {
           startPrefix: options.gadgetStartPrefix,
-          endPrefix: options.gadgetEndPrefix
+          endPrefix: options.gadgetEndPrefix,
+          argPrefix: options.gadgetArgPrefix
         });
         const baseMessages = baseBuilder.build();
         const initialMessages = (options.initialMessages ?? []).map((message) => ({
@@ -2676,9 +2543,9 @@ var init_agent = __esm({
           content: message.content
         }));
         this.conversation = new ConversationManager(baseMessages, initialMessages, {
-          parameterFormat: this.parameterFormat,
           startPrefix: options.gadgetStartPrefix,
-          endPrefix: options.gadgetEndPrefix
+          endPrefix: options.gadgetEndPrefix,
+          argPrefix: options.gadgetArgPrefix
         });
         this.userPromptProvided = !!options.userPrompt;
         if (options.userPrompt) {
@@ -2771,9 +2638,9 @@ var init_agent = __esm({
             const processor = new StreamProcessor({
               iteration: currentIteration,
               registry: this.registry,
-              parameterFormat: this.parameterFormat,
               gadgetStartPrefix: this.gadgetStartPrefix,
               gadgetEndPrefix: this.gadgetEndPrefix,
+              gadgetArgPrefix: this.gadgetArgPrefix,
               hooks: this.hooks,
               logger: this.logger.getSubLogger({ name: "stream-processor" }),
               onHumanInputRequired: this.onHumanInputRequired,
@@ -3066,9 +2933,9 @@ var init_builder = __esm({
       gadgets = [];
       initialMessages = [];
       onHumanInputRequired;
-      parameterFormat;
       gadgetStartPrefix;
       gadgetEndPrefix;
+      gadgetArgPrefix;
       textOnlyHandler;
       textWithGadgetsHandler;
       stopOnGadgetError;
@@ -3255,21 +3122,6 @@ var init_builder = __esm({
         this.onHumanInputRequired = handler;
         return this;
       }
-      /**
-       * Set the parameter format for gadget calls.
-       *
-       * @param format - Parameter format ("json" or "xml")
-       * @returns This builder for chaining
-       *
-       * @example
-       * ```typescript
-       * .withParameterFormat("xml")
-       * ```
-       */
-      withParameterFormat(format) {
-        this.parameterFormat = format;
-        return this;
-      }
       /**
        * Set custom gadget marker prefix.
        *
@@ -3300,6 +3152,21 @@ var init_builder = __esm({
         this.gadgetEndPrefix = suffix;
         return this;
       }
+      /**
+       * Set custom argument prefix for block format parameters.
+       *
+       * @param prefix - Custom prefix for argument markers (default: "!!!ARG:")
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withGadgetArgPrefix("<<ARG>>")
+       * ```
+       */
+      withGadgetArgPrefix(prefix) {
+        this.gadgetArgPrefix = prefix;
+        return this;
+      }
       /**
        * Set the text-only handler strategy.
        *
@@ -3499,8 +3366,7 @@ var init_builder = __esm({
       withSyntheticGadgetCall(gadgetName, parameters, result) {
         const startPrefix = this.gadgetStartPrefix ?? GADGET_START_PREFIX;
         const endPrefix = this.gadgetEndPrefix ?? GADGET_END_PREFIX;
-        const format = this.parameterFormat ?? "yaml";
-        const paramStr = this.formatSyntheticParameters(parameters, format);
+        const paramStr = this.formatBlockParameters(parameters, "");
         this.initialMessages.push({
           role: "assistant",
           content: `${startPrefix}${gadgetName}
@@ -3514,25 +3380,31 @@ ${endPrefix}`
         return this;
       }
       /**
-       * Format parameters for synthetic gadget calls.
-       * Uses heredoc for multiline string values.
+       * Format parameters as block format with JSON Pointer paths.
        */
-      formatSyntheticParameters(parameters, format) {
-        if (format === "json" || format === "auto") {
-          return JSON.stringify(parameters);
-        }
-        return Object.entries(parameters).map(([key, value]) => {
-          if (typeof value === "string" && value.includes("\n")) {
-            const separator = format === "yaml" ? ":" : " =";
-            return `${key}${separator} <<<EOF
-${value}
-EOF`;
-          }
-          if (format === "yaml") {
-            return typeof value === "string" ? `${key}: ${value}` : `${key}: ${JSON.stringify(value)}`;
+      formatBlockParameters(params, prefix) {
+        const lines = [];
+        const argPrefix = this.gadgetArgPrefix ?? GADGET_ARG_PREFIX;
+        for (const [key, value] of Object.entries(params)) {
+          const fullPath = prefix ? `${prefix}/${key}` : key;
+          if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+              const itemPath = `${fullPath}/${index}`;
+              if (typeof item === "object" && item !== null) {
+                lines.push(this.formatBlockParameters(item, itemPath));
+              } else {
+                lines.push(`${argPrefix}${itemPath}`);
+                lines.push(String(item));
+              }
+            });
+          } else if (typeof value === "object" && value !== null) {
+            lines.push(this.formatBlockParameters(value, fullPath));
+          } else {
+            lines.push(`${argPrefix}${fullPath}`);
+            lines.push(String(value));
           }
-          return `${key} = ${JSON.stringify(value)}`;
-        }).join("\n");
+        }
+        return lines.join("\n");
       }
       /**
        * Build and create the agent with the given user prompt.
@@ -3572,9 +3444,9 @@ EOF`;
           promptConfig: this.promptConfig,
           initialMessages: this.initialMessages,
           onHumanInputRequired: this.onHumanInputRequired,
-          parameterFormat: this.parameterFormat,
           gadgetStartPrefix: this.gadgetStartPrefix,
           gadgetEndPrefix: this.gadgetEndPrefix,
+          gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
           stopOnGadgetError: this.stopOnGadgetError,
@@ -3674,9 +3546,9 @@ EOF`;
           promptConfig: this.promptConfig,
           initialMessages: this.initialMessages,
           onHumanInputRequired: this.onHumanInputRequired,
-          parameterFormat: this.parameterFormat,
           gadgetStartPrefix: this.gadgetStartPrefix,
           gadgetEndPrefix: this.gadgetEndPrefix,
+          gadgetArgPrefix: this.gadgetArgPrefix,
           textOnlyHandler: this.textOnlyHandler,
           textWithGadgetsHandler: this.textWithGadgetsHandler,
           stopOnGadgetError: this.stopOnGadgetError,
@@ -5944,17 +5816,51 @@ function splitIntoChunks(text, minChunkSize = 5, maxChunkSize = 30) {
   }
   return chunks;
 }
+function serializeToBlockFormat(obj, prefix = "") {
+  let result = "";
+  for (const [key, value] of Object.entries(obj)) {
+    const pointer = prefix ? `${prefix}/${key}` : key;
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        const itemPointer = `${pointer}/${i}`;
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+          result += serializeToBlockFormat(item, itemPointer);
+        } else if (Array.isArray(item)) {
+          for (let j = 0; j < item.length; j++) {
+            result += `${GADGET_ARG_PREFIX}${itemPointer}/${j}
+${String(item[j])}
+`;
+          }
+        } else {
+          result += `${GADGET_ARG_PREFIX}${itemPointer}
+${String(item)}
+`;
+        }
+      }
+    } else if (typeof value === "object") {
+      result += serializeToBlockFormat(value, pointer);
+    } else {
+      result += `${GADGET_ARG_PREFIX}${pointer}
+${String(value)}
+`;
+    }
+  }
+  return result;
+}
 function formatGadgetCalls(gadgetCalls) {
   let text = "";
   const calls = [];
   for (const call of gadgetCalls) {
     const invocationId = call.invocationId ?? generateInvocationId();
     calls.push({ name: call.gadgetName, invocationId });
-    const paramsJson = JSON.stringify(call.parameters);
+    const blockParams = serializeToBlockFormat(call.parameters);
     text += `
 ${GADGET_START_PREFIX}${call.gadgetName}
-${paramsJson}
-${GADGET_END_PREFIX}`;
+${blockParams}${GADGET_END_PREFIX}`;
   }
   return { text, calls };
 }