@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/src/api/openai-completions.js

@@ -0,0 +1,484 @@
+import {
+  calculateCost2
+} from "../../chunks/account-limits-cache-zgzptd0z.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+import {
+  resolveCacheRetention2
+} from "../../chunks/account-limits-cache-d2a51dka.js";
+import {
+  normalizeProviderError2,
+  formatProviderError2
+} from "../../chunks/account-limits-cache-zcbkmrvy.js";
+import {
+  headersToRecord2,
+  mergeProviderHeaders2,
+  getClientApiKey2
+} from "../../chunks/account-limits-cache-ag5b8dja.js";
+import {
+  parseStreamingJson2,
+  parseToolCallArguments2
+} from "../../chunks/account-limits-cache-fbkaq46e.js";
+import {
+  getNyteUserAgent2
+} from "../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+import {
+  retryProviderRequest2
+} from "../../chunks/account-limits-cache-nbhht7xz.js";
+import {
+  getDeclaredTools2,
+  resolveTranscript2
+} from "../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import {
+  emptyCost2,
+  runAssistantStream2
+} from "../../chunks/account-limits-cache-fsktnetm.js";
+import {
+  appendGrammarToolInputJsonDelta2,
+  createGrammarToolInputProperties2
+} from "../../chunks/account-limits-cache-h92bzz1j.js";
+import {
+  buildCopilotDynamicHeaders2
+} from "../../chunks/account-limits-cache-za42x8a3.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import {
+  buildBaseOptions2,
+  simpleReasoningEffort2
+} from "../../chunks/account-limits-cache-k0pkzhbx.js";
+import {
+  NullableTokenCount2
+} from "../../chunks/account-limits-cache-736tdyme.js";
+import {
+  OpenAIReasoningDetailSchema2,
+  appendOpenAIReasoningDetail2,
+  CopilotReasoningOpaqueSchema2,
+  REASONING_DELTA_SCHEMAS2,
+  ReasoningDetailsDeltaSchema2
+} from "../../chunks/account-limits-cache-hj1h48sc.js";
+import"../../chunks/account-limits-cache-0af5gqeg.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-8qzk56vj.js";
+import {
+  resolveCompat2
+} from "../../chunks/account-limits-cache-fdwad56n.js";
+import"../../chunks/account-limits-cache-csbxvam7.js";
+import {
+  buildParams2
+} from "../../chunks/account-limits-cache-zn01kscn.js";
+
+// src/api/openai-completions.ts
+import OpenAI from "openai";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var ChoiceUsageSchema = Type.Object({
+  usage: Type.Object({
+    prompt_tokens: NullableTokenCount2,
+    completion_tokens: NullableTokenCount2,
+    cached_tokens: NullableTokenCount2,
+    prompt_cache_hit_tokens: NullableTokenCount2,
+    prompt_tokens_details: Type.Optional(Type.Union([
+      Type.Object({ cached_tokens: NullableTokenCount2, cache_write_tokens: NullableTokenCount2 }),
+      Type.Null()
+    ])),
+    completion_tokens_details: Type.Optional(Type.Union([Type.Object({ reasoning_tokens: NullableTokenCount2 }), Type.Null()]))
+  })
+});
+var OpenRouterErrorMetadataSchema = Type.Object({
+  error: Type.Object({ metadata: Type.Object({ raw: Type.Unknown() }) })
+});
+var stream = (model, context, options) => {
+  const normalizedContext = resolveTranscript2(context, resolveCompat2(model).supportsMidConvoSystemMessages);
+  return runAssistantStream2(model, options?.signal, "OpenAI Completions", async (output, stream) => {
+    const blocks = [];
+    output.content = blocks;
+    let streamedReasoningDetails;
+    const applyStreamedReasoningDetails = (block) => {
+      if (streamedReasoningDetails === undefined)
+        return;
+      block.thinkingSignature = JSON.stringify(streamedReasoningDetails);
+    };
+    const apiKey = getClientApiKey2(model.provider, options?.apiKey, options?.headers);
+    const compat = resolveCompat2(model);
+    const grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(normalizedContext.messages), compat.supportsOpenAIGrammarTools);
+    const cacheRetention = resolveCacheRetention2(options?.cacheRetention, options?.env);
+    const client = createClient({
+      model,
+      context: normalizedContext,
+      apiKey,
+      options,
+      cacheRetention,
+      compat
+    });
+    const params = buildParams2(model, normalizedContext, options, compat, cacheRetention, grammarToolInputProperties);
+    await options?.onPayload?.(params, model);
+    const requestOptions = {
+      signal: options?.signal,
+      maxRetries: 0
+    };
+    if (options?.timeoutMs !== undefined)
+      requestOptions.timeout = options.timeoutMs;
+    const result = await retryProviderRequest2(() => client.post("/chat/completions", {
+      body: params,
+      ...requestOptions,
+      stream: true,
+      __security: { bearerAuth: true }
+    }).withResponse(), {
+      maxRetries: options?.maxRetries,
+      maxRetryDelayMs: options?.maxRetryDelayMs,
+      signal: options?.signal
+    });
+    await options?.onResponse?.({ status: result.response.status, headers: headersToRecord2(result.response.headers) }, model);
+    stream.push({ type: "start", partial: output });
+    let textBlock = null;
+    let thinkingBlock = null;
+    let copilotReasoningOpaque;
+    let hasFinishReason = false;
+    const toolCallBlocksByIndex = new Map;
+    const toolCallBlocksById = new Map;
+    const getContentIndex = (block) => blocks.findIndex((candidate) => candidate === block);
+    const appendCustomToolCallInput = (block, nextInput, close) => {
+      const customInput = block.customInput;
+      if (!customInput)
+        return;
+      const delta = appendGrammarToolInputJsonDelta2(customInput.jsonBuffer, customInput.property, nextInput, close);
+      customInput.input = nextInput;
+      block.arguments = { [customInput.property]: nextInput };
+      return delta;
+    };
+    const finishBlock = (block) => {
+      const contentIndex = getContentIndex(block);
+      if (contentIndex === -1) {
+        return;
+      }
+      if (block.type === "text") {
+        stream.push({
+          type: "text_end",
+          contentIndex,
+          content: block.text,
+          partial: output
+        });
+      } else if (block.type === "thinking") {
+        stream.push({
+          type: "thinking_end",
+          contentIndex,
+          content: block.thinking,
+          partial: output
+        });
+      } else if (block.type === "toolCall") {
+        if (block.customInput) {
+          const delta = appendCustomToolCallInput(block, block.customInput.input, true);
+          if (delta !== undefined) {
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex,
+              delta,
+              partial: output
+            });
+          }
+        } else {
+          Object.assign(block, parseToolCallArguments2(block.partialArgs));
+        }
+        delete block.partialArgs;
+        delete block.customInput;
+        delete block.streamIndex;
+        stream.push({
+          type: "toolcall_end",
+          contentIndex,
+          toolCall: block,
+          partial: output
+        });
+      }
+    };
+    const ensureTextBlock = () => {
+      if (!textBlock) {
+        textBlock = { type: "text", text: "" };
+        blocks.push(textBlock);
+        stream.push({
+          type: "text_start",
+          contentIndex: getContentIndex(textBlock),
+          partial: output
+        });
+      }
+      return textBlock;
+    };
+    const ensureThinkingBlock = (thinkingSignature) => {
+      if (!thinkingBlock) {
+        thinkingBlock = {
+          type: "thinking",
+          thinking: "",
+          thinkingSignature
+        };
+        blocks.push(thinkingBlock);
+        stream.push({
+          type: "thinking_start",
+          contentIndex: getContentIndex(thinkingBlock),
+          partial: output
+        });
+      }
+      return thinkingBlock;
+    };
+    const ensureToolCallBlock = (toolCall) => {
+      const streamIndex = toolCall.index;
+      const name = toolCall.function?.name ?? toolCall.custom?.name ?? "";
+      let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
+      if (!block && toolCall.id) {
+        block = toolCallBlocksById.get(toolCall.id);
+      }
+      if (!block) {
+        const customInputProperty = toolCall.custom && !toolCall.function ? grammarToolInputProperties.get(name) ?? "input" : undefined;
+        const hasCustomInput = customInputProperty !== undefined;
+        block = {
+          type: "toolCall",
+          id: toolCall.id || "",
+          name,
+          arguments: hasCustomInput ? { [customInputProperty]: "" } : {},
+          partialArgs: hasCustomInput ? undefined : "",
+          customInput: hasCustomInput ? {
+            property: customInputProperty,
+            input: "",
+            jsonBuffer: { input: "", started: false, closed: false }
+          } : undefined,
+          streamIndex
+        };
+        if (streamIndex !== undefined) {
+          toolCallBlocksByIndex.set(streamIndex, block);
+        }
+        if (toolCall.id) {
+          toolCallBlocksById.set(toolCall.id, block);
+        }
+        blocks.push(block);
+        stream.push({
+          type: "toolcall_start",
+          contentIndex: getContentIndex(block),
+          partial: output
+        });
+      }
+      if (streamIndex !== undefined && block.streamIndex === undefined) {
+        block.streamIndex = streamIndex;
+        toolCallBlocksByIndex.set(streamIndex, block);
+      }
+      if (toolCall.id) {
+        toolCallBlocksById.set(toolCall.id, block);
+      }
+      if (!block.name && name) {
+        block.name = name;
+      }
+      if (toolCall.custom && !toolCall.function && !block.customInput) {
+        const customInputProperty = grammarToolInputProperties.get(block.name) ?? "input";
+        block.arguments = { [customInputProperty]: "" };
+        block.customInput = {
+          property: customInputProperty,
+          input: "",
+          jsonBuffer: { input: "", started: false, closed: false }
+        };
+        delete block.partialArgs;
+      }
+      return block;
+    };
+    try {
+      for await (const chunk of result.data) {
+        if (!chunk)
+          continue;
+        output.responseId ||= chunk.id;
+        if (chunk.model && chunk.model !== model.id) {
+          output.responseModel ||= chunk.model;
+        }
+        if (chunk.usage) {
+          output.usage = parseChunkUsage(chunk.usage, model);
+        }
+        const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : undefined;
+        if (!choice)
+          continue;
+        if (!chunk.usage && Value.Check(ChoiceUsageSchema, choice)) {
+          output.usage = parseChunkUsage(choice.usage, model);
+        }
+        if (choice.finish_reason) {
+          output.rawStopReason = choice.finish_reason;
+          const finishReasonResult = mapStopReason(choice.finish_reason);
+          output.stopReason = finishReasonResult.stopReason;
+          if (finishReasonResult.errorMessage) {
+            output.errorMessage = finishReasonResult.errorMessage;
+          }
+          hasFinishReason = true;
+        }
+        if (choice.delta) {
+          if (choice.delta.content !== null && choice.delta.content !== undefined && choice.delta.content.length > 0) {
+            const block = ensureTextBlock();
+            block.text += choice.delta.content;
+            stream.push({
+              type: "text_delta",
+              contentIndex: getContentIndex(block),
+              delta: choice.delta.content,
+              partial: output
+            });
+          }
+          const deltaFields = choice.delta;
+          for (const { field, schema } of REASONING_DELTA_SCHEMAS2) {
+            if (!Value.Check(schema, deltaFields))
+              continue;
+            const delta = deltaFields[field];
+            const thinkingSignature = model.provider === "opencode-go" && field === "reasoning" ? "reasoning_content" : field;
+            const block = ensureThinkingBlock(thinkingSignature);
+            block.thinking += delta;
+            stream.push({
+              type: "thinking_delta",
+              contentIndex: getContentIndex(block),
+              delta,
+              partial: output
+            });
+            break;
+          }
+          if (model.provider === "github-copilot" && Value.Check(CopilotReasoningOpaqueSchema2, deltaFields)) {
+            const reasoningOpaque = deltaFields.reasoning_opaque;
+            if (copilotReasoningOpaque !== undefined && copilotReasoningOpaque !== reasoningOpaque) {
+              throw new Error("GitHub Copilot sent multiple reasoning_opaque values in one response");
+            }
+            copilotReasoningOpaque = reasoningOpaque;
+            const block = ensureThinkingBlock("");
+            block.thinkingSignature = JSON.stringify({ reasoning_opaque: reasoningOpaque });
+          }
+          if (choice?.delta?.tool_calls) {
+            const toolCalls = choice.delta.tool_calls;
+            for (const toolCall of toolCalls) {
+              const block = ensureToolCallBlock(toolCall);
+              if (!block.id && toolCall.id) {
+                block.id = toolCall.id;
+                toolCallBlocksById.set(toolCall.id, block);
+              }
+              const name = toolCall.function?.name ?? toolCall.custom?.name;
+              if (!block.name && name) {
+                block.name = name;
+              }
+              let delta = "";
+              if (toolCall.function?.arguments) {
+                delta = toolCall.function.arguments;
+                block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
+                block.arguments = parseStreamingJson2(block.partialArgs);
+              } else if (toolCall.custom?.input) {
+                const nextInput = (block.customInput?.input ?? "") + toolCall.custom.input;
+                delta = appendCustomToolCallInput(block, nextInput, false) ?? "";
+              }
+              stream.push({
+                type: "toolcall_delta",
+                contentIndex: getContentIndex(block),
+                delta,
+                partial: output
+              });
+            }
+          }
+          if (Value.Check(ReasoningDetailsDeltaSchema2, deltaFields)) {
+            for (const detail of deltaFields.reasoning_details) {
+              if (!Value.Check(OpenAIReasoningDetailSchema2, detail))
+                continue;
+              ensureThinkingBlock("");
+              streamedReasoningDetails ??= [];
+              appendOpenAIReasoningDetail2(streamedReasoningDetails, detail);
+            }
+          }
+        }
+      }
+    } finally {
+      for (const block of blocks) {
+        if (block.type === "thinking")
+          applyStreamedReasoningDetails(block);
+      }
+    }
+    for (const block of blocks) {
+      finishBlock(block);
+    }
+    if (!hasFinishReason && !compat.supportsFinishReason) {
+      output.stopReason = output.content.some((block) => block.type === "toolCall") ? "toolUse" : "stop";
+    }
+    if (compat.supportsFinishReason && !hasFinishReason) {
+      throw new Error("Stream ended without finish_reason");
+    }
+  }, formatCompletionsError);
+};
+function formatCompletionsError(error) {
+  const message = formatProviderError2(normalizeProviderError2(error));
+  const rawMetadata = Value.Check(OpenRouterErrorMetadataSchema, error) ? error.error.metadata.raw : undefined;
+  return rawMetadata && !message.includes(String(rawMetadata)) ? `${message}
+${rawMetadata}` : message;
+}
+var streamSimple = (model, context, options) => {
+  getClientApiKey2(model.provider, options?.apiKey, options?.headers);
+  return stream(model, context, {
+    ...buildBaseOptions2(model, context, options),
+    reasoningEffort: simpleReasoningEffort2(model, options?.reasoning),
+    thinkingBudgets: options?.thinkingBudgets
+  });
+};
+function createClient(input) {
+  const copilotHeaders = input.model.provider === "github-copilot" ? buildCopilotDynamicHeaders2({
+    messages: input.context.messages,
+    sessionId: input.options?.sessionId
+  }) : undefined;
+  const cacheSessionId = input.cacheRetention === "none" ? undefined : input.options?.sessionId;
+  const affinityHeaders = {};
+  if (cacheSessionId && input.compat.sendSessionAffinityHeaders) {
+    if (input.compat.sessionAffinityFormat === "openrouter") {
+      affinityHeaders["x-session-id"] = cacheSessionId;
+    } else {
+      if (input.compat.sessionAffinityFormat === "openai") {
+        affinityHeaders.session_id = cacheSessionId;
+      }
+      affinityHeaders["x-client-request-id"] = cacheSessionId;
+      affinityHeaders["x-session-affinity"] = cacheSessionId;
+    }
+  }
+  return new OpenAI({
+    apiKey: input.apiKey,
+    baseURL: input.model.baseUrl,
+    dangerouslyAllowBrowser: true,
+    fetch: input.options?.fetch,
+    defaultHeaders: mergeProviderHeaders2({ "User-Agent": getNyteUserAgent2() }, input.model.headers, copilotHeaders, affinityHeaders, input.options?.headers)
+  });
+}
+function parseChunkUsage(rawUsage, model) {
+  const promptTokens = rawUsage.prompt_tokens || 0;
+  const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? rawUsage.cached_tokens ?? 0;
+  const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+  const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+  const outputTokens = rawUsage.completion_tokens || 0;
+  const usage = {
+    input,
+    output: outputTokens,
+    cacheRead: cacheReadTokens,
+    cacheWrite: cacheWriteTokens,
+    reasoning: rawUsage.completion_tokens_details?.reasoning_tokens || 0,
+    totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
+    cost: emptyCost2()
+  };
+  calculateCost2(model, usage);
+  return usage;
+}
+function mapStopReason(reason) {
+  if (reason === null)
+    return { stopReason: "stop" };
+  switch (reason) {
+    case "stop":
+    case "end":
+      return { stopReason: "stop" };
+    case "length":
+      return { stopReason: "length" };
+    case "function_call":
+    case "tool_calls":
+      return { stopReason: "toolUse" };
+    case "content_filter":
+      return { stopReason: "error", errorMessage: "Provider finish_reason: content_filter" };
+    case "network_error":
+      return { stopReason: "error", errorMessage: "Provider finish_reason: network_error" };
+    default:
+      return {
+        stopReason: "error",
+        errorMessage: `Provider finish_reason: ${reason}`
+      };
+  }
+}
+export {
+  stream,
+  streamSimple
+};

