@nema-project/nema 0.0.0-stage → 0.1.4

package/dist/direct/transport.d.ts

@@ -0,0 +1,177 @@
+import type { StoredAuth } from "./authStore.js";
+export type InputTextPart = {
+    type: "input_text";
+    text: string;
+};
+export type OutputTextPart = {
+    type: "output_text";
+    text: string;
+    annotations?: unknown[];
+};
+export type SummaryTextPart = {
+    type: "summary_text";
+    text: string;
+};
+/** Typed content parts only: the backend rejects string `content`. */
+export type InputItem = {
+    type: "message";
+    role: "user" | "developer" | "system";
+    content: InputTextPart[];
+} | {
+    type: "message";
+    role: "assistant";
+    content: OutputTextPart[];
+    id?: string;
+    status?: "completed";
+} | {
+    type: "function_call";
+    call_id: string;
+    name: string;
+    arguments: string;
+    id?: string;
+} | {
+    type: "function_call_output";
+    call_id: string;
+    output: string;
+} | {
+    type: "reasoning";
+    summary: SummaryTextPart[];
+    encrypted_content?: string | null;
+    id?: string;
+};
+export type FunctionTool = {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: Record<string, unknown>;
+};
+export type OutputMessage = {
+    type: "message";
+    role: "assistant";
+    content: Array<OutputTextPart | {
+        type: string;
+        [k: string]: unknown;
+    }>;
+    id?: string;
+    status?: string;
+};
+export type OutputFunctionCall = {
+    type: "function_call";
+    call_id: string;
+    name: string;
+    arguments: string;
+    id?: string;
+    status?: string;
+};
+export type OutputReasoning = {
+    type: "reasoning";
+    summary?: SummaryTextPart[];
+    encrypted_content?: string | null;
+    id?: string;
+};
+/** Items are passed through as the server sent them; other item types keep their raw shape. */
+export type OutputItem = OutputMessage | OutputFunctionCall | OutputReasoning | {
+    type: string;
+    [k: string]: unknown;
+};
+export declare const isFunctionCall: (i: OutputItem) => i is OutputFunctionCall;
+export declare const isMessage: (i: OutputItem) => i is OutputMessage;
+/** Concatenated `output_text` of all message items. */
+export declare const outputText: (items: OutputItem[]) => string;
+export type ResponsesRequest = {
+    model: string;
+    instructions: string;
+    input: InputItem[];
+    tools: FunctionTool[];
+    reasoning: {
+        effort: string;
+        summary: "auto";
+    };
+    sessionId: string;
+};
+export type CollectedResponse = {
+    status: "completed" | "incomplete";
+    items: OutputItem[];
+    incompleteReason?: string;
+};
+/** Anything that can hand the transport a bearer token. AuthStore and CodexFileTokenSource both qualify. */
+export type TokenSource = {
+    getAccessToken(opts?: {
+        force?: boolean;
+        rejectedAccessToken?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        accessToken: string;
+        auth: StoredAuth;
+    }>;
+    recordAuthError(reason: {
+        code: string;
+        message: string;
+    }, forAuth: StoredAuth): Promise<void>;
+};
+export type TransportProfile = {
+    baseUrl: string;
+    extraHeaders(auth: StoredAuth): Record<string, string>;
+    modelsPath: string;
+    /** Whether a 401 should force one token refresh. Defaults to true. */
+    refreshOn401?: boolean;
+    /** Tried once when modelsPath answers HTTP 400 (Codex catalog: client_version 99.0.0 then 0.0.0). */
+    modelsPathFallback?: string;
+    parseModels(json: unknown): string[];
+};
+/** [MODELS]: public API base, `GET /models`, keep `visibility === "list"` slugs in server order. */
+export declare const SIWC_PROFILE: TransportProfile;
+export declare const BYOK_PROFILE: TransportProfile;
+/**
+ * Hermes Codex route: `POST https://chatgpt.com/backend-api/codex/responses` with the Codex CLI's
+ * access token. Hidden catalog rows are dropped; the rest sort by (priority, slug). Identity stays
+ * `nema-room` — this does not impersonate the Codex CLI.
+ */
+export declare const COMPAT_PROFILE: TransportProfile;
+export type TransportContext = {
+    auth: TokenSource;
+    profile: TransportProfile;
+    /** Nema CLI version for `User-Agent: NemaRoom/<version>`. */
+    version: string;
+    signal: AbortSignal;
+    /** Delay before the single network/5xx retry (default 1000 ms). */
+    retryDelayMs?: number;
+};
+/** Codes meaning the plan's usage is exhausted or unavailable (HTTP body or inside response.failed / error). */
+export declare const QUOTA_CODES: readonly ["usage_limit_reached", "usage_limit_exceeded", "subscription_sharing_usage_limit_exceeded", "usage_not_included", "insufficient_quota", "subscription_sharing_usage_unavailable"];
+export declare class ModelQuotaError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    /** When usage resets, epoch milliseconds — only if the server said so. */
+    readonly resetsAt?: number;
+    constructor(o: {
+        status?: number;
+        code?: string;
+        message?: string;
+        resetsAt?: number;
+    });
+}
+export declare class ModelApiError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    constructor(o: {
+        status?: number;
+        code?: string;
+        message: string;
+    }, options?: ErrorOptions);
+}
+export declare class ByokRejectedError extends Error {
+    constructor();
+}
+/** The account's listed models. A 400 on modelsPath retries modelsPathFallback once (Codex catalog versions). */
+export declare function listModels(ctx: TransportContext): Promise<string[]>;
+/**
+ * One streaming Responses call. Text deltas go to `onTextDelta` as they arrive; the result is assembled from
+ * `response.output_item.done` items. Throws ModelQuotaError / ModelApiError / ReloginRequiredError (and the
+ * AuthStore's AuthRateLimitedError / TransientAuthError); an abort rejects with the signal's reason.
+ * A stream that breaks after it opened is not retried (deltas may already have been delivered).
+ */
+export declare function streamResponse(req: ResponsesRequest, ctx: TransportContext & {
+    onTextDelta?: (t: string) => void;
+}): Promise<CollectedResponse>;

