@nyte-ai/sdk 0.0.0-stage → 0.0.19

package/dist/chunks/capability-ec663cyt.js

@@ -0,0 +1,208 @@
+import {
+  createHeadViews2,
+  watchHead2,
+  watchHost2,
+  withUnsent2
+} from "./capability-ctnsbfx9.js";
+import {
+  createLink2,
+  createRows2
+} from "./capability-artgq59v.js";
+import {
+  journalLoop2
+} from "./capability-ke5yk1as.js";
+import {
+  partHandle2
+} from "./capability-9747w1b1.js";
+import {
+  receiptHandle2,
+  sendReceipt2,
+  runHandle2,
+  moveOutcome2
+} from "./capability-2q3s96kg.js";
+import {
+  loginHandle2
+} from "./capability-nh422cp0.js";
+import {
+  workspaceHandle2
+} from "./capability-xavf3m2f.js";
+
+// src/client.ts
+import { asId, isJson, SdkError } from "@nyte-ai/schema";
+import { dev, followTrace, traced, watchStore } from "@nyte-ai/core";
+var MAIN = asId("main");
+function createClient2(transport, context) {
+  const link = createLink2();
+  const rows = createRows2(transport, link);
+  const bound = {
+    rows,
+    journal: journalLoop2(rows, context.journal),
+    views: createHeadViews2(rows)
+  };
+  bound.journal.replay(context.journaled);
+  let hostFrames = context.hostFrames;
+  link.signal.addEventListener("abort", () => void hostFrames?.return?.(), { once: true });
+  const close = async () => {
+    link.close("client");
+  };
+  return {
+    hostId: context.hostId,
+    principal: context.principal,
+    credential: context.credential,
+    sessions: {
+      watch: (input) => rows.watch("sessions.watch", input ?? {}),
+      async start(input) {
+        const id = input.id ?? asId(crypto.randomUUID());
+        followTrace(id, id);
+        const started = await traced("sdk.send", id, { session: id }, () => rows.wait("sessions.start", { ...input, id }));
+        return {
+          session: sessionHandle(bound, started.session),
+          receipt: sendReceipt2(rows, started.session, started.receipt, started.message)
+        };
+      },
+      list: (input) => rows.call("sessions.list", input ?? {})
+    },
+    workspaces: {
+      list: () => rows.call("workspaces.list", {}),
+      inspect: (target) => rows.call("workspaces.inspect", { target }),
+      add: (target, options) => rows.call("workspaces.add", { target, options }),
+      forget: (id) => rows.call("workspaces.forget", { id })
+    },
+    session: (id) => sessionHandle(bound, id),
+    workspace: (id) => workspaceHandle2(rows, id),
+    watch: () => {
+      const opened = hostFrames;
+      hostFrames = undefined;
+      return watchHost2(rows, opened);
+    },
+    blob: (id) => rows.bytes("connection.blob", { id }),
+    models: {
+      list: () => rows.call("models.list", {}),
+      accounts: (provider) => rows.call("models.accounts", { provider }),
+      async selectAccount(provider, account) {
+        await rows.call("models.selectAccount", { provider, account });
+      },
+      usage: () => rows.call("models.usage", {}),
+      async refresh(provider) {
+        await rows.call("models.refresh", { provider });
+      },
+      setDefault: (ref) => rows.call("models.setDefault", { ref }),
+      setListing: (refs, listing) => rows.call("models.setListing", { refs, listing }),
+      verify: (provider) => rows.call("models.verify", { provider }),
+      login: (input) => loginHandle2(rows, async () => {
+        await rows.call("models.login", input);
+        return input.provider;
+      }, input.provider),
+      async logout(provider) {
+        await rows.call("models.logout", { provider });
+      }
+    },
+    settings: { apply: (id, value) => rows.call("settings.apply", { id, value }) },
+    github: {
+      account: () => rows.call("github.account", {}),
+      signIn: () => rows.call("github.signIn", {}),
+      signOut: () => rows.call("github.signOut", {})
+    },
+    plugins: {
+      replace: (plugins, scope) => rows.call("plugins.replace", { plugins: files(plugins), scope }),
+      check: (plugins) => rows.call("plugins.check", { plugins: files(plugins) })
+    },
+    principals: {
+      list: async () => (await rows.call("principals.list", {})).map((view) => ({
+        ...view,
+        authority: new Set(view.authority)
+      })),
+      pair: (input) => rows.call("principals.pair", { authority: [...input.authority], label: input.label }),
+      async revoke(id) {
+        await rows.call("principals.revoke", { id });
+      }
+    },
+    close,
+    [Symbol.asyncDispose]: close
+  };
+}
+function sessionHandle(bound, session) {
+  const { rows } = bound;
+  return {
+    ...headHandle(bound, session, MAIN),
+    id: session,
+    head: (name) => headHandle(bound, session, name),
+    heads: {
+      create: (name, input) => rows.call("heads.create", { session, name, input }),
+      merge: (name, options) => rows.call("heads.merge", { session, name, options }),
+      remove: (name, options) => rows.call("heads.remove", { session, name, options })
+    },
+    run: (id) => runHandle2(rows, session, id),
+    receipt: (id) => receiptHandle2(rows, session, id, (outcome) => outcome),
+    info: () => rows.call("session.info", { session }),
+    update: (patch) => rows.call("session.update", { session, patch }),
+    remove: () => rows.call("session.remove", { session }),
+    stop: () => rows.call("session.stop", { session }),
+    command: (name, text) => rows.call("session.command", { session, name, text }),
+    completeCommand: (name, prefix) => rows.call("session.completeCommand", { session, name, prefix }),
+    parts: {
+      async create(kind, input) {
+        const { part } = await rows.call("parts.create", {
+          session,
+          kind: kind.kind,
+          input: { ...input, state: jsonState(input.state) }
+        });
+        return partHandle2(rows, session, part, kind);
+      }
+    },
+    part: (id) => partHandle2(rows, session, id, null)
+  };
+}
+function headHandle(bound, session, head) {
+  const { rows, journal } = bound;
+  return {
+    sessionId: session,
+    name: head,
+    async send(content, options) {
+      const { id, ...rest } = options ?? {};
+      const receipt = id ?? asId(crypto.randomUUID());
+      dev("sdk", "send", { session, head, receipt });
+      followTrace(session, receipt);
+      const sent = await traced("sdk.send", receipt, { session }, () => journal.send({
+        id: receipt,
+        session,
+        head,
+        content,
+        options: rest,
+        at: Date.now()
+      }));
+      return sendReceipt2(rows, session, sent.receipt, sent.message);
+    },
+    configure: (patch) => rows.call("head.configure", { session, head, patch }),
+    async view(options) {
+      const view = await rows.call("head.view", { session, head, options });
+      journal.landed(session, head, view);
+      return withUnsent2(view, journal.unsent(session, head));
+    },
+    watch: (options) => watchHead2(bound.views, journal, { session, head, options }),
+    ...watchStore(() => watchHead2(bound.views, journal, { session, head })),
+    history: (input) => rows.call("head.history", { session, head, ...input }),
+    tree: () => rows.call("head.tree", { session, head }),
+    async move(position, options) {
+      const { receipt } = await rows.call("head.move", {
+        session,
+        head,
+        position,
+        options,
+        id: asId(crypto.randomUUID())
+      });
+      return receiptHandle2(rows, session, receipt, moveOutcome2);
+    },
+    compact: (input) => rows.call("head.compact", { session, head, ...input })
+  };
+}
+function jsonState(state) {
+  if (isJson(state))
+    return state;
+  throw new SdkError("invalid", "A part's state must be JSON.");
+}
+function files(plugins) {
+  return plugins.map((plugin) => ({ path: plugin.path }));
+}
+
+export { createClient2 };

