@hlix/sdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -7,7 +7,6 @@ function createHlixClient(options) {
     fetch: options.fetch
   });
 }
-
 // src/auth.ts
 var apiKeyCredential = (apiKey) => ({
   kind: "apiKey",
@@ -17,8 +16,19 @@ var sessionCredential = (cookie) => ({
   kind: "session",
   cookie
 });
+var bearerCredential = (token) => ({
+  kind: "bearer",
+  token
+});
 function credentialHeaders(credential) {
-  return credential.kind === "apiKey" ? { "x-api-key": credential.apiKey } : { cookie: credential.cookie };
+  switch (credential.kind) {
+    case "apiKey":
+      return { "x-api-key": credential.apiKey };
+    case "session":
+      return { cookie: credential.cookie };
+    case "bearer":
+      return { authorization: `Bearer ${credential.token}` };
+  }
 }
 function organizationHeaders(organizationId) {
   return organizationId ? { "X-Organization-Id": organizationId } : {};
@@ -32,11 +42,13 @@ function authHeaders(credential, organizationId) {
 
 // src/errors.ts
 function errorMessageOf(body) {
-  if (typeof body !== "object" || body === null) return null;
+  if (typeof body !== "object" || body === null)
+    return null;
   const { error } = body;
   return typeof error === "string" ? error : null;
 }
-var HlixError = class extends Error {
+
+class HlixError extends Error {
   status;
   body;
   requestId;
@@ -51,37 +63,46 @@ var HlixError = class extends Error {
     this.method = init.method;
     this.url = init.url;
   }
-};
-var HlixValidationError = class extends HlixError {
-  /** The decoded `ZodIssue[]`; empty when the server sent a plain message. */
+}
+
+class HlixValidationError extends HlixError {
   issues;
   constructor(message, init, issues) {
     super(message, init);
     this.issues = issues;
   }
-};
-var HlixBadRequestError = class extends HlixError {
-};
-var HlixAuthenticationError = class extends HlixError {
-};
-var HlixPermissionError = class extends HlixError {
-};
-var HlixNotFoundError = class extends HlixError {
-};
-var HlixConflictError = class extends HlixError {
-};
-var HlixRateLimitError = class extends HlixError {
+}
+
+class HlixBadRequestError extends HlixError {
+}
+
+class HlixAuthenticationError extends HlixError {
+}
+
+class HlixPermissionError extends HlixError {
+}
+
+class HlixNotFoundError extends HlixError {
+}
+
+class HlixConflictError extends HlixError {
+}
+
+class HlixRateLimitError extends HlixError {
   retryAfter;
   constructor(message, init, retryAfter) {
     super(message, init);
     this.retryAfter = retryAfter;
   }
-};
-var HlixNotImplementedError = class extends HlixError {
-};
-var HlixServerError = class extends HlixError {
-};
-var HlixTransportError = class extends Error {
+}
+
+class HlixNotImplementedError extends HlixError {
+}
+
+class HlixServerError extends HlixError {
+}
+
+class HlixTransportError extends Error {
   method;
   url;
   constructor(message, init) {
@@ -90,13 +111,16 @@ var HlixTransportError = class extends Error {
     this.method = init.method;
     this.url = init.url;
   }
-};
+}
 function validationIssues(body) {
-  if (typeof body !== "object" || body === null) return null;
+  if (typeof body !== "object" || body === null)
+    return null;
   const candidate = body;
-  if (candidate.success !== false) return null;
+  if (candidate.success !== false)
+    return null;
   const raw = candidate.error?.message;
-  if (typeof raw !== "string") return null;
+  if (typeof raw !== "string")
+    return null;
   try {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
@@ -106,7 +130,8 @@ function validationIssues(body) {
 }
 function retryAfterSeconds(headers) {
   const raw = headers.get("retry-after");
-  if (!raw) return null;
+  if (!raw)
+    return null;
   const seconds = Number(raw);
   return Number.isFinite(seconds) && seconds >= 0 ? seconds : null;
 }
@@ -122,11 +147,7 @@ function errorForResponse(response, body, request) {
   const fallback = `${request.method} ${request.url} failed with ${response.status}`;
   const issues = validationIssues(body);
   if (issues) {
-    return new HlixValidationError(
-      `${request.method} ${request.url}: request body failed validation`,
-      init,
-      issues
-    );
+    return new HlixValidationError(`${request.method} ${request.url}: request body failed validation`, init, issues);
   }
   const message = stated ?? fallback;
   switch (response.status) {
@@ -150,7 +171,7 @@ function errorForResponse(response, body, request) {
 }
 
 // src/retry.ts
-var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+var IDEMPOTENT_METHODS = new Set([
   "GET",
   "HEAD",
   "PUT",
@@ -161,7 +182,7 @@ var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
 function isIdempotent(method) {
   return IDEMPOTENT_METHODS.has(method.toUpperCase());
 }
-var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
+var RETRYABLE_STATUSES = new Set([
   429,
   500,
   502,
@@ -174,18 +195,20 @@ function isRetryableStatus(status) {
 var DEFAULT_RETRY = {
   attempts: 3,
   baseDelayMs: 200,
-  maxDelayMs: 5e3
+  maxDelayMs: 5000
 };
-function backoffDelayMs(attempt, policy, retryAfterSeconds3, random = Math.random) {
-  if (retryAfterSeconds3 !== null) {
-    return Math.min(retryAfterSeconds3 * 1e3, policy.maxDelayMs);
+function backoffDelayMs(attempt, policy, retryAfterSeconds, random = Math.random) {
+  if (retryAfterSeconds !== null) {
+    return Math.min(retryAfterSeconds * 1000, policy.maxDelayMs);
   }
   const ceiling = Math.min(policy.baseDelayMs * 2 ** attempt, policy.maxDelayMs);
   return Math.round(random() * ceiling);
 }
 function shouldRetry(input) {
-  if (!isIdempotent(input.method)) return false;
-  if (input.attempt + 1 >= input.policy.attempts) return false;
+  if (!isIdempotent(input.method))
+    return false;
+  if (input.attempt + 1 >= input.policy.attempts)
+    return false;
   return input.status === null || isRetryableStatus(input.status);
 }
 
@@ -193,7 +216,8 @@ function shouldRetry(input) {
 var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function retryAfterSeconds2(response) {
   const raw = response.headers.get("retry-after");
-  if (!raw) return null;
+  if (!raw)
+    return null;
   const seconds = Number(raw);
   return Number.isFinite(seconds) && seconds >= 0 ? seconds : null;
 }
@@ -204,17 +228,14 @@ function retryingFetch(options) {
   return async (input) => {
     const method = input.method.toUpperCase();
     const replayable = isIdempotent(method) ? input.clone() : null;
-    for (let attempt = 0; ; attempt += 1) {
+    for (let attempt = 0;; attempt += 1) {
       const request = attempt === 0 ? input : replayable.clone();
       let response;
       try {
         response = await base(request);
       } catch (cause) {
         if (!replayable || !shouldRetry({ method, attempt, policy, status: null })) {
-          throw new HlixTransportError(
-            `${method} ${input.url}: ${cause instanceof Error ? cause.message : String(cause)}`,
-            { method, url: input.url, cause }
-          );
+          throw new HlixTransportError(`${method} ${input.url}: ${cause instanceof Error ? cause.message : String(cause)}`, { method, url: input.url, cause });
         }
         await sleep(backoffDelayMs(attempt, policy, null, random));
         continue;
@@ -222,16 +243,53 @@ function retryingFetch(options) {
       if (!shouldRetry({ method, attempt, policy, status: response.status })) {
         return response;
       }
-      if (!replayable) return response;
+      if (!replayable)
+        return response;
       await sleep(backoffDelayMs(attempt, policy, retryAfterSeconds2(response), random));
     }
   };
 }
 function unwrap(result, request) {
-  if (result.response.ok) return result.data;
+  if (result.response.ok)
+    return result.data;
   throw errorForResponse(result.response, result.error ?? result.data, request);
 }
 
+// src/observe.ts
+var text = (value) => typeof value === "string" ? value : "";
+function parseObserveFrame(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const frame = parsed;
+  switch (frame.type) {
+    case "idle":
+      return { type: "idle" };
+    case "done":
+      return { type: "done" };
+    case "active":
+      return typeof frame.runId === "string" ? { type: "active", runId: frame.runId } : { type: "active" };
+    case "on_chat_model_stream":
+      return { type: "on_chat_model_stream", delta: text(frame.delta) };
+    case "reasoning":
+      return { type: "reasoning", delta: text(frame.delta) };
+    case "on_tool_start":
+      return { type: "on_tool_start", name: text(frame.name), input: frame.input };
+    case "on_tool_end":
+      return { type: "on_tool_end", name: text(frame.name), output: frame.output };
+    case "error":
+      return { type: "error", message: text(frame.message) };
+    default:
+      return null;
+  }
+}
+var isTerminalObserveFrame = (frame) => frame.type === "done" || frame.type === "idle" || frame.type === "error";
+
 // src/streaming.ts
 var emptyFrame = () => ({ event: null, data: [], id: null, retry: null });
 function applyField(frame, name, value) {
@@ -243,10 +301,12 @@ function applyField(frame, name, value) {
       frame.data.push(value);
       return;
     case "id":
-      if (!value.includes("\0")) frame.id = value;
+      if (!value.includes("\x00"))
+        frame.id = value;
       return;
     case "retry": {
-      if (/^\d+$/.test(value)) frame.retry = Number(value);
+      if (/^\d+$/.test(value))
+        frame.retry = Number(value);
       return;
     }
     default:
@@ -254,17 +314,21 @@ function applyField(frame, name, value) {
   }
 }
 function dispatch(frame) {
-  const data = frame.data.join("\n");
+  const data = frame.data.join(`
+`);
   const event = frame.event;
   const id = frame.id;
   frame.data = [];
   frame.event = null;
-  if (data === "") return null;
+  if (data === "")
+    return null;
   return { event, data, id, retry: frame.retry };
 }
 function consumeLine(frame, line) {
-  if (line === "") return dispatch(frame);
-  if (line.startsWith(":")) return null;
+  if (line === "")
+    return dispatch(frame);
+  if (line.startsWith(":"))
+    return null;
   const colon = line.indexOf(":");
   if (colon === -1) {
     applyField(frame, line, "");
@@ -272,66 +336,117 @@ function consumeLine(frame, line) {
   }
   const name = line.slice(0, colon);
   let value = line.slice(colon + 1);
-  if (value.startsWith(" ")) value = value.slice(1);
+  if (value.startsWith(" "))
+    value = value.slice(1);
   applyField(frame, name, value);
   return null;
 }
 function splitLines(buffer) {
   const lines = [];
   let start = 0;
-  for (let i = 0; i < buffer.length; i += 1) {
+  for (let i = 0;i < buffer.length; i += 1) {
     const ch = buffer[i];
-    if (ch !== "\n" && ch !== "\r") continue;
+    if (ch !== `
+` && ch !== "\r")
+      continue;
     lines.push(buffer.slice(start, i));
-    if (ch === "\r" && buffer[i + 1] === "\n") i += 1;
+    if (ch === "\r" && buffer[i + 1] === `
+`)
+      i += 1;
     start = i + 1;
   }
   return { lines, rest: buffer.slice(start) };
 }
 async function* parseSseStream(body, signal) {
   const reader = body.getReader();
-  const decoder = new TextDecoder();
+  const decoder = new TextDecoder;
   const frame = emptyFrame();
   let buffer = "";
-  const abort = () => void reader.cancel().catch(() => {
-  });
+  const abort = () => void reader.cancel().catch(() => {});
   signal?.addEventListener("abort", abort, { once: true });
   try {
-    for (; ; ) {
+    for (;; ) {
       const { done, value } = await reader.read();
-      if (done) break;
+      if (done)
+        break;
       buffer += decoder.decode(value, { stream: true });
       const { lines, rest } = splitLines(buffer);
       buffer = rest;
       for (const line of lines) {
         const event = consumeLine(frame, line);
-        if (event) yield event;
+        if (event)
+          yield event;
       }
-      if (signal?.aborted) return;
+      if (signal?.aborted)
+        return;
     }
     buffer += decoder.decode();
     if (buffer !== "") {
       const event = consumeLine(frame, buffer);
-      if (event) yield event;
+      if (event)
+        yield event;
     }
     const trailing = dispatch(frame);
-    if (trailing) yield trailing;
+    if (trailing)
+      yield trailing;
   } finally {
     signal?.removeEventListener("abort", abort);
     reader.releaseLock();
   }
 }
 
+// src/revision-watch.ts
+function parseRevisionWatchFrame(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const frame = parsed;
+  if (frame.kind === "ready")
+    return { kind: "ready" };
+  if (frame.kind === "workspace")
+    return { kind: "workspace" };
+  if (frame.kind === "head" && typeof frame.revisionId === "string" && typeof frame.generation === "number") {
+    return { kind: "head", revisionId: frame.revisionId, generation: frame.generation };
+  }
+  return null;
+}
+function isPermanentWatchFailure(error) {
+  return error instanceof HlixError && error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429;
+}
+var WATCH_RECONNECT = { firstDelayMs: 1000, maxDelayMs: 30000 };
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted)
+      return resolve();
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+
 // src/index.ts
-var Hlix = class {
-  /** The un-opinionated transport, for anything this facade does not wrap. */
+class Hlix {
   raw;
   baseUrl;
   headers;
   fetcher;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-    this.headers = authHeaders(options.credential, options.organizationId);
+    const auth = authHeaders(options.credential, options.organizationId);
+    const owned = new Set(Object.keys(auth).map((name) => name.toLowerCase()));
+    this.headers = {
+      ...Object.fromEntries(Object.entries(options.headers ?? {}).filter(([name]) => !owned.has(name.toLowerCase()))),
+      ...auth
+    };
     const policy = { ...DEFAULT_RETRY, ...options.retry };
     const base = options.fetch ?? ((input) => globalThis.fetch(input));
     this.fetcher = retryingFetch({ base, policy });
@@ -344,53 +459,135 @@ var Hlix = class {
   at(method, path) {
     return { method, url: `${this.baseUrl}${path}` };
   }
+  workspaces = {
+    list: async (options = {}) => unwrap(await this.raw.GET("/v1/api/workspaces", options), this.at("GET", "/v1/api/workspaces"))
+  };
   projects = {
-    list: async () => unwrap(
-      await this.raw.GET("/v1/api/projects"),
-      this.at("GET", "/v1/api/projects")
-    ),
-    get: async (id) => unwrap(
-      await this.raw.GET("/v1/api/projects/{id}", { params: { path: { id } } }),
-      this.at("GET", `/v1/api/projects/${id}`)
-    ),
-    create: async (body) => unwrap(
-      await this.raw.POST("/v1/api/projects", { body }),
-      this.at("POST", "/v1/api/projects")
-    ),
-    delete: async (id) => unwrap(
-      await this.raw.DELETE("/v1/api/projects/{id}", {
+    list: async () => unwrap(await this.raw.GET("/v1/api/projects"), this.at("GET", "/v1/api/projects")),
+    get: async (id, options = {}) => unwrap(await this.raw.GET("/v1/api/projects/{id}", { ...options, params: { path: { id } } }), this.at("GET", `/v1/api/projects/${id}`)),
+    create: async (body) => unwrap(await this.raw.POST("/v1/api/projects", { body }), this.at("POST", "/v1/api/projects")),
+    delete: async (id) => unwrap(await this.raw.DELETE("/v1/api/projects/{id}", {
+      params: { path: { id } }
+    }), this.at("DELETE", `/v1/api/projects/${id}`)),
+    start: async (id, body) => unwrap(await this.raw.POST("/v1/api/projects/{id}/start", {
+      params: { path: { id } },
+      body
+    }), this.at("POST", `/v1/api/projects/${id}/start`)),
+    refreshPreview: async (id) => unwrap(await this.raw.POST("/v1/api/projects/{id}/preview/refresh", {
+      params: { path: { id } }
+    }), this.at("POST", `/v1/api/projects/${id}/preview/refresh`)),
+    stop: async (id) => unwrap(await this.raw.POST("/v1/api/projects/{id}/stop", { params: { path: { id } } }), this.at("POST", `/v1/api/projects/${id}/stop`)),
+    status: async (id, options = {}) => unwrap(await this.raw.GET("/v1/api/projects/{id}/status", { ...options, params: { path: { id } } }), this.at("GET", `/v1/api/projects/${id}/status`)),
+    preview: async (id) => unwrap(await this.raw.GET("/v1/api/projects/{id}/preview", { params: { path: { id } } }), this.at("GET", `/v1/api/projects/${id}/preview`)),
+    deliver: async (id) => unwrap(await this.raw.POST("/v1/api/projects/{id}/delivery", { params: { path: { id } } }), this.at("POST", `/v1/api/projects/${id}/delivery`)),
+    connectRepo: async (id, body) => {
+      const result = await this.raw.POST("/v1/api/projects/{id}/repos/connect", {
+        params: { path: { id } },
+        body
+      });
+      return unwrap(result, this.at("POST", `/v1/api/projects/${id}/repos/connect`));
+    },
+    terminal: async (id) => unwrap(await this.raw.GET("/v1/api/projects/{id}/terminal", { params: { path: { id } } }), this.at("GET", `/v1/api/projects/${id}/terminal`)),
+    observeAgent: (projectId, agentId, init) => this.observeAgent(projectId, agentId, init),
+    workspace: (id) => ({
+      environment: async () => unwrap(await this.raw.GET("/v1/api/projects/{id}/environment", {
         params: { path: { id } }
-      }),
-      this.at("DELETE", `/v1/api/projects/${id}`)
-    ),
-    start: async (id, body) => unwrap(
-      await this.raw.POST("/v1/api/projects/{id}/start", {
+      }), this.at("GET", `/v1/api/projects/${id}/environment`)),
+      fs: async (body) => unwrap(await this.raw.POST("/v1/api/projects/{id}/workspace/fs", {
+        params: { path: { id } },
+        body
+      }), this.at("POST", `/v1/api/projects/${id}/workspace/fs`)),
+      exec: async (body) => unwrap(await this.raw.POST("/v1/api/projects/{id}/workspace/exec", {
         params: { path: { id } },
         body
-      }),
-      this.at("POST", `/v1/api/projects/${id}/start`)
-    )
+      }), this.at("POST", `/v1/api/projects/${id}/workspace/exec`))
+    })
+  };
+  secrets = {
+    listEntries: async (projectId) => unwrap(await this.raw.GET("/v1/api/secrets/project/{projectId}/entries", {
+      params: { path: { projectId } }
+    }), this.at("GET", `/v1/api/secrets/project/${projectId}/entries`)),
+    upsertEntries: async (projectId, body) => unwrap(await this.raw.PUT("/v1/api/secrets/project/{projectId}/entries", {
+      params: { path: { projectId } },
+      body
+    }), this.at("PUT", `/v1/api/secrets/project/${projectId}/entries`)),
+    importFiles: async (projectId, files) => unwrap(await this.raw.PUT("/v1/api/secrets/project/{projectId}/files", {
+      params: { path: { projectId } },
+      body: { files }
+    }), this.at("PUT", `/v1/api/secrets/project/${projectId}/files`)),
+    deleteEntry: async (projectId, key, source) => unwrap(await this.raw.DELETE("/v1/api/secrets/project/{projectId}/entries/{key}", {
+      params: {
+        path: { projectId, key },
+        ...source === undefined ? {} : { query: { source } }
+      }
+    }), this.at("DELETE", `/v1/api/secrets/project/${projectId}/entries/${encodeURIComponent(key)}`)),
+    exportEntries: async (projectId, options = {}) => {
+      const path = `/v1/api/secrets/project/${projectId}/export`;
+      const url = `${this.baseUrl}${path}`;
+      const response = await this.fetcher(new Request(url, {
+        method: "POST",
+        headers: { ...this.headers, "content-type": "application/json" },
+        body: JSON.stringify({
+          ...options.source === undefined ? {} : { source: options.source },
+          ...options.format === undefined ? {} : { format: options.format }
+        })
+      }));
+      if (!response.ok) {
+        throw errorForResponse(response, await response.json().catch(() => {
+          return;
+        }), { method: "POST", url });
+      }
+      return response.text();
+    }
   };
   imports = {
     create: async (body) => {
       const result = await this.raw.POST("/v1/api/imports", { body });
       return unwrap(result, this.at("POST", "/v1/api/imports"));
     },
-    get: async (id) => unwrap(
-      await this.raw.GET("/v1/api/imports/{id}", {
-        params: { path: { id } }
-      }),
-      this.at("GET", `/v1/api/imports/${id}`)
-    ),
-    finalize: async (id, body) => {
+    get: async (id, options = {}) => unwrap(await this.raw.GET("/v1/api/imports/{id}", {
+      signal: options.signal,
+      params: { path: { id } }
+    }), this.at("GET", `/v1/api/imports/${id}`)),
+    finalize: async (id, body, options = {}) => {
       const result = await this.raw.POST("/v1/api/imports/{id}/finalize", {
+        signal: options.signal,
         params: { path: { id } },
         body
       });
-      return unwrap(
-        result,
-        this.at("POST", `/v1/api/imports/${id}/finalize`)
-      );
+      return unwrap(result, this.at("POST", `/v1/api/imports/${id}/finalize`));
+    },
+    finalizeAndWait: async (id, body, options = {}) => {
+      const deadline = AbortSignal.timeout(options.timeoutMs ?? 600000);
+      const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
+      try {
+        return await this.imports.finalize(id, body, { signal });
+      } catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof HlixServerError || error instanceof HlixTransportError || error instanceof HlixConflictError))
+          throw error;
+      }
+      return this.imports.waitUntilReady(id, { ...options, signal });
+    },
+    waitUntilReady: async (id, options = {}) => {
+      const deadline = AbortSignal.timeout(options.timeoutMs ?? 600000);
+      const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
+      while (true) {
+        signal.throwIfAborted();
+        try {
+          const result = await this.imports.get(id, { signal });
+          if (result.import.status === "ready")
+            return result;
+          if (result.import.status !== "finalizing") {
+            throw new Error(`Import ${id} is ${result.import.status}: ${result.import.error ?? "rerun hlix import to resume this session"}`);
+          }
+        } catch (error) {
+          signal.throwIfAborted();
+          if (!(error instanceof HlixServerError || error instanceof HlixTransportError))
+            throw error;
+        }
+        await pause(options.pollIntervalMs ?? 2000, signal);
+      }
     },
     uploadBundle: async (upload, bundle, options = {}) => {
       const chunkSize = options.chunkSize ?? 8 * 1024 * 1024;
@@ -410,7 +607,8 @@ var Hlix = class {
           signal: options.signal
         });
         const response = await this.fetcher(request);
-        if (!response.ok) await this.throwUploadError(response, url);
+        if (!response.ok)
+          await this.throwUploadError(response, url);
         options.onProgress?.(bundle.size, bundle.size);
         return;
       }
@@ -441,18 +639,13 @@ var Hlix = class {
     }
   };
   revisions = {
-    head: async (projectId) => unwrap(
-      await this.raw.GET("/v1/api/projects/{id}/revisions/head", {
-        params: { path: { id: projectId } }
-      }),
-      this.at("GET", `/v1/api/projects/${projectId}/revisions/head`)
-    ),
-    protectedFiles: async (projectId) => unwrap(
-      await this.raw.GET("/v1/api/projects/{id}/protected-files", {
-        params: { path: { id: projectId } }
-      }),
-      this.at("GET", `/v1/api/projects/${projectId}/protected-files`)
-    ),
+    head: async (projectId, options = {}) => unwrap(await this.raw.GET("/v1/api/projects/{id}/revisions/head", {
+      ...options,
+      params: { path: { id: projectId } }
+    }), this.at("GET", `/v1/api/projects/${projectId}/revisions/head`)),
+    protectedFiles: async (projectId) => unwrap(await this.raw.GET("/v1/api/projects/{id}/protected-files", {
+      params: { path: { id: projectId } }
+    }), this.at("GET", `/v1/api/projects/${projectId}/protected-files`)),
     createUpload: async (projectId, body) => {
       const result = await this.raw.POST("/v1/api/projects/{id}/revisions/uploads", {
         params: { path: { id: projectId } },
@@ -461,16 +654,11 @@ var Hlix = class {
       return unwrap(result, this.at("POST", `/v1/api/projects/${projectId}/revisions/uploads`));
     },
     finalize: async (projectId, uploadId, body) => {
-      const result = await this.raw.POST(
-        "/v1/api/projects/{id}/revisions/uploads/{uploadId}/finalize",
-        { params: { path: { id: projectId, uploadId } }, body }
-      );
-      return unwrap(
-        result,
-        this.at("POST", `/v1/api/projects/${projectId}/revisions/uploads/${uploadId}/finalize`)
-      );
+      const result = await this.raw.POST("/v1/api/projects/{id}/revisions/uploads/{uploadId}/finalize", { params: { path: { id: projectId, uploadId } }, body });
+      return unwrap(result, this.at("POST", `/v1/api/projects/${projectId}/revisions/uploads/${uploadId}/finalize`));
     },
     uploadBundle: async (upload, bundle, options = {}) => this.imports.uploadBundle(upload, bundle, options),
+    watch: (projectId, init) => this.watchRevisions(projectId, init),
     downloadBundle: async (projectId, revisionId) => {
       const path = `/v1/api/projects/${projectId}/revisions/${revisionId}/bundle`;
       const request = new Request(`${this.baseUrl}${path}`, {
@@ -478,32 +666,24 @@ var Hlix = class {
         headers: this.headers
       });
       const response = await this.fetcher(request);
-      if (!response.ok) await this.throwUploadError(response, `${this.baseUrl}${path}`);
+      if (!response.ok)
+        await this.throwUploadError(response, `${this.baseUrl}${path}`);
       return response.blob();
     }
   };
   resources = {
-    importSkill: async (projectId, body) => unwrap(
-      await this.raw.POST("/v1/api/projects/{id}/resources/skill", {
-        params: { path: { id: projectId } },
-        body
-      }),
-      this.at("POST", `/v1/api/projects/${projectId}/resources/skill`)
-    ),
-    importAgent: async (projectId, body) => unwrap(
-      await this.raw.POST("/v1/api/projects/{id}/resources/agent", {
-        params: { path: { id: projectId } },
-        body
-      }),
-      this.at("POST", `/v1/api/projects/${projectId}/resources/agent`)
-    ),
-    importMcp: async (projectId, body) => unwrap(
-      await this.raw.POST("/v1/api/projects/{id}/resources/mcp", {
-        params: { path: { id: projectId } },
-        body
-      }),
-      this.at("POST", `/v1/api/projects/${projectId}/resources/mcp`)
-    )
+    importSkill: async (projectId, body) => unwrap(await this.raw.POST("/v1/api/projects/{id}/resources/skill", {
+      params: { path: { id: projectId } },
+      body
+    }), this.at("POST", `/v1/api/projects/${projectId}/resources/skill`)),
+    importAgent: async (projectId, body) => unwrap(await this.raw.POST("/v1/api/projects/{id}/resources/agent", {
+      params: { path: { id: projectId } },
+      body
+    }), this.at("POST", `/v1/api/projects/${projectId}/resources/agent`)),
+    importMcp: async (projectId, body) => unwrap(await this.raw.POST("/v1/api/projects/{id}/resources/mcp", {
+      params: { path: { id: projectId } },
+      body
+    }), this.at("POST", `/v1/api/projects/${projectId}/resources/mcp`))
   };
   async throwUploadError(response, url) {
     let body = null;
@@ -515,140 +695,127 @@ var Hlix = class {
     throw errorForResponse(response, body, { method: "PUT", url });
   }
   tasks = {
-    list: async (query) => unwrap(
-      await this.raw.GET("/v1/api/tasks", { params: { query: query ?? {} } }),
-      this.at("GET", "/v1/api/tasks")
-    ),
-    get: async (id) => unwrap(
-      await this.raw.GET("/v1/api/tasks/{id}", { params: { path: { id } } }),
-      this.at("GET", `/v1/api/tasks/${id}`)
-    ),
-    create: async (body) => unwrap(
-      await this.raw.POST("/v1/api/tasks", { body }),
-      this.at("POST", "/v1/api/tasks")
-    ),
-    update: async (id, body) => unwrap(
-      await this.raw.PATCH("/v1/api/tasks/{id}", {
-        params: { path: { id } },
-        body
-      }),
-      this.at("PATCH", `/v1/api/tasks/${id}`)
-    ),
-    listComments: async (id) => unwrap(
-      await this.raw.GET("/v1/api/tasks/{id}/comments", {
-        params: { path: { id } }
-      }),
-      this.at("GET", `/v1/api/tasks/${id}/comments`)
-    ),
-    addComment: async (id, body) => unwrap(
-      await this.raw.POST("/v1/api/tasks/{id}/comments", {
-        params: { path: { id } },
-        body
-      }),
-      this.at("POST", `/v1/api/tasks/${id}/comments`)
-    ),
-    /** The verified review evidence — the same observation QA reviews. */
-    review: async (id) => unwrap(
-      await this.raw.GET("/v1/api/tasks/{id}/review", {
-        params: { path: { id } }
-      }),
-      this.at("GET", `/v1/api/tasks/${id}/review`)
-    ),
-    /** Live status frames. A terminal status closes the stream server-side. */
+    list: async (query) => unwrap(await this.raw.GET("/v1/api/tasks", { params: { query: query ?? {} } }), this.at("GET", "/v1/api/tasks")),
+    get: async (id) => unwrap(await this.raw.GET("/v1/api/tasks/{id}", { params: { path: { id } } }), this.at("GET", `/v1/api/tasks/${id}`)),
+    create: async (body) => unwrap(await this.raw.POST("/v1/api/tasks", { body }), this.at("POST", "/v1/api/tasks")),
+    update: async (id, body) => unwrap(await this.raw.PATCH("/v1/api/tasks/{id}", {
+      params: { path: { id } },
+      body
+    }), this.at("PATCH", `/v1/api/tasks/${id}`)),
+    listComments: async (id) => unwrap(await this.raw.GET("/v1/api/tasks/{id}/comments", {
+      params: { path: { id } }
+    }), this.at("GET", `/v1/api/tasks/${id}/comments`)),
+    addComment: async (id, body) => unwrap(await this.raw.POST("/v1/api/tasks/{id}/comments", {
+      params: { path: { id } },
+      body
+    }), this.at("POST", `/v1/api/tasks/${id}/comments`)),
+    review: async (id) => unwrap(await this.raw.GET("/v1/api/tasks/{id}/review", {
+      params: { path: { id } }
+    }), this.at("GET", `/v1/api/tasks/${id}/review`)),
     stream: (id, init) => this.stream(`/v1/api/tasks/${id}/stream`, init)
   };
+  modelConfig = {
+    setProjectHarness: async (projectId, harness) => unwrap(await this.raw.PUT("/v1/api/model-config/harness/{projectId}", {
+      params: { path: { projectId } },
+      body: { harness }
+    }), this.at("PUT", `/v1/api/model-config/harness/${projectId}`)),
+    clearProjectHarness: async (projectId) => unwrap(await this.raw.DELETE("/v1/api/model-config/harness/{projectId}", {
+      params: { path: { projectId } }
+    }), this.at("DELETE", `/v1/api/model-config/harness/${projectId}`)),
+    setHarness: async (harness) => unwrap(await this.raw.PUT("/v1/api/model-config/harness", { body: { harness } }), this.at("PUT", "/v1/api/model-config/harness")),
+    clearHarness: async () => unwrap(await this.raw.DELETE("/v1/api/model-config/harness"), this.at("DELETE", "/v1/api/model-config/harness")),
+    resolvedHarness: async () => unwrap(await this.raw.GET("/v1/api/model-config/harness/resolved"), this.at("GET", "/v1/api/model-config/harness/resolved")),
+    resolvedProjectHarness: async (projectId) => unwrap(await this.raw.GET("/v1/api/model-config/harness/{projectId}/resolved", {
+      params: { path: { projectId } }
+    }), this.at("GET", `/v1/api/model-config/harness/${projectId}/resolved`))
+  };
+  ai = {
+    models: async (workspaceId, init) => unwrap(await this.raw.GET("/v1/api/ai/w/{workspaceId}/models", {
+      params: { path: { workspaceId } },
+      ...init?.signal ? { signal: init.signal } : {}
+    }), this.at("GET", `/v1/api/ai/w/${workspaceId}/models`))
+  };
   cycles = {
-    list: async (query) => unwrap(
-      await this.raw.GET("/v1/api/cycles", {
-        params: { query: query ?? {} }
-      }),
-      this.at("GET", "/v1/api/cycles")
-    ),
-    get: async (id) => unwrap(
-      await this.raw.GET("/v1/api/cycles/{id}", {
-        params: { path: { id } }
-      }),
-      this.at("GET", `/v1/api/cycles/${id}`)
-    ),
-    /** Creation is a PROPOSAL — the orchestrator owns the roadmap. */
-    propose: async (body) => unwrap(
-      await this.raw.POST("/v1/api/cycles", { body }),
-      this.at("POST", "/v1/api/cycles")
-    ),
+    list: async (query) => unwrap(await this.raw.GET("/v1/api/cycles", {
+      params: { query: query ?? {} }
+    }), this.at("GET", "/v1/api/cycles")),
+    get: async (id) => unwrap(await this.raw.GET("/v1/api/cycles/{id}", {
+      params: { path: { id } }
+    }), this.at("GET", `/v1/api/cycles/${id}`)),
+    propose: async (body) => unwrap(await this.raw.POST("/v1/api/cycles", { body }), this.at("POST", "/v1/api/cycles")),
     stream: (id, init) => this.stream(`/v1/api/cycles/${id}/stream`, init)
   };
-  /**
-   * Invoices the agency issues to its own customer.
-   *
-   * NOT the hlix subscription — that is Polar's, and the two never meet.
-   *
-   * There is no `update`, because there is no route that could edit an issued
-   * invoice: a correction is `void` plus a new draft naming it through
-   * `replacesInvoiceId`. And `create` names no customer — the customer is
-   * derived from the billables being invoiced.
-   */
+  chat = {
+    send: async (body) => unwrap(await this.raw.POST("/v1/api/chat/turns", { body }), this.at("POST", "/v1/api/chat/turns")),
+    turn: async (turnId, scope) => unwrap(await this.raw.GET("/v1/api/chat/turns/{turnId}", {
+      params: { path: { turnId }, query: scope }
+    }), this.at("GET", `/v1/api/chat/turns/${turnId}`))
+  };
+  pendingRequests = {
+    list: async (query) => unwrap(await this.raw.GET("/v1/api/pending-requests", { params: { query: query ?? {} } }), this.at("GET", "/v1/api/pending-requests")),
+    resolve: async (id, body) => unwrap(await this.raw.POST("/v1/api/pending-requests/{id}/resolve", {
+      params: { path: { id } },
+      body
+    }), this.at("POST", `/v1/api/pending-requests/${id}/resolve`))
+  };
   clientInvoices = {
-    list: async (query) => unwrap(
-      await this.raw.GET("/v1/api/client-billing/invoices", {
-        params: { query: query ?? {} }
-      }),
-      this.at("GET", "/v1/api/client-billing/invoices")
-    ),
-    get: async (id) => unwrap(
-      await this.raw.GET("/v1/api/client-billing/invoices/{id}", {
-        params: { path: { id } }
-      }),
-      this.at("GET", `/v1/api/client-billing/invoices/${id}`)
-    ),
-    createDraft: async (body) => unwrap(
-      await this.raw.POST("/v1/api/client-billing/invoices", { body }),
-      this.at("POST", "/v1/api/client-billing/invoices")
-    ),
-    /** The number is assigned by the server, gapless per workspace. */
-    issue: async (id) => unwrap(
-      await this.raw.POST("/v1/api/client-billing/invoices/{id}/issue", {
-        params: { path: { id } },
-        body: {}
-      }),
-      this.at("POST", `/v1/api/client-billing/invoices/${id}/issue`)
-    ),
-    void: async (id, reason) => unwrap(
-      await this.raw.POST("/v1/api/client-billing/invoices/{id}/void", {
-        params: { path: { id } },
-        body: { reason }
-      }),
-      this.at("POST", `/v1/api/client-billing/invoices/${id}/void`)
-    ),
-    pay: async (id) => unwrap(
-      await this.raw.POST("/v1/api/client-billing/invoices/{id}/pay", {
-        params: { path: { id } },
-        body: {}
-      }),
-      this.at("POST", `/v1/api/client-billing/invoices/${id}/pay`)
-    ),
-    /**
-     * Open a PROVIDER-HOSTED checkout. Returns a URL and nothing else — no card
-     * field and no payment credential ever passes through hlix or this client.
-     * It does not mark the invoice paid: that happens only when the provider's
-     * signed webhook reconciles.
-     */
-    paymentLink: async (id, body = {}) => unwrap(
-      await this.raw.POST(
-        "/v1/api/client-billing/invoices/{id}/payment-link",
-        { params: { path: { id } }, body }
-      ),
-      this.at("POST", `/v1/api/client-billing/invoices/${id}/payment-link`)
-    )
+    list: async (query) => unwrap(await this.raw.GET("/v1/api/client-billing/invoices", {
+      params: { query: query ?? {} }
+    }), this.at("GET", "/v1/api/client-billing/invoices")),
+    get: async (id) => unwrap(await this.raw.GET("/v1/api/client-billing/invoices/{id}", {
+      params: { path: { id } }
+    }), this.at("GET", `/v1/api/client-billing/invoices/${id}`)),
+    createDraft: async (body) => unwrap(await this.raw.POST("/v1/api/client-billing/invoices", { body }), this.at("POST", "/v1/api/client-billing/invoices")),
+    issue: async (id) => unwrap(await this.raw.POST("/v1/api/client-billing/invoices/{id}/issue", {
+      params: { path: { id } },
+      body: {}
+    }), this.at("POST", `/v1/api/client-billing/invoices/${id}/issue`)),
+    void: async (id, reason) => unwrap(await this.raw.POST("/v1/api/client-billing/invoices/{id}/void", {
+      params: { path: { id } },
+      body: { reason }
+    }), this.at("POST", `/v1/api/client-billing/invoices/${id}/void`)),
+    pay: async (id) => unwrap(await this.raw.POST("/v1/api/client-billing/invoices/{id}/pay", {
+      params: { path: { id } },
+      body: {}
+    }), this.at("POST", `/v1/api/client-billing/invoices/${id}/pay`)),
+    paymentLink: async (id, body = {}) => unwrap(await this.raw.POST("/v1/api/client-billing/invoices/{id}/payment-link", { params: { path: { id } }, body }), this.at("POST", `/v1/api/client-billing/invoices/${id}/payment-link`))
   };
-  /**
-   * Consume any `text/event-stream` route.
-   *
-   * Deliberately NOT routed through the typed client: `openapi-fetch` parses
-   * the body, and a stream must not be parsed — it has to be read as it
-   * arrives. Retry does not apply either; a stream that drops mid-flight has
-   * already delivered events, and silently restarting it would replay them.
-   */
-  async *stream(path, init) {
+  async* observeAgent(projectId, agentId, init) {
+    const path = `/v1/api/projects/${projectId}/agents/${agentId}/observe`;
+    for await (const event of this.stream(path, init)) {
+      const frame = parseObserveFrame(event.data);
+      if (!frame)
+        continue;
+      yield frame;
+      if (isTerminalObserveFrame(frame))
+        return;
+    }
+  }
+  async* watchRevisions(projectId, init) {
+    const path = `/v1/api/projects/${projectId}/revisions/watch`;
+    const signal = init?.signal;
+    let delay = WATCH_RECONNECT.firstDelayMs;
+    while (!signal?.aborted) {
+      try {
+        for await (const event of this.stream(path, init)) {
+          const frame = parseRevisionWatchFrame(event.data);
+          if (!frame)
+            continue;
+          if (frame.kind === "ready")
+            delay = WATCH_RECONNECT.firstDelayMs;
+          yield frame;
+        }
+      } catch (error) {
+        if (signal?.aborted)
+          return;
+        if (isPermanentWatchFailure(error))
+          throw error;
+      }
+      await pause(delay, signal);
+      delay = Math.min(delay * 2, WATCH_RECONNECT.maxDelayMs);
+    }
+  }
+  async* stream(path, init) {
     const url = `${this.baseUrl}${path}`;
     const request = new Request(url, {
       headers: { ...this.headers, accept: "text/event-stream" },
@@ -666,7 +833,7 @@ var Hlix = class {
     }
     yield* parseSseStream(response.body, init?.signal);
   }
-};
+}
 function createHlix(options) {
   return new Hlix(options);
 }
@@ -686,8 +853,13 @@ export {
   HlixValidationError,
   IDEMPOTENT_METHODS,
   apiKeyCredential,
+  bearerCredential,
   createHlix,
   isIdempotent,
+  isTerminalObserveFrame,
+  parseObserveFrame,
+  parseRevisionWatchFrame,
   parseSseStream,
+  pause,
   sessionCredential
 };