package/dist/direct/transport.js

@@ -0,0 +1,437 @@
+// direct/transport.js
+import { DEFAULT_BYOK_BASE_URL } from "../config.js";
+import { ReloginRequiredError } from "./authStore.js";
+import { codexAccountHeaders } from "./codexLogin.js";
+import { SIWC } from "./siwc.js";
+var isFunctionCall = (i) => i.type === "function_call";
+var isMessage = (i) => i.type === "message";
+var outputText = (items) => items.filter(isMessage).flatMap((m) => Array.isArray(m.content) ? m.content : []).map((p) => p.type === "output_text" && typeof p.text === "string" ? p.text : "").join("");
+var SIWC_PROFILE = {
+  baseUrl: SIWC.apiBase,
+  extraHeaders: () => ({}),
+  modelsPath: "/models",
+  parseModels(json) {
+    const models = json && typeof json === "object" ? json.models : void 0;
+    if (!Array.isArray(models))
+      throw new ModelApiError({ message: "\u6A21\u578B\u5217\u8868\u54CD\u5E94\u7F3A\u5C11 models \u6570\u7EC4" });
+    return models.filter((m) => !!m && typeof m === "object" && m.visibility === "list").map((m) => m.slug).filter((s) => typeof s === "string" && s !== "");
+  }
+};
+var BYOK_PROFILE = {
+  baseUrl: DEFAULT_BYOK_BASE_URL,
+  extraHeaders: () => ({}),
+  modelsPath: "/models",
+  refreshOn401: false,
+  parseModels: SIWC_PROFILE.parseModels
+};
+var COMPAT_PROFILE = {
+  baseUrl: "https://chatgpt.com/backend-api/codex",
+  extraHeaders: (auth) => codexAccountHeaders(auth.tokens.access_token),
+  modelsPath: "/models?client_version=99.0.0",
+  modelsPathFallback: "/models?client_version=0.0.0",
+  parseModels(json) {
+    const models = json && typeof json === "object" ? json.models : void 0;
+    if (!Array.isArray(models))
+      throw new ModelApiError({ message: "\u6A21\u578B\u5217\u8868\u54CD\u5E94\u7F3A\u5C11 models \u6570\u7EC4" });
+    const rows = [];
+    for (const item of models) {
+      if (!item || typeof item !== "object")
+        continue;
+      const m = item;
+      if (typeof m.slug !== "string" || m.slug.trim() === "")
+        continue;
+      const visibility = typeof m.visibility === "string" ? m.visibility.trim().toLowerCase() : "";
+      if (visibility === "hide" || visibility === "hidden")
+        continue;
+      const rank = typeof m.priority === "number" && Number.isFinite(m.priority) ? Math.trunc(m.priority) : 1e4;
+      rows.push({ rank, slug: m.slug.trim() });
+    }
+    rows.sort((a, b) => a.rank - b.rank || (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0));
+    const seen = /* @__PURE__ */ new Set();
+    const slugs = [];
+    for (const row of rows) {
+      if (seen.has(row.slug))
+        continue;
+      seen.add(row.slug);
+      slugs.push(row.slug);
+    }
+    return slugs;
+  }
+};
+var QUOTA_CODES = [
+  "usage_limit_reached",
+  "usage_limit_exceeded",
+  "subscription_sharing_usage_limit_exceeded",
+  "usage_not_included",
+  "insufficient_quota",
+  "subscription_sharing_usage_unavailable"
+];
+var ModelQuotaError = class extends Error {
+  status;
+  code;
+  /** When usage resets, epoch milliseconds — only if the server said so. */
+  resetsAt;
+  constructor(o) {
+    super(`\u8BA2\u9605\u989D\u5EA6\u4E0D\u53EF\u7528\uFF08${describe(o.status, o.code)}\uFF09${o.message ? `\uFF1A${o.message}` : ""}`);
+    this.name = "ModelQuotaError";
+    this.status = o.status;
+    this.code = o.code;
+    this.resetsAt = o.resetsAt;
+  }
+};
+var ModelApiError = class extends Error {
+  status;
+  code;
+  constructor(o, options) {
+    super(o.message, options);
+    this.name = "ModelApiError";
+    this.status = o.status;
+    this.code = o.code;
+  }
+};
+var ByokRejectedError = class extends Error {
+  constructor() {
+    super("API key \u88AB\u62D2\u7EDD\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C nema auth byok");
+    this.name = "ByokRejectedError";
+  }
+};
+function describe(status, code) {
+  return [status !== void 0 ? `HTTP ${status}` : "", code ?? ""].filter(Boolean).join(" ") || "\u672A\u77E5\u9519\u8BEF";
+}
+function parseErrorObject(o, now) {
+  if (!o || typeof o !== "object")
+    return {};
+  const body = o;
+  const nested = body.error && typeof body.error === "object" ? body.error : void 0;
+  const src = nested ?? body;
+  const str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+  const code = str(src.code) ?? str(src.type) ?? (typeof body.error === "string" ? body.error : void 0);
+  const message = str(src.message) ?? str(body.detail) ?? str(body.message);
+  let resetsAt;
+  const ra = src.resets_at ?? body.resets_at;
+  const rin = src.resets_in_seconds ?? body.resets_in_seconds;
+  if (typeof ra === "number" && Number.isFinite(ra) && ra > 0)
+    resetsAt = ra > 1e12 ? ra : ra * 1e3;
+  else if (typeof rin === "number" && Number.isFinite(rin) && rin >= 0)
+    resetsAt = now + rin * 1e3;
+  return { code, message, param: str(src.param), resetsAt };
+}
+function toError(p) {
+  if (p.code && QUOTA_CODES.includes(p.code)) {
+    return new ModelQuotaError({ status: p.status, code: p.code, message: p.message, resetsAt: p.resetsAt });
+  }
+  const detail = [p.message, p.param ? `param=${p.param}` : "", p.requestId ? `request id ${p.requestId}` : ""].filter(Boolean).join("\uFF1B");
+  return new ModelApiError({ status: p.status, code: p.code, message: `${describe(p.status, p.code)}${detail ? `\uFF1A${detail}` : ""}` });
+}
+async function httpError(res) {
+  let parsed = {};
+  const text = await res.text().catch(() => "");
+  try {
+    parsed = parseErrorObject(JSON.parse(text), Date.now());
+  } catch {
+    if (text.trim())
+      parsed = { message: text.trim().slice(0, 300) };
+  }
+  return { ...parsed, status: res.status, requestId: res.headers.get("x-request-id") ?? void 0 };
+}
+var errMessage = (e) => e instanceof Error ? e.message : String(e);
+function connectionMessage(e) {
+  const code = e?.cause?.code;
+  return typeof code === "string" && /^[A-Z0-9_]+$/.test(code) ? `\u65E0\u6CD5\u8FDE\u63A5\u6A21\u578B\u63A5\u53E3\uFF08${code}\uFF09` : "\u65E0\u6CD5\u8FDE\u63A5\u6A21\u578B\u63A5\u53E3";
+}
+function sleep(ms, signal) {
+  if (ms <= 0)
+    return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function send(ctx, url, init) {
+  let { accessToken, auth } = await ctx.auth.getAccessToken({ signal: ctx.signal });
+  let authRetried = false;
+  let transientRetried = false;
+  for (; ; ) {
+    ctx.signal.throwIfAborted();
+    const headers = {
+      ...ctx.profile.extraHeaders(auth),
+      Authorization: `Bearer ${accessToken}`,
+      originator: SIWC.originator,
+      "User-Agent": `NemaRoom/${ctx.version}`
+    };
+    let res;
+    try {
+      res = await fetch(url, { ...init(headers), signal: ctx.signal });
+    } catch (e) {
+      if (ctx.signal.aborted)
+        throw e;
+      if (!transientRetried) {
+        transientRetried = true;
+        await sleep(ctx.retryDelayMs ?? 1e3, ctx.signal);
+        continue;
+      }
+      throw new ModelApiError({ message: connectionMessage(e) }, { cause: e });
+    }
+    if (res.ok)
+      return res;
+    ctx.signal.throwIfAborted();
+    if (res.status === 401) {
+      if (ctx.profile.refreshOn401 === false)
+        throw new ByokRejectedError();
+      const err2 = await httpError(res);
+      if (authRetried) {
+        await ctx.auth.recordAuthError({ code: "model_unauthorized", message: `\u6A21\u578B\u63A5\u53E3\u4ECD\u8FD4\u56DE 401\uFF08${err2.code ?? "unauthorized"}\uFF09` }, auth);
+        throw new ReloginRequiredError(err2.code ?? "unauthorized");
+      }
+      authRetried = true;
+      ({ accessToken, auth } = await ctx.auth.getAccessToken({ force: true, rejectedAccessToken: accessToken, signal: ctx.signal }));
+      continue;
+    }
+    const err = toError(await httpError(res));
+    if (err instanceof ModelQuotaError)
+      throw err;
+    if (res.status >= 500 && !transientRetried) {
+      transientRetried = true;
+      await sleep(ctx.retryDelayMs ?? 1e3, ctx.signal);
+      continue;
+    }
+    throw err;
+  }
+}
+async function listModelsAt(ctx, modelsPath) {
+  const res = await send(ctx, `${ctx.profile.baseUrl}${modelsPath}`, (h) => ({ method: "GET", headers: { ...h, Accept: "application/json" } }));
+  let body;
+  try {
+    body = await res.json();
+  } catch (e) {
+    throw new ModelApiError({ status: res.status, message: `\u6A21\u578B\u5217\u8868\u54CD\u5E94\u4E0D\u662F JSON\uFF1A${errMessage(e)}` }, { cause: e });
+  }
+  return ctx.profile.parseModels(body);
+}
+async function listModels(ctx) {
+  try {
+    return await listModelsAt(ctx, ctx.profile.modelsPath);
+  } catch (e) {
+    if (ctx.profile.modelsPathFallback && e instanceof ModelApiError && e.status === 400) {
+      return await listModelsAt(ctx, ctx.profile.modelsPathFallback);
+    }
+    throw e;
+  }
+}
+function requestBody(req) {
+  return {
+    model: req.model,
+    instructions: req.instructions,
+    input: req.input,
+    store: false,
+    stream: true,
+    // Omitted when empty (research §3: the backend wants no empty tools array).
+    ...req.tools.length > 0 ? { tools: req.tools, tool_choice: "auto", parallel_tool_calls: false } : {},
+    reasoning: req.reasoning,
+    include: ["reasoning.encrypted_content"]
+  };
+}
+var Assembler = class {
+  onTextDelta;
+  seq = 0;
+  done = [];
+  pending = [];
+  constructor(onTextDelta) {
+    this.onTextDelta = onTextDelta;
+  }
+  findPending(ev) {
+    const id = typeof ev.item_id === "string" ? ev.item_id : void 0;
+    const idx = typeof ev.output_index === "number" ? ev.output_index : void 0;
+    return this.pending.find((p) => !p.done && (id !== void 0 && p.item.id === id || id === void 0 && idx !== void 0 && p.outputIndex === idx));
+  }
+  /** Returns the final result on a terminal event; throws on failure events. */
+  handle(ev) {
+    const idx = typeof ev.output_index === "number" ? ev.output_index : void 0;
+    switch (ev.type) {
+      case "response.output_text.delta":
+        if (typeof ev.delta === "string" && ev.delta !== "")
+          this.onTextDelta?.(ev.delta);
+        return null;
+      case "response.output_item.added": {
+        const item = ev.item;
+        if (item && item.type === "function_call") {
+          this.pending.push({ item, outputIndex: idx, seq: this.seq++, args: typeof item.arguments === "string" ? item.arguments : "", done: false });
+        }
+        return null;
+      }
+      case "response.function_call_arguments.delta": {
+        const p = this.findPending(ev);
+        if (p && typeof ev.delta === "string")
+          p.args += ev.delta;
+        return null;
+      }
+      case "response.function_call_arguments.done": {
+        const p = this.findPending(ev);
+        if (p && typeof ev.arguments === "string")
+          p.args = ev.arguments;
+        return null;
+      }
+      case "response.output_item.done": {
+        const item = ev.item;
+        if (!item || typeof item !== "object" || typeof item.type !== "string")
+          return null;
+        const p = this.pending.find((x) => !x.done && (typeof item.id === "string" && x.item.id === item.id || item.id === void 0 && idx !== void 0 && x.outputIndex === idx));
+        if (p)
+          p.done = true;
+        this.done.push({ item, outputIndex: idx, seq: p?.seq ?? this.seq++ });
+        return null;
+      }
+      case "response.completed":
+      case "response.incomplete": {
+        const response = ev.response ?? {};
+        const items = this.items(response.output);
+        if (ev.type === "response.incomplete") {
+          const details = response.incomplete_details;
+          return { status: "incomplete", items, incompleteReason: typeof details?.reason === "string" ? details.reason : "incomplete" };
+        }
+        if (!items.some((i) => i.type === "message" || i.type === "function_call")) {
+          return { status: "incomplete", items, incompleteReason: items.some((i) => i.type === "reasoning") ? "reasoning_only" : "empty_output" };
+        }
+        return { status: "completed", items };
+      }
+      case "response.failed": {
+        const response = ev.response ?? {};
+        const p = parseErrorObject({ error: response.error ?? {} }, Date.now());
+        throw toError({ ...p, code: p.code ?? "unknown_error", status: statusForCode(p.code) });
+      }
+      case "error": {
+        const p = parseErrorObject(ev, Date.now());
+        throw toError({ ...p, code: p.code ?? "unknown_error", status: statusForCode(p.code) });
+      }
+      default:
+        return null;
+    }
+  }
+  items(fallbackOutput) {
+    const entries = [...this.done];
+    for (const p of this.pending) {
+      if (!p.done)
+        entries.push({ item: { ...p.item, arguments: p.args }, outputIndex: p.outputIndex, seq: p.seq });
+    }
+    if (entries.length === 0 && Array.isArray(fallbackOutput)) {
+      return fallbackOutput.filter((i) => !!i && typeof i === "object" && typeof i.type === "string");
+    }
+    const byIndex = entries.every((e) => e.outputIndex !== void 0);
+    entries.sort((a, b) => byIndex ? a.outputIndex - b.outputIndex || a.seq - b.seq : a.seq - b.seq);
+    return entries.map((e) => e.item);
+  }
+};
+function statusForCode(code) {
+  switch (code) {
+    case "subscription_sharing_usage_limit_exceeded":
+    case "usage_limit_reached":
+    case "usage_not_included":
+    case "insufficient_quota":
+      return 429;
+    case "subscription_sharing_usage_unavailable":
+    case "subscription_sharing_user_unavailable":
+      return 503;
+    case "subscription_sharing_unsupported_capability":
+      return 400;
+    default:
+      return void 0;
+  }
+}
+function parseFrame(block) {
+  let event;
+  const data = [];
+  for (const line of block.split("\n")) {
+    if (line === "" || line.startsWith(":"))
+      continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+    if (field === "event")
+      event = value;
+    else if (field === "data")
+      data.push(value);
+  }
+  const raw = data.join("\n");
+  if (raw === "" || raw === "[DONE]")
+    return null;
+  let ev;
+  try {
+    ev = JSON.parse(raw);
+  } catch {
+    throw new ModelApiError({ message: `\u65E0\u6CD5\u89E3\u6790\u6A21\u578B\u4E8B\u4EF6\u6D41\uFF1A${raw.slice(0, 120)}` });
+  }
+  if (!ev || typeof ev !== "object")
+    return null;
+  const o = ev;
+  if (typeof o.type !== "string" && event)
+    o.type = event;
+  return o;
+}
+async function streamResponse(req, ctx) {
+  const body = JSON.stringify(requestBody(req));
+  const res = await send(ctx, `${ctx.profile.baseUrl}/responses`, (h) => ({
+    method: "POST",
+    headers: { ...h, "Content-Type": "application/json", Accept: "text/event-stream", session_id: req.sessionId },
+    body
+  }));
+  if (!res.body)
+    throw new ModelApiError({ status: res.status, message: "\u6A21\u578B\u63A5\u53E3\u8FD4\u56DE\u4E86\u7A7A\u7684\u54CD\u5E94\u6D41" });
+  const asm = new Assembler(ctx.onTextDelta);
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (e) {
+        if (ctx.signal.aborted)
+          throw ctx.signal.reason ?? e;
+        throw new ModelApiError({ message: `\u6A21\u578B\u4E8B\u4EF6\u6D41\u4E2D\u65AD\uFF1A${errMessage(e)}` }, { cause: e });
+      }
+      if (chunk.value)
+        buf = (buf + decoder.decode(chunk.value, { stream: true })).replace(/\r\n/g, "\n");
+      if (chunk.done)
+        buf = (buf + decoder.decode()).replace(/\r\n?/g, "\n") + "\n\n";
+      let at;
+      while ((at = buf.indexOf("\n\n")) !== -1) {
+        const block = buf.slice(0, at);
+        buf = buf.slice(at + 2);
+        const ev = parseFrame(block);
+        if (!ev)
+          continue;
+        const result = asm.handle(ev);
+        if (result)
+          return result;
+      }
+      if (chunk.done)
+        break;
+    }
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+  throw new ModelApiError({ code: "stream_ended", message: "\u6A21\u578B\u4E8B\u4EF6\u6D41\u5728 response.completed \u4E4B\u524D\u7ED3\u675F" });
+}
+export {
+  BYOK_PROFILE,
+  ByokRejectedError,
+  COMPAT_PROFILE,
+  ModelApiError,
+  ModelQuotaError,
+  QUOTA_CODES,
+  SIWC_PROFILE,
+  isFunctionCall,
+  isMessage,
+  listModels,
+  outputText,
+  streamResponse
+};

