@nema-project/nema 0.0.0-stage → 0.1.3

package/dist/direct/lock.js

@@ -0,0 +1,134 @@
+// direct/lock.js
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, linkSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs";
+var LockTimeoutError = class extends Error {
+  lockPath;
+  timeoutMs;
+  constructor(lockPath, timeoutMs) {
+    super(`Timed out after ${timeoutMs} ms waiting for lock ${lockPath}`);
+    this.lockPath = lockPath;
+    this.timeoutMs = timeoutMs;
+    this.name = "LockTimeoutError";
+  }
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code !== "ESRCH";
+  }
+}
+function readRaw(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return null;
+    throw e;
+  }
+}
+function parseHolder(raw) {
+  try {
+    const v = JSON.parse(raw);
+    if (Number.isInteger(v.pid) && v.pid > 0 && typeof v.at === "number")
+      return v;
+  } catch {
+  }
+  return null;
+}
+function isStale(path, raw, staleMs) {
+  const h = parseHolder(raw);
+  if (h)
+    return !pidAlive(h.pid);
+  try {
+    return Date.now() - statSync(path).mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+function takeOver(path, staleRaw) {
+  const tomb = `${path}.stale-${process.pid}-${randomUUID()}`;
+  try {
+    renameSync(path, tomb);
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+  try {
+    if (readRaw(tomb) !== staleRaw) {
+      try {
+        linkSync(tomb, path);
+      } catch {
+      }
+    }
+  } finally {
+    try {
+      unlinkSync(tomb);
+    } catch {
+    }
+  }
+}
+async function withFileLock(lockPath, fn, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  const pollMs = opts.pollMs ?? 50;
+  const staleMs = opts.staleMs ?? 3e4;
+  const token = randomUUID();
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      const fd = openSync(lockPath, "wx", 384);
+      try {
+        writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now(), token }));
+      } finally {
+        closeSync(fd);
+      }
+      break;
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        throw e;
+    }
+    const raw = readRaw(lockPath);
+    if (raw === null)
+      continue;
+    if (isStale(lockPath, raw, staleMs)) {
+      takeOver(lockPath, raw);
+      continue;
+    }
+    if (Date.now() >= deadline)
+      throw new LockTimeoutError(lockPath, timeoutMs);
+    await sleep(pollMs);
+  }
+  const heartbeat = setInterval(() => {
+    try {
+      const raw = readRaw(lockPath);
+      if (raw === null || parseHolder(raw)?.token !== token)
+        return;
+      const fd = openSync(lockPath, constants.O_WRONLY | constants.O_TRUNC | constants.O_NOFOLLOW);
+      try {
+        writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now(), token }));
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+    }
+  }, Math.max(1, Math.floor(staleMs / 3)));
+  heartbeat.unref();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(heartbeat);
+    try {
+      const raw = readRaw(lockPath);
+      if (raw !== null && parseHolder(raw)?.token === token)
+        unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+export {
+  LockTimeoutError,
+  withFileLock
+};

package/dist/direct/loop.d.ts

@@ -0,0 +1,33 @@
+import type { PluginToolSpec } from "@nema/shared";
+import type { RoomClient } from "../room/client.js";
+import { type RoomApi } from "./tools.js";
+import type { CollectedResponse, InputItem } from "./transport.js";
+export type LoopLimits = {
+    maxModelCalls: number;
+    maxToolCalls: number;
+    maxUnknownTools: number;
+    maxContinuations: number;
+};
+export declare const DEFAULT_LIMITS: LoopLimits;
+export declare const CONTINUE_TEXT = "\u8BF7\u7EE7\u7EED\u3002";
+export type ToolLoopOptions = {
+    /** Sent as the request `instructions` by `call`; kept here so callers pass the hub prompt in one place. */
+    instructions: string;
+    userText: string;
+    call: (input: InputItem[]) => Promise<CollectedResponse>;
+    room: RoomClient | RoomApi;
+    /** Plugin functions from `task.assign`. Routed through `dispatchTool`, so they count toward the tool limit. */
+    pluginTools?: PluginToolSpec[];
+    /** Short progress notes (e.g. which Room function is being called). */
+    onProgress: (text: string) => void;
+    limits?: LoopLimits;
+    /** Once aborted (timeout / run end) the loop stops and emits no further progress. */
+    signal?: AbortSignal;
+};
+/**
+ * Runs the model until it answers without function calls. Returns the final assistant text (all text of the
+ * final answer, joined across continuations). Throws an Error with a user-facing Chinese message on any limit.
+ */
+export declare function runToolLoop(opts: ToolLoopOptions): Promise<{
+    reply: string;
+}>;

package/dist/direct/loop.js

@@ -0,0 +1,110 @@
+// direct/loop.js
+import { createHash } from "node:crypto";
+import { dispatchTool } from "./tools.js";
+import { isFunctionCall, isMessage } from "./transport.js";
+var DEFAULT_LIMITS = { maxModelCalls: 24, maxToolCalls: 60, maxUnknownTools: 5, maxContinuations: 3 };
+var CONTINUE_TEXT = "\u8BF7\u7EE7\u7EED\u3002";
+var MAX_CALL_ID = 64;
+var userMessage = (text) => ({ type: "message", role: "user", content: [{ type: "input_text", text }] });
+var sha32 = (s) => createHash("sha256").update(s).digest("hex").slice(0, 32);
+var CallIds = class {
+  used = /* @__PURE__ */ new Set();
+  assign(raw) {
+    let base = typeof raw === "string" && raw !== "" ? raw : "call_missing";
+    if (base.length > MAX_CALL_ID)
+      base = `call_${sha32(base)}`;
+    let id = base;
+    for (let n = 1; this.used.has(id); n++) {
+      const suffix = `_dup${n}`;
+      id = base.length + suffix.length > MAX_CALL_ID ? `call_${sha32(base)}${suffix}` : base + suffix;
+    }
+    this.used.add(id);
+    return id;
+  }
+};
+var textParts = (m) => (Array.isArray(m.content) ? m.content : []).filter((p) => !!p && p.type === "output_text" && typeof p.text === "string").map((p) => ({ type: "output_text", text: p.text }));
+async function runToolLoop(opts) {
+  const limits = opts.limits ?? DEFAULT_LIMITS;
+  const history = [userMessage(opts.userText)];
+  const ids = new CallIds();
+  let modelCalls = 0;
+  let toolCalls = 0;
+  let unknownTools = 0;
+  let continuations = 0;
+  let answer = "";
+  const signal = opts.signal;
+  const progress = (text) => {
+    if (!signal?.aborted)
+      opts.onProgress(text);
+  };
+  for (; ; ) {
+    signal?.throwIfAborted();
+    if (modelCalls >= limits.maxModelCalls)
+      throw new Error(`Agent \u8D85\u51FA\u5355\u6B21\u8FD0\u884C\u4E0A\u9650\uFF08\u6A21\u578B\u8C03\u7528 ${limits.maxModelCalls} \u6B21\uFF09`);
+    modelCalls++;
+    const res = await opts.call([...history]);
+    signal?.throwIfAborted();
+    const calls = [];
+    let text = "";
+    for (const item of res.items) {
+      if (item.type === "reasoning") {
+        const enc = item.encrypted_content;
+        if (typeof enc !== "string" || enc === "")
+          continue;
+        const summary = item.summary;
+        const parts = (Array.isArray(summary) ? summary : []).filter((p) => !!p && p.type === "summary_text" && typeof p.text === "string").map((p) => ({ type: "summary_text", text: p.text }));
+        history.push({ type: "reasoning", summary: parts, encrypted_content: enc });
+      } else if (isMessage(item)) {
+        const parts = textParts(item);
+        if (parts.length === 0)
+          continue;
+        history.push({ type: "message", role: "assistant", content: parts });
+        text += parts.map((p) => p.text).join("");
+      } else if (isFunctionCall(item)) {
+        const call = {
+          call_id: ids.assign(item.call_id),
+          name: typeof item.name === "string" ? item.name : "",
+          arguments: typeof item.arguments === "string" ? item.arguments : ""
+        };
+        history.push({ type: "function_call", ...call });
+        calls.push(call);
+      }
+    }
+    if (calls.length > 0) {
+      answer = "";
+      for (const c of calls) {
+        if (toolCalls >= limits.maxToolCalls)
+          throw new Error(`Agent \u8D85\u51FA\u5355\u6B21\u8FD0\u884C\u4E0A\u9650\uFF08\u5DE5\u5177\u8C03\u7528 ${limits.maxToolCalls} \u6B21\uFF09`);
+        toolCalls++;
+        const r = await dispatchTool(c.name, c.arguments, opts.room, opts.pluginTools ?? []);
+        signal?.throwIfAborted();
+        if (!r.known) {
+          unknownTools++;
+          if (unknownTools > limits.maxUnknownTools)
+            throw new Error("Agent \u591A\u6B21\u8BF7\u6C42\u672A\u63D0\u4F9B\u7684\u5DE5\u5177\uFF0C\u5DF2\u4E2D\u6B62");
+        } else {
+          progress(`\u8C03\u7528 ${c.name}`);
+        }
+        history.push({ type: "function_call_output", call_id: c.call_id, output: r.output });
+      }
+      continue;
+    }
+    answer += text;
+    if (res.status === "completed") {
+      const reply = answer.trim();
+      if (reply === "")
+        throw new Error("Agent \u6CA1\u6709\u8FD4\u56DE\u56DE\u590D");
+      return { reply };
+    }
+    if (continuations >= limits.maxContinuations) {
+      throw new Error(`Agent \u8F93\u51FA\u4E0D\u5B8C\u6574\uFF0C\u7EED\u5199 ${limits.maxContinuations} \u6B21\u540E\u4ECD\u672A\u5B8C\u6210\uFF08${res.incompleteReason ?? "incomplete"}\uFF09`);
+    }
+    continuations++;
+    history.push(userMessage(CONTINUE_TEXT));
+  }
+}
+export {
+  CONTINUE_TEXT,
+  DEFAULT_LIMITS,
+  runToolLoop
+};

package/dist/direct/siwc.d.ts

@@ -0,0 +1,63 @@
+import { type Refresher, type StoredAuth } from "./authStore.js";
+export declare const SIWC: {
+    /** [SIGN-IN] first-time registration entrypoint; never saved or used for token exchange. */
+    readonly dynamicClientId: "dynamic_agent_client";
+    /** [SIGN-IN] app's actual name, used consistently, only on initial registration. */
+    readonly agentNameHint: "Nema Room";
+    /** [SIGN-IN] */
+    readonly authorizeUrl: "https://auth.openai.com/api/accounts/authorize";
+    /** [SIGN-IN] code exchange; [SESSIONS] refresh. */
+    readonly tokenUrl: "https://auth.openai.com/api/accounts/oauth/token";
+    /** [TOKENS] access-token `iss` in production. */
+    readonly issuer: "https://auth.openai.com";
+    /** [SIGN-IN] `resource` on authorize, exchange and refresh. */
+    readonly resource: "https://api.openai.com/v1";
+    /** [SIGN-IN] identity scopes (needed for the id_token / account identity). */
+    readonly identityScopes: "openid profile email";
+    /** [SIGN-IN] ChatGPT plan usage scopes. */
+    readonly planScopes: "offline_access resource.invoke chatgpt.tokens.use.direct";
+    /** [SIGN-IN] the granted scope that authorizes plan usage. */
+    readonly planUsageScope: "chatgpt.tokens.use.direct";
+    /** [SIGN-IN] loopback redirect `http://127.0.0.1:<port>/auth/callback`; only the port may vary. */
+    readonly callbackHost: "127.0.0.1";
+    readonly callbackPath: "/auth/callback";
+    /** [SIGN-IN] example port. */
+    readonly defaultPort: 1455;
+    /** [MODELS] */
+    readonly apiBase: "https://api.openai.com/v1";
+    /** Project rule (not from the docs). */
+    readonly originator: "nema-room";
+};
+/** [ERRORS] "Refresh errors": codes meaning the refresh token is unusable → re-login. */
+export declare const UNUSABLE_REFRESH_CODES: readonly ["invalid_grant", "invalid_client", "invalid_refresh_token", "token_expired", "refresh_token_expired", "refresh_token_invalidated", "refresh_token_reused"];
+export declare function cliVersion(): string;
+export declare const nemaUserAgent: () => string;
+export declare const nemaHeaders: () => Record<string, string>;
+/** This host's stable `ext_agent_host_id` ([SIGN-IN]: choose and persist it before the first sign-in). */
+export declare function hostId(nemaHome: string): string;
+export type SiwcEndpoints = {
+    authorizeUrl?: string;
+    tokenUrl?: string;
+};
+export type SiwcLoginOptions = {
+    nemaHome: string;
+    /** Always called with the authorize URL; the caller also prints it. */
+    openBrowser: (url: string) => void;
+    /** Default 1455; when omitted and 1455 is busy an OS-assigned port is used ([SIGN-IN]: only the port may vary). */
+    port?: number;
+    /** Default 300000. */
+    timeoutMs?: number;
+    /** Test-only override of the auth.openai.com endpoints. */
+    endpoints?: SiwcEndpoints;
+    /** Cancels the callback listener and token exchange owned by the caller. */
+    signal?: AbortSignal;
+    /** Desktop owner requires its production opener to receive only the fixed provider endpoint. */
+    requireTrustedAuthorizeUrl?: boolean;
+    /** Hides provider and callback error text from the OAuth browser page. */
+    redactCallbackErrors?: boolean;
+};
+/** Browser PKCE login ([SIGN-IN]); saves `<nemaHome>/auth.json` (mode "siwc") under auth.lock. */
+export declare function siwcLogin(opts: SiwcLoginOptions): Promise<StoredAuth>;
+/** Refresh per [SESSIONS] "Refreshing tokens". `tokenUrl` is overridable for tests. */
+export declare function makeSiwcRefresher(tokenUrl?: string): Refresher;
+export declare const siwcRefresher: Refresher;