@p-sw/brainbox 0.1.2-alpha.11 → 0.1.2-alpha.13

package/dist/index.js

@@ -489,15 +489,100 @@ function stripThinkTags(content) {
 }
 function parseModelJson(content) {
   const cleaned = stripThinkTags(content);
-  try {
-    return JSON.parse(cleaned);
-  } catch (first) {
-    const fence = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    if (fence?.[1]) {
-      return JSON.parse(fence[1].trim());
+  const candidates = [cleaned];
+  const fence = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence?.[1])
+    candidates.push(fence[1].trim());
+  const extracted = extractJsonSlice(cleaned);
+  if (extracted)
+    candidates.push(extracted);
+  let lastErr;
+  for (const candidate of candidates) {
+    try {
+      return decodeJsonValue(candidate);
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error("Failed to parse model JSON");
+}
+function decodeJsonValue(text) {
+  let value = JSON.parse(text);
+  for (let i = 0;i < 2 && typeof value === "string"; i++) {
+    const inner = value.trim();
+    if (!(inner.startsWith("{") && inner.endsWith("}") || inner.startsWith("[") && inner.endsWith("]") || inner.startsWith('"') && inner.endsWith('"'))) {
+      break;
+    }
+    value = JSON.parse(inner);
+  }
+  return value;
+}
+function extractJsonSlice(text) {
+  const start = text.search(/[\{\[]/);
+  if (start < 0)
+    return;
+  const open = text[start];
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start;i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === open)
+      depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0)
+        return text.slice(start, i + 1);
     }
-    throw first;
   }
+  return;
+}
+function schemaToolName(name) {
+  const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+  return cleaned.length > 0 ? cleaned : "submit_result";
+}
+function buildStructuredJsonRequest(options) {
+  const toolName = schemaToolName(options.jsonSchemaName);
+  return {
+    toolName,
+    tool: {
+      name: toolName,
+      description: `Submit the structured ${options.jsonSchemaName} result.`,
+      parameters: options.jsonSchema ?? {
+        type: "object",
+        additionalProperties: true
+      }
+    },
+    instruction: `${options.instruction}
+
+You MUST call the \`${toolName}\` tool exactly once with the complete answer.
+Do not write the JSON as plain text or inside a markdown code fence.`
+  };
+}
+function parseStructuredJsonResult(choice, toolName) {
+  const call = choice.message.toolCalls?.find((c) => c.function.name === toolName) ?? choice.message.toolCalls?.[0];
+  if (call?.function.arguments) {
+    return parseModelJson(call.function.arguments);
+  }
+  if (choice.message.content) {
+    return parseModelJson(choice.message.content);
+  }
+  throw new Error("Empty response from model");
 }
 function readAuthString(auth, key, envName) {
   const fromAuth = typeof auth?.[key] === "string" ? auth[key] : undefined;
@@ -512,6 +597,42 @@ function readAuthString(auth, key, envName) {
 }
 
 class LLMExecutor {
+  async chatWithToolExecution(model, options) {
+    const messages = options.messages.slice();
+    const maxSteps = options.maxSteps ?? 20;
+    let last;
+    for (let step = 0;step < maxSteps; step += 1) {
+      log2.debug(`chatWithToolExecution: step ${step + 1}/${maxSteps} msgs=${messages.length}`);
+      last = await this.chatWithTools(model, {
+        instruction: options.instruction,
+        messages,
+        tools: options.tools,
+        caller: options.caller,
+        reasoningEffort: options.reasoningEffort,
+        parallelToolCalls: options.parallelToolCalls,
+        toolChoice: options.toolChoice
+      });
+      const toolCalls = last.message.toolCalls ?? [];
+      log2.debug(`chatWithToolExecution: step ${step + 1} toolCalls=${toolCalls.length}`);
+      if (toolCalls.length === 0)
+        return last;
+      messages.push({
+        role: "assistant",
+        content: last.message.content,
+        toolCalls
+      });
+      for (const call of toolCalls) {
+        const content = await options.executeTool(call);
+        messages.push({
+          role: "tool",
+          toolCallId: call.id,
+          content
+        });
+      }
+    }
+    log2.warn(`chatWithToolExecution: reached maxSteps (${maxSteps}) without final reply`);
+    return last;
+  }
   static providers = [];
   static registerProvider(p) {
     LLMExecutor.providers.push(p);
@@ -781,6 +902,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
   chatPath;
   noBearerPrefix;
   reasoningEffortInQuery;
+  supportsResponseFormat;
   constructor(opts) {
     super();
     this.providerName = opts.providerName;
@@ -790,6 +912,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     this.chatPath = opts.chatPath ?? "/chat/completions";
     this.noBearerPrefix = opts.noBearerPrefix ?? false;
     this.reasoningEffortInQuery = opts.reasoningEffortInQuery ?? false;
+    this.supportsResponseFormat = opts.supportsResponseFormat ?? true;
     this.models = {
       conversation: opts.conversationModel,
       identity: opts.identityModel
@@ -861,6 +984,9 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     return data;
   }
   async call(model, options) {
+    if ("jsonSchemaName" in options && !this.supportsResponseFormat) {
+      return this.callJsonViaTool(model, options);
+    }
     const jsonMode = "jsonSchemaName" in options;
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     log4.debug(`call: provider=${this.providerName} model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
@@ -886,6 +1012,19 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     log4.debug(`call: response ${content.length} chars`);
     return jsonMode ? parseModelJson(content) : content;
   }
+  async callJsonViaTool(model, options) {
+    const { toolName, tool, instruction } = buildStructuredJsonRequest(options);
+    log4.debug(`callJsonViaTool: provider=${this.providerName} model=${model} tool=${toolName}`);
+    const choice = await this.chatWithTools(model, {
+      caller: options.caller ?? options.jsonSchemaName,
+      instruction,
+      messages: [{ role: "user", content: options.message }],
+      tools: [tool],
+      reasoningEffort: "none",
+      parallelToolCalls: false
+    });
+    return parseStructuredJsonResult(choice, toolName);
+  }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     log4.debug(`chatWithTools: provider=${this.providerName} model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
@@ -1219,7 +1358,8 @@ function minimaxOpts(providerName, baseURL, opts) {
     baseURL,
     apiKey: opts.apiKey,
     conversationModel: opts.conversationModel,
-    identityModel: opts.identityModel
+    identityModel: opts.identityModel,
+    supportsResponseFormat: false
   };
 }
 
@@ -1295,7 +1435,8 @@ class LmStudioExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:1234/v1",
       apiKey: opts.apiKey || "lm-studio",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1308,7 +1449,8 @@ class OllamaExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:11434/v1",
       apiKey: opts.apiKey || "ollama",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1334,7 +1476,8 @@ class LlamaCppExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:8080/v1",
       apiKey: opts.apiKey || "llama.cpp",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1573,17 +1716,17 @@ var AnthropicAuthSchema = z4.object({
   apiVersion: z4.string().optional()
 }).loose();
 function toAnthropicMessages(messages) {
-  let system;
-  const msgs = [];
+  let system2;
+  const msgs2 = [];
   for (const m of messages) {
     if (m.role === "system") {
-      system = (system ? system + `
+      system2 = (system2 ? system2 + `
 
 ` : "") + m.content;
       continue;
     }
     if (m.role === "user") {
-      msgs.push({ role: "user", content: m.content });
+      msgs2.push({ role: "user", content: m.content });
       continue;
     }
     if (m.role === "assistant") {
@@ -1606,11 +1749,11 @@ function toAnthropicMessages(messages) {
           });
         }
       }
-      msgs.push({ role: "assistant", content: blocks });
+      msgs2.push({ role: "assistant", content: blocks });
       continue;
     }
     if (m.role === "tool") {
-      msgs.push({
+      msgs2.push({
         role: "user",
         content: [
           {
@@ -1622,7 +1765,7 @@ function toAnthropicMessages(messages) {
       });
     }
   }
-  return { system, msgs };
+  return { system: system2, msgs: msgs2 };
 }
 function toAnthropicTool(t) {
   return {
@@ -1669,10 +1812,25 @@ class AnthropicExecutor extends LLMExecutor {
     return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
+    if ("jsonSchemaName" in options) {
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool],
+        reasoningEffort: "none",
+        toolChoice: { type: "tool", name: toolName }
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const outputCap = 4096;
     const body = {
       model,
@@ -1696,21 +1854,27 @@ class AnthropicExecutor extends LLMExecutor {
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return text;
   }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
     log5.debug(`chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
-    const { system, msgs } = toAnthropicMessages(options.messages);
+    const { system: system2, msgs: msgs2 } = toAnthropicMessages(options.messages);
     const outputCap = 4096;
     const body = {
       model,
       max_tokens: outputCap,
-      system: system ?? options.instruction,
-      messages: msgs,
+      system: system2 ?? options.instruction,
+      messages: msgs2,
       tools: options.tools.map(toAnthropicTool)
     };
+    if (options.toolChoice) {
+      body["tool_choice"] = {
+        type: "tool",
+        name: options.toolChoice.name
+      };
+    }
     if (reasoning !== "none") {
       const budget = REASONING_BUDGET[reasoning];
       body["max_tokens"] = budget + outputCap;
@@ -1789,58 +1953,6 @@ function signRequest(opts) {
     headers["X-Amz-Security-Token"] = opts.sessionToken;
   return headers;
 }
-function toAnthropicMessages2(messages) {
-  let system;
-  const msgs = [];
-  for (const m of messages) {
-    if (m.role === "system") {
-      system = (system ? system + `
-
-` : "") + m.content;
-      continue;
-    }
-    if (m.role === "user") {
-      msgs.push({ role: "user", content: [{ type: "text", text: m.content }] });
-      continue;
-    }
-    if (m.role === "assistant") {
-      const blocks = [];
-      if (m.content)
-        blocks.push({ type: "text", text: m.content });
-      if (m.toolCalls) {
-        for (const c of m.toolCalls) {
-          let input = {};
-          try {
-            input = c.function.arguments ? JSON.parse(c.function.arguments) : {};
-          } catch {
-            input = {};
-          }
-          blocks.push({
-            type: "tool_use",
-            id: c.id,
-            name: c.function.name,
-            input
-          });
-        }
-      }
-      msgs.push({ role: "assistant", content: blocks });
-      continue;
-    }
-    if (m.role === "tool") {
-      msgs.push({
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: m.toolCallId,
-            content: [{ type: "text", text: m.content }]
-          }
-        ]
-      });
-    }
-  }
-  return { system, msgs };
-}
 function toAnthropicTool2(t) {
   return {
     name: t.name,
@@ -1909,9 +2021,24 @@ class BedrockExecutor extends LLMExecutor {
     return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:bedrock");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    if ("jsonSchemaName" in options) {
+      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool],
+        toolChoice: { type: "tool", name: toolName }
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
@@ -1926,7 +2053,7 @@ class BedrockExecutor extends LLMExecutor {
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return text;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:bedrock");
@@ -1934,7 +2061,6 @@ class BedrockExecutor extends LLMExecutor {
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
-    const { system, msgs } = toAnthropicMessages2(options.messages);
     const body = {
       anthropic_version: "bedrock-2023-05-31",
       max_tokens: 4096,
@@ -1942,6 +2068,12 @@ class BedrockExecutor extends LLMExecutor {
       messages: msgs,
       tools: options.tools.map(toAnthropicTool2)
     };
+    if (options.toolChoice) {
+      body.tool_choice = {
+        type: "tool",
+        name: options.toolChoice.name
+      };
+    }
     const data = await this.invoke(model, body, resolveLlmCaller(options));
     const { text, toolCalls } = extractAnthropicContent(data);
     return { message: { content: text || undefined, toolCalls } };
@@ -2208,9 +2340,23 @@ class GitLabDuoExecutor extends LLMExecutor {
     return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:gitlab-duo");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    if ("jsonSchemaName" in options) {
+      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool]
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2226,7 +2372,7 @@ class GitLabDuoExecutor extends LLMExecutor {
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:gitlab-duo");
@@ -2325,10 +2471,25 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
-    const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:snowflake-cortex");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    if ("jsonSchemaName" in options) {
+      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
+      const { toolName, tool, instruction } = buildStructuredJsonRequest({
+        instruction: options.instruction,
+        jsonSchemaName: options.jsonSchemaName,
+        jsonSchema: options.jsonSchema
+      });
+      const choice = await this.chatWithTools(model, {
+        caller: options.caller ?? options.jsonSchemaName,
+        instruction,
+        messages: [{ role: "user", content: options.message }],
+        tools: [tool],
+        reasoningEffort: "none"
+      });
+      return parseStructuredJsonResult(choice, toolName);
+    }
+    const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2347,7 +2508,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:snowflake-cortex");
@@ -3016,75 +3177,46 @@ class Brain {
         content: userPrompt
       }
     ];
-    for (let step = 0;step < maxSteps; step += 1) {
-      log7.debug(`sendMessage: step ${step + 1}/${maxSteps} → model`);
-      let choice;
-      try {
-        choice = await llm.chatWithTools(llm.models.conversation, {
-          caller: initiate ? "start-conversation" : "send-message",
-          instruction: `${this.brainbase.baseSystemPrompt}
+    try {
+      await llm.chatWithToolExecution(llm.models.conversation, {
+        caller: initiate ? "start-conversation" : "send-message",
+        instruction: `${this.brainbase.baseSystemPrompt}
 
 ${instruction}`,
-          messages,
-          tools
-        });
-      } catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        logger.error(`sendMessage: LLM call failed at step ${step}: ${reason}`);
-        return replyMessages;
-      }
-      const assistantMessage = choice.message;
-      const toolCalls = assistantMessage.toolCalls ?? [];
-      const hasContent = typeof assistantMessage.content === "string" && assistantMessage.content.length > 0;
-      log7.debug(`sendMessage: step ${step + 1} → toolCalls=${toolCalls.length} hasContent=${hasContent}`);
-      if (toolCalls.length === 0) {
-        log7.debug(`sendMessage: model returned no tool calls; finalising with ${replyMessages.length} replies`);
-        return replyMessages;
-      }
-      messages.push(stripAssistantForHistory(assistantMessage));
-      for (const call of toolCalls) {
-        if (call.function.name === "addReplyMessage") {
-          const content = parseAddReplyMessageArguments(call.function.arguments);
-          if (content !== null) {
-            log7.debug(`sendMessage: addReplyMessage[${replyMessages.length}] (${content.length} chars)`);
-            send(content);
-            replyMessages.push(content);
-          } else {
+        messages,
+        tools,
+        maxSteps,
+        executeTool: async (call) => {
+          if (call.function.name === "addReplyMessage") {
+            const content = parseAddReplyMessageArguments(call.function.arguments);
+            if (content !== null) {
+              log7.debug(`sendMessage: addReplyMessage[${replyMessages.length}] (${content.length} chars)`);
+              await send(content);
+              replyMessages.push(content);
+              return JSON.stringify({
+                ok: true,
+                index: replyMessages.length - 1
+              });
+            }
             log7.debug(`sendMessage: addReplyMessage rejected (invalid arguments: ${call.function.arguments})`);
+            return JSON.stringify({ ok: false, error: "invalid arguments" });
           }
-          messages.push({
-            role: "tool",
-            toolCallId: call.id,
-            content: content === null ? JSON.stringify({ ok: false, error: "invalid arguments" }) : JSON.stringify({ ok: true, index: replyMessages.length - 1 })
-          });
-          continue;
-        }
-        if (call.function.name === "searchMemory") {
-          log7.debug(`sendMessage: searchMemory tool call`);
-          const result = await this.executeSearchTool(call.function.arguments);
-          messages.push({
-            role: "tool",
-            toolCallId: call.id,
-            content: result
-          });
-          continue;
-        }
-        log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
-        messages.push({
-          role: "tool",
-          toolCallId: call.id,
-          content: JSON.stringify({
+          if (call.function.name === "searchMemory") {
+            log7.debug(`sendMessage: searchMemory tool call`);
+            return this.executeSearchTool(call.function.arguments);
+          }
+          log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
+          return JSON.stringify({
             ok: false,
             error: `Unknown tool: ${call.function.name}`
-          })
-        });
-      }
-      if (!hasContent && toolCalls.every((c) => c.function.name === "searchMemory")) {
-        log7.debug(`sendMessage: step was pure searchMemory, looping back`);
-        continue;
-      }
+          });
+        }
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      logger.error(`sendMessage: LLM call failed: ${reason}`);
     }
-    logger.warn(`sendMessage: reached maxSteps (${maxSteps}) without final reply`);
+    log7.debug(`sendMessage: done with ${replyMessages.length} replies`);
     return replyMessages;
   }
   async buildMemoryBlock() {
@@ -3336,13 +3468,6 @@ function parseSearchArguments(json) {
   }
   return null;
 }
-function stripAssistantForHistory(message) {
-  return {
-    role: "assistant",
-    content: message.content,
-    toolCalls: message.toolCalls
-  };
-}
 
 // src/channel/discord.ts
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p-sw/brainbox",
-  "version": "0.1.2-alpha.11",
+  "version": "0.1.2-alpha.13",
   "module": "dist/index.js",
   "main": "dist/index.js",
   "type": "module",