package/dist/doctor.d.ts

@@ -0,0 +1,28 @@
+import type { NemaConfig } from "./config.js";
+import { type GraphifyOpts } from "./repos/graphify.js";
+export type DoctorCheck = {
+    name: string;
+    ok: boolean;
+    detail: string;
+};
+export type DoctorOpts = {
+    codexBin: string;
+    userCodexHome: string;
+    hubUrl: string;
+    tokenFile: string;
+    /** Where Nema's own direct login lives (`<nemaHome>/auth.json`). */
+    nemaHome: string;
+    /** The configured adapter: a missing login only fails the check when this is codex-direct. */
+    adapter: NemaConfig["adapter"];
+    /** Defaults to siwc. compat reads the Codex CLI login instead of ~/.nema/auth.json. */
+    authMode?: NemaConfig["authMode"];
+    model?: NemaConfig["model"];
+    /** For tests: production passes nothing and runs `graphify` from PATH. */
+    graphify?: GraphifyOpts;
+    /** Home dir holding ~/.claude and ~/.codex for the report-hook rows. Defaults to os.homedir(). */
+    agentHome?: string;
+    /** For tests: production runs `github-mcp-server` from PATH. */
+    githubMcpServerBin?: string;
+};
+export declare function defaultTokenFile(env?: NodeJS.ProcessEnv): string;
+export declare function runDoctor(opts: DoctorOpts): Promise<DoctorCheck[]>;