@ulpi/cli 0.1.5 → 0.1.7

package/dist/chunk-SNQ7NAIS.js

@@ -0,0 +1,453 @@
+import {
+  getBinaryPath
+} from "./chunk-C7CLUQI6.js";
+
+// ../../packages/agent-converter/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
+var CLAUDE_ONLY_SKILLS = /* @__PURE__ */ new Set([
+  "update-claude-settings",
+  "update-skill-learnings",
+  "update-agent-learnings"
+]);
+var ADAPTABLE_SKILLS = /* @__PURE__ */ new Set([
+  "start",
+  "update-claude-learnings",
+  "update-claude-md-after-install",
+  "update-claude-md-after-install-monorepo"
+]);
+function parseClaudeAgentFrontmatter(content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!fmMatch) {
+    return { name: "", description: "", tools: [], model: "", body: content };
+  }
+  const yaml = fmMatch[1];
+  const body = fmMatch[2];
+  const getField = (key) => {
+    const m = yaml.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    return m ? m[1].trim() : "";
+  };
+  const toolsRaw = getField("tools");
+  const tools = toolsRaw ? toolsRaw.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  return {
+    name: getField("name"),
+    description: getField("description"),
+    tools,
+    model: getField("model"),
+    body
+  };
+}
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function adaptContentForKiro(content, skillName) {
+  let out = content;
+  out = out.replace(/\.claude\/skills\//g, ".kiro/skills/");
+  out = out.replace(/\.claude\/claude-md-refs\//g, ".kiro/docs/");
+  out = out.replace(/\.claude\/plans\//g, ".kiro/plans/");
+  out = out.replace(/\.claude\/agents\//g, ".kiro/agents/");
+  out = out.replace(/`\.claude\//g, "`.kiro/");
+  out = out.replace(/@\.claude\//g, ".kiro/");
+  out = out.replace(/CLAUDE\.md/g, "KIRO.md");
+  out = out.replace(/claude-md-refs/g, "kiro-docs");
+  out = out.replace(
+    /[Uu]se the Skill tool to (?:invoke|read|run|load) (?:it|the skill(?: file)?)/g,
+    "Read the skill from .kiro/skills/"
+  );
+  out = out.replace(/\bSkill tool\b/g, "skill resources");
+  out = out.replace(/\bTodoWrite\b/g, "task tracking");
+  out = out.replace(/\bAskUserQuestion\b/g, "user prompting");
+  out = out.replace(
+    /Use the Task tool with `subagent_type=\[([^\]]+)\]`/g,
+    "Delegate to the $1 specialist"
+  );
+  out = out.replace(/\bTask tool\b/g, "agent delegation");
+  out = out.replace(/@imports?\b/g, "file imports");
+  out = out.replace(/Claude Code/g, "Kiro");
+  out = out.replace(/\bClaude\b/g, "Kiro");
+  out = out.replace(/\/update-claude-learnings/g, "/update-kiro-learnings");
+  out = out.replace(/\/update-claude-md-after-install-monorepo/g, "/update-kiro-docs-monorepo");
+  out = out.replace(/\/update-claude-md-after-install/g, "/update-kiro-docs-after-install");
+  out = out.replace(/`update-claude-learnings`/g, "`update-kiro-learnings`");
+  out = out.replace(/`update-claude-md-after-install-monorepo`/g, "`update-kiro-docs-monorepo`");
+  out = out.replace(/`update-claude-md-after-install`/g, "`update-kiro-docs-after-install`");
+  if (skillName === "update-claude-md-after-install") {
+    out = out.replace(
+      /^(---\nname: )update-claude-md-after-install$/m,
+      "$1update-kiro-docs-after-install"
+    );
+  } else if (skillName === "update-claude-md-after-install-monorepo") {
+    out = out.replace(
+      /^(---\nname: )update-claude-md-after-install-monorepo$/m,
+      "$1update-kiro-docs-monorepo"
+    );
+  } else if (skillName === "update-claude-learnings") {
+    out = out.replace(
+      /^(---\nname: )update-claude-learnings$/m,
+      "$1update-kiro-learnings"
+    );
+  }
+  return out;
+}
+function adaptContentForCodex(content) {
+  let out = content;
+  out = out.replace(/\.claude\/skills\//g, ".codex/skills/");
+  out = out.replace(/\.claude\/claude-md-refs\//g, ".codex/docs/");
+  out = out.replace(/\.claude\/plans\//g, ".codex/plans/");
+  out = out.replace(/\.claude\/agents\//g, ".codex/agents/");
+  out = out.replace(/`\.claude\//g, "`.codex/");
+  out = out.replace(/@\.claude\//g, ".codex/");
+  out = out.replace(/CLAUDE\.md/g, "AGENTS.md");
+  out = out.replace(/claude-md-refs/g, "codex-docs");
+  out = out.replace(
+    /[Uu]se the Skill tool to (?:invoke|read|run|load) (?:it|the skill(?: file)?)/g,
+    "Read the skill from .codex/skills/"
+  );
+  out = out.replace(/\bSkill tool\b/g, "skill resources");
+  out = out.replace(/\bTodoWrite\b/g, "task tracking");
+  out = out.replace(/\bAskUserQuestion\b/g, "user prompting");
+  out = out.replace(
+    /Use the Task tool with `subagent_type=\[([^\]]+)\]`/g,
+    "Delegate to the $1 specialist"
+  );
+  out = out.replace(/\bTask tool\b/g, "agent delegation");
+  out = out.replace(/@imports?\b/g, "file imports");
+  out = out.replace(/Claude Code/g, "Codex");
+  out = out.replace(/\bClaude\b/g, "Codex");
+  out = out.replace(/\/update-claude-learnings/g, "/update-codex-learnings");
+  out = out.replace(/\/update-claude-md-after-install-monorepo/g, "/update-codex-docs-monorepo");
+  out = out.replace(/\/update-claude-md-after-install/g, "/update-codex-docs-after-install");
+  out = out.replace(/`update-claude-learnings`/g, "`update-codex-learnings`");
+  out = out.replace(/`update-claude-md-after-install-monorepo`/g, "`update-codex-docs-monorepo`");
+  out = out.replace(/`update-claude-md-after-install`/g, "`update-codex-docs-after-install`");
+  return out;
+}
+function kiroSkillsDir(projectDir) {
+  return path2.join(projectDir, ".kiro", "skills");
+}
+function buildHooks() {
+  const binary = getBinaryPath();
+  return {
+    agentSpawn: [{ command: `${binary} session-start` }],
+    preToolUse: [{ matcher: "*", command: `${binary} pre-tool` }],
+    postToolUse: [{ matcher: "*", command: `${binary} post-tool` }],
+    stop: [{ command: `${binary} stop` }]
+  };
+}
+function buildMcpServers() {
+  const binary = getBinaryPath();
+  return {
+    "ulpi-codemap": {
+      command: binary,
+      args: ["codemap", "serve"],
+      transportType: "stdio"
+    },
+    "ulpi-memory": {
+      command: binary,
+      args: ["memory", "serve"],
+      transportType: "stdio"
+    }
+  };
+}
+function mapClaudeToolsToKiro(tools) {
+  const TOOL_MAP = {
+    Read: "read",
+    Glob: "read",
+    Grep: "read",
+    Write: "write",
+    Edit: "write",
+    Bash: "shell",
+    BashOutput: "shell",
+    KillShell: "shell",
+    WebFetch: "browser",
+    WebSearch: "browser"
+  };
+  const kiroTools = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    const mapped = TOOL_MAP[tool];
+    if (mapped) kiroTools.add(mapped);
+  }
+  return [...kiroTools];
+}
+function extractKiroMcpServers(tools) {
+  const mcpTools = tools.filter((t) => t.startsWith("mcp__"));
+  if (mcpTools.length === 0) return {};
+  const serverNames = /* @__PURE__ */ new Set();
+  for (const tool of mcpTools) {
+    const parts = tool.split("__");
+    if (parts.length >= 2) serverNames.add(parts[1]);
+  }
+  const KNOWN_SERVERS2 = {
+    context7: {
+      command: "npx",
+      args: ["-y", "@anthropic-ai/context7-mcp@latest"],
+      transportType: "stdio"
+    }
+  };
+  const result = {};
+  for (const name of serverNames) {
+    if (name === "codemap" || name === "memory") continue;
+    if (KNOWN_SERVERS2[name]) {
+      result[name] = KNOWN_SERVERS2[name];
+    }
+  }
+  return result;
+}
+function convertClaudeSkillsToKiro(projectDir) {
+  const claudeSkillsDir = path2.join(projectDir, ".claude", "skills");
+  if (!fs2.existsSync(claudeSkillsDir)) return 0;
+  const destDir = kiroSkillsDir(projectDir);
+  let count = 0;
+  const entries = fs2.readdirSync(claudeSkillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (CLAUDE_ONLY_SKILLS.has(entry.name)) continue;
+    const srcSkillDir = path2.join(claudeSkillsDir, entry.name);
+    const srcSkillMd = path2.join(srcSkillDir, "SKILL.md");
+    if (!fs2.existsSync(srcSkillMd)) continue;
+    const destSkillDir = path2.join(destDir, entry.name);
+    const destSkillMd = path2.join(destSkillDir, "SKILL.md");
+    if (fs2.existsSync(destSkillMd)) continue;
+    fs2.mkdirSync(destSkillDir, { recursive: true });
+    if (ADAPTABLE_SKILLS.has(entry.name)) {
+      const raw = fs2.readFileSync(srcSkillMd, "utf-8");
+      const adapted = adaptContentForKiro(raw, entry.name);
+      fs2.writeFileSync(destSkillMd, adapted, "utf-8");
+    } else {
+      fs2.copyFileSync(srcSkillMd, destSkillMd);
+    }
+    const srcRefs = path2.join(srcSkillDir, "references");
+    if (fs2.existsSync(srcRefs) && fs2.statSync(srcRefs).isDirectory()) {
+      const destRefs = path2.join(destSkillDir, "references");
+      copyDirRecursive(srcRefs, destRefs);
+    }
+    count++;
+  }
+  return count;
+}
+function convertClaudeAgentsToKiro(projectDir) {
+  const claudeAgentsDir = path2.join(projectDir, ".claude", "agents");
+  if (!fs2.existsSync(claudeAgentsDir)) return 0;
+  const kiroAgentsBase = path2.join(projectDir, ".kiro", "agents");
+  let count = 0;
+  const entries = fs2.readdirSync(claudeAgentsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) continue;
+    if (!entry.name.endsWith(".md")) continue;
+    const agentName = entry.name.replace(/\.md$/, "");
+    const kiroAgentJson = path2.join(kiroAgentsBase, `${agentName}.json`);
+    if (fs2.existsSync(kiroAgentJson)) continue;
+    const raw = fs2.readFileSync(path2.join(claudeAgentsDir, entry.name), "utf-8");
+    const parsed = parseClaudeAgentFrontmatter(raw);
+    if (!parsed.name) continue;
+    const kiroTools = mapClaudeToolsToKiro(parsed.tools);
+    const externalMcps = extractKiroMcpServers(parsed.tools);
+    const adaptedBody = adaptContentForKiro(parsed.body, agentName);
+    const agentConfig = {
+      name: parsed.name,
+      description: parsed.description,
+      tools: kiroTools.length > 0 ? kiroTools : ["read", "write", "shell"],
+      allowedTools: ["read"],
+      hooks: buildHooks(),
+      resources: [
+        `file://.kiro/agents/${agentName}/prompt.md`,
+        "skill://.kiro/skills/*/SKILL.md",
+        "file://.ulpi/guards.yml"
+      ],
+      mcpServers: { ...buildMcpServers(), ...externalMcps }
+    };
+    fs2.mkdirSync(kiroAgentsBase, { recursive: true });
+    fs2.writeFileSync(kiroAgentJson, JSON.stringify(agentConfig, null, 2) + "\n", "utf-8");
+    const promptDir = path2.join(kiroAgentsBase, agentName);
+    fs2.mkdirSync(promptDir, { recursive: true });
+    fs2.writeFileSync(path2.join(promptDir, "prompt.md"), adaptedBody, "utf-8");
+    count++;
+  }
+  return count;
+}
+function serializeTomlTable(data) {
+  const lines = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (Array.isArray(value)) {
+      const items = value.map((v) => `"${v}"`).join(", ");
+      lines.push(`${key} = [${items}]`);
+    } else if (typeof value === "string") {
+      lines.push(`${key} = "${value}"`);
+    } else {
+      lines.push(`${key} = ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function appendTomlSection(filePath, sectionHeader, data) {
+  let content = "";
+  if (fs3.existsSync(filePath)) {
+    content = fs3.readFileSync(filePath, "utf-8");
+  }
+  if (content.includes(`[${sectionHeader}]`)) {
+    return false;
+  }
+  const section = `
+[${sectionHeader}]
+${serializeTomlTable(data)}
+`;
+  content += section;
+  const dir = path3.dirname(filePath);
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+function mapClaudeModelToCodex(model) {
+  switch (model.toLowerCase()) {
+    case "opus":
+      return { model: "gpt-5.3-codex", effort: "high" };
+    case "sonnet":
+      return { model: "gpt-5.3-codex", effort: "medium" };
+    case "haiku":
+      return { model: "gpt-5-codex-mini", effort: "medium" };
+    default:
+      return { model: "gpt-5.3-codex", effort: "medium" };
+  }
+}
+function inferSandboxMode(tools) {
+  const hasWrite = tools.some((t) => ["Write", "Edit", "Bash", "BashOutput", "KillShell"].includes(t));
+  if (!hasWrite) {
+    const hasRead = tools.some((t) => ["Read", "Glob", "Grep"].includes(t));
+    if (hasRead) return "read-only";
+  }
+  return "workspace-write";
+}
+var KNOWN_SERVERS = {
+  context7: { command: "npx", args: ["-y", "@anthropic-ai/context7-mcp@latest"] }
+};
+function extractCodexMcpServers(tools) {
+  const mcpTools = tools.filter((t) => t.startsWith("mcp__"));
+  if (mcpTools.length === 0) return {};
+  const serverNames = /* @__PURE__ */ new Set();
+  for (const tool of mcpTools) {
+    const parts = tool.split("__");
+    if (parts.length >= 2) serverNames.add(parts[1]);
+  }
+  const result = {};
+  for (const name of serverNames) {
+    if (name === "codemap" || name === "memory") continue;
+    if (KNOWN_SERVERS[name]) {
+      result[name] = KNOWN_SERVERS[name];
+    }
+  }
+  return result;
+}
+function convertClaudeAgentsToCodex(projectDir) {
+  const claudeAgentsDir = path4.join(projectDir, ".claude", "agents");
+  if (!fs4.existsSync(claudeAgentsDir)) return 0;
+  const codexAgentsBase = path4.join(projectDir, ".codex", "agents");
+  const configToml = path4.join(projectDir, ".codex", "config.toml");
+  let count = 0;
+  const entries = fs4.readdirSync(claudeAgentsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) continue;
+    if (!entry.name.endsWith(".md")) continue;
+    const agentName = entry.name.replace(/\.md$/, "");
+    const codexAgentToml = path4.join(codexAgentsBase, `${agentName}.toml`);
+    if (fs4.existsSync(codexAgentToml)) continue;
+    const raw = fs4.readFileSync(path4.join(claudeAgentsDir, entry.name), "utf-8");
+    const parsed = parseClaudeAgentFrontmatter(raw);
+    if (!parsed.name) continue;
+    const { model, effort } = mapClaudeModelToCodex(parsed.model);
+    const sandbox = inferSandboxMode(parsed.tools);
+    const adaptedBody = adaptContentForCodex(parsed.body);
+    fs4.mkdirSync(codexAgentsBase, { recursive: true });
+    const agentTomlContent = [
+      `model = "${model}"`,
+      `model_reasoning_effort = "${effort}"`,
+      `sandbox_mode = "${sandbox}"`,
+      `model_instructions_file = "agents/${agentName}/instructions.md"`,
+      ""
+    ].join("\n");
+    fs4.writeFileSync(codexAgentToml, agentTomlContent, "utf-8");
+    const instructionsDir = path4.join(codexAgentsBase, agentName);
+    fs4.mkdirSync(instructionsDir, { recursive: true });
+    fs4.writeFileSync(path4.join(instructionsDir, "instructions.md"), adaptedBody, "utf-8");
+    appendTomlSection(configToml, `agents.${agentName}`, {
+      description: parsed.description,
+      config_file: `agents/${agentName}.toml`
+    });
+    const externalMcps = extractCodexMcpServers(parsed.tools);
+    for (const [name, mcpEntry] of Object.entries(externalMcps)) {
+      appendTomlSection(configToml, `mcp_servers.${name}`, {
+        command: mcpEntry.command,
+        args: mcpEntry.args
+      });
+    }
+    count++;
+  }
+  return count;
+}
+function convertClaudeSkillsToCodex(projectDir) {
+  const claudeSkillsDir = path4.join(projectDir, ".claude", "skills");
+  if (!fs4.existsSync(claudeSkillsDir)) return 0;
+  const destDir = path4.join(projectDir, ".codex", "skills");
+  let count = 0;
+  const entries = fs4.readdirSync(claudeSkillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (CLAUDE_ONLY_SKILLS.has(entry.name)) continue;
+    const srcSkillDir = path4.join(claudeSkillsDir, entry.name);
+    const srcSkillMd = path4.join(srcSkillDir, "SKILL.md");
+    if (!fs4.existsSync(srcSkillMd)) continue;
+    const destSkillDir = path4.join(destDir, entry.name);
+    const destSkillMd = path4.join(destSkillDir, "SKILL.md");
+    if (fs4.existsSync(destSkillMd)) continue;
+    fs4.mkdirSync(destSkillDir, { recursive: true });
+    if (ADAPTABLE_SKILLS.has(entry.name)) {
+      const raw = fs4.readFileSync(srcSkillMd, "utf-8");
+      const adapted = adaptContentForCodex(raw);
+      fs4.writeFileSync(destSkillMd, adapted, "utf-8");
+    } else {
+      fs4.copyFileSync(srcSkillMd, destSkillMd);
+    }
+    const srcRefs = path4.join(srcSkillDir, "references");
+    if (fs4.existsSync(srcRefs) && fs4.statSync(srcRefs).isDirectory()) {
+      const destRefs = path4.join(destSkillDir, "references");
+      copyDirRecursive(srcRefs, destRefs);
+    }
+    count++;
+  }
+  return count;
+}
+
+export {
+  CLAUDE_ONLY_SKILLS,
+  ADAPTABLE_SKILLS,
+  parseClaudeAgentFrontmatter,
+  copyDirRecursive,
+  adaptContentForKiro,
+  adaptContentForCodex,
+  mapClaudeToolsToKiro,
+  extractKiroMcpServers,
+  convertClaudeSkillsToKiro,
+  convertClaudeAgentsToKiro,
+  serializeTomlTable,
+  appendTomlSection,
+  mapClaudeModelToCodex,
+  inferSandboxMode,
+  extractCodexMcpServers,
+  convertClaudeAgentsToCodex,
+  convertClaudeSkillsToCodex
+};

package/dist/{ulpi-RMMCUAGP-EWYUE7RU.js → chunk-TSLDGT5O.js}

@@ -1,10 +1,9 @@
 import {
   resolveApiKey,
   resolveUlpiUrl
-} from "./chunk-DDRLI6JU.js";
-import "./chunk-4VNS5WPM.js";
+} from "./chunk-C7CLUQI6.js";
 
-// ../../packages/codemap-engine/dist/ulpi-RMMCUAGP.js
+// ../../packages/embed-engine/dist/chunk-EW7O4NSJ.js
 var MAX_RETRIES = 3;
 var RETRY_BASE_MS = 1e3;
 var BATCH_POLL_INTERVAL_MS = 2e3;
@@ -39,7 +38,8 @@ var UlpiEmbedder = class {
         const response = await fetch(`${this.baseUrl}/api/v1/embeddings`, {
           method: "POST",
           headers: this.headers,
-          body: JSON.stringify(body)
+          body: JSON.stringify(body),
+          redirect: "error"
         });
         if (!response.ok) {
           lastError = await this.handleErrorResponse(response);
@@ -49,7 +49,12 @@ var UlpiEmbedder = class {
           }
           throw lastError;
         }
-        const data = await response.json();
+        const data = await this.safeJson(response);
+        if (!Array.isArray(data.data)) {
+          throw new Error(
+            `ULPI embedding API error (${response.status}): ${JSON.stringify(data)}`
+          );
+        }
         const sorted = data.data.sort((a, b) => a.index - b.index);
         return sorted.map((item) => item.embedding);
       } catch (err) {
@@ -83,17 +88,30 @@ var UlpiEmbedder = class {
     console.error(
       `[ulpi-embedder] submitBatch: ${texts.length} texts, payload=${(payload.length / 1024).toFixed(0)}KB, chars: total=${totalChars} avg=${avgChars} max=${maxChars}, model=${this.model}, url=${this.baseUrl}/api/v1/embeddings/batch`
     );
-    const response = await fetch(`${this.baseUrl}/api/v1/embeddings/batch`, {
-      method: "POST",
-      headers: this.headers,
-      body: payload
-    });
-    if (!response.ok) {
-      throw await this.handleErrorResponse(response);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 6e4);
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/embeddings/batch`, {
+        method: "POST",
+        headers: this.headers,
+        body: payload,
+        redirect: "error",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw await this.handleErrorResponse(response);
+      }
+      const result = await this.safeJson(response);
+      if (!result.data?.id) {
+        throw new Error(
+          `ULPI batch API error (${response.status}): ${JSON.stringify(result)}`
+        );
+      }
+      console.error(`[ulpi-embedder] submitBatch: got batchId=${result.data.id}`);
+      return result.data.id;
+    } finally {
+      clearTimeout(timeoutId);
     }
-    const result = await response.json();
-    console.error(`[ulpi-embedder] submitBatch: got batchId=${result.data.id}`);
-    return result.data.id;
   }
   /**
    * Poll the status of an async batch.
@@ -102,28 +120,47 @@ var UlpiEmbedder = class {
    * as they arrive rather than waiting for full batch completion.
    */
   async pollBatch(batchId) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1/embeddings/batch/${encodeURIComponent(batchId)}`,
-      { headers: this.headers }
-    );
-    if (!response.ok) {
-      throw await this.handleErrorResponse(response);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/v1/embeddings/batch/${encodeURIComponent(batchId)}`,
+        { headers: this.headers, redirect: "error", signal: controller.signal }
+      );
+      if (!response.ok) {
+        throw await this.handleErrorResponse(response);
+      }
+      const json = await this.safeJson(response);
+      const batch = json.data;
+      let results;
+      if (json.results?.data && json.results.data.length > 0) {
+        const sorted = json.results.data.sort((a, b) => a.index - b.index);
+        results = sorted.map((item) => item.embedding);
+      }
+      const allProcessed = batch.processed_inputs >= batch.total_inputs;
+      return {
+        id: batch.id,
+        status: allProcessed && batch.status !== "failed" ? "completed" : batch.status,
+        totalInputs: batch.total_inputs,
+        processedInputs: batch.processed_inputs,
+        results
+      };
+    } finally {
+      clearTimeout(timeoutId);
     }
-    const json = await response.json();
-    const batch = json.data;
-    let results;
-    if (json.results?.data && json.results.data.length > 0) {
-      const sorted = json.results.data.sort((a, b) => a.index - b.index);
-      results = sorted.map((item) => item.embedding);
+  }
+  /**
+   * Parse JSON from response, guarding against HTML error pages.
+   */
+  async safeJson(response) {
+    const ct = response.headers.get("content-type") ?? "";
+    if (ct.includes("text/html")) {
+      const snippet = (await response.text()).slice(0, 200);
+      throw new Error(
+        `ULPI embedding API returned HTML instead of JSON (${response.status}). The endpoint may be misconfigured. Response: ${snippet}`
+      );
     }
-    const allProcessed = batch.processed_inputs >= batch.total_inputs;
-    return {
-      id: batch.id,
-      status: allProcessed && batch.status !== "failed" ? "completed" : batch.status,
-      totalInputs: batch.total_inputs,
-      processedInputs: batch.processed_inputs,
-      results
-    };
+    return await response.json();
   }
   async handleErrorResponse(response) {
     const errorText = await response.text();
@@ -155,6 +192,7 @@ var UlpiEmbedder = class {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
 export {
   BATCH_POLL_INTERVAL_MS,
   UlpiEmbedder