neagen 0.1.0 → 0.1.2

package/lib/ansi.mjs

@@ -0,0 +1,2 @@
+export const dim = (text) => `\x1b[2m${text}\x1b[0m`;
+export const bold = (text) => `\x1b[1m${text}\x1b[0m`;

package/lib/api.mjs

@@ -1,5 +1,4 @@
 const DEFAULT_TIMEOUT_MS = 8_000;
-
 export async function probeHost(host) {
   const res = await fetch(`${host}/eve/v1/health`, {
     signal: AbortSignal.timeout(5_000),
@@ -8,7 +7,7 @@ export async function probeHost(host) {
   return true;
 }
 
-export async function apiFetch(host, path, { token, method = "GET", body } = {}) {
+export async function apiFetch(host, path, { token, method = "GET", body, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
   const res = await fetch(`${host}${path}`, {
     method,
     headers: {
@@ -16,12 +15,24 @@ export async function apiFetch(host, path, { token, method = "GET", body } = {})
       ...(body ? { "content-type": "application/json" } : {}),
     },
     body: body ? JSON.stringify(body) : undefined,
-    signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+    signal: AbortSignal.timeout(timeoutMs),
   });
   const data = await res.json().catch(() => null);
   return { res, data };
 }
 
+function apiErrorMessage(res, data) {
+  const serverMessage = data?.error?.message;
+  if (serverMessage) return serverMessage;
+  return `HTTP ${res.status}`;
+}
+
+export async function apiRequest(host, path, { token, method = "GET", body, timeoutMs } = {}) {
+  const { res, data } = await apiFetch(host, path, { token, method, body, timeoutMs });
+  if (!res.ok) throw new Error(apiErrorMessage(res, data));
+  return data;
+}
+
 /** Resolve owner identity — /api/me when deployed, else Ably token clientId. */
 export async function resolveIdentity(host, token) {
   const me = await apiFetch(host, "/api/me", { token });
@@ -54,3 +65,20 @@ export async function resolveIdentity(host, token) {
       : (ably.data?.error?.message ?? `identity check failed (${ably.res.status})`),
   );
 }
+
+export async function getSelectedModel(host, token) {
+  return apiRequest(host, "/api/models/selection", { token });
+}
+
+export async function selectModel(host, token, modelId) {
+  return apiRequest(host, "/api/models/selection", {
+    token,
+    method: "PATCH",
+    body: { modelId },
+  });
+}
+
+export async function listModels(host, token) {
+  const data = await apiRequest(host, "/api/models", { token });
+  return data?.models ?? [];
+}

package/lib/device-login.mjs

@@ -4,8 +4,8 @@
 // approval page (${host}/device), and polls ${host}/api/auth/device/token until
 // the Owner approves. The grant only ever mints a session for an ALREADY-EXISTING
 // account — it can never create one — so a brand-new user must first create their
-// account on the web (the /device page bounces them to sign-up). Passkey stays the
-// identity root.
+// account on the web (the /device page bounces them to sign-in; first-timers toggle
+// to sign-up on that screen). Passkey stays the identity root.
 
 import { execFile } from "node:child_process";
 import { saveCreds } from "./creds.mjs";
@@ -85,10 +85,12 @@ export async function runDeviceGrantLogin({ host, profile, renderer }) {
 
     ui.renderLine(`Your code:  ${code.user_code}`, "info");
     ui.renderLine(code.verification_uri_complete, "info");
-    ui.renderLine("Opening your browser — approve with your passkey…", "info");
+    ui.renderLine("Opening your browser — create or sign in, then approve…", "info");
     // Mirror to stderr so login is never silent if the panel hasn't painted yet.
     console.error(
-      `\n  Your code:   ${code.user_code}\n  Approve at:  ${code.verification_uri_complete}\n`,
+      `\n  Your code:   ${code.user_code}\n  Approve at:  ${code.verification_uri_complete}\n\n` +
+        `  Returning? Sign in with your passkey on that page, then approve this device.\n` +
+        `  First time? Switch to create your Neagen on that page. Use the same browser throughout.\n`,
     );
     openBrowser(code.verification_uri_complete);
 

package/lib/eve-chat.mjs

@@ -0,0 +1,224 @@
+import { Client } from "eve/client";
+import {
+  createTurnStatusSpinner,
+  createTurnStreamRenderer,
+  readTurnSseStream,
+} from "./turn-stream.mjs";
+
+export function createEveClient(host, token) {
+  return new Client({
+    host,
+    auth: { bearer: token },
+    preserveCompletedSessions: true,
+    redirect: "manual",
+  });
+}
+
+export function summarizeResult(result) {
+  const neagenBody = cleanReply(result?.neagenMessage?.body);
+  if (neagenBody) return neagenBody;
+  const message = cleanReply(result?.message);
+  if (message) return message;
+  if (result?.runtimeStatus === "waiting") return "(waiting)";
+  if (result?.status) return `(${result.status})`;
+  return "(no reply)";
+}
+
+function cleanReply(value) {
+  if (typeof value !== "string") return undefined;
+  const text = value.trim();
+  if (!text || text === "undefined" || text === "null") return undefined;
+  return text;
+}
+
+export function requestToolName(request) {
+  return request?.action?.toolName ?? "input";
+}
+
+function preview(value) {
+  if (typeof value !== "string") return undefined;
+  return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+}
+
+export function formatRequestDetails(request) {
+  const input = request?.action?.input;
+  if (!input || typeof input !== "object") return "";
+  const parts = [];
+  if (typeof input.to === "string") parts.push(`to: ${input.to}`);
+  if (typeof input.path === "string") parts.push(`path: ${input.path}`);
+  if (typeof input.draftId === "string") parts.push(`draft: ${input.draftId}`);
+  const body = preview(input.body);
+  if (body !== undefined) parts.push(`body: ${JSON.stringify(body)}`);
+  return parts.join(", ");
+}
+
+export function pickOption(request, approved) {
+  const options = request?.options ?? [];
+  const pattern = approved ? /approve|allow|yes|confirm/i : /deny|reject|no|cancel/i;
+  return (
+    options.find((option) => pattern.test(`${option.id} ${option.label}`)) ??
+    options[approved ? 0 : options.length - 1]
+  );
+}
+
+export function approvalResponse(request, approved) {
+  const option = pickOption(request, approved);
+  return { requestId: request.requestId, optionId: option?.id ?? (approved ? "approve" : "deny") };
+}
+
+export function questionResponse(request, answer) {
+  const value = answer.trim();
+  const numeric = Number(value);
+  const option = Number.isInteger(numeric) ? request.options?.[numeric - 1] : undefined;
+  if (option) return { requestId: request.requestId, optionId: option.id };
+
+  const byText = request.options?.find((entry) => {
+    const haystack = `${entry.id} ${entry.label}`.toLowerCase();
+    return haystack === value.toLowerCase() || entry.label.toLowerCase() === value.toLowerCase();
+  });
+  if (byText) return { requestId: request.requestId, optionId: byText.id };
+
+  return { requestId: request.requestId, text: answer };
+}
+
+export function wakeSyncPrompt(event) {
+  return (
+    `[mail] You just received new mail (${event.kind === "message" ? "a text message" : "a file"}) from a connection. ` +
+    "Call sync_inbox once to fetch it, then tell me in one short line who it is from and what it is."
+  );
+}
+
+export async function settleInputRequests(result, session, handlers) {
+  let settled = result;
+  while ((settled.inputRequests?.length ?? 0) > 0) {
+    const request = settled.inputRequests[0];
+    const response =
+      requestToolName(request) === "ask_question"
+        ? questionResponse(request, await handlers.askQuestion(request))
+        : approvalResponse(request, await handlers.askApproval(request));
+
+    const resumed = await session.send({ inputResponses: [response] });
+    settled = await resumed.result();
+  }
+  return settled;
+}
+
+export async function sendEveTurn(session, message, options = {}) {
+  const response = await session.send({
+    message,
+    ...(options.clientContext ? { clientContext: options.clientContext } : {}),
+  });
+  const result = await response.result();
+  return options.settle ? options.settle(result, session) : result;
+}
+
+function resolveTurnPayload(events) {
+  const finalized = events.find((entry) => entry.event === "neagen.finalized")?.data;
+  const waiting = events.find((entry) => entry.event === "neagen.waiting_saved")?.data;
+  const declined = events.find((entry) => entry.event === "neagen.gate_declined")?.data;
+  const legacyTurn = events.find((entry) => entry.event === "turn")?.data;
+
+  if (waiting) {
+    return {
+      conversationId: waiting.conversationId,
+      runtimeStatus: waiting.runtimeStatus,
+      inputRequests: waiting.inputRequests,
+    };
+  }
+  if (finalized) return finalized;
+  if (declined) return declined;
+  if (legacyTurn) return legacyTurn;
+  throw new Error("Turn stream ended without a Neagen result.");
+}
+
+async function postTurnStream(host, token, body, { render } = {}) {
+  const res = await fetch(`${host.replace(/\/$/, "")}/api/turns`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      accept: "text/event-stream",
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(120_000),
+  });
+
+  const renderer = render ?? createTurnStreamRenderer();
+  const spinner = createTurnStatusSpinner("thinking");
+  let streamError;
+
+  try {
+    const events = await readTurnSseStream(res, (event, data) => {
+      spinner.stop();
+      if (event === "neagen.error") {
+        streamError = new Error(data?.message ?? "Turn failed.");
+      }
+      renderer.handle(event, data);
+    });
+    renderer.finish();
+
+    if (streamError) throw streamError;
+
+    return {
+      result: resolveTurnPayload(events),
+      assistantTextStreamed: renderer.assistantTextStreamed,
+    };
+  } finally {
+    spinner.stop();
+  }
+}
+
+export async function sendWakeSyncTurn({ host, token, event, handlers, render }) {
+  return sendTransportTurn({
+    host,
+    token,
+    conversationId: undefined,
+    message: wakeSyncPrompt(event),
+    handlers,
+    render,
+  });
+}
+
+export async function sendTransportTurn({
+  host,
+  token,
+  conversationId,
+  message,
+  handlers,
+  render,
+}) {
+  const renderer = render ?? createTurnStreamRenderer();
+  renderer.reset();
+  let assistantTextStreamed = false;
+
+  let leg = await postTurnStream(
+    host,
+    token,
+    { conversationId, body: message },
+    { render: renderer },
+  );
+  assistantTextStreamed ||= leg.assistantTextStreamed;
+  let result = leg.result;
+
+  while ((result?.inputRequests?.length ?? 0) > 0) {
+    const request = result.inputRequests[0];
+    const response =
+      requestToolName(request) === "ask_question"
+        ? questionResponse(request, await handlers.askQuestion(request))
+        : approvalResponse(request, await handlers.askApproval(request));
+    renderer.reset();
+    leg = await postTurnStream(
+      host,
+      token,
+      {
+        conversationId: result.conversationId,
+        inputResponses: [response],
+      },
+      { render: renderer },
+    );
+    assistantTextStreamed ||= leg.assistantTextStreamed;
+    result = leg.result;
+  }
+
+  return { ...result, assistantTextStreamed };
+}