@ljoukov/llm 0.1.2 → 2.0.0

package/dist/index.js

@@ -1518,10 +1518,13 @@ function convertGooglePartsToLlmParts(parts) {
 function assertLlmRole(value) {
   switch (value) {
     case "user":
-    case "model":
+    case "assistant":
     case "system":
+    case "developer":
     case "tool":
       return value;
+    case "model":
+      return "assistant";
     default:
       throw new Error(`Unsupported LLM role: ${String(value)}`);
   }
@@ -1551,8 +1554,9 @@ function toGeminiPart(part) {
   }
 }
 function convertLlmContentToGeminiContent(content) {
+  const role = content.role === "assistant" ? "model" : "user";
   return {
-    role: content.role,
+    role,
     parts: content.parts.map(toGeminiPart)
   };
 }
@@ -1598,6 +1602,20 @@ function isInlineImageMime(mimeType) {
   }
   return mimeType.startsWith("image/");
 }
+function guessInlineDataFilename(mimeType) {
+  switch (mimeType) {
+    case "application/pdf":
+      return "document.pdf";
+    case "application/json":
+      return "data.json";
+    case "text/markdown":
+      return "document.md";
+    case "text/plain":
+      return "document.txt";
+    default:
+      return "attachment.bin";
+  }
+}
 function mergeConsecutiveTextParts(parts) {
   if (parts.length === 0) {
     return [];
@@ -1709,28 +1727,350 @@ function parseJsonFromLlmText(rawText) {
   const repairedText = escapeNewlinesInStrings(cleanedText);
   return JSON.parse(repairedText);
 }
-function resolveTextContents(input) {
-  if ("contents" in input) {
-    return input.contents;
+function parsePartialJsonFromLlmText(rawText) {
+  const jsonStart = extractJsonStartText(rawText);
+  if (!jsonStart) {
+    return null;
+  }
+  try {
+    return parsePartialJson(jsonStart);
+  } catch {
+    return null;
+  }
+}
+function extractJsonStartText(rawText) {
+  let text = rawText.trimStart();
+  if (text.startsWith("```")) {
+    text = text.replace(/^```[a-zA-Z0-9_-]*\s*\n?/, "");
+  }
+  const objIndex = text.indexOf("{");
+  const arrIndex = text.indexOf("[");
+  let start = -1;
+  if (objIndex !== -1 && arrIndex !== -1) {
+    start = Math.min(objIndex, arrIndex);
+  } else {
+    start = objIndex !== -1 ? objIndex : arrIndex;
+  }
+  if (start === -1) {
+    return null;
+  }
+  return text.slice(start);
+}
+function parsePartialJson(text) {
+  let i = 0;
+  const len = text.length;
+  const isWhitespace = (char) => char === " " || char === "\n" || char === "\r" || char === "	";
+  const skipWhitespace = () => {
+    while (i < len && isWhitespace(text[i] ?? "")) {
+      i += 1;
+    }
+  };
+  const parseString = () => {
+    if (text[i] !== '"') {
+      return null;
+    }
+    i += 1;
+    let value = "";
+    while (i < len) {
+      const ch = text[i] ?? "";
+      if (ch === '"') {
+        i += 1;
+        return { value, complete: true };
+      }
+      if (ch === "\\") {
+        if (i + 1 >= len) {
+          return { value, complete: false };
+        }
+        const esc = text[i + 1] ?? "";
+        switch (esc) {
+          case '"':
+          case "\\":
+          case "/":
+            value += esc;
+            i += 2;
+            continue;
+          case "b":
+            value += "\b";
+            i += 2;
+            continue;
+          case "f":
+            value += "\f";
+            i += 2;
+            continue;
+          case "n":
+            value += "\n";
+            i += 2;
+            continue;
+          case "r":
+            value += "\r";
+            i += 2;
+            continue;
+          case "t":
+            value += "	";
+            i += 2;
+            continue;
+          case "u": {
+            if (i + 5 >= len) {
+              return { value, complete: false };
+            }
+            const hex = text.slice(i + 2, i + 6);
+            if (!/^[0-9a-fA-F]{4}$/u.test(hex)) {
+              value += "u";
+              i += 2;
+              continue;
+            }
+            value += String.fromCharCode(Number.parseInt(hex, 16));
+            i += 6;
+            continue;
+          }
+          default:
+            value += esc;
+            i += 2;
+            continue;
+        }
+      }
+      value += ch;
+      i += 1;
+    }
+    return { value, complete: false };
+  };
+  const parseNumber = () => {
+    const start = i;
+    while (i < len) {
+      const ch = text[i] ?? "";
+      if (isWhitespace(ch) || ch === "," || ch === "}" || ch === "]") {
+        break;
+      }
+      i += 1;
+    }
+    const raw = text.slice(start, i);
+    if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u.test(raw)) {
+      i = start;
+      return null;
+    }
+    return { value: Number(raw), complete: true };
+  };
+  const parseLiteral = () => {
+    if (text.startsWith("true", i)) {
+      i += 4;
+      return { value: true, complete: true };
+    }
+    if (text.startsWith("false", i)) {
+      i += 5;
+      return { value: false, complete: true };
+    }
+    if (text.startsWith("null", i)) {
+      i += 4;
+      return { value: null, complete: true };
+    }
+    return null;
+  };
+  skipWhitespace();
+  const first = text[i];
+  if (first !== "{" && first !== "[") {
+    return null;
   }
+  const root = first === "{" ? {} : [];
+  const stack = first === "{" ? [{ type: "object", value: root, state: "keyOrEnd" }] : [{ type: "array", value: root, state: "valueOrEnd" }];
+  i += 1;
+  while (stack.length > 0) {
+    skipWhitespace();
+    if (i >= len) {
+      break;
+    }
+    const ctx = stack[stack.length - 1];
+    if (!ctx) {
+      break;
+    }
+    const ch = text[i] ?? "";
+    if (ctx.type === "object") {
+      if (ctx.state === "keyOrEnd") {
+        if (ch === "}") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        if (ch === ",") {
+          i += 1;
+          continue;
+        }
+        if (ch !== '"') {
+          break;
+        }
+        const key = parseString();
+        if (!key) {
+          break;
+        }
+        if (!key.complete) {
+          break;
+        }
+        ctx.key = key.value;
+        ctx.state = "colon";
+        continue;
+      }
+      if (ctx.state === "colon") {
+        if (ch === ":") {
+          i += 1;
+          ctx.state = "value";
+          continue;
+        }
+        break;
+      }
+      if (ctx.state === "value") {
+        if (ch === "}") {
+          i += 1;
+          ctx.key = void 0;
+          stack.pop();
+          continue;
+        }
+        if (ch === ",") {
+          i += 1;
+          ctx.key = void 0;
+          ctx.state = "keyOrEnd";
+          continue;
+        }
+        const key = ctx.key;
+        if (!key) {
+          break;
+        }
+        if (ch === "{" || ch === "[") {
+          const container = ch === "{" ? {} : [];
+          ctx.value[key] = container;
+          ctx.key = void 0;
+          ctx.state = "commaOrEnd";
+          stack.push(
+            ch === "{" ? { type: "object", value: container, state: "keyOrEnd" } : { type: "array", value: container, state: "valueOrEnd" }
+          );
+          i += 1;
+          continue;
+        }
+        let primitive = null;
+        if (ch === '"') {
+          primitive = parseString();
+        } else if (ch === "-" || ch >= "0" && ch <= "9") {
+          primitive = parseNumber();
+        } else {
+          primitive = parseLiteral();
+        }
+        if (!primitive) {
+          break;
+        }
+        ctx.value[key] = primitive.value;
+        ctx.key = void 0;
+        ctx.state = "commaOrEnd";
+        if (!primitive.complete) {
+          break;
+        }
+        continue;
+      }
+      if (ctx.state === "commaOrEnd") {
+        if (ch === ",") {
+          i += 1;
+          ctx.state = "keyOrEnd";
+          continue;
+        }
+        if (ch === "}") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        break;
+      }
+    } else {
+      if (ctx.state === "valueOrEnd") {
+        if (ch === "]") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        if (ch === ",") {
+          i += 1;
+          continue;
+        }
+        if (ch === "{" || ch === "[") {
+          const container = ch === "{" ? {} : [];
+          ctx.value.push(container);
+          ctx.state = "commaOrEnd";
+          stack.push(
+            ch === "{" ? { type: "object", value: container, state: "keyOrEnd" } : { type: "array", value: container, state: "valueOrEnd" }
+          );
+          i += 1;
+          continue;
+        }
+        let primitive = null;
+        if (ch === '"') {
+          primitive = parseString();
+        } else if (ch === "-" || ch >= "0" && ch <= "9") {
+          primitive = parseNumber();
+        } else {
+          primitive = parseLiteral();
+        }
+        if (!primitive) {
+          break;
+        }
+        ctx.value.push(primitive.value);
+        ctx.state = "commaOrEnd";
+        if (!primitive.complete) {
+          break;
+        }
+        continue;
+      }
+      if (ctx.state === "commaOrEnd") {
+        if (ch === ",") {
+          i += 1;
+          ctx.state = "valueOrEnd";
+          continue;
+        }
+        if (ch === "]") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        break;
+      }
+    }
+  }
+  return root;
+}
+function resolveTextContents(input) {
   const contents = [];
-  if (input.systemPrompt) {
+  if (input.instructions) {
+    const instructions = input.instructions.trim();
+    if (instructions.length > 0) {
+      contents.push({
+        role: "system",
+        parts: [{ type: "text", text: instructions }]
+      });
+    }
+  }
+  if (typeof input.input === "string") {
     contents.push({
-      role: "system",
-      parts: [{ type: "text", text: input.systemPrompt }]
+      role: "user",
+      parts: [{ type: "text", text: input.input }]
+    });
+    return contents;
+  }
+  for (const message of input.input) {
+    const parts = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+    contents.push({
+      role: message.role,
+      parts: parts.map(
+        (part) => part.type === "text" ? {
+          type: "text",
+          text: part.text,
+          thought: "thought" in part && part.thought === true ? true : void 0
+        } : { type: "inlineData", data: part.data, mimeType: part.mimeType }
+      )
     });
   }
-  contents.push({
-    role: "user",
-    parts: [{ type: "text", text: input.prompt }]
-  });
   return contents;
 }
 function toOpenAiInput(contents) {
   const OPENAI_ROLE_FROM_LLM = {
     user: "user",
-    model: "assistant",
+    assistant: "assistant",
     system: "system",
+    developer: "developer",
     tool: "assistant"
   };
   return contents.map((content) => {
@@ -1740,9 +2080,18 @@ function toOpenAiInput(contents) {
         parts.push({ type: "input_text", text: part.text });
         continue;
       }
-      const mimeType = part.mimeType ?? "application/octet-stream";
-      const dataUrl = `data:${mimeType};base64,${part.data}`;
-      parts.push({ type: "input_image", image_url: dataUrl, detail: "auto" });
+      const mimeType = part.mimeType;
+      if (isInlineImageMime(mimeType)) {
+        const dataUrl = `data:${mimeType};base64,${part.data}`;
+        parts.push({ type: "input_image", image_url: dataUrl, detail: "auto" });
+        continue;
+      }
+      const fileData = decodeInlineDataBuffer(part.data).toString("base64");
+      parts.push({
+        type: "input_file",
+        filename: guessInlineDataFilename(mimeType),
+        file_data: fileData
+      });
     }
     if (parts.length === 1 && parts[0]?.type === "input_text" && typeof parts[0].text === "string") {
       return {
@@ -1760,7 +2109,7 @@ function toChatGptInput(contents) {
   const instructionsParts = [];
   const input = [];
   for (const content of contents) {
-    if (content.role === "system") {
+    if (content.role === "system" || content.role === "developer") {
       for (const part of content.parts) {
         if (part.type === "text") {
           instructionsParts.push(part.text);
@@ -1768,7 +2117,7 @@ function toChatGptInput(contents) {
       }
       continue;
     }
-    const isAssistant = content.role === "model";
+    const isAssistant = content.role === "assistant" || content.role === "tool";
     const parts = [];
     for (const part of content.parts) {
       if (part.type === "text") {
@@ -1778,19 +2127,29 @@ function toChatGptInput(contents) {
         });
         continue;
       }
-      const mimeType = part.mimeType ?? "application/octet-stream";
-      const dataUrl = `data:${mimeType};base64,${part.data}`;
       if (isAssistant) {
+        const mimeType = part.mimeType ?? "application/octet-stream";
         parts.push({
           type: "output_text",
-          text: `[image:${mimeType}]`
+          text: isInlineImageMime(part.mimeType) ? `[image:${mimeType}]` : `[file:${mimeType}]`
         });
       } else {
-        parts.push({
-          type: "input_image",
-          image_url: dataUrl,
-          detail: "auto"
-        });
+        if (isInlineImageMime(part.mimeType)) {
+          const mimeType = part.mimeType ?? "application/octet-stream";
+          const dataUrl = `data:${mimeType};base64,${part.data}`;
+          parts.push({
+            type: "input_image",
+            image_url: dataUrl,
+            detail: "auto"
+          });
+        } else {
+          const fileData = decodeInlineDataBuffer(part.data).toString("base64");
+          parts.push({
+            type: "input_file",
+            filename: guessInlineDataFilename(part.mimeType),
+            file_data: fileData
+          });
+        }
       }
     }
     if (parts.length === 0) {
@@ -2478,7 +2837,7 @@ async function runTextCall(params) {
     });
   }
   const mergedParts = mergeConsecutiveTextParts(responseParts);
-  const content = mergedParts.length > 0 ? { role: responseRole ?? "model", parts: mergedParts } : void 0;
+  const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
   const { text, thoughts } = extractTextByChannel(content);
   const costUsd = estimateCallCostUsd({
     modelId: modelVersion,
@@ -2528,8 +2887,7 @@ async function generateText(request) {
   }
   return await call.result;
 }
-async function generateJson(request) {
-  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+function buildJsonSchemaConfig(request) {
   const schemaName = (request.openAiSchemaName ?? "llm-response").trim() || "llm-response";
   const providerInfo = resolveProvider(request.model);
   const isOpenAiVariant = providerInfo.provider === "openai" || providerInfo.provider === "chatgpt";
@@ -2541,31 +2899,143 @@ async function generateJson(request) {
   if (isOpenAiVariant && !isJsonSchemaObject(responseJsonSchema)) {
     throw new Error("OpenAI structured outputs require a JSON object schema at the root.");
   }
-  const openAiTextFormat = providerInfo.provider === "openai" ? {
+  const openAiTextFormat = isOpenAiVariant ? {
     type: "json_schema",
     name: schemaName,
     strict: true,
     schema: normalizeOpenAiSchema(responseJsonSchema)
   } : void 0;
+  return { providerInfo, responseJsonSchema, openAiTextFormat };
+}
+function streamJson(request) {
+  const queue = createAsyncQueue();
+  const abortController = new AbortController();
+  const resolveAbortSignal = () => {
+    if (!request.signal) {
+      return abortController.signal;
+    }
+    if (request.signal.aborted) {
+      abortController.abort(request.signal.reason);
+    } else {
+      request.signal.addEventListener(
+        "abort",
+        () => abortController.abort(request.signal?.reason),
+        {
+          once: true
+        }
+      );
+    }
+    return abortController.signal;
+  };
+  const result = (async () => {
+    const signal = resolveAbortSignal();
+    const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+    const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
+    const streamMode = request.streamMode ?? "partial";
+    const failures = [];
+    let openAiTextFormatForAttempt = openAiTextFormat;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      let rawText = "";
+      let lastPartial = "";
+      try {
+        const call = streamText({
+          model: request.model,
+          input: request.input,
+          instructions: request.instructions,
+          tools: request.tools,
+          responseMimeType: request.responseMimeType ?? "application/json",
+          responseJsonSchema,
+          openAiReasoningEffort: request.openAiReasoningEffort,
+          ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
+          signal
+        });
+        try {
+          for await (const event of call.events) {
+            queue.push(event);
+            if (event.type === "delta" && event.channel === "response") {
+              rawText += event.text;
+              if (streamMode === "partial") {
+                const partial = parsePartialJsonFromLlmText(rawText);
+                if (partial !== null) {
+                  const serialized = JSON.stringify(partial);
+                  if (serialized !== lastPartial) {
+                    lastPartial = serialized;
+                    queue.push({
+                      type: "json",
+                      stage: "partial",
+                      value: partial
+                    });
+                  }
+                }
+              }
+            }
+          }
+        } catch (streamError) {
+          await call.result.catch(() => void 0);
+          throw streamError;
+        }
+        const result2 = await call.result;
+        rawText = rawText || result2.text;
+        const cleanedText = normalizeJsonText(rawText);
+        const repairedText = escapeNewlinesInStrings(cleanedText);
+        const payload = JSON.parse(repairedText);
+        const normalized = typeof request.normalizeJson === "function" ? request.normalizeJson(payload) : payload;
+        const parsed = request.schema.parse(normalized);
+        queue.push({ type: "json", stage: "final", value: parsed });
+        queue.close();
+        return { value: parsed, rawText, result: result2 };
+      } catch (error) {
+        const handled = error instanceof Error ? error : new Error(String(error));
+        failures.push({ attempt, rawText, error: handled });
+        if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
+          openAiTextFormatForAttempt = void 0;
+        }
+        if (attempt >= maxAttempts) {
+          throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
+        }
+      }
+    }
+    throw new LlmJsonCallError("LLM JSON call failed", failures);
+  })().catch((error) => {
+    const err = error instanceof Error ? error : new Error(String(error));
+    queue.fail(err);
+    throw err;
+  });
+  return {
+    events: queue.iterable,
+    result,
+    abort: () => abortController.abort()
+  };
+}
+async function generateJson(request) {
+  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+  const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
+  let openAiTextFormatForAttempt = openAiTextFormat;
   const failures = [];
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     let rawText = "";
     try {
-      const contents = resolveTextContents(request);
       const call = streamText({
         model: request.model,
-        contents,
+        input: request.input,
+        instructions: request.instructions,
         tools: request.tools,
         responseMimeType: request.responseMimeType ?? "application/json",
         responseJsonSchema,
         openAiReasoningEffort: request.openAiReasoningEffort,
-        ...openAiTextFormat ? { openAiTextFormat } : {},
+        ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
         signal: request.signal
       });
-      for await (const event of call.events) {
-        if (event.type === "delta" && event.channel === "response") {
-          rawText += event.text;
+      try {
+        for await (const event of call.events) {
+          request.onEvent?.(event);
+          if (event.type === "delta" && event.channel === "response") {
+            rawText += event.text;
+          }
         }
+      } catch (streamError) {
+        await call.result.catch(() => void 0);
+        throw streamError;
       }
       const result = await call.result;
       rawText = rawText || result.text;
@@ -2578,6 +3048,9 @@ async function generateJson(request) {
     } catch (error) {
       const handled = error instanceof Error ? error : new Error(String(error));
       failures.push({ attempt, rawText, error: handled });
+      if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
+        openAiTextFormatForAttempt = void 0;
+      }
       if (attempt >= maxAttempts) {
         throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
       }
@@ -3163,7 +3636,7 @@ async function gradeGeneratedImage(params) {
   ];
   const { value } = await generateJson({
     model: params.model,
-    contents: [{ role: "user", parts }],
+    input: [{ role: "user", content: parts }],
     schema: IMAGE_GRADE_SCHEMA
   });
   return value;
@@ -3240,7 +3713,7 @@ async function generateImages(request) {
     lines.push(`\\nPlease make all ${pending.length} remaining images.`);
     return [{ type: "text", text: lines.join("\\n") }];
   };
-  const contents = [{ role: "user", parts: buildInitialPromptParts() }];
+  const inputMessages = [{ role: "user", content: buildInitialPromptParts() }];
   const orderedEntries = [...promptEntries];
   const resolvedImages = /* @__PURE__ */ new Map();
   const removeResolvedEntries = (resolved) => {
@@ -3260,7 +3733,7 @@ async function generateImages(request) {
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     const result = await generateText({
       model: request.model,
-      contents,
+      input: inputMessages,
       responseModalities: ["IMAGE", "TEXT"],
       imageAspectRatio: request.imageAspectRatio,
       imageSize: request.imageSize ?? "2K"
@@ -3307,8 +3780,11 @@ async function generateImages(request) {
     if (promptEntries.length === 0) {
       break;
     }
-    contents.push(result.content);
-    contents.push({ role: "user", parts: buildContinuationPromptParts(promptEntries) });
+    inputMessages.push({
+      role: "assistant",
+      content: result.content.parts
+    });
+    inputMessages.push({ role: "user", content: buildContinuationPromptParts(promptEntries) });
   }
   const orderedImages = [];
   for (const entry of orderedEntries) {
@@ -3404,6 +3880,7 @@ export {
   refreshChatGptOauthToken,
   runToolLoop,
   sanitisePartForLogging,
+  streamJson,
   streamText,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,