package/dist/chunks/capability-ke5yk1as.js

@@ -0,0 +1,165 @@
+import {
+  retryDelay2,
+  backoff2
+} from "./capability-artgq59v.js";
+
+// src/journal.ts
+import { asId, SdkError } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+function createSendJournal2() {
+  const entries = new Map;
+  return {
+    load: async () => [...entries.values()],
+    async put(entry) {
+      entries.set(entry.id, entry);
+    },
+    async remove(id) {
+      entries.delete(id);
+    }
+  };
+}
+function journalLoop2(rows, journal) {
+  const held = new Map;
+  const tails = new Map;
+  const shown = new Map;
+  const listeners = new Set;
+  const changed = () => {
+    for (const listener of listeners)
+      listener();
+  };
+  const post = async (current) => {
+    const { id, session, head, content, options } = current.entry;
+    for (;; ) {
+      try {
+        return await rows.call("head.send", {
+          session,
+          head,
+          content,
+          options: { ...options, id }
+        });
+      } catch (error) {
+        const closing = rows.link.signal.aborted;
+        if (closing || !(error instanceof SdkError && (error.code === "unavailable" || error.code === "stale"))) {
+          if (!closing)
+            await journal.remove(id);
+          held.delete(id);
+          changed();
+          throw error;
+        }
+        current.attempts += 1;
+        const delay = retryDelay2(current.attempts);
+        dev("sdk", "send retrying", { receipt: id, attempts: current.attempts, delay });
+        current.retrying = { at: Date.now() + delay, reason: error.message };
+        changed();
+        await backoff2(rows.link, delay, rows.link.signal);
+      }
+    }
+  };
+  const retarget = async (current, message) => {
+    const target = current.entry.options.replace ?? current.entry.id;
+    if (message === target)
+      return;
+    const all = [...held.values()];
+    const later = all.slice(all.findIndex((row) => row === current) + 1).filter(({ entry }) => entry.session === current.entry.session && entry.head === current.entry.head && entry.options.replace === target);
+    for (const row of later)
+      row.entry = { ...row.entry, options: { ...row.entry.options, replace: message } };
+    await Promise.all(later.map((row) => journal.put(row.entry)));
+  };
+  const hold = (entry) => {
+    const current = {
+      entry,
+      attempts: 0,
+      retrying: null,
+      answered: null,
+      answeredAfter: null
+    };
+    const key = JSON.stringify([entry.session, entry.head]);
+    const sent = (tails.get(key) ?? Promise.resolve()).then(async () => {
+      const answer = await post(current);
+      current.answered = answer.message;
+      current.answeredAfter = shown.get(key) ?? null;
+      await retarget(current, answer.message);
+      dev("sdk", "send answered", { receipt: entry.id, attempts: current.attempts + 1 });
+      changed();
+      return answer;
+    });
+    const tail = sent.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    tails.set(key, tail);
+    tail.then(() => {
+      if (tails.get(key) === tail)
+        tails.delete(key);
+    });
+    held.set(entry.id, current);
+    changed();
+    return sent;
+  };
+  return {
+    async send(entry) {
+      await journal.put(entry);
+      return hold(entry);
+    },
+    replay(entries) {
+      for (const entry of entries)
+        hold(entry).catch((error) => dev("sdk", "replay failed", {
+          receipt: entry.id,
+          code: error instanceof SdkError ? error.code : "internal"
+        }));
+    },
+    unsent(session, head) {
+      const shown = new Map;
+      const slots = new Map;
+      for (const current of held.values()) {
+        if (current.entry.session !== session || current.entry.head !== head)
+          continue;
+        const target = current.entry.options.replace ?? asId(current.entry.id);
+        const slot = slots.get(target) ?? target;
+        shown.set(slot, current);
+        if (current.answered !== null && current.answered !== target)
+          slots.set(current.answered, slot);
+      }
+      return [...shown].map(([id, current]) => unsentMessage(id, current));
+    },
+    landed(session, head, view) {
+      const key = JSON.stringify([session, head]);
+      shown.set(key, Math.max(shown.get(key) ?? 0, view.seq));
+      if (held.size === 0)
+        return;
+      const ids = new Set(view.messages.map((message) => message.id));
+      if (view.leadingPrompt !== null)
+        ids.add(view.leadingPrompt.id);
+      for (const [receipt, current] of held) {
+        const { answered, answeredAfter, entry } = current;
+        if (answered === null || entry.session !== session || entry.head !== head || !ids.has(answered) && answeredAfter !== null && view.seq <= answeredAfter)
+          continue;
+        held.delete(receipt);
+        journal.remove(current.entry.id).catch(() => dev("sdk", "journal remove failed", { receipt }));
+        dev("sdk", "send landed", { receipt });
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function unsentMessage(id, { entry, attempts, retrying }) {
+  return {
+    id,
+    turn: asId(`pending:${id}`),
+    at: entry.at,
+    kind: "user",
+    content: entry.content,
+    source: entry.options.source ?? { kind: "user" },
+    delivery: entry.options.delivery ?? "steer",
+    status: { kind: "unsent", attempts, retrying },
+    siblings: { index: 0, count: 1, ids: [] }
+  };
+}
+
+export { createSendJournal2, journalLoop2 };

package/dist/chunks/capability-mr5m2wn2.js

@@ -0,0 +1,6 @@
+// src/capability.ts
+function resolveCapability2(wire, bind) {
+  return wire.kind === "available" ? { kind: "available", api: bind() } : wire;
+}
+
+export { resolveCapability2 };

package/dist/chunks/capability-nh422cp0.js

@@ -0,0 +1,35 @@
+// src/login.ts
+import { SdkError } from "@nyte-ai/schema";
+import { closable } from "@nyte-ai/core";
+function loginHandle2(rows, begin, known) {
+  let started = null;
+  return {
+    steps: () => closable(() => {
+      let steps = null;
+      let closed = false;
+      return {
+        async pull() {
+          if (steps === null) {
+            const provider = await (started ??= begin());
+            if (closed)
+              return { done: true, value: undefined };
+            steps = rows.frames("login.steps", { provider })[Symbol.asyncIterator]();
+          }
+          return steps.next();
+        },
+        close() {
+          closed = true;
+          steps?.return?.();
+        }
+      };
+    }),
+    async answer(code) {
+      const provider = started === null ? known : await started;
+      if (provider === null)
+        throw new SdkError("invalid", "Read the login's steps before answering.");
+      await rows.call("login.answer", { provider, code });
+    }
+  };
+}
+
+export { loginHandle2 };

package/dist/chunks/capability-swbs68d8.js

@@ -0,0 +1,32 @@
+// src/paint-spans.ts
+import { followedTrace, startSpan, tracing } from "@nyte-ai/core";
+import { mapped } from "@nyte-ai/protocol";
+function tracePaints2(views, session, painted) {
+  if (!tracing.enabled)
+    return views;
+  return {
+    [Symbol.asyncIterator]() {
+      let shown = null;
+      return mapped(views, (view) => {
+        if (view.messages === shown)
+          return view;
+        const known = shown === null ? null : new Set(shown.map((message) => message.id));
+        const followed = followedTrace(session);
+        for (const message of view.messages) {
+          if (known === null ? message.id !== followed : known.has(message.id))
+            continue;
+          const user = message.kind === "user";
+          const ended = startSpan("client.paint", user ? message.id : followed, {
+            session,
+            kind: user ? "user" : message.partKind
+          });
+          painted().then(() => ended());
+        }
+        shown = view.messages;
+        return view;
+      })[Symbol.asyncIterator]();
+    }
+  };
+}
+
+export { tracePaints2 };

package/dist/chunks/capability-t9k5jy3d.js

@@ -0,0 +1,96 @@
+import {
+  pushed2
+} from "./capability-ctnsbfx9.js";
+
+// src/history.ts
+function pagedViews2(head, options) {
+  let pages = [];
+  let turns = [];
+  let leadingPrompt = null;
+  let latest = null;
+  let shown = null;
+  let push = null;
+  let loading = null;
+  let exhausted = null;
+  const show = (view) => {
+    const first = view.messages[0];
+    const moved = first === undefined || first.id !== latest?.messages[0]?.id;
+    const previous = moved || latest === null || shown === null ? null : { view: latest, shown };
+    if (moved) {
+      const before = shown?.messages ?? [];
+      const kept = first === undefined ? -1 : before.findIndex((message) => message.id === first.id);
+      pages = kept < 0 ? [] : before.slice(0, kept);
+      leadingPrompt = shown?.leadingPrompt ?? null;
+      const paged = new Set(pages.map((message) => message.turn));
+      turns = (shown?.turns ?? []).filter((turn) => paged.has(turn.id));
+    }
+    if (view.leadingPrompt !== null && view.leadingPrompt.id === leadingPrompt?.id)
+      leadingPrompt = view.leadingPrompt;
+    latest = view;
+    shown = pages.length === 0 ? view : withPages(view, { pages, turns, leadingPrompt }, previous);
+    push?.(shown);
+  };
+  const load = async (limit) => {
+    const oldest = shown?.messages[0];
+    if (oldest === undefined || oldest.id === exhausted)
+      return 0;
+    const page = await head.history({ before: oldest.id, limit });
+    const current = latest;
+    if (page.messages.length === 0) {
+      exhausted = oldest.id;
+      return 0;
+    }
+    if (current === null || shown?.messages[0]?.id !== oldest.id)
+      return 0;
+    const known = new Set(turns.map((turn) => turn.id));
+    pages = [...page.messages, ...pages];
+    turns = [...page.turns.filter((turn) => !known.has(turn.id)), ...turns];
+    leadingPrompt = page.leadingPrompt;
+    shown = withPages(current, { pages, turns, leadingPrompt }, null);
+    push?.(shown);
+    return page.messages.length;
+  };
+  return {
+    [Symbol.asyncIterator]: () => pushed2((sink) => {
+      const views = head.watch(options)[Symbol.asyncIterator]();
+      push = (view) => sink.next(view);
+      (async () => {
+        try {
+          for (;; ) {
+            const next = await views.next();
+            if (next.done === true)
+              break;
+            show(next.value);
+          }
+          sink.end();
+        } catch (error) {
+          sink.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+      })();
+      return () => {
+        push = null;
+        views.return?.();
+      };
+    })[Symbol.asyncIterator](),
+    earlier(limit) {
+      loading ??= load(limit).finally(() => {
+        loading = null;
+      });
+      return loading;
+    }
+  };
+}
+function withPages(view, paged, previous) {
+  return {
+    ...view,
+    messages: previous?.view.messages === view.messages ? previous.shown.messages : [...paged.pages, ...view.messages],
+    leadingPrompt: paged.leadingPrompt,
+    turns: previous?.view.turns === view.turns ? previous.shown.turns : pagedTurns(paged.turns, view.turns)
+  };
+}
+function pagedTurns(paged, own) {
+  const ids = new Set(own.map((turn) => turn.id));
+  return [...paged.filter((turn) => !ids.has(turn.id)), ...own];
+}
+
+export { pagedViews2 };