package/dist/src/api/openai-completions.lazy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Lazy OpenAI-compatible Chat Completions adapter.
+ */
+import type { ProviderStreams } from "../types.ts";
+export declare const openAICompletionsApi: () => ProviderStreams;

package/dist/src/api/openai-completions.lazy.js

@@ -0,0 +1,11 @@
+import {
+  openAICompletionsApi2
+} from "../../chunks/account-limits-cache-eyx1jcxc.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+export {
+  openAICompletionsApi2 as openAICompletionsApi
+};

package/dist/src/api/openai-prompt-cache.d.ts

@@ -0,0 +1 @@
+export declare function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined;

package/dist/src/api/openai-prompt-cache.js

@@ -0,0 +1,6 @@
+import {
+  clampOpenAIPromptCacheKey2
+} from "../../chunks/account-limits-cache-csbxvam7.js";
+export {
+  clampOpenAIPromptCacheKey2 as clampOpenAIPromptCacheKey
+};

package/dist/src/api/openai-responses-convert.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Conversion of the neutral transcript and tools into Responses API input,
+ * shared by the OpenAI Responses and Codex adapters.
+ */
+import type { CustomTool, FunctionTool, ResponseInputItem, ResponseToolSearchOutputItemParam } from "openai/resources/responses/responses.js";
+import { type Static, Type } from "typebox";
+import type { Model, TextSignatureV1, Tool, TranscriptContext } from "../types.ts";
+/** A function tool as sent; `strict` is omitted for providers that reject or ignore the field. */
+type ResponsesFunctionTool = Omit<FunctionTool, "strict"> & Partial<Pick<FunctionTool, "strict">>;
+export type ResponsesTool = CustomTool | ResponsesFunctionTool;
+/** Loads deferred tools in place, for providers that support `additional_tools`. */
+interface ResponsesAdditionalToolsItem {
+    type: "additional_tools";
+    role: "developer";
+    tools: ResponsesTool[];
+}
+/** A client-executed tool search result, which loads deferred tools for `tool-search` providers. */
+interface ResponsesToolSearchOutputItem extends Omit<ResponseToolSearchOutputItemParam, "tools"> {
+    tools: ResponsesTool[];
+}
+/** An item the matching provider produced, replayed verbatim. */
+declare const ReplayedItemSchema: Type.TObject<{
+    type: Type.TString;
+}>;
+type ReplayedResponsesItem = Static<typeof ReplayedItemSchema>;
+type ResponsesInputItem = ResponseInputItem | ResponsesAdditionalToolsItem | ResponsesToolSearchOutputItem | ReplayedResponsesItem;
+export type ResponsesInput = ResponsesInputItem[];
+export declare function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string;
+interface ConvertResponsesMessagesOptions {
+    includeSystemPrompt?: boolean;
+    grammarToolInputProperties?: ReadonlyMap<string, string>;
+    /** Whether later system messages are sent in place; otherwise they are folded into the leading prompt. */
+    supportsMidConvoSystemMessages?: boolean;
+    /** Request-list tools that tool results load via `addedToolNames`. */
+    deferredTools?: ReadonlyMap<string, Tool>;
+    /** How late tools reach the model: system-message anchors and `addedToolNames` loads share it. */
+    deferredToolsMode?: "additional-tools" | "tool-search";
+    toolOptions?: ConvertResponsesToolsOptions;
+}
+interface ConvertResponsesToolsOptions {
+    strict?: boolean | null;
+    supportsStrictMode?: boolean;
+    supportsOpenAIGrammarTools?: boolean;
+    deferLoading?: boolean;
+}
+/**
+ * The transcript as Responses input items.
+ *
+ * - Tool call item ids must start with `fc_`, and message ids are at most 64 characters.
+ * - Tool calls from a different model drop their item id: OpenAI tracks which item ids were
+ *   paired with `rs_*` reasoning items, and omitting the id avoids that pairing validation, as
+ *   for cross-provider calls. Ids that do not match the replayed item type are dropped too:
+ *   `function_call` ids must be `fc_*` and `custom_tool_call` ids `ctc_*`. Foreign ids normalize
+ *   to `fc_*`, and a call switches type when grammar tool support differs.
+ */
+export declare function convertResponsesMessages(model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, context: TranscriptContext, allowedToolCallProviders: ReadonlySet<string>, options?: ConvertResponsesMessagesOptions): ResponsesInput;
+export declare function convertResponsesTools(tools: readonly Tool[], options?: ConvertResponsesToolsOptions): ResponsesTool[];
+export {};

package/dist/src/api/openai-responses-convert.js

@@ -0,0 +1,16 @@
+import {
+  encodeTextSignatureV12,
+  convertResponsesMessages2,
+  convertResponsesTools2
+} from "../../chunks/account-limits-cache-n3yk6g5c.js";
+import"../../chunks/account-limits-cache-8qzk56vj.js";
+import"../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-0af5gqeg.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-6250ykn6.js";
+export {
+  convertResponsesMessages2 as convertResponsesMessages,
+  convertResponsesTools2 as convertResponsesTools,
+  encodeTextSignatureV12 as encodeTextSignatureV1
+};